mixpanel-browser 2.43.0 → 2.46.0

package/dist/mixpanel.globals.js

@@ -3,7 +3,7 @@
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.43.0'
+        LIB_VERSION: '2.46.0'
     };
 
     // since es6 imports are static and we run unit tests from the console, window won't be defined when importing this file
@@ -37,11 +37,11 @@
     var toString = ObjProto.toString;
     var hasOwnProperty = ObjProto.hasOwnProperty;
     var windowConsole = window$1.console;
-    var navigator$1 = window$1.navigator;
+    var navigator = window$1.navigator;
     var document$1 = window$1.document;
     var windowOpera = window$1.opera;
     var screen = window$1.screen;
-    var userAgent = navigator$1.userAgent;
+    var userAgent = navigator.userAgent;
     var nativeBind = FuncProto.bind;
     var nativeForEach = ArrayProto.forEach;
     var nativeIndexOf = ArrayProto.indexOf;
@@ -153,14 +153,6 @@
         return bound;
     };
 
-    _.bind_instance_methods = function(obj) {
-        for (var func in obj) {
-            if (typeof(obj[func]) === 'function') {
-                obj[func] = _.bind(obj[func], obj);
-            }
-        }
-    };
-
     /**
      * @param {*=} obj
      * @param {function(...*)=} iterator
@@ -189,19 +181,6 @@
         }
     };
 
-    _.escapeHTML = function(s) {
-        var escaped = s;
-        if (escaped && _.isString(escaped)) {
-            escaped = escaped
-                .replace(/&/g, '&')
-                .replace(/</g, '&lt;')
-                .replace(/>/g, '&gt;')
-                .replace(/"/g, '&quot;')
-                .replace(/'/g, '&#039;');
-        }
-        return escaped;
-    };
-
     _.extend = function(obj) {
         _.each(slice.call(arguments, 1), function(source) {
             for (var prop in source) {
@@ -377,33 +356,6 @@
             pad(d.getUTCSeconds());
     };
 
-    _.safewrap = function(f) {
-        return function() {
-            try {
-                return f.apply(this, arguments);
-            } catch (e) {
-                console.critical('Implementation error. Please turn on debug and contact support@mixpanel.com.');
-                if (Config.DEBUG){
-                    console.critical(e);
-                }
-            }
-        };
-    };
-
-    _.safewrap_class = function(klass, functions) {
-        for (var i = 0; i < functions.length; i++) {
-            klass.prototype[functions[i]] = _.safewrap(klass.prototype[functions[i]]);
-        }
-    };
-
-    _.safewrap_instance_methods = function(obj) {
-        for (var func in obj) {
-            if (typeof(obj[func]) === 'function') {
-                obj[func] = _.safewrap(obj[func]);
-            }
-        }
-    };
-
     _.strip_empty_properties = function(p) {
         var ret = {};
         _.each(p, function(v, k) {
@@ -1647,13 +1599,13 @@
         properties: function() {
             return _.extend(_.strip_empty_properties({
                 '$os': _.info.os(),
-                '$browser': _.info.browser(userAgent, navigator$1.vendor, windowOpera),
+                '$browser': _.info.browser(userAgent, navigator.vendor, windowOpera),
                 '$referrer': document$1.referrer,
                 '$referring_domain': _.info.referringDomain(document$1.referrer),
                 '$device': _.info.device(userAgent)
             }), {
                 '$current_url': window$1.location.href,
-                '$browser_version': _.info.browserVersion(userAgent, navigator$1.vendor, windowOpera),
+                '$browser_version': _.info.browserVersion(userAgent, navigator.vendor, windowOpera),
                 '$screen_height': screen.height,
                 '$screen_width': screen.width,
                 'mp_lib': 'web',
@@ -1666,9 +1618,9 @@
         people_properties: function() {
             return _.extend(_.strip_empty_properties({
                 '$os': _.info.os(),
-                '$browser': _.info.browser(userAgent, navigator$1.vendor, windowOpera)
+                '$browser': _.info.browser(userAgent, navigator.vendor, windowOpera)
             }), {
-                '$browser_version': _.info.browserVersion(userAgent, navigator$1.vendor, windowOpera)
+                '$browser_version': _.info.browserVersion(userAgent, navigator.vendor, windowOpera)
             });
         },
 
@@ -1676,7 +1628,7 @@
             return _.strip_empty_properties({
                 'mp_page': page,
                 'mp_referrer': document$1.referrer,
-                'mp_browser': _.info.browser(userAgent, navigator$1.vendor, windowOpera),
+                'mp_browser': _.info.browser(userAgent, navigator.vendor, windowOpera),
                 'mp_platform': _.info.os()
             });
         }
@@ -2058,6 +2010,7 @@
         options = options || {};
         this.storageKey = storageKey;
         this.storage = options.storage || window.localStorage;
+        this.reportError = options.errorReporter || _.bind(logger$1.error, logger$1);
         this.lock = new SharedLock(storageKey, {storage: this.storage});
 
         this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
@@ -2095,18 +2048,18 @@
                     this.memQueue.push(queueEntry);
                 }
             } catch(err) {
-                logger$1.error('Error enqueueing item', item);
+                this.reportError('Error enqueueing item', item);
                 succeeded = false;
             }
             if (cb) {
                 cb(succeeded);
             }
-        }, this), function lockFailure(err) {
-            logger$1.error('Error acquiring storage lock', err);
+        }, this), _.bind(function lockFailure(err) {
+            this.reportError('Error acquiring storage lock', err);
             if (cb) {
                 cb(false);
             }
-        }, this.pid);
+        }, this), this.pid);
     };
 
     /**
@@ -2166,25 +2119,61 @@
         _.each(ids, function(id) { idSet[id] = true; });
 
         this.memQueue = filterOutIDsAndInvalid(this.memQueue, idSet);
-        this.lock.withLock(_.bind(function lockAcquired() {
+
+        var removeFromStorage = _.bind(function() {
             var succeeded;
             try {
                 var storedQueue = this.readFromStorage();
                 storedQueue = filterOutIDsAndInvalid(storedQueue, idSet);
                 succeeded = this.saveToStorage(storedQueue);
+
+                // an extra check: did storage report success but somehow
+                // the items are still there?
+                if (succeeded) {
+                    storedQueue = this.readFromStorage();
+                    for (var i = 0; i < storedQueue.length; i++) {
+                        var item = storedQueue[i];
+                        if (item['id'] && !!idSet[item['id']]) {
+                            this.reportError('Item not removed from storage');
+                            return false;
+                        }
+                    }
+                }
             } catch(err) {
-                logger$1.error('Error removing items', ids);
+                this.reportError('Error removing items', ids);
                 succeeded = false;
             }
+            return succeeded;
+        }, this);
+
+        this.lock.withLock(function lockAcquired() {
+            var succeeded = removeFromStorage();
             if (cb) {
                 cb(succeeded);
             }
-        }, this), function lockFailure(err) {
-            logger$1.error('Error acquiring storage lock', err);
+        }, _.bind(function lockFailure(err) {
+            var succeeded = false;
+            this.reportError('Error acquiring storage lock', err);
+            if (!localStorageSupported(this.storage, true)) {
+                // Looks like localStorage writes have stopped working sometime after
+                // initialization (probably full), and so nobody can acquire locks
+                // anymore. Consider it temporarily safe to remove items without the
+                // lock, since nobody's writing successfully anyway.
+                succeeded = removeFromStorage();
+                if (!succeeded) {
+                    // OK, we couldn't even write out the smaller queue. Try clearing it
+                    // entirely.
+                    try {
+                        this.storage.removeItem(this.storageKey);
+                    } catch(err) {
+                        this.reportError('Error clearing queue', err);
+                    }
+                }
+            }
             if (cb) {
-                cb(false);
+                cb(succeeded);
             }
-        }, this.pid);
+        }, this), this.pid);
     };
 
     // internal helper for RequestQueue.updatePayloads
@@ -2219,18 +2208,18 @@
                 storedQueue = updatePayloads(storedQueue, itemsToUpdate);
                 succeeded = this.saveToStorage(storedQueue);
             } catch(err) {
-                logger$1.error('Error updating items', itemsToUpdate);
+                this.reportError('Error updating items', itemsToUpdate);
                 succeeded = false;
             }
             if (cb) {
                 cb(succeeded);
             }
-        }, this), function lockFailure(err) {
-            logger$1.error('Error acquiring storage lock', err);
+        }, this), _.bind(function lockFailure(err) {
+            this.reportError('Error acquiring storage lock', err);
             if (cb) {
                 cb(false);
             }
-        }, this.pid);
+        }, this), this.pid);
     };
 
     /**
@@ -2244,12 +2233,12 @@
             if (storageEntry) {
                 storageEntry = JSONParse(storageEntry);
                 if (!_.isArray(storageEntry)) {
-                    logger$1.error('Invalid storage entry:', storageEntry);
+                    this.reportError('Invalid storage entry:', storageEntry);
                     storageEntry = null;
                 }
             }
         } catch (err) {
-            logger$1.error('Error retrieving queue', err);
+            this.reportError('Error retrieving queue', err);
             storageEntry = null;
         }
         return storageEntry || [];
@@ -2263,7 +2252,7 @@
             this.storage.setItem(this.storageKey, JSONStringify(queue));
             return true;
         } catch (err) {
-            logger$1.error('Error saving queue', err);
+            this.reportError('Error saving queue', err);
             return false;
         }
     };
@@ -2290,17 +2279,26 @@
      * @constructor
      */
     var RequestBatcher = function(storageKey, options) {
-        this.queue = new RequestQueue(storageKey, {storage: options.storage});
+        this.errorReporter = options.errorReporter;
+        this.queue = new RequestQueue(storageKey, {
+            errorReporter: _.bind(this.reportError, this),
+            storage: options.storage
+        });
 
         this.libConfig = options.libConfig;
         this.sendRequest = options.sendRequestFunc;
         this.beforeSendHook = options.beforeSendHook;
+        this.stopAllBatching = options.stopAllBatchingFunc;
 
         // seed variable batch size + flush interval with configured values
         this.batchSize = this.libConfig['batch_size'];
         this.flushInterval = this.libConfig['batch_flush_interval_ms'];
 
         this.stopped = !this.libConfig['batch_autostart'];
+        this.consecutiveRemovalFailures = 0;
+
+        // extra client-side dedupe
+        this.itemIdsSentSuccessfully = {};
     };
 
     /**
@@ -2316,6 +2314,7 @@
      */
     RequestBatcher.prototype.start = function() {
         this.stopped = false;
+        this.consecutiveRemovalFailures = 0;
         this.flush();
     };
 
@@ -2392,7 +2391,34 @@
                     payload = this.beforeSendHook(payload);
                 }
                 if (payload) {
-                    dataForRequest.push(payload);
+                    // mp_sent_by_lib_version prop captures which lib version actually
+                    // sends each event (regardless of which version originally queued
+                    // it for sending)
+                    if (payload['event'] && payload['properties']) {
+                        payload['properties'] = _.extend(
+                            {},
+                            payload['properties'],
+                            {'mp_sent_by_lib_version': Config.LIB_VERSION}
+                        );
+                    }
+                    var addPayload = true;
+                    var itemId = item['id'];
+                    if (itemId) {
+                        if ((this.itemIdsSentSuccessfully[itemId] || 0) > 5) {
+                            this.reportError('[dupe] item ID sent too many times, not sending', {
+                                item: item,
+                                batchSize: batch.length,
+                                timesSent: this.itemIdsSentSuccessfully[itemId]
+                            });
+                            addPayload = false;
+                        }
+                    } else {
+                        this.reportError('[dupe] found item with no ID', {item: item});
+                    }
+
+                    if (addPayload) {
+                        dataForRequest.push(payload);
+                    }
                 }
                 transformedItems[item['id']] = payload;
             }, this);
@@ -2420,7 +2446,7 @@
                         res.error === 'timeout' &&
                         new Date().getTime() - startTime >= timeoutMS
                     ) {
-                        logger.error('Network timeout; retrying');
+                        this.reportError('Network timeout; retrying');
                         this.flush();
                     } else if (
                         _.isObject(res) &&
@@ -2437,17 +2463,17 @@
                             }
                         }
                         retryMS = Math.min(MAX_RETRY_INTERVAL_MS, retryMS);
-                        logger.error('Error; retry in ' + retryMS + ' ms');
+                        this.reportError('Error; retry in ' + retryMS + ' ms');
                         this.scheduleFlush(retryMS);
                     } else if (_.isObject(res) && res.xhr_req && res.xhr_req['status'] === 413) {
                         // 413 Payload Too Large
                         if (batch.length > 1) {
                             var halvedBatchSize = Math.max(1, Math.floor(currentBatchSize / 2));
                             this.batchSize = Math.min(this.batchSize, halvedBatchSize, batch.length - 1);
-                            logger.error('413 response; reducing batch size to ' + this.batchSize);
+                            this.reportError('413 response; reducing batch size to ' + this.batchSize);
                             this.resetFlush();
                         } else {
-                            logger.error('Single-event request too large; dropping', batch);
+                            this.reportError('Single-event request too large; dropping', batch);
                             this.resetBatchSize();
                             removeItemsFromQueue = true;
                         }
@@ -2460,12 +2486,43 @@
                     if (removeItemsFromQueue) {
                         this.queue.removeItemsByID(
                             _.map(batch, function(item) { return item['id']; }),
-                            _.bind(this.flush, this) // handle next batch if the queue isn't empty
+                            _.bind(function(succeeded) {
+                                if (succeeded) {
+                                    this.consecutiveRemovalFailures = 0;
+                                    this.flush(); // handle next batch if the queue isn't empty
+                                } else {
+                                    this.reportError('Failed to remove items from queue');
+                                    if (++this.consecutiveRemovalFailures > 5) {
+                                        this.reportError('Too many queue failures; disabling batching system.');
+                                        this.stopAllBatching();
+                                    } else {
+                                        this.resetFlush();
+                                    }
+                                }
+                            }, this)
                         );
+
+                        // client-side dedupe
+                        _.each(batch, _.bind(function(item) {
+                            var itemId = item['id'];
+                            if (itemId) {
+                                this.itemIdsSentSuccessfully[itemId] = this.itemIdsSentSuccessfully[itemId] || 0;
+                                this.itemIdsSentSuccessfully[itemId]++;
+                                if (this.itemIdsSentSuccessfully[itemId] > 5) {
+                                    this.reportError('[dupe] item ID sent too many times', {
+                                        item: item,
+                                        batchSize: batch.length,
+                                        timesSent: this.itemIdsSentSuccessfully[itemId]
+                                    });
+                                }
+                            } else {
+                                this.reportError('[dupe] found item with no ID while removing', {item: item});
+                            }
+                        }, this));
                     }
 
                 } catch(err) {
-                    logger.error('Error handling API response', err);
+                    this.reportError('Error handling API response', err);
                     this.resetFlush();
                 }
             }, this);
@@ -2482,11 +2539,28 @@
             this.sendRequest(dataForRequest, requestOptions, batchSendCallback);
 
         } catch(err) {
-            logger.error('Error flushing request queue', err);
+            this.reportError('Error flushing request queue', err);
             this.resetFlush();
         }
     };
 
+    /**
+     * Log error to global logger and optional user-defined logger.
+     */
+    RequestBatcher.prototype.reportError = function(msg, err) {
+        logger.error.apply(logger.error, arguments);
+        if (this.errorReporter) {
+            try {
+                if (!(err instanceof Error)) {
+                    err = new Error(msg);
+                }
+                this.errorReporter(msg, err);
+            } catch(err) {
+                logger.error(err);
+            }
+        }
+    };
+
     /**
      * A function used to track a Mixpanel event (e.g. MixpanelLib.track)
      * @callback trackFunction
@@ -3058,2755 +3132,931 @@
     MixpanelGroup.prototype['unset']    = MixpanelGroup.prototype.unset;
     MixpanelGroup.prototype['toString'] = MixpanelGroup.prototype.toString;
 
-    /*
-     * Constants
-     */
-    /** @const */ var SET_QUEUE_KEY          = '__mps';
-    /** @const */ var SET_ONCE_QUEUE_KEY     = '__mpso';
-    /** @const */ var UNSET_QUEUE_KEY        = '__mpus';
-    /** @const */ var ADD_QUEUE_KEY          = '__mpa';
-    /** @const */ var APPEND_QUEUE_KEY       = '__mpap';
-    /** @const */ var REMOVE_QUEUE_KEY       = '__mpr';
-    /** @const */ var UNION_QUEUE_KEY        = '__mpu';
-    // This key is deprecated, but we want to check for it to see whether aliasing is allowed.
-    /** @const */ var PEOPLE_DISTINCT_ID_KEY = '$people_distinct_id';
-    /** @const */ var ALIAS_ID_KEY           = '__alias';
-    /** @const */ var CAMPAIGN_IDS_KEY       = '__cmpns';
-    /** @const */ var EVENT_TIMERS_KEY       = '__timers';
-    /** @const */ var RESERVED_PROPERTIES = [
-        SET_QUEUE_KEY,
-        SET_ONCE_QUEUE_KEY,
-        UNSET_QUEUE_KEY,
-        ADD_QUEUE_KEY,
-        APPEND_QUEUE_KEY,
-        REMOVE_QUEUE_KEY,
-        UNION_QUEUE_KEY,
-        PEOPLE_DISTINCT_ID_KEY,
-        ALIAS_ID_KEY,
-        CAMPAIGN_IDS_KEY,
-        EVENT_TIMERS_KEY
-    ];
-
     /**
-     * Mixpanel Persistence Object
+     * Mixpanel People Object
      * @constructor
      */
-    var MixpanelPersistence = function(config) {
-        this['props'] = {};
-        this.campaign_params_saved = false;
-
-        if (config['persistence_name']) {
-            this.name = 'mp_' + config['persistence_name'];
-        } else {
-            this.name = 'mp_' + config['token'] + '_mixpanel';
-        }
-
-        var storage_type = config['persistence'];
-        if (storage_type !== 'cookie' && storage_type !== 'localStorage') {
-            console.critical('Unknown persistence type ' + storage_type + '; falling back to cookie');
-            storage_type = config['persistence'] = 'cookie';
-        }
-
-        if (storage_type === 'localStorage' && _.localStorage.is_supported()) {
-            this.storage = _.localStorage;
-        } else {
-            this.storage = _.cookie;
-        }
-
-        this.load();
-        this.update_config(config);
-        this.upgrade(config);
-        this.save();
-    };
-
-    MixpanelPersistence.prototype.properties = function() {
-        var p = {};
-        // Filter out reserved properties
-        _.each(this['props'], function(v, k) {
-            if (!_.include(RESERVED_PROPERTIES, k)) {
-                p[k] = v;
-            }
-        });
-        return p;
-    };
-
-    MixpanelPersistence.prototype.load = function() {
-        if (this.disabled) { return; }
+    var MixpanelPeople = function() {};
 
-        var entry = this.storage.parse(this.name);
+    _.extend(MixpanelPeople.prototype, apiActions);
 
-        if (entry) {
-            this['props'] = _.extend({}, entry);
-        }
+    MixpanelPeople.prototype._init = function(mixpanel_instance) {
+        this._mixpanel = mixpanel_instance;
     };
 
-    MixpanelPersistence.prototype.upgrade = function(config) {
-        var upgrade_from_old_lib = config['upgrade'],
-            old_cookie_name,
-            old_cookie;
-
-        if (upgrade_from_old_lib) {
-            old_cookie_name = 'mp_super_properties';
-            // Case where they had a custom cookie name before.
-            if (typeof(upgrade_from_old_lib) === 'string') {
-                old_cookie_name = upgrade_from_old_lib;
-            }
-
-            old_cookie = this.storage.parse(old_cookie_name);
-
-            // remove the cookie
-            this.storage.remove(old_cookie_name);
-            this.storage.remove(old_cookie_name, true);
-
-            if (old_cookie) {
-                this['props'] = _.extend(
-                    this['props'],
-                    old_cookie['all'],
-                    old_cookie['events']
-                );
-            }
+    /*
+    * Set properties on a user record.
+    *
+    * ### Usage:
+    *
+    *     mixpanel.people.set('gender', 'm');
+    *
+    *     // or set multiple properties at once
+    *     mixpanel.people.set({
+    *         'Company': 'Acme',
+    *         'Plan': 'Premium',
+    *         'Upgrade date': new Date()
+    *     });
+    *     // properties can be strings, integers, dates, or lists
+    *
+    * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
+    * @param {*} [to] A value to set on the given property name
+    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
+    */
+    MixpanelPeople.prototype.set = addOptOutCheckMixpanelPeople(function(prop, to, callback) {
+        var data = this.set_action(prop, to);
+        if (_.isObject(prop)) {
+            callback = to;
         }
-
-        if (!config['cookie_name'] && config['name'] !== 'mixpanel') {
-            // special case to handle people with cookies of the form
-            // mp_TOKEN_INSTANCENAME from the first release of this library
-            old_cookie_name = 'mp_' + config['token'] + '_' + config['name'];
-            old_cookie = this.storage.parse(old_cookie_name);
-
-            if (old_cookie) {
-                this.storage.remove(old_cookie_name);
-                this.storage.remove(old_cookie_name, true);
-
-                // Save the prop values that were in the cookie from before -
-                // this should only happen once as we delete the old one.
-                this.register_once(old_cookie);
-            }
+        // make sure that the referrer info has been updated and saved
+        if (this._get_config('save_referrer')) {
+            this._mixpanel['persistence'].update_referrer_info(document.referrer);
         }
 
-        if (this.storage === _.localStorage) {
-            old_cookie = _.cookie.parse(this.name);
-
-            _.cookie.remove(this.name);
-            _.cookie.remove(this.name, true);
+        // update $set object with default people properties
+        data[SET_ACTION] = _.extend(
+            {},
+            _.info.people_properties(),
+            this._mixpanel['persistence'].get_referrer_info(),
+            data[SET_ACTION]
+        );
+        return this._send_request(data, callback);
+    });
 
-            if (old_cookie) {
-                this.register_once(old_cookie);
-            }
+    /*
+    * Set properties on a user record, only if they do not yet exist.
+    * This will not overwrite previous people property values, unlike
+    * people.set().
+    *
+    * ### Usage:
+    *
+    *     mixpanel.people.set_once('First Login Date', new Date());
+    *
+    *     // or set multiple properties at once
+    *     mixpanel.people.set_once({
+    *         'First Login Date': new Date(),
+    *         'Starting Plan': 'Premium'
+    *     });
+    *
+    *     // properties can be strings, integers or dates
+    *
+    * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
+    * @param {*} [to] A value to set on the given property name
+    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
+    */
+    MixpanelPeople.prototype.set_once = addOptOutCheckMixpanelPeople(function(prop, to, callback) {
+        var data = this.set_once_action(prop, to);
+        if (_.isObject(prop)) {
+            callback = to;
         }
-    };
+        return this._send_request(data, callback);
+    });
 
-    MixpanelPersistence.prototype.save = function() {
-        if (this.disabled) { return; }
-        this._expire_notification_campaigns();
-        this.storage.set(
-            this.name,
-            _.JSONEncode(this['props']),
-            this.expire_days,
-            this.cross_subdomain,
-            this.secure,
-            this.cross_site,
-            this.cookie_domain
-        );
-    };
-
-    MixpanelPersistence.prototype.remove = function() {
-        // remove both domain and subdomain cookies
-        this.storage.remove(this.name, false, this.cookie_domain);
-        this.storage.remove(this.name, true, this.cookie_domain);
-    };
-
-    // removes the storage entry and deletes all loaded data
-    // forced name for tests
-    MixpanelPersistence.prototype.clear = function() {
-        this.remove();
-        this['props'] = {};
-    };
-
-    /**
-    * @param {Object} props
-    * @param {*=} default_value
-    * @param {number=} days
+    /*
+    * Unset properties on a user record (permanently removes the properties and their values from a profile).
+    *
+    * ### Usage:
+    *
+    *     mixpanel.people.unset('gender');
+    *
+    *     // or unset multiple properties at once
+    *     mixpanel.people.unset(['gender', 'Company']);
+    *
+    * @param {Array|String} prop If a string, this is the name of the property. If an array, this is a list of property names.
+    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
     */
-    MixpanelPersistence.prototype.register_once = function(props, default_value, days) {
-        if (_.isObject(props)) {
-            if (typeof(default_value) === 'undefined') { default_value = 'None'; }
-            this.expire_days = (typeof(days) === 'undefined') ? this.default_expiry : days;
+    MixpanelPeople.prototype.unset = addOptOutCheckMixpanelPeople(function(prop, callback) {
+        var data = this.unset_action(prop);
+        return this._send_request(data, callback);
+    });
 
-            _.each(props, function(val, prop) {
-                if (!this['props'].hasOwnProperty(prop) || this['props'][prop] === default_value) {
-                    this['props'][prop] = val;
+    /*
+    * Increment/decrement numeric people analytics properties.
+    *
+    * ### Usage:
+    *
+    *     mixpanel.people.increment('page_views', 1);
+    *
+    *     // or, for convenience, if you're just incrementing a counter by
+    *     // 1, you can simply do
+    *     mixpanel.people.increment('page_views');
+    *
+    *     // to decrement a counter, pass a negative number
+    *     mixpanel.people.increment('credits_left', -1);
+    *
+    *     // like mixpanel.people.set(), you can increment multiple
+    *     // properties at once:
+    *     mixpanel.people.increment({
+    *         counter1: 1,
+    *         counter2: 6
+    *     });
+    *
+    * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and numeric values.
+    * @param {Number} [by] An amount to increment the given property
+    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
+    */
+    MixpanelPeople.prototype.increment = addOptOutCheckMixpanelPeople(function(prop, by, callback) {
+        var data = {};
+        var $add = {};
+        if (_.isObject(prop)) {
+            _.each(prop, function(v, k) {
+                if (!this._is_reserved_property(k)) {
+                    if (isNaN(parseFloat(v))) {
+                        console.error('Invalid increment value passed to mixpanel.people.increment - must be a number');
+                        return;
+                    } else {
+                        $add[k] = v;
+                    }
                 }
             }, this);
+            callback = by;
+        } else {
+            // convenience: mixpanel.people.increment('property'); will
+            // increment 'property' by 1
+            if (_.isUndefined(by)) {
+                by = 1;
+            }
+            $add[prop] = by;
+        }
+        data[ADD_ACTION] = $add;
 
-            this.save();
+        return this._send_request(data, callback);
+    });
 
-            return true;
+    /*
+    * Append a value to a list-valued people analytics property.
+    *
+    * ### Usage:
+    *
+    *     // append a value to a list, creating it if needed
+    *     mixpanel.people.append('pages_visited', 'homepage');
+    *
+    *     // like mixpanel.people.set(), you can append multiple
+    *     // properties at once:
+    *     mixpanel.people.append({
+    *         list1: 'bob',
+    *         list2: 123
+    *     });
+    *
+    * @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
+    * @param {*} [value] value An item to append to the list
+    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
+    */
+    MixpanelPeople.prototype.append = addOptOutCheckMixpanelPeople(function(list_name, value, callback) {
+        if (_.isObject(list_name)) {
+            callback = value;
         }
-        return false;
-    };
+        var data = this.append_action(list_name, value);
+        return this._send_request(data, callback);
+    });
 
-    /**
-    * @param {Object} props
-    * @param {number=} days
+    /*
+    * Remove a value from a list-valued people analytics property.
+    *
+    * ### Usage:
+    *
+    *     mixpanel.people.remove('School', 'UCB');
+    *
+    * @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
+    * @param {*} [value] value Item to remove from the list
+    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
     */
-    MixpanelPersistence.prototype.register = function(props, days) {
-        if (_.isObject(props)) {
-            this.expire_days = (typeof(days) === 'undefined') ? this.default_expiry : days;
-
-            _.extend(this['props'], props);
-
-            this.save();
-
-            return true;
+    MixpanelPeople.prototype.remove = addOptOutCheckMixpanelPeople(function(list_name, value, callback) {
+        if (_.isObject(list_name)) {
+            callback = value;
         }
-        return false;
-    };
+        var data = this.remove_action(list_name, value);
+        return this._send_request(data, callback);
+    });
 
-    MixpanelPersistence.prototype.unregister = function(prop) {
-        if (prop in this['props']) {
-            delete this['props'][prop];
-            this.save();
+    /*
+    * Merge a given list with a list-valued people analytics property,
+    * excluding duplicate values.
+    *
+    * ### Usage:
+    *
+    *     // merge a value to a list, creating it if needed
+    *     mixpanel.people.union('pages_visited', 'homepage');
+    *
+    *     // like mixpanel.people.set(), you can append multiple
+    *     // properties at once:
+    *     mixpanel.people.union({
+    *         list1: 'bob',
+    *         list2: 123
+    *     });
+    *
+    *     // like mixpanel.people.append(), you can append multiple
+    *     // values to the same list:
+    *     mixpanel.people.union({
+    *         list1: ['bob', 'billy']
+    *     });
+    *
+    * @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
+    * @param {*} [value] Value / values to merge with the given property
+    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
+    */
+    MixpanelPeople.prototype.union = addOptOutCheckMixpanelPeople(function(list_name, values, callback) {
+        if (_.isObject(list_name)) {
+            callback = values;
         }
-    };
+        var data = this.union_action(list_name, values);
+        return this._send_request(data, callback);
+    });
 
-    MixpanelPersistence.prototype._expire_notification_campaigns = _.safewrap(function() {
-        var campaigns_shown = this['props'][CAMPAIGN_IDS_KEY],
-            EXPIRY_TIME = Config.DEBUG ? 60 * 1000 : 60 * 60 * 1000; // 1 minute (Config.DEBUG) / 1 hour (PDXN)
-        if (!campaigns_shown) {
-            return;
-        }
-        for (var campaign_id in campaigns_shown) {
-            if (1 * new Date() - campaigns_shown[campaign_id] > EXPIRY_TIME) {
-                delete campaigns_shown[campaign_id];
+    /*
+     * Record that you have charged the current user a certain amount
+     * of money. Charges recorded with track_charge() will appear in the
+     * Mixpanel revenue report.
+     *
+     * ### Usage:
+     *
+     *     // charge a user $50
+     *     mixpanel.people.track_charge(50);
+     *
+     *     // charge a user $30.50 on the 2nd of january
+     *     mixpanel.people.track_charge(30.50, {
+     *         '$time': new Date('jan 1 2012')
+     *     });
+     *
+     * @param {Number} amount The amount of money charged to the current user
+     * @param {Object} [properties] An associative array of properties associated with the charge
+     * @param {Function} [callback] If provided, the callback will be called when the server responds
+     * @deprecated
+     */
+    MixpanelPeople.prototype.track_charge = addOptOutCheckMixpanelPeople(function(amount, properties, callback) {
+        if (!_.isNumber(amount)) {
+            amount = parseFloat(amount);
+            if (isNaN(amount)) {
+                console.error('Invalid value passed to mixpanel.people.track_charge - must be a number');
+                return;
             }
         }
-        if (_.isEmptyObject(campaigns_shown)) {
-            delete this['props'][CAMPAIGN_IDS_KEY];
-        }
+
+        return this.append('$transactions', _.extend({
+            '$amount': amount
+        }, properties), callback);
     });
 
-    MixpanelPersistence.prototype.update_campaign_params = function() {
-        if (!this.campaign_params_saved) {
-            this.register_once(_.info.campaignParams());
-            this.campaign_params_saved = true;
+    /*
+     * Permanently clear all revenue report transactions from the
+     * current user's people analytics profile.
+     *
+     * ### Usage:
+     *
+     *     mixpanel.people.clear_charges();
+     *
+     * @param {Function} [callback] If provided, the callback will be called after tracking the event.
+     * @deprecated
+     */
+    MixpanelPeople.prototype.clear_charges = function(callback) {
+        return this.set('$transactions', [], callback);
+    };
+
+    /*
+    * Permanently deletes the current people analytics profile from
+    * Mixpanel (using the current distinct_id).
+    *
+    * ### Usage:
+    *
+    *     // remove the all data you have stored about the current user
+    *     mixpanel.people.delete_user();
+    *
+    */
+    MixpanelPeople.prototype.delete_user = function() {
+        if (!this._identify_called()) {
+            console.error('mixpanel.people.delete_user() requires you to call identify() first');
+            return;
         }
+        var data = {'$delete': this._mixpanel.get_distinct_id()};
+        return this._send_request(data);
     };
 
-    MixpanelPersistence.prototype.update_search_keyword = function(referrer) {
-        this.register(_.info.searchInfo(referrer));
+    MixpanelPeople.prototype.toString = function() {
+        return this._mixpanel.toString() + '.people';
     };
 
-    // EXPORTED METHOD, we test this directly.
-    MixpanelPersistence.prototype.update_referrer_info = function(referrer) {
-        // If referrer doesn't exist, we want to note the fact that it was type-in traffic.
-        this.register_once({
-            '$initial_referrer': referrer || '$direct',
-            '$initial_referring_domain': _.info.referringDomain(referrer) || '$direct'
-        }, '');
-    };
+    MixpanelPeople.prototype._send_request = function(data, callback) {
+        data['$token'] = this._get_config('token');
+        data['$distinct_id'] = this._mixpanel.get_distinct_id();
+        var device_id = this._mixpanel.get_property('$device_id');
+        var user_id = this._mixpanel.get_property('$user_id');
+        var had_persisted_distinct_id = this._mixpanel.get_property('$had_persisted_distinct_id');
+        if (device_id) {
+            data['$device_id'] = device_id;
+        }
+        if (user_id) {
+            data['$user_id'] = user_id;
+        }
+        if (had_persisted_distinct_id) {
+            data['$had_persisted_distinct_id'] = had_persisted_distinct_id;
+        }
 
-    MixpanelPersistence.prototype.get_referrer_info = function() {
-        return _.strip_empty_properties({
-            '$initial_referrer': this['props']['$initial_referrer'],
-            '$initial_referring_domain': this['props']['$initial_referring_domain']
-        });
-    };
+        var date_encoded_data = _.encodeDates(data);
 
-    // safely fills the passed in object with stored properties,
-    // does not override any properties defined in both
-    // returns the passed in object
-    MixpanelPersistence.prototype.safe_merge = function(props) {
-        _.each(this['props'], function(val, prop) {
-            if (!(prop in props)) {
-                props[prop] = val;
+        if (!this._identify_called()) {
+            this._enqueue(data);
+            if (!_.isUndefined(callback)) {
+                if (this._get_config('verbose')) {
+                    callback({status: -1, error: null});
+                } else {
+                    callback(-1);
+                }
             }
-        });
+            return _.truncate(date_encoded_data, 255);
+        }
 
-        return props;
+        return this._mixpanel._track_or_batch({
+            type: 'people',
+            data: date_encoded_data,
+            endpoint: this._get_config('api_host') + '/engage/',
+            batcher: this._mixpanel.request_batchers.people
+        }, callback);
     };
 
-    MixpanelPersistence.prototype.update_config = function(config) {
-        this.default_expiry = this.expire_days = config['cookie_expiration'];
-        this.set_disabled(config['disable_persistence']);
-        this.set_cookie_domain(config['cookie_domain']);
-        this.set_cross_site(config['cross_site_cookie']);
-        this.set_cross_subdomain(config['cross_subdomain_cookie']);
-        this.set_secure(config['secure_cookie']);
+    MixpanelPeople.prototype._get_config = function(conf_var) {
+        return this._mixpanel.get_config(conf_var);
     };
 
-    MixpanelPersistence.prototype.set_disabled = function(disabled) {
-        this.disabled = disabled;
-        if (this.disabled) {
-            this.remove();
+    MixpanelPeople.prototype._identify_called = function() {
+        return this._mixpanel._flags.identify_called === true;
+    };
+
+    // Queue up engage operations if identify hasn't been called yet.
+    MixpanelPeople.prototype._enqueue = function(data) {
+        if (SET_ACTION in data) {
+            this._mixpanel['persistence']._add_to_people_queue(SET_ACTION, data);
+        } else if (SET_ONCE_ACTION in data) {
+            this._mixpanel['persistence']._add_to_people_queue(SET_ONCE_ACTION, data);
+        } else if (UNSET_ACTION in data) {
+            this._mixpanel['persistence']._add_to_people_queue(UNSET_ACTION, data);
+        } else if (ADD_ACTION in data) {
+            this._mixpanel['persistence']._add_to_people_queue(ADD_ACTION, data);
+        } else if (APPEND_ACTION in data) {
+            this._mixpanel['persistence']._add_to_people_queue(APPEND_ACTION, data);
+        } else if (REMOVE_ACTION in data) {
+            this._mixpanel['persistence']._add_to_people_queue(REMOVE_ACTION, data);
+        } else if (UNION_ACTION in data) {
+            this._mixpanel['persistence']._add_to_people_queue(UNION_ACTION, data);
         } else {
-            this.save();
+            console.error('Invalid call to _enqueue():', data);
         }
     };
 
-    MixpanelPersistence.prototype.set_cookie_domain = function(cookie_domain) {
-        if (cookie_domain !== this.cookie_domain) {
-            this.remove();
-            this.cookie_domain = cookie_domain;
-            this.save();
+    MixpanelPeople.prototype._flush_one_queue = function(action, action_method, callback, queue_to_params_fn) {
+        var _this = this;
+        var queued_data = _.extend({}, this._mixpanel['persistence']._get_queue(action));
+        var action_params = queued_data;
+
+        if (!_.isUndefined(queued_data) && _.isObject(queued_data) && !_.isEmptyObject(queued_data)) {
+            _this._mixpanel['persistence']._pop_from_people_queue(action, queued_data);
+            if (queue_to_params_fn) {
+                action_params = queue_to_params_fn(queued_data);
+            }
+            action_method.call(_this, action_params, function(response, data) {
+                // on bad response, we want to add it back to the queue
+                if (response === 0) {
+                    _this._mixpanel['persistence']._add_to_people_queue(action, queued_data);
+                }
+                if (!_.isUndefined(callback)) {
+                    callback(response, data);
+                }
+            });
         }
     };
 
-    MixpanelPersistence.prototype.set_cross_site = function(cross_site) {
-        if (cross_site !== this.cross_site) {
-            this.cross_site = cross_site;
-            this.remove();
-            this.save();
+    // Flush queued engage operations - order does not matter,
+    // and there are network level race conditions anyway
+    MixpanelPeople.prototype._flush = function(
+        _set_callback, _add_callback, _append_callback, _set_once_callback, _union_callback, _unset_callback, _remove_callback
+    ) {
+        var _this = this;
+        var $append_queue = this._mixpanel['persistence']._get_queue(APPEND_ACTION);
+        var $remove_queue = this._mixpanel['persistence']._get_queue(REMOVE_ACTION);
+
+        this._flush_one_queue(SET_ACTION, this.set, _set_callback);
+        this._flush_one_queue(SET_ONCE_ACTION, this.set_once, _set_once_callback);
+        this._flush_one_queue(UNSET_ACTION, this.unset, _unset_callback, function(queue) { return _.keys(queue); });
+        this._flush_one_queue(ADD_ACTION, this.increment, _add_callback);
+        this._flush_one_queue(UNION_ACTION, this.union, _union_callback);
+
+        // we have to fire off each $append individually since there is
+        // no concat method server side
+        if (!_.isUndefined($append_queue) && _.isArray($append_queue) && $append_queue.length) {
+            var $append_item;
+            var append_callback = function(response, data) {
+                if (response === 0) {
+                    _this._mixpanel['persistence']._add_to_people_queue(APPEND_ACTION, $append_item);
+                }
+                if (!_.isUndefined(_append_callback)) {
+                    _append_callback(response, data);
+                }
+            };
+            for (var i = $append_queue.length - 1; i >= 0; i--) {
+                $append_item = $append_queue.pop();
+                if (!_.isEmptyObject($append_item)) {
+                    _this.append($append_item, append_callback);
+                }
+            }
+            // Save the shortened append queue
+            _this._mixpanel['persistence'].save();
         }
-    };
 
-    MixpanelPersistence.prototype.set_cross_subdomain = function(cross_subdomain) {
-        if (cross_subdomain !== this.cross_subdomain) {
-            this.cross_subdomain = cross_subdomain;
-            this.remove();
-            this.save();
+        // same for $remove
+        if (!_.isUndefined($remove_queue) && _.isArray($remove_queue) && $remove_queue.length) {
+            var $remove_item;
+            var remove_callback = function(response, data) {
+                if (response === 0) {
+                    _this._mixpanel['persistence']._add_to_people_queue(REMOVE_ACTION, $remove_item);
+                }
+                if (!_.isUndefined(_remove_callback)) {
+                    _remove_callback(response, data);
+                }
+            };
+            for (var j = $remove_queue.length - 1; j >= 0; j--) {
+                $remove_item = $remove_queue.pop();
+                if (!_.isEmptyObject($remove_item)) {
+                    _this.remove($remove_item, remove_callback);
+                }
+            }
+            _this._mixpanel['persistence'].save();
         }
     };
 
-    MixpanelPersistence.prototype.get_cross_subdomain = function() {
-        return this.cross_subdomain;
+    MixpanelPeople.prototype._is_reserved_property = function(prop) {
+        return prop === '$distinct_id' || prop === '$token' || prop === '$device_id' || prop === '$user_id' || prop === '$had_persisted_distinct_id';
     };
 
-    MixpanelPersistence.prototype.set_secure = function(secure) {
-        if (secure !== this.secure) {
-            this.secure = secure ? true : false;
-            this.remove();
-            this.save();
+    // MixpanelPeople Exports
+    MixpanelPeople.prototype['set']           = MixpanelPeople.prototype.set;
+    MixpanelPeople.prototype['set_once']      = MixpanelPeople.prototype.set_once;
+    MixpanelPeople.prototype['unset']         = MixpanelPeople.prototype.unset;
+    MixpanelPeople.prototype['increment']     = MixpanelPeople.prototype.increment;
+    MixpanelPeople.prototype['append']        = MixpanelPeople.prototype.append;
+    MixpanelPeople.prototype['remove']        = MixpanelPeople.prototype.remove;
+    MixpanelPeople.prototype['union']         = MixpanelPeople.prototype.union;
+    MixpanelPeople.prototype['track_charge']  = MixpanelPeople.prototype.track_charge;
+    MixpanelPeople.prototype['clear_charges'] = MixpanelPeople.prototype.clear_charges;
+    MixpanelPeople.prototype['delete_user']   = MixpanelPeople.prototype.delete_user;
+    MixpanelPeople.prototype['toString']      = MixpanelPeople.prototype.toString;
+
+    /*
+     * Constants
+     */
+    /** @const */ var SET_QUEUE_KEY          = '__mps';
+    /** @const */ var SET_ONCE_QUEUE_KEY     = '__mpso';
+    /** @const */ var UNSET_QUEUE_KEY        = '__mpus';
+    /** @const */ var ADD_QUEUE_KEY          = '__mpa';
+    /** @const */ var APPEND_QUEUE_KEY       = '__mpap';
+    /** @const */ var REMOVE_QUEUE_KEY       = '__mpr';
+    /** @const */ var UNION_QUEUE_KEY        = '__mpu';
+    // This key is deprecated, but we want to check for it to see whether aliasing is allowed.
+    /** @const */ var PEOPLE_DISTINCT_ID_KEY = '$people_distinct_id';
+    /** @const */ var ALIAS_ID_KEY           = '__alias';
+    /** @const */ var EVENT_TIMERS_KEY       = '__timers';
+    /** @const */ var RESERVED_PROPERTIES = [
+        SET_QUEUE_KEY,
+        SET_ONCE_QUEUE_KEY,
+        UNSET_QUEUE_KEY,
+        ADD_QUEUE_KEY,
+        APPEND_QUEUE_KEY,
+        REMOVE_QUEUE_KEY,
+        UNION_QUEUE_KEY,
+        PEOPLE_DISTINCT_ID_KEY,
+        ALIAS_ID_KEY,
+        EVENT_TIMERS_KEY
+    ];
+
+    /**
+     * Mixpanel Persistence Object
+     * @constructor
+     */
+    var MixpanelPersistence = function(config) {
+        this['props'] = {};
+        this.campaign_params_saved = false;
+
+        if (config['persistence_name']) {
+            this.name = 'mp_' + config['persistence_name'];
+        } else {
+            this.name = 'mp_' + config['token'] + '_mixpanel';
         }
-    };
 
-    MixpanelPersistence.prototype._add_to_people_queue = function(queue, data) {
-        var q_key = this._get_queue_key(queue),
-            q_data = data[queue],
-            set_q = this._get_or_create_queue(SET_ACTION),
-            set_once_q = this._get_or_create_queue(SET_ONCE_ACTION),
-            unset_q = this._get_or_create_queue(UNSET_ACTION),
-            add_q = this._get_or_create_queue(ADD_ACTION),
-            union_q = this._get_or_create_queue(UNION_ACTION),
-            remove_q = this._get_or_create_queue(REMOVE_ACTION, []),
-            append_q = this._get_or_create_queue(APPEND_ACTION, []);
+        var storage_type = config['persistence'];
+        if (storage_type !== 'cookie' && storage_type !== 'localStorage') {
+            console.critical('Unknown persistence type ' + storage_type + '; falling back to cookie');
+            storage_type = config['persistence'] = 'cookie';
+        }
 
-        if (q_key === SET_QUEUE_KEY) {
-            // Update the set queue - we can override any existing values
-            _.extend(set_q, q_data);
-            // if there was a pending increment, override it
-            // with the set.
-            this._pop_from_people_queue(ADD_ACTION, q_data);
-            // if there was a pending union, override it
-            // with the set.
-            this._pop_from_people_queue(UNION_ACTION, q_data);
-            this._pop_from_people_queue(UNSET_ACTION, q_data);
-        } else if (q_key === SET_ONCE_QUEUE_KEY) {
-            // only queue the data if there is not already a set_once call for it.
-            _.each(q_data, function(v, k) {
-                if (!(k in set_once_q)) {
-                    set_once_q[k] = v;
-                }
-            });
-            this._pop_from_people_queue(UNSET_ACTION, q_data);
-        } else if (q_key === UNSET_QUEUE_KEY) {
-            _.each(q_data, function(prop) {
-
-                // undo previously-queued actions on this key
-                _.each([set_q, set_once_q, add_q, union_q], function(enqueued_obj) {
-                    if (prop in enqueued_obj) {
-                        delete enqueued_obj[prop];
-                    }
-                });
-                _.each(append_q, function(append_obj) {
-                    if (prop in append_obj) {
-                        delete append_obj[prop];
-                    }
-                });
-
-                unset_q[prop] = true;
-
-            });
-        } else if (q_key === ADD_QUEUE_KEY) {
-            _.each(q_data, function(v, k) {
-                // If it exists in the set queue, increment
-                // the value
-                if (k in set_q) {
-                    set_q[k] += v;
-                } else {
-                    // If it doesn't exist, update the add
-                    // queue
-                    if (!(k in add_q)) {
-                        add_q[k] = 0;
-                    }
-                    add_q[k] += v;
-                }
-            }, this);
-            this._pop_from_people_queue(UNSET_ACTION, q_data);
-        } else if (q_key === UNION_QUEUE_KEY) {
-            _.each(q_data, function(v, k) {
-                if (_.isArray(v)) {
-                    if (!(k in union_q)) {
-                        union_q[k] = [];
-                    }
-                    // We may send duplicates, the server will dedup them.
-                    union_q[k] = union_q[k].concat(v);
-                }
-            });
-            this._pop_from_people_queue(UNSET_ACTION, q_data);
-        } else if (q_key === REMOVE_QUEUE_KEY) {
-            remove_q.push(q_data);
-            this._pop_from_people_queue(APPEND_ACTION, q_data);
-        } else if (q_key === APPEND_QUEUE_KEY) {
-            append_q.push(q_data);
-            this._pop_from_people_queue(UNSET_ACTION, q_data);
-        }
-
-        console.log('MIXPANEL PEOPLE REQUEST (QUEUED, PENDING IDENTIFY):');
-        console.log(data);
-
-        this.save();
-    };
-
-    MixpanelPersistence.prototype._pop_from_people_queue = function(queue, data) {
-        var q = this._get_queue(queue);
-        if (!_.isUndefined(q)) {
-            _.each(data, function(v, k) {
-                if (queue === APPEND_ACTION || queue === REMOVE_ACTION) {
-                    // list actions: only remove if both k+v match
-                    // e.g. remove should not override append in a case like
-                    // append({foo: 'bar'}); remove({foo: 'qux'})
-                    _.each(q, function(queued_action) {
-                        if (queued_action[k] === v) {
-                            delete queued_action[k];
-                        }
-                    });
-                } else {
-                    delete q[k];
-                }
-            }, this);
-
-            this.save();
-        }
-    };
-
-    MixpanelPersistence.prototype._get_queue_key = function(queue) {
-        if (queue === SET_ACTION) {
-            return SET_QUEUE_KEY;
-        } else if (queue === SET_ONCE_ACTION) {
-            return SET_ONCE_QUEUE_KEY;
-        } else if (queue === UNSET_ACTION) {
-            return UNSET_QUEUE_KEY;
-        } else if (queue === ADD_ACTION) {
-            return ADD_QUEUE_KEY;
-        } else if (queue === APPEND_ACTION) {
-            return APPEND_QUEUE_KEY;
-        } else if (queue === REMOVE_ACTION) {
-            return REMOVE_QUEUE_KEY;
-        } else if (queue === UNION_ACTION) {
-            return UNION_QUEUE_KEY;
+        if (storage_type === 'localStorage' && _.localStorage.is_supported()) {
+            this.storage = _.localStorage;
         } else {
-            console.error('Invalid queue:', queue);
+            this.storage = _.cookie;
         }
-    };
-
-    MixpanelPersistence.prototype._get_queue = function(queue) {
-        return this['props'][this._get_queue_key(queue)];
-    };
-    MixpanelPersistence.prototype._get_or_create_queue = function(queue, default_val) {
-        var key = this._get_queue_key(queue);
-        default_val = _.isUndefined(default_val) ? {} : default_val;
 
-        return this['props'][key] || (this['props'][key] = default_val);
-    };
-
-    MixpanelPersistence.prototype.set_event_timer = function(event_name, timestamp) {
-        var timers = this['props'][EVENT_TIMERS_KEY] || {};
-        timers[event_name] = timestamp;
-        this['props'][EVENT_TIMERS_KEY] = timers;
+        this.load();
+        this.update_config(config);
+        this.upgrade(config);
         this.save();
     };
 
-    MixpanelPersistence.prototype.remove_event_timer = function(event_name) {
-        var timers = this['props'][EVENT_TIMERS_KEY] || {};
-        var timestamp = timers[event_name];
-        if (!_.isUndefined(timestamp)) {
-            delete this['props'][EVENT_TIMERS_KEY][event_name];
-            this.save();
-        }
-        return timestamp;
+    MixpanelPersistence.prototype.properties = function() {
+        var p = {};
+        // Filter out reserved properties
+        _.each(this['props'], function(v, k) {
+            if (!_.include(RESERVED_PROPERTIES, k)) {
+                p[k] = v;
+            }
+        });
+        return p;
     };
 
-    /*
-     * This file is a js implementation for a subset in eval_node.c
-     */
+    MixpanelPersistence.prototype.load = function() {
+        if (this.disabled) { return; }
 
-    /*
-     * Constants
-     */
-    // Metadata keys
-    /** @const */   var OPERATOR_KEY                  = 'operator';
-    /** @const */   var PROPERTY_KEY                  = 'property';
-    /** @const */   var WINDOW_KEY                    = 'window';
-    /** @const */   var UNIT_KEY                      = 'unit';
-    /** @const */   var VALUE_KEY                     = 'value';
-    /** @const */   var HOUR_KEY                      = 'hour';
-    /** @const */   var DAY_KEY                       = 'day';
-    /** @const */   var WEEK_KEY                      = 'week';
-    /** @const */   var MONTH_KEY                     = 'month';
-
-    // Operands
-    /** @const */   var EVENT_PROPERTY         = 'event';
-    /** @const */   var LITERAL_PROPERTY       = 'literal';
-
-    // Binary Operators
-    /** @const */   var AND_OPERATOR           = 'and';
-    /** @const */   var OR_OPERATOR            = 'or';
-    /** @const */   var IN_OPERATOR            = 'in';
-    /** @const */   var NOT_IN_OPERATOR        = 'not in';
-    /** @const */   var PLUS_OPERATOR          = '+';
-    /** @const */   var MINUS_OPERATOR         = '-';
-    /** @const */   var MUL_OPERATOR           = '*';
-    /** @const */   var DIV_OPERATOR           = '/';
-    /** @const */   var MOD_OPERATOR           = '%';
-    /** @const */   var EQUALS_OPERATOR        = '==';
-    /** @const */   var NOT_EQUALS_OPERATOR    = '!=';
-    /** @const */   var GREATER_OPERATOR       = '>';
-    /** @const */   var LESS_OPERATOR          = '<';
-    /** @const */   var GREATER_EQUAL_OPERATOR = '>=';
-    /** @const */   var LESS_EQUAL_OPERATOR    = '<=';
-
-    // Typecast Operators
-    /** @const */   var BOOLEAN_OPERATOR       = 'boolean';
-    /** @const */   var DATETIME_OPERATOR      = 'datetime';
-    /** @const */   var LIST_OPERATOR          = 'list';
-    /** @const */   var NUMBER_OPERATOR        = 'number';
-    /** @const */   var STRING_OPERATOR        = 'string';
-
-    // Unary Operators
-    /** @const */   var NOT_OPERATOR           = 'not';
-    /** @const */   var DEFINED_OPERATOR       = 'defined';
-    /** @const */   var NOT_DEFINED_OPERATOR   = 'not defined';
-
-    // Special literals
-    /** @const */   var NOW_LITERAL            = 'now';
-
-    // Type cast functions
-    function toNumber(value) {
-        if (value === null) {
-            return null;
-        }
+        var entry = this.storage.parse(this.name);
 
-        switch (typeof(value)) {
-            case 'object':
-                if (_.isDate(value) && value.getTime() >= 0) {
-                    return value.getTime();
-                }
-                return null;
-            case 'boolean':
-                return Number(value);
-            case 'number':
-                return value;
-            case 'string':
-                value = Number(value);
-                if (!isNaN(value)) {
-                    return value;
-                }
-                return 0;
+        if (entry) {
+            this['props'] = _.extend({}, entry);
         }
-        return null;
-    }
+    };
 
-    function evaluateNumber(op, properties) {
-        if (!op['operator'] || op['operator'] !== NUMBER_OPERATOR || !op['children'] || op['children'].length !== 1) {
-            throw ('Invalid cast operator: number ' + op);
-        }
+    MixpanelPersistence.prototype.upgrade = function(config) {
+        var upgrade_from_old_lib = config['upgrade'],
+            old_cookie_name,
+            old_cookie;
 
-        return toNumber(evaluateSelector(op['children'][0], properties));
-    }
+        if (upgrade_from_old_lib) {
+            old_cookie_name = 'mp_super_properties';
+            // Case where they had a custom cookie name before.
+            if (typeof(upgrade_from_old_lib) === 'string') {
+                old_cookie_name = upgrade_from_old_lib;
+            }
 
-    function toBoolean(value) {
-        if (value === null) {
-            return false;
-        }
+            old_cookie = this.storage.parse(old_cookie_name);
 
-        switch (typeof value) {
-            case 'boolean':
-                return value;
-            case 'number':
-                return value !== 0.0;
-            case 'string':
-                return value.length > 0;
-            case 'object':
-                if (_.isArray(value) && value.length > 0) {
-                    return true;
-                }
-                if (_.isDate(value) && value.getTime() > 0) {
-                    return true;
-                }
-                if (_.isObject(value) && !_.isEmptyObject(value)) {
-                    return true;
-                }
-                return false;
-        }
-        return false;
-    }
+            // remove the cookie
+            this.storage.remove(old_cookie_name);
+            this.storage.remove(old_cookie_name, true);
 
-    function evaluateBoolean(op, properties) {
-        if (!op['operator'] || op['operator'] !== BOOLEAN_OPERATOR || !op['children'] || op['children'].length !== 1) {
-            throw ('Invalid cast operator: boolean ' + op);
+            if (old_cookie) {
+                this['props'] = _.extend(
+                    this['props'],
+                    old_cookie['all'],
+                    old_cookie['events']
+                );
+            }
         }
 
-        return toBoolean(evaluateSelector(op['children'][0], properties));
-    }
-
-    function evaluateDateTime(op, properties) {
-        if (!op['operator'] || op['operator'] !== DATETIME_OPERATOR || !op['children'] || op['children'].length !== 1) {
-            throw ('Invalid cast operator: datetime ' + op);
-        }
+        if (!config['cookie_name'] && config['name'] !== 'mixpanel') {
+            // special case to handle people with cookies of the form
+            // mp_TOKEN_INSTANCENAME from the first release of this library
+            old_cookie_name = 'mp_' + config['token'] + '_' + config['name'];
+            old_cookie = this.storage.parse(old_cookie_name);
 
-        var v = evaluateSelector(op['children'][0], properties);
-        if (v === null) {
-            return null;
-        }
+            if (old_cookie) {
+                this.storage.remove(old_cookie_name);
+                this.storage.remove(old_cookie_name, true);
 
-        switch (typeof(v)) {
-            case 'number':
-            case 'string':
-                var d = new Date(v);
-                if (isNaN(d.getTime())) {
-                    return null;
-                }
-                return d;
-            case 'object':
-                if (_.isDate(v)) {
-                    return v;
-                }
+                // Save the prop values that were in the cookie from before -
+                // this should only happen once as we delete the old one.
+                this.register_once(old_cookie);
+            }
         }
 
-        return null;
-    }
+        if (this.storage === _.localStorage) {
+            old_cookie = _.cookie.parse(this.name);
 
-    function evaluateList(op, properties) {
-        if (!op['operator'] || op['operator'] !== LIST_OPERATOR || !op['children'] || op['children'].length !== 1) {
-            throw ('Invalid cast operator: list ' + op);
-        }
+            _.cookie.remove(this.name);
+            _.cookie.remove(this.name, true);
 
-        var v = evaluateSelector(op['children'][0], properties);
-        if (v === null) {
-            return null;
+            if (old_cookie) {
+                this.register_once(old_cookie);
+            }
         }
+    };
 
-        if (_.isArray(v)) {
-            return v;
-        }
+    MixpanelPersistence.prototype.save = function() {
+        if (this.disabled) { return; }
+        this.storage.set(
+            this.name,
+            _.JSONEncode(this['props']),
+            this.expire_days,
+            this.cross_subdomain,
+            this.secure,
+            this.cross_site,
+            this.cookie_domain
+        );
+    };
 
-        return null;
-    }
+    MixpanelPersistence.prototype.remove = function() {
+        // remove both domain and subdomain cookies
+        this.storage.remove(this.name, false, this.cookie_domain);
+        this.storage.remove(this.name, true, this.cookie_domain);
+    };
 
-    function evaluateString(op, properties) {
-        if (!op['operator'] || op['operator'] !== STRING_OPERATOR || !op['children'] || op['children'].length !== 1) {
-            throw ('Invalid cast operator: string ' + op);
-        }
+    // removes the storage entry and deletes all loaded data
+    // forced name for tests
+    MixpanelPersistence.prototype.clear = function() {
+        this.remove();
+        this['props'] = {};
+    };
 
-        var v = evaluateSelector(op['children'][0], properties);
-        switch (typeof(v)) {
-            case 'object':
-                if (_.isDate(v)) {
-                    return v.toJSON();
-                }
-                return JSON.stringify(v);
-        }
-        return String(v);
-    }
-
-    // Operators
-    function evaluateAnd(op, properties) {
-        if (!op['operator'] || op['operator'] !== AND_OPERATOR || !op['children'] || op['children'].length !== 2) {
-            throw ('Invalid operator: AND ' + op);
-        }
-
-        return toBoolean(evaluateSelector(op['children'][0], properties)) && toBoolean(evaluateSelector(op['children'][1], properties));
-    }
-
-    function evaluateOr(op, properties) {
-        if (!op['operator'] || op['operator'] !== OR_OPERATOR || !op['children'] || op['children'].length !== 2) {
-            throw ('Invalid operator: OR ' + op);
-        }
-
-        return toBoolean(evaluateSelector(op['children'][0], properties)) || toBoolean(evaluateSelector(op['children'][1], properties));
-    }
-
-    function evaluateIn(op, properties) {
-        if (!op['operator'] || [IN_OPERATOR, NOT_IN_OPERATOR].indexOf(op['operator']) === -1 || !op['children'] || op['children'].length !== 2) {
-            throw ('Invalid operator: IN/NOT IN ' + op);
-        }
-        var leftValue = evaluateSelector(op['children'][0], properties);
-        var rightValue = evaluateSelector(op['children'][1], properties);
-
-        if (!_.isArray(rightValue) && !_.isString(rightValue)) {
-            throw ('Invalid operand for operator IN: invalid type' + rightValue);
-        }
-
-        var v = rightValue.indexOf(leftValue) > -1;
-        if (op['operator'] === NOT_IN_OPERATOR) {
-            return !v;
-        }
-        return v;
-    }
-
-    function evaluatePlus(op, properties) {
-        if (!op['operator'] || op['operator'] !== PLUS_OPERATOR || !op['children'] || op['children'].length < 2) {
-            throw ('Invalid operator: PLUS ' + op);
-        }
-        var l = evaluateSelector(op['children'][0], properties);
-        var r = evaluateSelector(op['children'][1], properties);
-
-        if (typeof l === 'number' && typeof r === 'number') {
-            return l + r;
-        }
-        if (typeof l === 'string' && typeof r === 'string') {
-            return l + r;
-        }
-        return null;
-    }
-
-    function evaluateArithmetic(op, properties) {
-        if (!op['operator'] || [MINUS_OPERATOR, MUL_OPERATOR, DIV_OPERATOR, MOD_OPERATOR].indexOf(op['operator']) === -1 ||
-            !op['children'] || op['children'].length < 2) {
-            throw ('Invalid arithmetic operator ' + op);
-        }
-
-        var l = evaluateSelector(op['children'][0], properties);
-        var r = evaluateSelector(op['children'][1], properties);
-
-        if (typeof l === 'number' && typeof r === 'number') {
-            switch (op['operator']) {
-                case MINUS_OPERATOR:
-                    return l - r;
-                case MUL_OPERATOR:
-                    return l * r;
-                case DIV_OPERATOR:
-                    if (r !== 0) {
-                        return l / r;
-                    }
-                    return null;
-                case MOD_OPERATOR:
-                    if (r === 0) {
-                        return null;
-                    }
-                    if (l === 0) {
-                        return 0;
-                    }
-                    if ((l < 0 && r > 0) || (l > 0 && r < 0)) {
-                        /* Mimic python modulo - result takes sign of the divisor
-                         * if one operand is negative. */
-                        return -(Math.floor(l / r) * r - l);
-                    }
-                    return l % r;
-                default:
-                    throw('Unknown operator: ' + op['operator']);
-            }
-        }
-
-        return null;
-    }
-
-    function _isArrayEqual(l, r) {
-        if (l === r) return true;
-        if (l === null || r === null) return false;
-        if (l.length !== r.length) return false;
+    /**
+    * @param {Object} props
+    * @param {*=} default_value
+    * @param {number=} days
+    */
+    MixpanelPersistence.prototype.register_once = function(props, default_value, days) {
+        if (_.isObject(props)) {
+            if (typeof(default_value) === 'undefined') { default_value = 'None'; }
+            this.expire_days = (typeof(days) === 'undefined') ? this.default_expiry : days;
 
-        for (var i = 0; i < l.length; i++) {
-            if (l[i] !== r[i]) {
-                return false;
-            }
-        }
+            _.each(props, function(val, prop) {
+                if (!this['props'].hasOwnProperty(prop) || this['props'][prop] === default_value) {
+                    this['props'][prop] = val;
+                }
+            }, this);
 
-        return true;
-    }
+            this.save();
 
-    function _isEqual(l, r) {
-        if ( l === null && l === r ) {
             return true;
         }
-        if (typeof l === typeof r) {
-            switch (typeof l) {
-                case 'number':
-                case 'string':
-                case 'boolean':
-                    return l === r;
-                case 'object':
-                    if (_.isArray(l) && _.isArray(r)) {
-                        return _isArrayEqual(l, r);
-                    }
-                    if (_.isDate(l) && _.isDate(r)) {
-                        return l.getTime() === r.getTime();
-                    }
-                    if (_.isObject(l) && _.isObject(r)) {
-                        return JSON.stringify(l) === JSON.stringify(r);
-                    }
-            }
-        }
         return false;
-    }
-
-    function evaluateEquality(op, properties) {
-        if (!op['operator'] || [EQUALS_OPERATOR, NOT_EQUALS_OPERATOR].indexOf(op['operator']) === -1 || !op['children'] || op['children'].length !== 2) {
-            throw ('Invalid equality operator ' + op);
-        }
-
-        var v = _isEqual(evaluateSelector(op['children'][0], properties), evaluateSelector(op['children'][1], properties));
-
-        switch (op['operator']) {
-            case EQUALS_OPERATOR:
-                return v;
-            case NOT_EQUALS_OPERATOR:
-                return !v;
-        }
-    }
-
-    function evaluateComparison(op, properties) {
-        if (!op['operator'] ||
-            [GREATER_OPERATOR, GREATER_EQUAL_OPERATOR, LESS_OPERATOR, LESS_EQUAL_OPERATOR].indexOf(op['operator']) === -1 ||
-            !op['children'] || op['children'].length !== 2) {
-            throw ('Invalid comparison operator ' + op);
-        }
-        var l = evaluateSelector(op['children'][0], properties);
-        var r = evaluateSelector(op['children'][1], properties);
-
-        if (typeof(l) === typeof(r)) {
-            if (typeof(r) === 'number' || _.isDate(r)) {
-                l = toNumber(l);
-                r = toNumber(r);
-                switch (op['operator']) {
-                    case GREATER_OPERATOR:
-                        return l > r;
-                    case GREATER_EQUAL_OPERATOR:
-                        return l >= r;
-                    case LESS_OPERATOR:
-                        return l < r;
-                    case LESS_EQUAL_OPERATOR:
-                        return l <= r;
-                }
-            } else if (typeof(r) === 'string') {
-                var compare = l.localeCompare(r);
-                switch (op['operator']) {
-                    case GREATER_OPERATOR:
-                        return compare > 0;
-                    case GREATER_EQUAL_OPERATOR:
-                        return compare >= 0;
-                    case LESS_OPERATOR:
-                        return compare < 0;
-                    case LESS_EQUAL_OPERATOR:
-                        return compare <= 0;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    function evaluateDefined(op, properties) {
-        if (!op['operator'] || [DEFINED_OPERATOR, NOT_DEFINED_OPERATOR].indexOf(op['operator']) === -1 ||
-            !op['children'] || op['children'].length !== 1) {
-            throw ('Invalid defined/not defined operator: ' + op);
-        }
+    };
 
-        var b = evaluateSelector(op['children'][0], properties) !== null;
-        if (op['operator'] === NOT_DEFINED_OPERATOR) {
-            return !b;
-        }
+    /**
+    * @param {Object} props
+    * @param {number=} days
+    */
+    MixpanelPersistence.prototype.register = function(props, days) {
+        if (_.isObject(props)) {
+            this.expire_days = (typeof(days) === 'undefined') ? this.default_expiry : days;
 
-        return b;
-    }
+            _.extend(this['props'], props);
 
-    function evaluateNot(op, properties) {
-        if (!op['operator'] || op['operator'] !== NOT_OPERATOR || !op['children'] || op['children'].length !== 1) {
-            throw ('Invalid not operator: ' + op);
-        }
+            this.save();
 
-        var v = evaluateSelector(op['children'][0], properties);
-        if (v === null) {
             return true;
         }
+        return false;
+    };
 
-        if (typeof(v) === 'boolean') {
-            return !v;
-        }
-
-        return null;
-    }
-
-    function evaluateOperator(op, properties) {
-        if (!op['operator']) {
-            throw ('Invalid operator: operator key missing ' + op);
-        }
-
-        switch (op['operator']) {
-            case AND_OPERATOR:
-                return evaluateAnd(op, properties);
-            case OR_OPERATOR:
-                return evaluateOr(op, properties);
-            case IN_OPERATOR:
-            case NOT_IN_OPERATOR:
-                return evaluateIn(op, properties);
-            case PLUS_OPERATOR:
-                return evaluatePlus(op, properties);
-            case MINUS_OPERATOR:
-            case MUL_OPERATOR:
-            case DIV_OPERATOR:
-            case MOD_OPERATOR:
-                return evaluateArithmetic(op, properties);
-            case EQUALS_OPERATOR:
-            case NOT_EQUALS_OPERATOR:
-                return evaluateEquality(op, properties);
-            case GREATER_OPERATOR:
-            case LESS_OPERATOR:
-            case GREATER_EQUAL_OPERATOR:
-            case LESS_EQUAL_OPERATOR:
-                return evaluateComparison(op, properties);
-            case BOOLEAN_OPERATOR:
-                return evaluateBoolean(op, properties);
-            case DATETIME_OPERATOR:
-                return evaluateDateTime(op, properties);
-            case LIST_OPERATOR:
-                return evaluateList(op, properties);
-            case NUMBER_OPERATOR:
-                return evaluateNumber(op, properties);
-            case STRING_OPERATOR:
-                return evaluateString(op, properties);
-            case DEFINED_OPERATOR:
-            case NOT_DEFINED_OPERATOR:
-                return evaluateDefined(op, properties);
-            case NOT_OPERATOR:
-                return evaluateNot(op, properties);
-        }
-    }
-
-    function evaluateWindow(value) {
-        var win = value[WINDOW_KEY];
-        if (!win || !win[UNIT_KEY] || !win[VALUE_KEY]) {
-            throw('Invalid window: missing required keys ' + JSON.stringify(value));
-        }
-        var out = new Date();
-        switch (win[UNIT_KEY]) {
-            case HOUR_KEY:
-                out.setTime(out.getTime() + (win[VALUE_KEY]*-1*60*60*1000));
-                break;
-            case DAY_KEY:
-                out.setTime(out.getTime() + (win[VALUE_KEY]*-1*24*60*60*1000));
-                break;
-            case WEEK_KEY:
-                out.setTime(out.getTime() + (win[VALUE_KEY]*-1*7*24*60*60*1000));
-                break;
-            case MONTH_KEY:
-                out.setTime(out.getTime() + (win[VALUE_KEY]*-1*30*24*60*60*1000));
-                break;
-            default:
-                throw('Invalid unit: ' + win[UNIT_KEY]);
-        }
-
-        return out;
-    }
-
-    function evaluateOperand(op, properties) {
-        if (!op['property'] || !op['value']) {
-            throw('Invalid operand: missing required keys ' + op);
-        }
-        switch (op['property']) {
-            case EVENT_PROPERTY:
-                if (properties[op['value']] !== undefined) {
-                    return properties[op['value']];
-                }
-                return null;
-            case LITERAL_PROPERTY:
-                if (op['value'] === NOW_LITERAL) {
-                    return new Date();
-                }
-                if (typeof(op['value']) === 'object') {
-                    return evaluateWindow(op['value']);
-                }
-                return op['value'];
-            default:
-                throw('Invalid operand: Invalid property type ' + op['property']);
-        }
-    }
-
-    function evaluateSelector(filters, properties) {
-        if (filters[PROPERTY_KEY]) {
-            return evaluateOperand(filters, properties);
-        }
-        if (filters[OPERATOR_KEY]) {
-            return evaluateOperator(filters, properties);
-        }
-    }
-
-    // Internal class for notification display
-
-    var MixpanelNotification = function(notif_data, mixpanel_instance) {
-        _.bind_instance_methods(this);
-
-        this.mixpanel          = mixpanel_instance;
-        this.persistence       = this.mixpanel['persistence'];
-        this.resource_protocol = this.mixpanel.get_config('inapp_protocol');
-        this.cdn_host          = this.mixpanel.get_config('cdn');
-
-        this.campaign_id = _.escapeHTML(notif_data['id']);
-        this.message_id  = _.escapeHTML(notif_data['message_id']);
-
-        this.body            = (_.escapeHTML(notif_data['body']) || '').replace(/\n/g, '<br/>');
-        this.cta             = _.escapeHTML(notif_data['cta']) || 'Close';
-        this.notif_type      = _.escapeHTML(notif_data['type']) || 'takeover';
-        this.style           = _.escapeHTML(notif_data['style']) || 'light';
-        this.title           = _.escapeHTML(notif_data['title']) || '';
-        this.video_width     = MixpanelNotification.VIDEO_WIDTH;
-        this.video_height    = MixpanelNotification.VIDEO_HEIGHT;
-
-        this.display_triggers = notif_data['display_triggers'] || [];
-
-        // These fields are url-sanitized in the backend already.
-        this.dest_url        = notif_data['cta_url'] || null;
-        this.image_url       = notif_data['image_url'] || null;
-        this.thumb_image_url = notif_data['thumb_image_url'] || null;
-        this.video_url       = notif_data['video_url'] || null;
-
-        if (this.thumb_image_url && this.thumb_image_url.indexOf('//') === 0) {
-            this.thumb_image_url = this.thumb_image_url.replace('//', this.resource_protocol);
-        }
-
-        this.clickthrough = true;
-        if (!this.dest_url) {
-            this.dest_url = '#dismiss';
-            this.clickthrough = false;
+    MixpanelPersistence.prototype.unregister = function(prop) {
+        if (prop in this['props']) {
+            delete this['props'][prop];
+            this.save();
         }
+    };
 
-        this.mini = this.notif_type === 'mini';
-        if (!this.mini) {
-            this.notif_type = 'takeover';
+    MixpanelPersistence.prototype.update_campaign_params = function() {
+        if (!this.campaign_params_saved) {
+            this.register_once(_.info.campaignParams());
+            this.campaign_params_saved = true;
         }
-        this.notif_width = !this.mini ? MixpanelNotification.NOTIF_WIDTH : MixpanelNotification.NOTIF_WIDTH_MINI;
-
-        this._set_client_config();
-        this.imgs_to_preload = this._init_image_html();
-        this._init_video();
     };
 
-    MixpanelNotification.ANIM_TIME         = 200;
-    MixpanelNotification.MARKUP_PREFIX     = 'mixpanel-notification';
-    MixpanelNotification.BG_OPACITY        = 0.6;
-    MixpanelNotification.NOTIF_TOP         = 25;
-    MixpanelNotification.NOTIF_START_TOP   = 200;
-    MixpanelNotification.NOTIF_WIDTH       = 388;
-    MixpanelNotification.NOTIF_WIDTH_MINI  = 420;
-    MixpanelNotification.NOTIF_HEIGHT_MINI = 85;
-    MixpanelNotification.THUMB_BORDER_SIZE = 5;
-    MixpanelNotification.THUMB_IMG_SIZE    = 60;
-    MixpanelNotification.THUMB_OFFSET      = Math.round(MixpanelNotification.THUMB_IMG_SIZE / 2);
-    MixpanelNotification.VIDEO_WIDTH       = 595;
-    MixpanelNotification.VIDEO_HEIGHT      = 334;
+    MixpanelPersistence.prototype.update_search_keyword = function(referrer) {
+        this.register(_.info.searchInfo(referrer));
+    };
 
-    MixpanelNotification.prototype.show = function() {
-        var self = this;
-        this._set_client_config();
+    // EXPORTED METHOD, we test this directly.
+    MixpanelPersistence.prototype.update_referrer_info = function(referrer) {
+        // If referrer doesn't exist, we want to note the fact that it was type-in traffic.
+        this.register_once({
+            '$initial_referrer': referrer || '$direct',
+            '$initial_referring_domain': _.info.referringDomain(referrer) || '$direct'
+        }, '');
+    };
 
-        // don't display until HTML body exists
-        if (!this.body_el) {
-            setTimeout(function() { self.show(); }, 300);
-            return;
-        }
+    MixpanelPersistence.prototype.get_referrer_info = function() {
+        return _.strip_empty_properties({
+            '$initial_referrer': this['props']['$initial_referrer'],
+            '$initial_referring_domain': this['props']['$initial_referring_domain']
+        });
+    };
 
-        this._init_styles();
-        this._init_notification_el();
+    // safely fills the passed in object with stored properties,
+    // does not override any properties defined in both
+    // returns the passed in object
+    MixpanelPersistence.prototype.safe_merge = function(props) {
+        _.each(this['props'], function(val, prop) {
+            if (!(prop in props)) {
+                props[prop] = val;
+            }
+        });
 
-        // wait for any images to load before showing notification
-        this._preload_images(this._attach_and_animate);
+        return props;
     };
 
-    MixpanelNotification.prototype.dismiss = _.safewrap(function() {
-        if (!this.marked_as_shown) {
-            // unexpected condition: user interacted with notif even though we didn't consider it
-            // visible (see _mark_as_shown()); send tracking signals to mark delivery
-            this._mark_delivery({'invisible': true});
-        }
+    MixpanelPersistence.prototype.update_config = function(config) {
+        this.default_expiry = this.expire_days = config['cookie_expiration'];
+        this.set_disabled(config['disable_persistence']);
+        this.set_cookie_domain(config['cookie_domain']);
+        this.set_cross_site(config['cross_site_cookie']);
+        this.set_cross_subdomain(config['cross_subdomain_cookie']);
+        this.set_secure(config['secure_cookie']);
+    };
 
-        var exiting_el = this.showing_video ? this._get_el('video') : this._get_notification_display_el();
-        if (this.use_transitions) {
-            this._remove_class('bg', 'visible');
-            this._add_class(exiting_el, 'exiting');
-            setTimeout(this._remove_notification_el, MixpanelNotification.ANIM_TIME);
+    MixpanelPersistence.prototype.set_disabled = function(disabled) {
+        this.disabled = disabled;
+        if (this.disabled) {
+            this.remove();
         } else {
-            var notif_attr, notif_start, notif_goal;
-            if (this.mini) {
-                notif_attr  = 'right';
-                notif_start = 20;
-                notif_goal  = -100;
-            } else {
-                notif_attr  = 'top';
-                notif_start = MixpanelNotification.NOTIF_TOP;
-                notif_goal  = MixpanelNotification.NOTIF_START_TOP + MixpanelNotification.NOTIF_TOP;
-            }
-            this._animate_els([
-                {
-                    el:    this._get_el('bg'),
-                    attr:  'opacity',
-                    start: MixpanelNotification.BG_OPACITY,
-                    goal:  0.0
-                },
-                {
-                    el:    exiting_el,
-                    attr:  'opacity',
-                    start: 1.0,
-                    goal:  0.0
-                },
-                {
-                    el:    exiting_el,
-                    attr:  notif_attr,
-                    start: notif_start,
-                    goal:  notif_goal
-                }
-            ], MixpanelNotification.ANIM_TIME, this._remove_notification_el);
-        }
-    });
-
-    MixpanelNotification.prototype._add_class = _.safewrap(function(el, class_name) {
-        class_name = MixpanelNotification.MARKUP_PREFIX + '-' + class_name;
-        if (typeof el === 'string') {
-            el = this._get_el(el);
-        }
-        if (!el.className) {
-            el.className = class_name;
-        } else if (!~(' ' + el.className + ' ').indexOf(' ' + class_name + ' ')) {
-            el.className += ' ' + class_name;
-        }
-    });
-    MixpanelNotification.prototype._remove_class = _.safewrap(function(el, class_name) {
-        class_name = MixpanelNotification.MARKUP_PREFIX + '-' + class_name;
-        if (typeof el === 'string') {
-            el = this._get_el(el);
-        }
-        if (el.className) {
-            el.className = (' ' + el.className + ' ')
-                .replace(' ' + class_name + ' ', '')
-                .replace(/^[\s\xA0]+/, '')
-                .replace(/[\s\xA0]+$/, '');
+            this.save();
         }
-    });
+    };
 
-    MixpanelNotification.prototype._animate_els = _.safewrap(function(anims, mss, done_cb, start_time) {
-        var self = this,
-            in_progress = false,
-            ai, anim,
-            cur_time = 1 * new Date(), time_diff;
-
-        start_time = start_time || cur_time;
-        time_diff = cur_time - start_time;
-
-        for (ai = 0; ai < anims.length; ai++) {
-            anim = anims[ai];
-            if (typeof anim.val === 'undefined') {
-                anim.val = anim.start;
-            }
-            if (anim.val !== anim.goal) {
-                in_progress = true;
-                var anim_diff = anim.goal - anim.start,
-                    anim_dir = anim.goal >= anim.start ? 1 : -1;
-                anim.val = anim.start + anim_diff * time_diff / mss;
-                if (anim.attr !== 'opacity') {
-                    anim.val = Math.round(anim.val);
-                }
-                if ((anim_dir > 0 && anim.val >= anim.goal) || (anim_dir < 0 && anim.val <= anim.goal)) {
-                    anim.val = anim.goal;
-                }
-            }
-        }
-        if (!in_progress) {
-            if (done_cb) {
-                done_cb();
-            }
-            return;
+    MixpanelPersistence.prototype.set_cookie_domain = function(cookie_domain) {
+        if (cookie_domain !== this.cookie_domain) {
+            this.remove();
+            this.cookie_domain = cookie_domain;
+            this.save();
         }
+    };
 
-        for (ai = 0; ai < anims.length; ai++) {
-            anim = anims[ai];
-            if (anim.el) {
-                var suffix = anim.attr === 'opacity' ? '' : 'px';
-                anim.el.style[anim.attr] = String(anim.val) + suffix;
-            }
+    MixpanelPersistence.prototype.set_cross_site = function(cross_site) {
+        if (cross_site !== this.cross_site) {
+            this.cross_site = cross_site;
+            this.remove();
+            this.save();
         }
-        setTimeout(function() { self._animate_els(anims, mss, done_cb, start_time); }, 10);
-    });
-
-    MixpanelNotification.prototype._attach_and_animate = _.safewrap(function() {
-        var self = this;
+    };
 
-        // no possibility to double-display
-        if (this.shown || this._get_shown_campaigns()[this.campaign_id]) {
-            return;
+    MixpanelPersistence.prototype.set_cross_subdomain = function(cross_subdomain) {
+        if (cross_subdomain !== this.cross_subdomain) {
+            this.cross_subdomain = cross_subdomain;
+            this.remove();
+            this.save();
         }
-        this.shown = true;
-
-        this.body_el.appendChild(this.notification_el);
-        setTimeout(function() {
-            var notif_el = self._get_notification_display_el();
-            if (self.use_transitions) {
-                if (!self.mini) {
-                    self._add_class('bg', 'visible');
-                }
-                self._add_class(notif_el, 'visible');
-                self._mark_as_shown();
-            } else {
-                var notif_attr, notif_start, notif_goal;
-                if (self.mini) {
-                    notif_attr  = 'right';
-                    notif_start = -100;
-                    notif_goal  = 20;
-                } else {
-                    notif_attr  = 'top';
-                    notif_start = MixpanelNotification.NOTIF_START_TOP + MixpanelNotification.NOTIF_TOP;
-                    notif_goal  = MixpanelNotification.NOTIF_TOP;
-                }
-                self._animate_els([
-                    {
-                        el:    self._get_el('bg'),
-                        attr:  'opacity',
-                        start: 0.0,
-                        goal:  MixpanelNotification.BG_OPACITY
-                    },
-                    {
-                        el:    notif_el,
-                        attr:  'opacity',
-                        start: 0.0,
-                        goal:  1.0
-                    },
-                    {
-                        el:    notif_el,
-                        attr:  notif_attr,
-                        start: notif_start,
-                        goal:  notif_goal
-                    }
-                ], MixpanelNotification.ANIM_TIME, self._mark_as_shown);
-            }
-        }, 100);
-        _.register_event(self._get_el('cancel'), 'click', function(e) {
-            e.preventDefault();
-            self.dismiss();
-        });
-        var click_el = self._get_el('button') ||
-                            self._get_el('mini-content');
-        _.register_event(click_el, 'click', function(e) {
-            e.preventDefault();
-            if (self.show_video) {
-                self._track_event('$campaign_open', {'$resource_type': 'video'});
-                self._switch_to_video();
-            } else {
-                self.dismiss();
-                if (self.clickthrough) {
-                    var tracking_cb = null;
-                    if (self.mixpanel.get_config('inapp_link_new_window')) {
-                        window.open(self.dest_url);
-                    } else {
-                        tracking_cb = function() {
-                            window.location.href = self.dest_url;
-                        };
-                    }
-                    self._track_event('$campaign_open', {'$resource_type': 'link'}, tracking_cb);
-                }
-            }
-        });
-    });
-
-    MixpanelNotification.prototype._get_el = function(id) {
-        return document.getElementById(MixpanelNotification.MARKUP_PREFIX + '-' + id);
     };
 
-    MixpanelNotification.prototype._get_notification_display_el = function() {
-        return this._get_el(this.notif_type);
+    MixpanelPersistence.prototype.get_cross_subdomain = function() {
+        return this.cross_subdomain;
     };
 
-    MixpanelNotification.prototype._get_shown_campaigns = function() {
-        return this.persistence['props'][CAMPAIGN_IDS_KEY] || (this.persistence['props'][CAMPAIGN_IDS_KEY] = {});
+    MixpanelPersistence.prototype.set_secure = function(secure) {
+        if (secure !== this.secure) {
+            this.secure = secure ? true : false;
+            this.remove();
+            this.save();
+        }
     };
 
-    MixpanelNotification.prototype._matches_event_data = _.safewrap(function(event_data) {
-        var event_name = event_data['event'] || '';
-        for (var i = 0; i < this.display_triggers.length; i++) {
-            var display_trigger = this.display_triggers[i];
-            var match_event = display_trigger['event'] || '';
-            if (match_event === '$any_event' || event_name === display_trigger['event']) {
-                if (display_trigger['selector'] && !_.isEmptyObject(display_trigger['selector'])) {
-                    if (evaluateSelector(display_trigger['selector'], event_data['properties'])) {
-                        return true;
-                    }
-                } else {
-                    return true;
-                }
-            }
-        }
-        return false;
-    });
-
-
-    MixpanelNotification.prototype._browser_lte = function(browser, version) {
-        return this.browser_versions[browser] && this.browser_versions[browser] <= version;
-    };
-
-    MixpanelNotification.prototype._init_image_html = function() {
-        var imgs_to_preload = [];
-
-        if (!this.mini) {
-            if (this.image_url) {
-                imgs_to_preload.push(this.image_url);
-                this.img_html = '<img id="img" src="' + this.image_url + '"/>';
-            } else {
-                this.img_html = '';
-            }
-            if (this.thumb_image_url) {
-                imgs_to_preload.push(this.thumb_image_url);
-                this.thumb_img_html =
-                        '<div id="thumbborder-wrapper"><div id="thumbborder"></div></div>' +
-                        '<img id="thumbnail"' +
-                            ' src="' + this.thumb_image_url + '"' +
-                            ' width="' + MixpanelNotification.THUMB_IMG_SIZE + '"' +
-                            ' height="' + MixpanelNotification.THUMB_IMG_SIZE + '"' +
-                        '/>' +
-                        '<div id="thumbspacer"></div>';
-            } else {
-                this.thumb_img_html = '';
-            }
-        } else {
-            this.thumb_image_url = this.thumb_image_url || (this.cdn_host + '/site_media/images/icons/notifications/mini-news-dark.png');
-            imgs_to_preload.push(this.thumb_image_url);
-        }
-
-        return imgs_to_preload;
-    };
-
-    MixpanelNotification.prototype._init_notification_el = function() {
-        var notification_html = '';
-        var video_src         = '';
-        var video_html        = '';
-        var cancel_html       = '<div id="cancel">' +
-                                        '<div id="cancel-icon"></div>' +
-                                    '</div>';
-
-        this.notification_el = document.createElement('div');
-        this.notification_el.id = MixpanelNotification.MARKUP_PREFIX + '-wrapper';
-        if (!this.mini) {
-            // TAKEOVER notification
-            var close_html  = (this.clickthrough || this.show_video) ? '' : '<div id="button-close"></div>',
-                play_html   = this.show_video ? '<div id="button-play"></div>' : '';
-            if (this._browser_lte('ie', 7)) {
-                close_html = '';
-                play_html = '';
-            }
-            notification_html =
-                    '<div id="takeover">' +
-                        this.thumb_img_html +
-                        '<div id="mainbox">' +
-                            cancel_html +
-                            '<div id="content">' +
-                                this.img_html +
-                                '<div id="title">' + this.title + '</div>' +
-                                '<div id="body">' + this.body + '</div>' +
-                                '<div id="tagline">' +
-                                    '<a href="http://mixpanel.com?from=inapp" target="_blank">POWERED BY MIXPANEL</a>' +
-                                '</div>' +
-                            '</div>' +
-                            '<div id="button">' +
-                                close_html +
-                                '<a id="button-link" href="' + this.dest_url + '">' + this.cta + '</a>' +
-                                play_html +
-                            '</div>' +
-                        '</div>' +
-                    '</div>';
-        } else {
-            // MINI notification
-            notification_html =
-                    '<div id="mini">' +
-                        '<div id="mainbox">' +
-                            cancel_html +
-                            '<div id="mini-content">' +
-                                '<div id="mini-icon">' +
-                                    '<div id="mini-icon-img"></div>' +
-                                '</div>' +
-                                '<div id="body">' +
-                                    '<div id="body-text"><div>' + this.body + '</div></div>' +
-                                '</div>' +
-                            '</div>' +
-                        '</div>' +
-                        '<div id="mini-border"></div>' +
-                    '</div>';
-        }
-        if (this.youtube_video) {
-            video_src = this.resource_protocol + 'www.youtube.com/embed/' + this.youtube_video +
-                    '?wmode=transparent&showinfo=0&modestbranding=0&rel=0&autoplay=1&loop=0&vq=hd1080';
-            if (this.yt_custom) {
-                video_src += '&enablejsapi=1&html5=1&controls=0';
-                video_html =
-                        '<div id="video-controls">' +
-                            '<div id="video-progress" class="video-progress-el">' +
-                                '<div id="video-progress-total" class="video-progress-el"></div>' +
-                                '<div id="video-elapsed" class="video-progress-el"></div>' +
-                            '</div>' +
-                            '<div id="video-time" class="video-progress-el"></div>' +
-                        '</div>';
-            }
-        } else if (this.vimeo_video) {
-            video_src = this.resource_protocol + 'player.vimeo.com/video/' + this.vimeo_video + '?autoplay=1&title=0&byline=0&portrait=0';
-        }
-        if (this.show_video) {
-            this.video_iframe =
-                    '<iframe id="' + MixpanelNotification.MARKUP_PREFIX + '-video-frame" ' +
-                        'width="' + this.video_width + '" height="' + this.video_height + '" ' +
-                        ' src="' + video_src + '"' +
-                        ' frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen="1" scrolling="no"' +
-                    '></iframe>';
-            video_html =
-                    '<div id="video-' + (this.flip_animate ? '' : 'no') + 'flip">' +
-                        '<div id="video">' +
-                            '<div id="video-holder"></div>' +
-                            video_html +
-                        '</div>' +
-                    '</div>';
-        }
-        var main_html = video_html + notification_html;
-        if (this.flip_animate) {
-            main_html =
-                    (this.mini ? notification_html : '') +
-                    '<div id="flipcontainer"><div id="flipper">' +
-                        (this.mini ? video_html : main_html) +
-                    '</div></div>';
-        }
-
-        this.notification_el.innerHTML =
-            ('<div id="overlay" class="' + this.notif_type + '">' +
-                '<div id="campaignid-' + this.campaign_id + '">' +
-                    '<div id="bgwrapper">' +
-                        '<div id="bg"></div>' +
-                        main_html +
-                    '</div>' +
-                '</div>' +
-            '</div>')
-                .replace(/class="/g, 'class="' + MixpanelNotification.MARKUP_PREFIX + '-')
-                .replace(/id="/g, 'id="' + MixpanelNotification.MARKUP_PREFIX + '-');
-    };
-
-    MixpanelNotification.prototype._init_styles = function() {
-        if (this.style === 'dark') {
-            this.style_vals = {
-                bg:             '#1d1f25',
-                bg_actions:     '#282b32',
-                bg_hover:       '#3a4147',
-                bg_light:       '#4a5157',
-                border_gray:    '#32353c',
-                cancel_opacity: '0.4',
-                mini_hover:     '#2a3137',
-                text_title:     '#fff',
-                text_main:      '#9498a3',
-                text_tagline:   '#464851',
-                text_hover:     '#ddd'
-            };
-        } else {
-            this.style_vals = {
-                bg:             '#fff',
-                bg_actions:     '#e7eaee',
-                bg_hover:       '#eceff3',
-                bg_light:       '#f5f5f5',
-                border_gray:    '#e4ecf2',
-                cancel_opacity: '1.0',
-                mini_hover:     '#fafafa',
-                text_title:     '#5c6578',
-                text_main:      '#8b949b',
-                text_tagline:   '#ced9e6',
-                text_hover:     '#7c8598'
-            };
-        }
-        var shadow = '0px 0px 35px 0px rgba(45, 49, 56, 0.7)',
-            video_shadow = shadow,
-            mini_shadow = shadow,
-            thumb_total_size = MixpanelNotification.THUMB_IMG_SIZE + MixpanelNotification.THUMB_BORDER_SIZE * 2,
-            anim_seconds = (MixpanelNotification.ANIM_TIME / 1000) + 's';
-        if (this.mini) {
-            shadow = 'none';
-        }
-
-        // don't display on small viewports
-        var notif_media_queries = {},
-            min_width = MixpanelNotification.NOTIF_WIDTH_MINI + 20;
-        notif_media_queries['@media only screen and (max-width: ' + (min_width - 1) + 'px)'] = {
-            '#overlay': {
-                'display': 'none'
-            }
-        };
-        var notif_styles = {
-            '.flipped': {
-                'transform': 'rotateY(180deg)'
-            },
-            '#overlay': {
-                'position': 'fixed',
-                'top': '0',
-                'left': '0',
-                'width': '100%',
-                'height': '100%',
-                'overflow': 'auto',
-                'text-align': 'center',
-                'z-index': '10000',
-                'font-family': '"Helvetica", "Arial", sans-serif',
-                '-webkit-font-smoothing': 'antialiased',
-                '-moz-osx-font-smoothing': 'grayscale'
-            },
-            '#overlay.mini': {
-                'height': '0',
-                'overflow': 'visible'
-            },
-            '#overlay a': {
-                'width': 'initial',
-                'padding': '0',
-                'text-decoration': 'none',
-                'text-transform': 'none',
-                'color': 'inherit'
-            },
-            '#bgwrapper': {
-                'position': 'relative',
-                'width': '100%',
-                'height': '100%'
-            },
-            '#bg': {
-                'position': 'fixed',
-                'top': '0',
-                'left': '0',
-                'width': '100%',
-                'height': '100%',
-                'min-width': this.doc_width * 4 + 'px',
-                'min-height': this.doc_height * 4 + 'px',
-                'background-color': 'black',
-                'opacity': '0.0',
-                '-ms-filter': 'progid:DXImageTransform.Microsoft.Alpha(Opacity=60)', // IE8
-                'filter': 'alpha(opacity=60)', // IE5-7
-                'transition': 'opacity ' + anim_seconds
-            },
-            '#bg.visible': {
-                'opacity': MixpanelNotification.BG_OPACITY
-            },
-            '.mini #bg': {
-                'width': '0',
-                'height': '0',
-                'min-width': '0'
-            },
-            '#flipcontainer': {
-                'perspective': '1000px',
-                'position': 'absolute',
-                'width': '100%'
-            },
-            '#flipper': {
-                'position': 'relative',
-                'transform-style': 'preserve-3d',
-                'transition': '0.3s'
-            },
-            '#takeover': {
-                'position': 'absolute',
-                'left': '50%',
-                'width': MixpanelNotification.NOTIF_WIDTH + 'px',
-                'margin-left': Math.round(-MixpanelNotification.NOTIF_WIDTH / 2) + 'px',
-                'backface-visibility': 'hidden',
-                'transform': 'rotateY(0deg)',
-                'opacity': '0.0',
-                'top': MixpanelNotification.NOTIF_START_TOP + 'px',
-                'transition': 'opacity ' + anim_seconds + ', top ' + anim_seconds
-            },
-            '#takeover.visible': {
-                'opacity': '1.0',
-                'top': MixpanelNotification.NOTIF_TOP + 'px'
-            },
-            '#takeover.exiting': {
-                'opacity': '0.0',
-                'top': MixpanelNotification.NOTIF_START_TOP + 'px'
-            },
-            '#thumbspacer': {
-                'height': MixpanelNotification.THUMB_OFFSET + 'px'
-            },
-            '#thumbborder-wrapper': {
-                'position': 'absolute',
-                'top': (-MixpanelNotification.THUMB_BORDER_SIZE) + 'px',
-                'left': (MixpanelNotification.NOTIF_WIDTH / 2 - MixpanelNotification.THUMB_OFFSET - MixpanelNotification.THUMB_BORDER_SIZE) + 'px',
-                'width': thumb_total_size + 'px',
-                'height': (thumb_total_size / 2) + 'px',
-                'overflow': 'hidden'
-            },
-            '#thumbborder': {
-                'position': 'absolute',
-                'width': thumb_total_size + 'px',
-                'height': thumb_total_size + 'px',
-                'border-radius': thumb_total_size + 'px',
-                'background-color': this.style_vals.bg_actions,
-                'opacity': '0.5'
-            },
-            '#thumbnail': {
-                'position': 'absolute',
-                'top': '0px',
-                'left': (MixpanelNotification.NOTIF_WIDTH / 2 - MixpanelNotification.THUMB_OFFSET) + 'px',
-                'width': MixpanelNotification.THUMB_IMG_SIZE + 'px',
-                'height': MixpanelNotification.THUMB_IMG_SIZE + 'px',
-                'overflow': 'hidden',
-                'z-index': '100',
-                'border-radius': MixpanelNotification.THUMB_IMG_SIZE + 'px'
-            },
-            '#mini': {
-                'position': 'absolute',
-                'right': '20px',
-                'top': MixpanelNotification.NOTIF_TOP + 'px',
-                'width': this.notif_width + 'px',
-                'height': MixpanelNotification.NOTIF_HEIGHT_MINI * 2 + 'px',
-                'margin-top': 20 - MixpanelNotification.NOTIF_HEIGHT_MINI + 'px',
-                'backface-visibility': 'hidden',
-                'opacity': '0.0',
-                'transform': 'rotateX(90deg)',
-                'transition': 'opacity 0.3s, transform 0.3s, right 0.3s'
-            },
-            '#mini.visible': {
-                'opacity': '1.0',
-                'transform': 'rotateX(0deg)'
-            },
-            '#mini.exiting': {
-                'opacity': '0.0',
-                'right': '-150px'
-            },
-            '#mainbox': {
-                'border-radius': '4px',
-                'box-shadow': shadow,
-                'text-align': 'center',
-                'background-color': this.style_vals.bg,
-                'font-size': '14px',
-                'color': this.style_vals.text_main
-            },
-            '#mini #mainbox': {
-                'height': MixpanelNotification.NOTIF_HEIGHT_MINI + 'px',
-                'margin-top': MixpanelNotification.NOTIF_HEIGHT_MINI + 'px',
-                'border-radius': '3px',
-                'transition': 'background-color ' + anim_seconds
-            },
-            '#mini-border': {
-                'height': (MixpanelNotification.NOTIF_HEIGHT_MINI + 6) + 'px',
-                'width': (MixpanelNotification.NOTIF_WIDTH_MINI + 6) + 'px',
-                'position': 'absolute',
-                'top': '-3px',
-                'left': '-3px',
-                'margin-top': MixpanelNotification.NOTIF_HEIGHT_MINI + 'px',
-                'border-radius': '6px',
-                'opacity': '0.25',
-                'background-color': '#fff',
-                'z-index': '-1',
-                'box-shadow': mini_shadow
-            },
-            '#mini-icon': {
-                'position': 'relative',
-                'display': 'inline-block',
-                'width': '75px',
-                'height': MixpanelNotification.NOTIF_HEIGHT_MINI + 'px',
-                'border-radius': '3px 0 0 3px',
-                'background-color': this.style_vals.bg_actions,
-                'background': 'linear-gradient(135deg, ' + this.style_vals.bg_light + ' 0%, ' + this.style_vals.bg_actions + ' 100%)',
-                'transition': 'background-color ' + anim_seconds
-            },
-            '#mini:hover #mini-icon': {
-                'background-color': this.style_vals.mini_hover
-            },
-            '#mini:hover #mainbox': {
-                'background-color': this.style_vals.mini_hover
-            },
-            '#mini-icon-img': {
-                'position': 'absolute',
-                'background-image': 'url(' + this.thumb_image_url + ')',
-                'width': '48px',
-                'height': '48px',
-                'top': '20px',
-                'left': '12px'
-            },
-            '#content': {
-                'padding': '30px 20px 0px 20px'
-            },
-            '#mini-content': {
-                'text-align': 'left',
-                'height': MixpanelNotification.NOTIF_HEIGHT_MINI + 'px',
-                'cursor': 'pointer'
-            },
-            '#img': {
-                'width': '328px',
-                'margin-top': '30px',
-                'border-radius': '5px'
-            },
-            '#title': {
-                'max-height': '600px',
-                'overflow': 'hidden',
-                'word-wrap': 'break-word',
-                'padding': '25px 0px 20px 0px',
-                'font-size': '19px',
-                'font-weight': 'bold',
-                'color': this.style_vals.text_title
-            },
-            '#body': {
-                'max-height': '600px',
-                'margin-bottom': '25px',
-                'overflow': 'hidden',
-                'word-wrap': 'break-word',
-                'line-height': '21px',
-                'font-size': '15px',
-                'font-weight': 'normal',
-                'text-align': 'left'
-            },
-            '#mini #body': {
-                'display': 'inline-block',
-                'max-width': '250px',
-                'margin': '0 0 0 30px',
-                'height': MixpanelNotification.NOTIF_HEIGHT_MINI + 'px',
-                'font-size': '16px',
-                'letter-spacing': '0.8px',
-                'color': this.style_vals.text_title
-            },
-            '#mini #body-text': {
-                'display': 'table',
-                'height': MixpanelNotification.NOTIF_HEIGHT_MINI + 'px'
-            },
-            '#mini #body-text div': {
-                'display': 'table-cell',
-                'vertical-align': 'middle'
-            },
-            '#tagline': {
-                'margin-bottom': '15px',
-                'font-size': '10px',
-                'font-weight': '600',
-                'letter-spacing': '0.8px',
-                'color': '#ccd7e0',
-                'text-align': 'left'
-            },
-            '#tagline a': {
-                'color': this.style_vals.text_tagline,
-                'transition': 'color ' + anim_seconds
-            },
-            '#tagline a:hover': {
-                'color': this.style_vals.text_hover
-            },
-            '#cancel': {
-                'position': 'absolute',
-                'right': '0',
-                'width': '8px',
-                'height': '8px',
-                'padding': '10px',
-                'border-radius': '20px',
-                'margin': '12px 12px 0 0',
-                'box-sizing': 'content-box',
-                'cursor': 'pointer',
-                'transition': 'background-color ' + anim_seconds
-            },
-            '#mini #cancel': {
-                'margin': '7px 7px 0 0'
-            },
-            '#cancel-icon': {
-                'width': '8px',
-                'height': '8px',
-                'overflow': 'hidden',
-                'background-image': 'url(' + this.cdn_host + '/site_media/images/icons/notifications/cancel-x.png)',
-                'opacity': this.style_vals.cancel_opacity
-            },
-            '#cancel:hover': {
-                'background-color': this.style_vals.bg_hover
-            },
-            '#button': {
-                'display': 'block',
-                'height': '60px',
-                'line-height': '60px',
-                'text-align': 'center',
-                'background-color': this.style_vals.bg_actions,
-                'border-radius': '0 0 4px 4px',
-                'overflow': 'hidden',
-                'cursor': 'pointer',
-                'transition': 'background-color ' + anim_seconds
-            },
-            '#button-close': {
-                'display': 'inline-block',
-                'width': '9px',
-                'height': '60px',
-                'margin-right': '8px',
-                'vertical-align': 'top',
-                'background-image': 'url(' + this.cdn_host + '/site_media/images/icons/notifications/close-x-' + this.style + '.png)',
-                'background-repeat': 'no-repeat',
-                'background-position': '0px 25px'
-            },
-            '#button-play': {
-                'display': 'inline-block',
-                'width': '30px',
-                'height': '60px',
-                'margin-left': '15px',
-                'background-image': 'url(' + this.cdn_host + '/site_media/images/icons/notifications/play-' + this.style + '-small.png)',
-                'background-repeat': 'no-repeat',
-                'background-position': '0px 15px'
-            },
-            'a#button-link': {
-                'display': 'inline-block',
-                'vertical-align': 'top',
-                'text-align': 'center',
-                'font-size': '17px',
-                'font-weight': 'bold',
-                'overflow': 'hidden',
-                'word-wrap': 'break-word',
-                'color': this.style_vals.text_title,
-                'transition': 'color ' + anim_seconds
-            },
-            '#button:hover': {
-                'background-color': this.style_vals.bg_hover,
-                'color': this.style_vals.text_hover
-            },
-            '#button:hover a': {
-                'color': this.style_vals.text_hover
-            },
-
-            '#video-noflip': {
-                'position': 'relative',
-                'top': (-this.video_height * 2) + 'px'
-            },
-            '#video-flip': {
-                'backface-visibility': 'hidden',
-                'transform': 'rotateY(180deg)'
-            },
-            '#video': {
-                'position': 'absolute',
-                'width': (this.video_width - 1) + 'px',
-                'height': this.video_height + 'px',
-                'top': MixpanelNotification.NOTIF_TOP + 'px',
-                'margin-top': '100px',
-                'left': '50%',
-                'margin-left': Math.round(-this.video_width / 2) + 'px',
-                'overflow': 'hidden',
-                'border-radius': '5px',
-                'box-shadow': video_shadow,
-                'transform': 'translateZ(1px)', // webkit rendering bug http://stackoverflow.com/questions/18167981/clickable-link-area-unexpectedly-smaller-after-css-transform
-                'transition': 'opacity ' + anim_seconds + ', top ' + anim_seconds
-            },
-            '#video.exiting': {
-                'opacity': '0.0',
-                'top': this.video_height + 'px'
-            },
-            '#video-holder': {
-                'position': 'absolute',
-                'width': (this.video_width - 1) + 'px',
-                'height': this.video_height + 'px',
-                'overflow': 'hidden',
-                'border-radius': '5px'
-            },
-            '#video-frame': {
-                'margin-left': '-1px',
-                'width': this.video_width + 'px'
-            },
-            '#video-controls': {
-                'opacity': '0',
-                'transition': 'opacity 0.5s'
-            },
-            '#video:hover #video-controls': {
-                'opacity': '1.0'
-            },
-            '#video .video-progress-el': {
-                'position': 'absolute',
-                'bottom': '0',
-                'height': '25px',
-                'border-radius': '0 0 0 5px'
-            },
-            '#video-progress': {
-                'width': '90%'
-            },
-            '#video-progress-total': {
-                'width': '100%',
-                'background-color': this.style_vals.bg,
-                'opacity': '0.7'
-            },
-            '#video-elapsed': {
-                'width': '0',
-                'background-color': '#6cb6f5',
-                'opacity': '0.9'
-            },
-            '#video #video-time': {
-                'width': '10%',
-                'right': '0',
-                'font-size': '11px',
-                'line-height': '25px',
-                'color': this.style_vals.text_main,
-                'background-color': '#666',
-                'border-radius': '0 0 5px 0'
-            }
-        };
-
-        // IE hacks
-        if (this._browser_lte('ie', 8)) {
-            _.extend(notif_styles, {
-                '* html #overlay': {
-                    'position': 'absolute'
-                },
-                '* html #bg': {
-                    'position': 'absolute'
-                },
-                'html, body': {
-                    'height': '100%'
-                }
-            });
-        }
-        if (this._browser_lte('ie', 7)) {
-            _.extend(notif_styles, {
-                '#mini #body': {
-                    'display': 'inline',
-                    'zoom': '1',
-                    'border': '1px solid ' + this.style_vals.bg_hover
-                },
-                '#mini #body-text': {
-                    'padding': '20px'
-                },
-                '#mini #mini-icon': {
-                    'display': 'none'
-                }
-            });
-        }
-
-        // add vendor-prefixed style rules
-        var VENDOR_STYLES = [
-                'backface-visibility', 'border-radius', 'box-shadow', 'opacity',
-                'perspective', 'transform', 'transform-style', 'transition'
-            ],
-            VENDOR_PREFIXES = ['khtml', 'moz', 'ms', 'o', 'webkit'];
-        for (var selector in notif_styles) {
-            for (var si = 0; si < VENDOR_STYLES.length; si++) {
-                var prop = VENDOR_STYLES[si];
-                if (prop in notif_styles[selector]) {
-                    var val = notif_styles[selector][prop];
-                    for (var pi = 0; pi < VENDOR_PREFIXES.length; pi++) {
-                        notif_styles[selector]['-' + VENDOR_PREFIXES[pi] + '-' + prop] = val;
-                    }
-                }
-            }
-        }
-
-        var inject_styles = function(styles, media_queries) {
-            var create_style_text = function(style_defs) {
-                var st = '';
-                for (var selector in style_defs) {
-                    var mp_selector = selector
-                        .replace(/#/g, '#' + MixpanelNotification.MARKUP_PREFIX + '-')
-                        .replace(/\./g, '.' + MixpanelNotification.MARKUP_PREFIX + '-');
-                    st += '\n' + mp_selector + ' {';
-                    var props = style_defs[selector];
-                    for (var k in props) {
-                        st += k + ':' + props[k] + ';';
-                    }
-                    st += '}';
-                }
-                return st;
-            };
-            var create_media_query_text = function(mq_defs) {
-                var mqt = '';
-                for (var mq in mq_defs) {
-                    mqt += '\n' + mq + ' {' + create_style_text(mq_defs[mq]) + '\n}';
-                }
-                return mqt;
-            };
-
-            var style_text = create_style_text(styles) + create_media_query_text(media_queries),
-                head_el = document.head || document.getElementsByTagName('head')[0] || document.documentElement,
-                style_el = document.createElement('style');
-            head_el.appendChild(style_el);
-            style_el.setAttribute('type', 'text/css');
-            if (style_el.styleSheet) { // IE
-                style_el.styleSheet.cssText = style_text;
-            } else {
-                style_el.textContent = style_text;
-            }
-        };
-        inject_styles(notif_styles, notif_media_queries);
-    };
-
-    MixpanelNotification.prototype._init_video = _.safewrap(function() {
-        if (!this.video_url) {
-            return;
-        }
-        var self = this;
-
-        // Youtube iframe API compatibility
-        self.yt_custom = 'postMessage' in window;
-
-        self.dest_url = self.video_url;
-        var youtube_match = self.video_url.match(
-                // http://stackoverflow.com/questions/2936467/parse-youtube-video-id-using-preg-match
-                /(?:youtube(?:-nocookie)?\.com\/(?:[^/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?/ ]{11})/i
-            ),
-            vimeo_match = self.video_url.match(
-                /vimeo\.com\/.*?(\d+)/i
-            );
-        if (youtube_match) {
-            self.show_video = true;
-            self.youtube_video = youtube_match[1];
-
-            if (self.yt_custom) {
-                window['onYouTubeIframeAPIReady'] = function() {
-                    if (self._get_el('video-frame')) {
-                        self._yt_video_ready();
-                    }
-                };
-
-                // load Youtube iframe API; see https://developers.google.com/youtube/iframe_api_reference
-                var tag = document.createElement('script');
-                tag.src = self.resource_protocol + 'www.youtube.com/iframe_api';
-                var firstScriptTag = document.getElementsByTagName('script')[0];
-                firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);
-            }
-        } else if (vimeo_match) {
-            self.show_video = true;
-            self.vimeo_video = vimeo_match[1];
-        }
-
-        // IE <= 7, FF <= 3: fall through to video link rather than embedded player
-        if (self._browser_lte('ie', 7) || self._browser_lte('firefox', 3)) {
-            self.show_video = false;
-            self.clickthrough = true;
-        }
-    });
-
-    MixpanelNotification.prototype._mark_as_shown = _.safewrap(function() {
-        // click on background to dismiss
-        var self = this;
-        _.register_event(self._get_el('bg'), 'click', function() {
-            self.dismiss();
-        });
-
-        var get_style = function(el, style_name) {
-            var styles = {};
-            if (document.defaultView && document.defaultView.getComputedStyle) {
-                styles = document.defaultView.getComputedStyle(el, null); // FF3 requires both args
-            } else if (el.currentStyle) { // IE
-                styles = el.currentStyle;
-            }
-            return styles[style_name];
-        };
-
-        if (this.campaign_id) {
-            var notif_el = this._get_el('overlay');
-            if (notif_el && get_style(notif_el, 'visibility') !== 'hidden' && get_style(notif_el, 'display') !== 'none') {
-                this._mark_delivery();
-            }
-        }
-    });
-
-    MixpanelNotification.prototype._mark_delivery = _.safewrap(function(extra_props) {
-        if (!this.marked_as_shown) {
-            this.marked_as_shown = true;
-
-            if (this.campaign_id) {
-                // mark notification shown (local cache)
-                this._get_shown_campaigns()[this.campaign_id] = 1 * new Date();
-                this.persistence.save();
-            }
-
-            // track delivery
-            this._track_event('$campaign_delivery', extra_props);
+    MixpanelPersistence.prototype._add_to_people_queue = function(queue, data) {
+        var q_key = this._get_queue_key(queue),
+            q_data = data[queue],
+            set_q = this._get_or_create_queue(SET_ACTION),
+            set_once_q = this._get_or_create_queue(SET_ONCE_ACTION),
+            unset_q = this._get_or_create_queue(UNSET_ACTION),
+            add_q = this._get_or_create_queue(ADD_ACTION),
+            union_q = this._get_or_create_queue(UNION_ACTION),
+            remove_q = this._get_or_create_queue(REMOVE_ACTION, []),
+            append_q = this._get_or_create_queue(APPEND_ACTION, []);
 
-            // mark notification shown (mixpanel property)
-            this.mixpanel['people']['append']({
-                '$campaigns': this.campaign_id,
-                '$notifications': {
-                    'campaign_id': this.campaign_id,
-                    'message_id':  this.message_id,
-                    'type':        'web',
-                    'time':        new Date()
+        if (q_key === SET_QUEUE_KEY) {
+            // Update the set queue - we can override any existing values
+            _.extend(set_q, q_data);
+            // if there was a pending increment, override it
+            // with the set.
+            this._pop_from_people_queue(ADD_ACTION, q_data);
+            // if there was a pending union, override it
+            // with the set.
+            this._pop_from_people_queue(UNION_ACTION, q_data);
+            this._pop_from_people_queue(UNSET_ACTION, q_data);
+        } else if (q_key === SET_ONCE_QUEUE_KEY) {
+            // only queue the data if there is not already a set_once call for it.
+            _.each(q_data, function(v, k) {
+                if (!(k in set_once_q)) {
+                    set_once_q[k] = v;
                 }
             });
-        }
-    });
-
-    MixpanelNotification.prototype._preload_images = function(all_loaded_cb) {
-        var self = this;
-        if (this.imgs_to_preload.length === 0) {
-            all_loaded_cb();
-            return;
-        }
-
-        var preloaded_imgs = 0;
-        var img_objs = [];
-        var onload = function() {
-            preloaded_imgs++;
-            if (preloaded_imgs === self.imgs_to_preload.length && all_loaded_cb) {
-                all_loaded_cb();
-                all_loaded_cb = null;
-            }
-        };
-        for (var i = 0; i < this.imgs_to_preload.length; i++) {
-            var img = new Image();
-            img.onload = onload;
-            img.src = this.imgs_to_preload[i];
-            if (img.complete) {
-                onload();
-            }
-            img_objs.push(img);
-        }
+            this._pop_from_people_queue(UNSET_ACTION, q_data);
+        } else if (q_key === UNSET_QUEUE_KEY) {
+            _.each(q_data, function(prop) {
 
-        // IE6/7 doesn't fire onload reliably
-        if (this._browser_lte('ie', 7)) {
-            setTimeout(function() {
-                var imgs_loaded = true;
-                for (i = 0; i < img_objs.length; i++) {
-                    if (!img_objs[i].complete) {
-                        imgs_loaded = false;
+                // undo previously-queued actions on this key
+                _.each([set_q, set_once_q, add_q, union_q], function(enqueued_obj) {
+                    if (prop in enqueued_obj) {
+                        delete enqueued_obj[prop];
                     }
-                }
-                if (imgs_loaded && all_loaded_cb) {
-                    all_loaded_cb();
-                    all_loaded_cb = null;
-                }
-            }, 500);
-        }
-    };
-
-    MixpanelNotification.prototype._remove_notification_el = _.safewrap(function() {
-        window.clearInterval(this._video_progress_checker);
-        this.notification_el.style.visibility = 'hidden';
-        this.body_el.removeChild(this.notification_el);
-    });
-
-    MixpanelNotification.prototype._set_client_config = function() {
-        var get_browser_version = function(browser_ex) {
-            var match = navigator.userAgent.match(browser_ex);
-            return match && match[1];
-        };
-        this.browser_versions = {};
-        this.browser_versions['chrome']  = get_browser_version(/Chrome\/(\d+)/);
-        this.browser_versions['firefox'] = get_browser_version(/Firefox\/(\d+)/);
-        this.browser_versions['ie']      = get_browser_version(/MSIE (\d+).+/);
-        if (!this.browser_versions['ie'] && !(window.ActiveXObject) && 'ActiveXObject' in window) {
-            this.browser_versions['ie'] = 11;
-        }
-
-        this.body_el = document.body || document.getElementsByTagName('body')[0];
-        if (this.body_el) {
-            this.doc_width = Math.max(
-                this.body_el.scrollWidth, document.documentElement.scrollWidth,
-                this.body_el.offsetWidth, document.documentElement.offsetWidth,
-                this.body_el.clientWidth, document.documentElement.clientWidth
-            );
-            this.doc_height = Math.max(
-                this.body_el.scrollHeight, document.documentElement.scrollHeight,
-                this.body_el.offsetHeight, document.documentElement.offsetHeight,
-                this.body_el.clientHeight, document.documentElement.clientHeight
-            );
-        }
-
-        // detect CSS compatibility
-        var ie_ver = this.browser_versions['ie'];
-        var sample_styles = document.createElement('div').style,
-            is_css_compatible = function(rule) {
-                if (rule in sample_styles) {
-                    return true;
-                }
-                if (!ie_ver) {
-                    rule = rule[0].toUpperCase() + rule.slice(1);
-                    var props = ['O' + rule, 'Webkit' + rule, 'Moz' + rule];
-                    for (var i = 0; i < props.length; i++) {
-                        if (props[i] in sample_styles) {
-                            return true;
-                        }
+                });
+                _.each(append_q, function(append_obj) {
+                    if (prop in append_obj) {
+                        delete append_obj[prop];
                     }
-                }
-                return false;
-            };
-        this.use_transitions = this.body_el &&
-            is_css_compatible('transition') &&
-            is_css_compatible('transform');
-        this.flip_animate = (this.browser_versions['chrome'] >= 33 || this.browser_versions['firefox'] >= 15) &&
-            this.body_el &&
-            is_css_compatible('backfaceVisibility') &&
-            is_css_compatible('perspective') &&
-            is_css_compatible('transform');
-    };
-
-    MixpanelNotification.prototype._switch_to_video = _.safewrap(function() {
-        var self = this,
-            anims = [
-                {
-                    el:    self._get_notification_display_el(),
-                    attr:  'opacity',
-                    start: 1.0,
-                    goal:  0.0
-                },
-                {
-                    el:    self._get_notification_display_el(),
-                    attr:  'top',
-                    start: MixpanelNotification.NOTIF_TOP,
-                    goal:  -500
-                },
-                {
-                    el:    self._get_el('video-noflip'),
-                    attr:  'opacity',
-                    start: 0.0,
-                    goal:  1.0
-                },
-                {
-                    el:    self._get_el('video-noflip'),
-                    attr:  'top',
-                    start: -self.video_height * 2,
-                    goal:  0
-                }
-            ];
-
-        if (self.mini) {
-            var bg = self._get_el('bg'),
-                overlay = self._get_el('overlay');
-            bg.style.width = '100%';
-            bg.style.height = '100%';
-            overlay.style.width = '100%';
-
-            self._add_class(self._get_notification_display_el(), 'exiting');
-            self._add_class(bg, 'visible');
-
-            anims.push({
-                el:    self._get_el('bg'),
-                attr:  'opacity',
-                start: 0.0,
-                goal:  MixpanelNotification.BG_OPACITY
-            });
-        }
-
-        var video_el = self._get_el('video-holder');
-        video_el.innerHTML = self.video_iframe;
-
-        var video_ready = function() {
-            if (window['YT'] && window['YT']['loaded']) {
-                self._yt_video_ready();
-            }
-            self.showing_video = true;
-            self._get_notification_display_el().style.visibility = 'hidden';
-        };
-        if (self.flip_animate) {
-            self._add_class('flipper', 'flipped');
-            setTimeout(video_ready, MixpanelNotification.ANIM_TIME);
-        } else {
-            self._animate_els(anims, MixpanelNotification.ANIM_TIME, video_ready);
-        }
-    });
-
-    MixpanelNotification.prototype._track_event = function(event_name, properties, cb) {
-        if (this.campaign_id) {
-            properties = properties || {};
-            properties = _.extend(properties, {
-                'campaign_id':     this.campaign_id,
-                'message_id':      this.message_id,
-                'message_type':    'web_inapp',
-                'message_subtype': this.notif_type
-            });
-            this.mixpanel['track'](event_name, properties, cb);
-        } else if (cb) {
-            cb.call();
-        }
-    };
-
-    MixpanelNotification.prototype._yt_video_ready = _.safewrap(function() {
-        var self = this;
-        if (self.video_inited) {
-            return;
-        }
-        self.video_inited = true;
-
-        var progress_bar  = self._get_el('video-elapsed'),
-            progress_time = self._get_el('video-time'),
-            progress_el   = self._get_el('video-progress');
-
-        new window['YT']['Player'](MixpanelNotification.MARKUP_PREFIX + '-video-frame', {
-            'events': {
-                'onReady': function(event) {
-                    var ytplayer = event['target'],
-                        video_duration = ytplayer['getDuration'](),
-                        pad = function(i) {
-                            return ('00' + i).slice(-2);
-                        },
-                        update_video_time = function(current_time) {
-                            var secs = Math.round(video_duration - current_time),
-                                mins = Math.floor(secs / 60),
-                                hours = Math.floor(mins / 60);
-                            secs -= mins * 60;
-                            mins -= hours * 60;
-                            progress_time.innerHTML = '-' + (hours ? hours + ':' : '') + pad(mins) + ':' + pad(secs);
-                        };
-                    update_video_time(0);
-                    self._video_progress_checker = window.setInterval(function() {
-                        var current_time = ytplayer['getCurrentTime']();
-                        progress_bar.style.width = (current_time / video_duration * 100) + '%';
-                        update_video_time(current_time);
-                    }, 250);
-                    _.register_event(progress_el, 'click', function(e) {
-                        var clickx = Math.max(0, e.pageX - progress_el.getBoundingClientRect().left);
-                        ytplayer['seekTo'](video_duration * clickx / progress_el.clientWidth, true);
-                    });
-                }
-            }
-        });
-    });
-
-    /**
-     * Mixpanel People Object
-     * @constructor
-     */
-    var MixpanelPeople = function() {};
-
-    _.extend(MixpanelPeople.prototype, apiActions);
-
-    MixpanelPeople.prototype._init = function(mixpanel_instance) {
-        this._mixpanel = mixpanel_instance;
-    };
-
-    /*
-    * Set properties on a user record.
-    *
-    * ### Usage:
-    *
-    *     mixpanel.people.set('gender', 'm');
-    *
-    *     // or set multiple properties at once
-    *     mixpanel.people.set({
-    *         'Company': 'Acme',
-    *         'Plan': 'Premium',
-    *         'Upgrade date': new Date()
-    *     });
-    *     // properties can be strings, integers, dates, or lists
-    *
-    * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
-    * @param {*} [to] A value to set on the given property name
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.set = addOptOutCheckMixpanelPeople(function(prop, to, callback) {
-        var data = this.set_action(prop, to);
-        if (_.isObject(prop)) {
-            callback = to;
-        }
-        // make sure that the referrer info has been updated and saved
-        if (this._get_config('save_referrer')) {
-            this._mixpanel['persistence'].update_referrer_info(document.referrer);
-        }
+                });
 
-        // update $set object with default people properties
-        data[SET_ACTION] = _.extend(
-            {},
-            _.info.people_properties(),
-            this._mixpanel['persistence'].get_referrer_info(),
-            data[SET_ACTION]
-        );
-        return this._send_request(data, callback);
-    });
-
-    /*
-    * Set properties on a user record, only if they do not yet exist.
-    * This will not overwrite previous people property values, unlike
-    * people.set().
-    *
-    * ### Usage:
-    *
-    *     mixpanel.people.set_once('First Login Date', new Date());
-    *
-    *     // or set multiple properties at once
-    *     mixpanel.people.set_once({
-    *         'First Login Date': new Date(),
-    *         'Starting Plan': 'Premium'
-    *     });
-    *
-    *     // properties can be strings, integers or dates
-    *
-    * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
-    * @param {*} [to] A value to set on the given property name
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.set_once = addOptOutCheckMixpanelPeople(function(prop, to, callback) {
-        var data = this.set_once_action(prop, to);
-        if (_.isObject(prop)) {
-            callback = to;
-        }
-        return this._send_request(data, callback);
-    });
-
-    /*
-    * Unset properties on a user record (permanently removes the properties and their values from a profile).
-    *
-    * ### Usage:
-    *
-    *     mixpanel.people.unset('gender');
-    *
-    *     // or unset multiple properties at once
-    *     mixpanel.people.unset(['gender', 'Company']);
-    *
-    * @param {Array|String} prop If a string, this is the name of the property. If an array, this is a list of property names.
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.unset = addOptOutCheckMixpanelPeople(function(prop, callback) {
-        var data = this.unset_action(prop);
-        return this._send_request(data, callback);
-    });
-
-    /*
-    * Increment/decrement numeric people analytics properties.
-    *
-    * ### Usage:
-    *
-    *     mixpanel.people.increment('page_views', 1);
-    *
-    *     // or, for convenience, if you're just incrementing a counter by
-    *     // 1, you can simply do
-    *     mixpanel.people.increment('page_views');
-    *
-    *     // to decrement a counter, pass a negative number
-    *     mixpanel.people.increment('credits_left', -1);
-    *
-    *     // like mixpanel.people.set(), you can increment multiple
-    *     // properties at once:
-    *     mixpanel.people.increment({
-    *         counter1: 1,
-    *         counter2: 6
-    *     });
-    *
-    * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and numeric values.
-    * @param {Number} [by] An amount to increment the given property
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.increment = addOptOutCheckMixpanelPeople(function(prop, by, callback) {
-        var data = {};
-        var $add = {};
-        if (_.isObject(prop)) {
-            _.each(prop, function(v, k) {
-                if (!this._is_reserved_property(k)) {
-                    if (isNaN(parseFloat(v))) {
-                        console.error('Invalid increment value passed to mixpanel.people.increment - must be a number');
-                        return;
-                    } else {
-                        $add[k] = v;
-                    }
-                }
-            }, this);
-            callback = by;
-        } else {
-            // convenience: mixpanel.people.increment('property'); will
-            // increment 'property' by 1
-            if (_.isUndefined(by)) {
-                by = 1;
-            }
-            $add[prop] = by;
-        }
-        data[ADD_ACTION] = $add;
-
-        return this._send_request(data, callback);
-    });
-
-    /*
-    * Append a value to a list-valued people analytics property.
-    *
-    * ### Usage:
-    *
-    *     // append a value to a list, creating it if needed
-    *     mixpanel.people.append('pages_visited', 'homepage');
-    *
-    *     // like mixpanel.people.set(), you can append multiple
-    *     // properties at once:
-    *     mixpanel.people.append({
-    *         list1: 'bob',
-    *         list2: 123
-    *     });
-    *
-    * @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
-    * @param {*} [value] value An item to append to the list
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.append = addOptOutCheckMixpanelPeople(function(list_name, value, callback) {
-        if (_.isObject(list_name)) {
-            callback = value;
-        }
-        var data = this.append_action(list_name, value);
-        return this._send_request(data, callback);
-    });
-
-    /*
-    * Remove a value from a list-valued people analytics property.
-    *
-    * ### Usage:
-    *
-    *     mixpanel.people.remove('School', 'UCB');
-    *
-    * @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
-    * @param {*} [value] value Item to remove from the list
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.remove = addOptOutCheckMixpanelPeople(function(list_name, value, callback) {
-        if (_.isObject(list_name)) {
-            callback = value;
-        }
-        var data = this.remove_action(list_name, value);
-        return this._send_request(data, callback);
-    });
-
-    /*
-    * Merge a given list with a list-valued people analytics property,
-    * excluding duplicate values.
-    *
-    * ### Usage:
-    *
-    *     // merge a value to a list, creating it if needed
-    *     mixpanel.people.union('pages_visited', 'homepage');
-    *
-    *     // like mixpanel.people.set(), you can append multiple
-    *     // properties at once:
-    *     mixpanel.people.union({
-    *         list1: 'bob',
-    *         list2: 123
-    *     });
-    *
-    *     // like mixpanel.people.append(), you can append multiple
-    *     // values to the same list:
-    *     mixpanel.people.union({
-    *         list1: ['bob', 'billy']
-    *     });
-    *
-    * @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
-    * @param {*} [value] Value / values to merge with the given property
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.union = addOptOutCheckMixpanelPeople(function(list_name, values, callback) {
-        if (_.isObject(list_name)) {
-            callback = values;
-        }
-        var data = this.union_action(list_name, values);
-        return this._send_request(data, callback);
-    });
-
-    /*
-    * Record that you have charged the current user a certain amount
-    * of money. Charges recorded with track_charge() will appear in the
-    * Mixpanel revenue report.
-    *
-    * ### Usage:
-    *
-    *     // charge a user $50
-    *     mixpanel.people.track_charge(50);
-    *
-    *     // charge a user $30.50 on the 2nd of january
-    *     mixpanel.people.track_charge(30.50, {
-    *         '$time': new Date('jan 1 2012')
-    *     });
-    *
-    * @param {Number} amount The amount of money charged to the current user
-    * @param {Object} [properties] An associative array of properties associated with the charge
-    * @param {Function} [callback] If provided, the callback will be called when the server responds
-    */
-    MixpanelPeople.prototype.track_charge = addOptOutCheckMixpanelPeople(function(amount, properties, callback) {
-        if (!_.isNumber(amount)) {
-            amount = parseFloat(amount);
-            if (isNaN(amount)) {
-                console.error('Invalid value passed to mixpanel.people.track_charge - must be a number');
-                return;
-            }
-        }
-
-        return this.append('$transactions', _.extend({
-            '$amount': amount
-        }, properties), callback);
-    });
-
-    /*
-    * Permanently clear all revenue report transactions from the
-    * current user's people analytics profile.
-    *
-    * ### Usage:
-    *
-    *     mixpanel.people.clear_charges();
-    *
-    * @param {Function} [callback] If provided, the callback will be called after tracking the event.
-    */
-    MixpanelPeople.prototype.clear_charges = function(callback) {
-        return this.set('$transactions', [], callback);
-    };
-
-    /*
-    * Permanently deletes the current people analytics profile from
-    * Mixpanel (using the current distinct_id).
-    *
-    * ### Usage:
-    *
-    *     // remove the all data you have stored about the current user
-    *     mixpanel.people.delete_user();
-    *
-    */
-    MixpanelPeople.prototype.delete_user = function() {
-        if (!this._identify_called()) {
-            console.error('mixpanel.people.delete_user() requires you to call identify() first');
-            return;
-        }
-        var data = {'$delete': this._mixpanel.get_distinct_id()};
-        return this._send_request(data);
-    };
-
-    MixpanelPeople.prototype.toString = function() {
-        return this._mixpanel.toString() + '.people';
-    };
-
-    MixpanelPeople.prototype._send_request = function(data, callback) {
-        data['$token'] = this._get_config('token');
-        data['$distinct_id'] = this._mixpanel.get_distinct_id();
-        var device_id = this._mixpanel.get_property('$device_id');
-        var user_id = this._mixpanel.get_property('$user_id');
-        var had_persisted_distinct_id = this._mixpanel.get_property('$had_persisted_distinct_id');
-        if (device_id) {
-            data['$device_id'] = device_id;
-        }
-        if (user_id) {
-            data['$user_id'] = user_id;
-        }
-        if (had_persisted_distinct_id) {
-            data['$had_persisted_distinct_id'] = had_persisted_distinct_id;
-        }
-
-        var date_encoded_data = _.encodeDates(data);
+                unset_q[prop] = true;
 
-        if (!this._identify_called()) {
-            this._enqueue(data);
-            if (!_.isUndefined(callback)) {
-                if (this._get_config('verbose')) {
-                    callback({status: -1, error: null});
+            });
+        } else if (q_key === ADD_QUEUE_KEY) {
+            _.each(q_data, function(v, k) {
+                // If it exists in the set queue, increment
+                // the value
+                if (k in set_q) {
+                    set_q[k] += v;
                 } else {
-                    callback(-1);
+                    // If it doesn't exist, update the add
+                    // queue
+                    if (!(k in add_q)) {
+                        add_q[k] = 0;
+                    }
+                    add_q[k] += v;
                 }
-            }
-            return _.truncate(date_encoded_data, 255);
+            }, this);
+            this._pop_from_people_queue(UNSET_ACTION, q_data);
+        } else if (q_key === UNION_QUEUE_KEY) {
+            _.each(q_data, function(v, k) {
+                if (_.isArray(v)) {
+                    if (!(k in union_q)) {
+                        union_q[k] = [];
+                    }
+                    // We may send duplicates, the server will dedup them.
+                    union_q[k] = union_q[k].concat(v);
+                }
+            });
+            this._pop_from_people_queue(UNSET_ACTION, q_data);
+        } else if (q_key === REMOVE_QUEUE_KEY) {
+            remove_q.push(q_data);
+            this._pop_from_people_queue(APPEND_ACTION, q_data);
+        } else if (q_key === APPEND_QUEUE_KEY) {
+            append_q.push(q_data);
+            this._pop_from_people_queue(UNSET_ACTION, q_data);
         }
 
-        return this._mixpanel._track_or_batch({
-            type: 'people',
-            data: date_encoded_data,
-            endpoint: this._get_config('api_host') + '/engage/',
-            batcher: this._mixpanel.request_batchers.people
-        }, callback);
-    };
+        console.log('MIXPANEL PEOPLE REQUEST (QUEUED, PENDING IDENTIFY):');
+        console.log(data);
 
-    MixpanelPeople.prototype._get_config = function(conf_var) {
-        return this._mixpanel.get_config(conf_var);
+        this.save();
     };
 
-    MixpanelPeople.prototype._identify_called = function() {
-        return this._mixpanel._flags.identify_called === true;
-    };
+    MixpanelPersistence.prototype._pop_from_people_queue = function(queue, data) {
+        var q = this._get_queue(queue);
+        if (!_.isUndefined(q)) {
+            _.each(data, function(v, k) {
+                if (queue === APPEND_ACTION || queue === REMOVE_ACTION) {
+                    // list actions: only remove if both k+v match
+                    // e.g. remove should not override append in a case like
+                    // append({foo: 'bar'}); remove({foo: 'qux'})
+                    _.each(q, function(queued_action) {
+                        if (queued_action[k] === v) {
+                            delete queued_action[k];
+                        }
+                    });
+                } else {
+                    delete q[k];
+                }
+            }, this);
 
-    // Queue up engage operations if identify hasn't been called yet.
-    MixpanelPeople.prototype._enqueue = function(data) {
-        if (SET_ACTION in data) {
-            this._mixpanel['persistence']._add_to_people_queue(SET_ACTION, data);
-        } else if (SET_ONCE_ACTION in data) {
-            this._mixpanel['persistence']._add_to_people_queue(SET_ONCE_ACTION, data);
-        } else if (UNSET_ACTION in data) {
-            this._mixpanel['persistence']._add_to_people_queue(UNSET_ACTION, data);
-        } else if (ADD_ACTION in data) {
-            this._mixpanel['persistence']._add_to_people_queue(ADD_ACTION, data);
-        } else if (APPEND_ACTION in data) {
-            this._mixpanel['persistence']._add_to_people_queue(APPEND_ACTION, data);
-        } else if (REMOVE_ACTION in data) {
-            this._mixpanel['persistence']._add_to_people_queue(REMOVE_ACTION, data);
-        } else if (UNION_ACTION in data) {
-            this._mixpanel['persistence']._add_to_people_queue(UNION_ACTION, data);
-        } else {
-            console.error('Invalid call to _enqueue():', data);
+            this.save();
         }
     };
 
-    MixpanelPeople.prototype._flush_one_queue = function(action, action_method, callback, queue_to_params_fn) {
-        var _this = this;
-        var queued_data = _.extend({}, this._mixpanel['persistence']._get_queue(action));
-        var action_params = queued_data;
-
-        if (!_.isUndefined(queued_data) && _.isObject(queued_data) && !_.isEmptyObject(queued_data)) {
-            _this._mixpanel['persistence']._pop_from_people_queue(action, queued_data);
-            if (queue_to_params_fn) {
-                action_params = queue_to_params_fn(queued_data);
-            }
-            action_method.call(_this, action_params, function(response, data) {
-                // on bad response, we want to add it back to the queue
-                if (response === 0) {
-                    _this._mixpanel['persistence']._add_to_people_queue(action, queued_data);
-                }
-                if (!_.isUndefined(callback)) {
-                    callback(response, data);
-                }
-            });
+    MixpanelPersistence.prototype._get_queue_key = function(queue) {
+        if (queue === SET_ACTION) {
+            return SET_QUEUE_KEY;
+        } else if (queue === SET_ONCE_ACTION) {
+            return SET_ONCE_QUEUE_KEY;
+        } else if (queue === UNSET_ACTION) {
+            return UNSET_QUEUE_KEY;
+        } else if (queue === ADD_ACTION) {
+            return ADD_QUEUE_KEY;
+        } else if (queue === APPEND_ACTION) {
+            return APPEND_QUEUE_KEY;
+        } else if (queue === REMOVE_ACTION) {
+            return REMOVE_QUEUE_KEY;
+        } else if (queue === UNION_ACTION) {
+            return UNION_QUEUE_KEY;
+        } else {
+            console.error('Invalid queue:', queue);
         }
     };
 
-    // Flush queued engage operations - order does not matter,
-    // and there are network level race conditions anyway
-    MixpanelPeople.prototype._flush = function(
-        _set_callback, _add_callback, _append_callback, _set_once_callback, _union_callback, _unset_callback, _remove_callback
-    ) {
-        var _this = this;
-        var $append_queue = this._mixpanel['persistence']._get_queue(APPEND_ACTION);
-        var $remove_queue = this._mixpanel['persistence']._get_queue(REMOVE_ACTION);
-
-        this._flush_one_queue(SET_ACTION, this.set, _set_callback);
-        this._flush_one_queue(SET_ONCE_ACTION, this.set_once, _set_once_callback);
-        this._flush_one_queue(UNSET_ACTION, this.unset, _unset_callback, function(queue) { return _.keys(queue); });
-        this._flush_one_queue(ADD_ACTION, this.increment, _add_callback);
-        this._flush_one_queue(UNION_ACTION, this.union, _union_callback);
-
-        // we have to fire off each $append individually since there is
-        // no concat method server side
-        if (!_.isUndefined($append_queue) && _.isArray($append_queue) && $append_queue.length) {
-            var $append_item;
-            var append_callback = function(response, data) {
-                if (response === 0) {
-                    _this._mixpanel['persistence']._add_to_people_queue(APPEND_ACTION, $append_item);
-                }
-                if (!_.isUndefined(_append_callback)) {
-                    _append_callback(response, data);
-                }
-            };
-            for (var i = $append_queue.length - 1; i >= 0; i--) {
-                $append_item = $append_queue.pop();
-                if (!_.isEmptyObject($append_item)) {
-                    _this.append($append_item, append_callback);
-                }
-            }
-            // Save the shortened append queue
-            _this._mixpanel['persistence'].save();
-        }
+    MixpanelPersistence.prototype._get_queue = function(queue) {
+        return this['props'][this._get_queue_key(queue)];
+    };
+    MixpanelPersistence.prototype._get_or_create_queue = function(queue, default_val) {
+        var key = this._get_queue_key(queue);
+        default_val = _.isUndefined(default_val) ? {} : default_val;
 
-        // same for $remove
-        if (!_.isUndefined($remove_queue) && _.isArray($remove_queue) && $remove_queue.length) {
-            var $remove_item;
-            var remove_callback = function(response, data) {
-                if (response === 0) {
-                    _this._mixpanel['persistence']._add_to_people_queue(REMOVE_ACTION, $remove_item);
-                }
-                if (!_.isUndefined(_remove_callback)) {
-                    _remove_callback(response, data);
-                }
-            };
-            for (var j = $remove_queue.length - 1; j >= 0; j--) {
-                $remove_item = $remove_queue.pop();
-                if (!_.isEmptyObject($remove_item)) {
-                    _this.remove($remove_item, remove_callback);
-                }
-            }
-            _this._mixpanel['persistence'].save();
-        }
+        return this['props'][key] || (this['props'][key] = default_val);
     };
 
-    MixpanelPeople.prototype._is_reserved_property = function(prop) {
-        return prop === '$distinct_id' || prop === '$token' || prop === '$device_id' || prop === '$user_id' || prop === '$had_persisted_distinct_id';
+    MixpanelPersistence.prototype.set_event_timer = function(event_name, timestamp) {
+        var timers = this['props'][EVENT_TIMERS_KEY] || {};
+        timers[event_name] = timestamp;
+        this['props'][EVENT_TIMERS_KEY] = timers;
+        this.save();
     };
 
-    // MixpanelPeople Exports
-    MixpanelPeople.prototype['set']           = MixpanelPeople.prototype.set;
-    MixpanelPeople.prototype['set_once']      = MixpanelPeople.prototype.set_once;
-    MixpanelPeople.prototype['unset']         = MixpanelPeople.prototype.unset;
-    MixpanelPeople.prototype['increment']     = MixpanelPeople.prototype.increment;
-    MixpanelPeople.prototype['append']        = MixpanelPeople.prototype.append;
-    MixpanelPeople.prototype['remove']        = MixpanelPeople.prototype.remove;
-    MixpanelPeople.prototype['union']         = MixpanelPeople.prototype.union;
-    MixpanelPeople.prototype['track_charge']  = MixpanelPeople.prototype.track_charge;
-    MixpanelPeople.prototype['clear_charges'] = MixpanelPeople.prototype.clear_charges;
-    MixpanelPeople.prototype['delete_user']   = MixpanelPeople.prototype.delete_user;
-    MixpanelPeople.prototype['toString']      = MixpanelPeople.prototype.toString;
+    MixpanelPersistence.prototype.remove_event_timer = function(event_name) {
+        var timers = this['props'][EVENT_TIMERS_KEY] || {};
+        var timestamp = timers[event_name];
+        if (!_.isUndefined(timestamp)) {
+            delete this['props'][EVENT_TIMERS_KEY][event_name];
+            this.save();
+        }
+        return timestamp;
+    };
 
     /*
      * Mixpanel JS Library
@@ -5846,6 +4096,7 @@
     /** @const */ var PRIMARY_INSTANCE_NAME = 'mixpanel';
     /** @const */ var PAYLOAD_TYPE_BASE64   = 'base64';
     /** @const */ var PAYLOAD_TYPE_JSON     = 'json';
+    /** @const */ var DEVICE_ID_PREFIX      = '$device:';
 
 
     /*
@@ -5862,10 +4113,10 @@
 
     // save reference to navigator.sendBeacon so it can be minified
     var sendBeacon = null;
-    if (navigator$1['sendBeacon']) {
+    if (navigator['sendBeacon']) {
         sendBeacon = function() {
             // late reference to navigator.sendBeacon to allow patching/spying
-            return navigator$1['sendBeacon'].apply(navigator$1, arguments);
+            return navigator['sendBeacon'].apply(navigator, arguments);
         };
     }
 
@@ -5881,6 +4132,7 @@
         'cdn':                               'https://cdn.mxpnl.com',
         'cross_site_cookie':                 false,
         'cross_subdomain_cookie':            true,
+        'error_reporter':                    NOOP_FUNC,
         'persistence':                       'cookie',
         'persistence_name':                  '',
         'cookie_domain':                     '',
@@ -5905,8 +4157,6 @@
         'opt_out_tracking_cookie_prefix':    null,
         'property_blacklist':                [],
         'xhr_headers':                       {}, // { header: value, header2: value }
-        'inapp_protocol':                    '//',
-        'inapp_link_new_window':             false,
         'ignore_dnt':                        false,
         'batch_requests':                    true,
         'batch_size':                        50,
@@ -5948,8 +4198,6 @@
         }
 
         instance._cached_groups = {}; // cache groups in a pool
-        instance._user_decide_check_complete = false;
-        instance._events_tracked_before_user_decide_check_complete = [];
 
         instance._init(token, config, name);
 
@@ -5992,11 +4240,11 @@
      */
     MixpanelLib.prototype.init = function (token, config, name) {
         if (_.isUndefined(name)) {
-            console.error('You must name your new library: init(token, config, name)');
+            this.report_error('You must name your new library: init(token, config, name)');
             return;
         }
         if (name === PRIMARY_INSTANCE_NAME) {
-            console.error('You must initialize the main mixpanel object right after you include the Mixpanel js snippet');
+            this.report_error('You must initialize the main mixpanel object right after you include the Mixpanel js snippet');
             return;
         }
 
@@ -6019,7 +4267,6 @@
 
         this['__loaded'] = true;
         this['config'] = {};
-        this['_triggered_notifs'] = [];
 
         var variable_features = {};
 
@@ -6097,7 +4344,7 @@
             // or the device id if something was already stored
             // in the persitence
             this.register_once({
-                'distinct_id': uuid,
+                'distinct_id': DEVICE_ID_PREFIX + uuid,
                 '$device_id': uuid
             }, '');
         }
@@ -6138,7 +4385,7 @@
 
     MixpanelLib.prototype._track_dom = function(DomClass, args) {
         if (this.get_config('img')) {
-            console.error('You can\'t use DOM tracking functions with img = true.');
+            this.report_error('You can\'t use DOM tracking functions with img = true.');
             return false;
         }
 
@@ -6240,6 +4487,7 @@
 
         url += '?' + _.HTTPBuildQuery(data);
 
+        var lib = this;
         if ('img' in data) {
             var img = document$1.createElement('img');
             img.src = url;
@@ -6248,7 +4496,7 @@
             try {
                 succeeded = sendBeacon(url, body_data);
             } catch (e) {
-                console.error(e);
+                lib.report_error(e);
                 succeeded = false;
             }
             try {
@@ -6256,7 +4504,7 @@
                     callback(succeeded ? 1 : 0);
                 }
             } catch (e) {
-                console.error(e);
+                lib.report_error(e);
             }
         } else if (USE_XHR) {
             try {
@@ -6288,7 +4536,7 @@
                                     try {
                                         response = _.JSONDecode(req.responseText);
                                     } catch (e) {
-                                        console.error(e);
+                                        lib.report_error(e);
                                         if (options.ignore_json_errors) {
                                             response = req.responseText;
                                         } else {
@@ -6311,7 +4559,7 @@
                             } else {
                                 error = 'Bad HTTP status: ' + req.status + ' ' + req.statusText;
                             }
-                            console.error(error);
+                            lib.report_error(error);
                             if (callback) {
                                 if (verbose_mode) {
                                     callback({status: 0, error: error, xhr_req: req});
@@ -6324,7 +4572,7 @@
                 };
                 req.send(body_data);
             } catch (e) {
-                console.error(e);
+                lib.report_error(e);
                 succeeded = false;
             }
         } else {
@@ -6414,7 +4662,9 @@
                         }, this),
                         beforeSendHook: _.bind(function(item) {
                             return this._run_hook('before_send_' + attrs.type, item);
-                        }, this)
+                        }, this),
+                        errorReporter: this.get_config('error_reporter'),
+                        stopAllBatchingFunc: _.bind(this.stop_batch_senders, this)
                     }
                 );
             }, this);
@@ -6571,7 +4821,7 @@
         }
 
         if (_.isUndefined(event_name)) {
-            console.error('No event name provided to mixpanel.track');
+            this.report_error('No event name provided to mixpanel.track');
             return;
         }
 
@@ -6612,7 +4862,7 @@
                 delete properties[blacklisted_prop];
             });
         } else {
-            console.error('Invalid value for property_blacklist config: ' + property_blacklist);
+            this.report_error('Invalid value for property_blacklist config: ' + property_blacklist);
         }
 
         var data = {
@@ -6628,8 +4878,6 @@
             send_request_options: options
         }, callback);
 
-        this._check_and_handle_triggered_notifications(data);
-
         return ret;
     });
 
@@ -6857,7 +5105,7 @@
      */
     MixpanelLib.prototype.time_event = function(event_name) {
         if (_.isUndefined(event_name)) {
-            console.error('No event name provided to mixpanel.time_event');
+            this.report_error('No event name provided to mixpanel.time_event');
             return;
         }
 
@@ -7022,7 +5270,15 @@
         //  _unset_callback:function  A callback to be run if and when the People unset queue is flushed
 
         var previous_distinct_id = this.get_distinct_id();
-        this.register({'$user_id': new_distinct_id});
+        if (new_distinct_id && previous_distinct_id !== new_distinct_id) {
+            // we allow the following condition if previous distinct_id is same as new_distinct_id
+            // so that you can force flush people updates for anonymous profiles.
+            if (typeof new_distinct_id === 'string' && new_distinct_id.indexOf(DEVICE_ID_PREFIX) === 0) {
+                this.report_error('distinct_id cannot have $device: prefix');
+                return -1;
+            }
+            this.register({'$user_id': new_distinct_id});
+        }
 
         if (!this.get_property('$device_id')) {
             // The persisted distinct id might not actually be a device id at all
@@ -7040,7 +5296,6 @@
             this.unregister(ALIAS_ID_KEY);
             this.register({'distinct_id': new_distinct_id});
         }
-        this._check_and_handle_notifications(this.get_distinct_id());
         this._flags.identify_called = true;
         // Flush any queued up people requests
         this['people']._flush(_set_callback, _add_callback, _append_callback, _set_once_callback, _union_callback, _unset_callback, _remove_callback);
@@ -7064,7 +5319,7 @@
         this._flags.identify_called = false;
         var uuid = _.UUID();
         this.register_once({
-            'distinct_id': uuid,
+            'distinct_id': DEVICE_ID_PREFIX + uuid,
             '$device_id': uuid
         }, '');
     };
@@ -7130,7 +5385,7 @@
         // mixpanel.people.identify() call made for this user. It is VERY BAD to make an alias with
         // this ID, as it will duplicate users.
         if (alias === this.get_property(PEOPLE_DISTINCT_ID_KEY)) {
-            console.critical('Attempting to create alias for existing People user - aborting.');
+            this.report_error('Attempting to create alias for existing People user - aborting.');
             return -2;
         }
 
@@ -7150,7 +5405,7 @@
                 _this.identify(alias);
             });
         } else {
-            console.error('alias matches current distinct_id - skipping api call.');
+            this.report_error('alias matches current distinct_id - skipping api call.');
             this.identify(alias);
             return -1;
         }
@@ -7189,8 +5444,8 @@
      *       // batching or retry mechanisms.
      *       api_transport: 'XHR'
      *
-     *       // turn on request-batching/queueing/retry
-     *       batch_requests: false,
+     *       // request-batching/queueing/retry
+     *       batch_requests: true,
      *
      *       // maximum number of events/updates to send in a single
      *       // network request
@@ -7277,14 +5532,6 @@
      *       // the format {'Header-Name': value}
      *       xhr_headers: {}
      *
-     *       // protocol for fetching in-app message resources, e.g.
-     *       // 'https://' or 'http://'; defaults to '//' (which defers to the
-     *       // current page's protocol)
-     *       inapp_protocol: '//'
-     *
-     *       // whether to open in-app message link in new tab/window
-     *       inapp_link_new_window: false
-     *
      *       // whether to ignore or respect the web browser's Do Not Track setting
      *       ignore_dnt: false
      *     }
@@ -7333,7 +5580,7 @@
     MixpanelLib.prototype._run_hook = function(hook_name) {
         var ret = (this['config']['hooks'][hook_name] || IDENTITY_FUNC).apply(this, slice.call(arguments, 1));
         if (typeof ret === 'undefined') {
-            console.error(hook_name + ' hook did not return a value');
+            this.report_error(hook_name + ' hook did not return a value');
             ret = null;
         }
         return ret;
@@ -7375,75 +5622,6 @@
             _.include(this.__disabled_events, event_name);
     };
 
-    MixpanelLib.prototype._check_and_handle_triggered_notifications = addOptOutCheckMixpanelLib(function(event_data) {
-        if (!this._user_decide_check_complete) {
-            this._events_tracked_before_user_decide_check_complete.push(event_data);
-        } else {
-            var arr = this['_triggered_notifs'];
-            for (var i = 0; i < arr.length; i++) {
-                var notif = new MixpanelNotification(arr[i], this);
-                if (notif._matches_event_data(event_data)) {
-                    this._show_notification(arr[i]);
-                    return;
-                }
-            }
-        }
-    });
-
-    MixpanelLib.prototype._check_and_handle_notifications = addOptOutCheckMixpanelLib(function(distinct_id) {
-        if (
-            !distinct_id ||
-            this._flags.identify_called ||
-            this.get_config('disable_notifications')
-        ) {
-            return;
-        }
-
-        console.log('MIXPANEL NOTIFICATION CHECK');
-
-        var data = {
-            'verbose':     true,
-            'version':     '3',
-            'lib':         'web',
-            'token':       this.get_config('token'),
-            'distinct_id': distinct_id
-        };
-        this._send_request(
-            this.get_config('api_host') + '/decide/',
-            data,
-            {method: 'GET', transport: 'XHR'},
-            this._prepare_callback(_.bind(function(result) {
-                if (result['notifications'] && result['notifications'].length > 0) {
-                    this['_triggered_notifs'] = [];
-                    var notifications = [];
-                    _.each(result['notifications'], function(notif) {
-                        (notif['display_triggers'] && notif['display_triggers'].length > 0 ? this['_triggered_notifs'] : notifications).push(notif);
-                    }, this);
-                    if (notifications.length > 0) {
-                        this._show_notification.call(this, notifications[0]);
-                    }
-                }
-                this._handle_user_decide_check_complete();
-            }, this))
-        );
-    });
-
-    MixpanelLib.prototype._handle_user_decide_check_complete = function() {
-        this._user_decide_check_complete = true;
-
-        // check notifications against events that were tracked before decide call completed
-        var events = this._events_tracked_before_user_decide_check_complete;
-        while (events.length > 0) {
-            var data = events.shift(); // replay in the same order they came in
-            this._check_and_handle_triggered_notifications(data);
-        }
-    };
-
-    MixpanelLib.prototype._show_notification = function(notif_data) {
-        var notification = new MixpanelNotification(notif_data, this);
-        notification.show();
-    };
-
     // perform some housekeeping around GDPR opt-in/out state
     MixpanelLib.prototype._gdpr_init = function() {
         var is_localStorage_requested = this.get_config('opt_out_tracking_persistence_type') === 'localStorage';
@@ -7689,6 +5867,18 @@
         this._gdpr_update_persistence(options);
     };
 
+    MixpanelLib.prototype.report_error = function(msg, err) {
+        console.error.apply(console.error, arguments);
+        try {
+            if (!err && !(msg instanceof Error)) {
+                msg = new Error(msg);
+            }
+            this.get_config('error_reporter')(msg, err);
+        } catch(err) {
+            console.error(err);
+        }
+    };
+
     // EXPORTS (for closure compiler)
 
     // MixpanelLib Exports
@@ -7711,9 +5901,6 @@
     MixpanelLib.prototype['get_property']                       = MixpanelLib.prototype.get_property;
     MixpanelLib.prototype['get_distinct_id']                    = MixpanelLib.prototype.get_distinct_id;
     MixpanelLib.prototype['toString']                           = MixpanelLib.prototype.toString;
-    MixpanelLib.prototype['_check_and_handle_notifications']    = MixpanelLib.prototype._check_and_handle_notifications;
-    MixpanelLib.prototype['_handle_user_decide_check_complete'] = MixpanelLib.prototype._handle_user_decide_check_complete;
-    MixpanelLib.prototype['_show_notification']                 = MixpanelLib.prototype._show_notification;
     MixpanelLib.prototype['opt_out_tracking']                   = MixpanelLib.prototype.opt_out_tracking;
     MixpanelLib.prototype['opt_in_tracking']                    = MixpanelLib.prototype.opt_in_tracking;
     MixpanelLib.prototype['has_opted_out_tracking']             = MixpanelLib.prototype.has_opted_out_tracking;
@@ -7734,8 +5921,6 @@
     MixpanelPersistence.prototype['get_cross_subdomain']   = MixpanelPersistence.prototype.get_cross_subdomain;
     MixpanelPersistence.prototype['clear']                 = MixpanelPersistence.prototype.clear;
 
-    _.safewrap_class(MixpanelLib, ['identify', '_check_and_handle_notifications', '_show_notification']);
-
 
     var instances = {};
     var extend_mp = function() {