@usermaven/sdk-js 1.0.0 → 1.0.4

package/dist/npm/usermaven.es.js

@@ -217,10 +217,1506 @@ function createLogger(logLevel) {
     return logger;
 }
 
+var Config$1 = {
+    DEBUG: false,
+    LIB_VERSION: '1.0.0',
+};
+
+/* eslint camelcase: "off", eqeqeq: "off" */
+
+/*
+ * Saved references to long variable names, so that closure compiler can
+ * minimize file size.
+ */
+
+const ArrayProto = Array.prototype,
+    FuncProto = Function.prototype,
+    ObjProto = Object.prototype,
+    slice = ArrayProto.slice,
+    toString = ObjProto.toString,
+    hasOwnProperty = ObjProto.hasOwnProperty,
+    win = typeof window !== 'undefined' ? window : {},
+    navigator$1 = win.navigator || { userAgent: '' },
+    document$1 = win.document || {},
+    userAgent = navigator$1.userAgent;
+
+const nativeBind = FuncProto.bind,
+    nativeForEach = ArrayProto.forEach,
+    nativeIndexOf = ArrayProto.indexOf,
+    nativeIsArray = Array.isArray,
+    breaker = {};
+
+var _ = {
+    trim: function (str) {
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill
+        return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '')
+    },
+};
+
+// Console override
+var console$1 = {
+    /** @type {function(...*)} */
+    log: function () {
+    },
+    /** @type {function(...*)} */
+    error: function () {
+    },
+    /** @type {function(...*)} */
+    critical: function () {
+        if (!_.isUndefined(window.console) && window.console) {
+            var args = ['UserMaven error:', ...arguments];
+            try {
+                window.console.error.apply(window.console, args);
+            } catch (err) {
+                _.each(args, function (arg) {
+                    window.console.error(arg);
+                });
+            }
+        }
+    },
+};
+
+// UNDERSCORE
+// Embed part of the Underscore Library
+_.bind = function (func, context) {
+    var args, bound;
+    if (nativeBind && func.bind === nativeBind) {
+        return nativeBind.apply(func, slice.call(arguments, 1))
+    }
+    if (!_.isFunction(func)) {
+        throw new TypeError()
+    }
+    args = slice.call(arguments, 2);
+    bound = function () {
+        if (!(this instanceof bound)) {
+            return func.apply(context, args.concat(slice.call(arguments)))
+        }
+        var ctor = {};
+        ctor.prototype = func.prototype;
+        var self = new ctor();
+        ctor.prototype = null;
+        var result = func.apply(self, args.concat(slice.call(arguments)));
+        if (Object(result) === result) {
+            return result
+        }
+        return self
+    };
+    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
+ * @param {Object=} context
+ */
+_.each = function (obj, iterator, context) {
+    if (obj === null || obj === undefined) {
+        return
+    }
+    if (nativeForEach && obj.forEach === nativeForEach) {
+        obj.forEach(iterator, context);
+    } else if (obj.length === +obj.length) {
+        for (var i = 0, l = obj.length; i < l; i++) {
+            if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) {
+                return
+            }
+        }
+    } else {
+        for (var key in obj) {
+            if (hasOwnProperty.call(obj, key)) {
+                if (iterator.call(context, obj[key], key, obj) === breaker) {
+                    return
+                }
+            }
+        }
+    }
+};
+
+_.extend = function (obj) {
+    _.each(slice.call(arguments, 1), function (source) {
+        for (var prop in source) {
+            if (source[prop] !== void 0) {
+                obj[prop] = source[prop];
+            }
+        }
+    });
+    return obj
+};
+
+_.isArray =
+    nativeIsArray ||
+    function (obj) {
+        return toString.call(obj) === '[object Array]'
+    };
+
+// from a comment on http://dbj.org/dbj/?p=286
+// fails on only one very rare and deliberate custom object:
+// var bomb = { toString : undefined, valueOf: function(o) { return "function BOMBA!"; }};
+_.isFunction = function (f) {
+    try {
+        return /^\s*\bfunction\b/.test(f)
+    } catch (x) {
+        return false
+    }
+};
+
+_.include = function (obj, target) {
+    var found = false;
+    if (obj === null) {
+        return found
+    }
+    if (nativeIndexOf && obj.indexOf === nativeIndexOf) {
+        return obj.indexOf(target) != -1
+    }
+    _.each(obj, function (value) {
+        if (found || (found = value === target)) {
+            return breaker
+        }
+    });
+    return found
+};
+
+_.includes = function (str, needle) {
+    return str.indexOf(needle) !== -1
+};
+
+// Underscore Addons
+_.isObject = function (obj) {
+    return obj === Object(obj) && !_.isArray(obj)
+};
+
+_.isEmptyObject = function (obj) {
+    if (_.isObject(obj)) {
+        for (var key in obj) {
+            if (hasOwnProperty.call(obj, key)) {
+                return false
+            }
+        }
+        return true
+    }
+    return false
+};
+
+_.isUndefined = function (obj) {
+    return obj === void 0
+};
+
+_.isString = function (obj) {
+    return toString.call(obj) == '[object String]'
+};
+
+_.isDate = function (obj) {
+    return toString.call(obj) == '[object Date]'
+};
+
+_.isNumber = function (obj) {
+    return toString.call(obj) == '[object Number]'
+};
+
+_.encodeDates = function (obj) {
+    _.each(obj, function (v, k) {
+        if (_.isDate(v)) {
+            obj[k] = _.formatDate(v);
+        } else if (_.isObject(v)) {
+            obj[k] = _.encodeDates(v); // recurse
+        }
+    });
+    return obj
+};
+
+_.timestamp = function () {
+    Date.now =
+        Date.now ||
+        function () {
+            return +new Date()
+        };
+    return Date.now()
+};
+
+_.formatDate = function (d) {
+    // YYYY-MM-DDTHH:MM:SS in UTC
+    function pad(n) {
+        return n < 10 ? '0' + n : n
+    }
+    return (
+        d.getUTCFullYear() +
+        '-' +
+        pad(d.getUTCMonth() + 1) +
+        '-' +
+        pad(d.getUTCDate()) +
+        'T' +
+        pad(d.getUTCHours()) +
+        ':' +
+        pad(d.getUTCMinutes()) +
+        ':' +
+        pad(d.getUTCSeconds())
+    )
+};
+
+_.safewrap = function (f) {
+    return function () {
+        try {
+            return f.apply(this, arguments)
+        } catch (e) {
+            console$1.critical('Implementation error. Please turn on debug and contact support@usermaven.com.');
+        }
+    }
+};
+
+_.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) {
+        if (_.isString(v) && v.length > 0) {
+            ret[k] = v;
+        }
+    });
+    return ret
+};
+
+// Deep copies an object.
+// It handles cycles by replacing all references to them with `undefined`
+// Also supports customizing native values
+const COPY_IN_PROGRESS_ATTRIBUTE =
+    typeof Symbol !== 'undefined' ? Symbol('__deepCircularCopyInProgress__') : '__deepCircularCopyInProgress__';
+
+function deepCircularCopy(value, customizer) {
+    if (value !== Object(value)) return customizer ? customizer(value) : value // primitive value
+
+    if (value[COPY_IN_PROGRESS_ATTRIBUTE]) return undefined
+
+    value[COPY_IN_PROGRESS_ATTRIBUTE] = true;
+    let result;
+
+    if (_.isArray(value)) {
+        result = [];
+        _.each(value, (it) => {
+            result.push(deepCircularCopy(it, customizer));
+        });
+    } else {
+        result = {};
+        _.each(value, (val, key) => {
+            if (key !== COPY_IN_PROGRESS_ATTRIBUTE) {
+                result[key] = deepCircularCopy(val, customizer);
+            }
+        });
+    }
+    delete value[COPY_IN_PROGRESS_ATTRIBUTE];
+    return result
+}
+
+_.copyAndTruncateStrings = (object, maxStringLength) =>
+    deepCircularCopy(
+        object,
+        (value) => {
+            if (typeof value === 'string' && maxStringLength !== null) {
+                value = value.slice(0, maxStringLength);
+            }
+            return value
+        });
+
+_.base64Encode = function (data) {
+    var b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+    var o1,
+        o2,
+        o3,
+        h1,
+        h2,
+        h3,
+        h4,
+        bits,
+        i = 0,
+        ac = 0,
+        enc = '',
+        tmp_arr = [];
+
+    if (!data) {
+        return data
+    }
+
+    data = _.utf8Encode(data);
+
+    do {
+        // pack three octets into four hexets
+        o1 = data.charCodeAt(i++);
+        o2 = data.charCodeAt(i++);
+        o3 = data.charCodeAt(i++);
+
+        bits = (o1 << 16) | (o2 << 8) | o3;
+
+        h1 = (bits >> 18) & 0x3f;
+        h2 = (bits >> 12) & 0x3f;
+        h3 = (bits >> 6) & 0x3f;
+        h4 = bits & 0x3f;
+
+        // use hexets to index into b64, and append result to encoded string
+        tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
+    } while (i < data.length)
+
+    enc = tmp_arr.join('');
+
+    switch (data.length % 3) {
+        case 1:
+            enc = enc.slice(0, -2) + '==';
+            break
+        case 2:
+            enc = enc.slice(0, -1) + '=';
+            break
+    }
+
+    return enc
+};
+
+_.utf8Encode = function (string) {
+    string = (string + '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+    var utftext = '',
+        start,
+        end;
+    var stringl = 0,
+        n;
+
+    start = end = 0;
+    stringl = string.length;
+
+    for (n = 0; n < stringl; n++) {
+        var c1 = string.charCodeAt(n);
+        var enc = null;
+
+        if (c1 < 128) {
+            end++;
+        } else if (c1 > 127 && c1 < 2048) {
+            enc = String.fromCharCode((c1 >> 6) | 192, (c1 & 63) | 128);
+        } else {
+            enc = String.fromCharCode((c1 >> 12) | 224, ((c1 >> 6) & 63) | 128, (c1 & 63) | 128);
+        }
+        if (enc !== null) {
+            if (end > start) {
+                utftext += string.substring(start, end);
+            }
+            utftext += enc;
+            start = end = n + 1;
+        }
+    }
+
+    if (end > start) {
+        utftext += string.substring(start, string.length);
+    }
+
+    return utftext
+};
+
+_.UUID = (function () {
+    // Time/ticks information
+    // 1*new Date() is a cross browser version of Date.now()
+    var T = function () {
+        var d = 1 * new Date(),
+            i = 0;
+
+        // this while loop figures how many browser ticks go by
+        // before 1*new Date() returns a new number, ie the amount
+        // of ticks that go by per millisecond
+        while (d == 1 * new Date()) {
+            i++;
+        }
+
+        return d.toString(16) + i.toString(16)
+    };
+
+    // Math.Random entropy
+    var R = function () {
+        return Math.random().toString(16).replace('.', '')
+    };
+
+    // User agent entropy
+    // This function takes the user agent string, and then xors
+    // together each sequence of 8 bytes.  This produces a final
+    // sequence of 8 bytes which it returns as hex.
+    var UA = function () {
+        var ua = userAgent,
+            i,
+            ch,
+            buffer = [],
+            ret = 0;
+
+        function xor(result, byte_array) {
+            var j,
+                tmp = 0;
+            for (j = 0; j < byte_array.length; j++) {
+                tmp |= buffer[j] << (j * 8);
+            }
+            return result ^ tmp
+        }
+
+        for (i = 0; i < ua.length; i++) {
+            ch = ua.charCodeAt(i);
+            buffer.unshift(ch & 0xff);
+            if (buffer.length >= 4) {
+                ret = xor(ret, buffer);
+                buffer = [];
+            }
+        }
+
+        if (buffer.length > 0) {
+            ret = xor(ret, buffer);
+        }
+
+        return ret.toString(16)
+    };
+
+    return function () {
+        var se = (window.screen.height * window.screen.width).toString(16);
+        return T() + '-' + R() + '-' + UA() + '-' + se + '-' + T()
+    }
+})();
+
+// _.isBlockedUA()
+// This is to block various web spiders from executing our JS and
+// sending false captureing data
+_.isBlockedUA = function (ua) {
+    if (/(google web preview|baiduspider|yandexbot|bingbot|googlebot|yahoo! slurp)/i.test(ua)) {
+        return true
+    }
+    return false
+};
+
+/**
+ * @param {Object=} formdata
+ * @param {string=} arg_separator
+ */
+_.HTTPBuildQuery = function (formdata, arg_separator) {
+    var use_val,
+        use_key,
+        tph_arr = [];
+
+    if (_.isUndefined(arg_separator)) {
+        arg_separator = '&';
+    }
+
+    _.each(formdata, function (val, key) {
+        use_val = encodeURIComponent(val.toString());
+        use_key = encodeURIComponent(key);
+        tph_arr[tph_arr.length] = use_key + '=' + use_val;
+    });
+
+    return tph_arr.join(arg_separator)
+};
+
+_.getQueryParam = function (url, param) {
+    // Expects a raw URL
+
+    param = param.replace(/[[]/, '\\[').replace(/[\]]/, '\\]');
+    var regexS = '[\\?&]' + param + '=([^&#]*)',
+        regex = new RegExp(regexS),
+        results = regex.exec(url);
+    if (results === null || (results && typeof results[1] !== 'string' && results[1].length)) {
+        return ''
+    } else {
+        var result = results[1];
+        try {
+            result = decodeURIComponent(result);
+        } catch (err) {
+        }
+        return result.replace(/\+/g, ' ')
+    }
+};
+
+_.getHashParam = function (hash, param) {
+    var matches = hash.match(new RegExp(param + '=([^&]*)'));
+    return matches ? matches[1] : null
+};
+
+_.register_event = (function () {
+    // written by Dean Edwards, 2005
+    // with input from Tino Zijdel - crisp@xs4all.nl
+    // with input from Carl Sverre - mail@carlsverre.com
+    // http://dean.edwards.name/weblog/2005/10/add-event/
+    // https://gist.github.com/1930440
+
+    /**
+     * @param {Object} element
+     * @param {string} type
+     * @param {function(...*)} handler
+     * @param {boolean=} oldSchool
+     * @param {boolean=} useCapture
+     */
+    var register_event = function (element, type, handler, oldSchool, useCapture) {
+        if (!element) {
+            return
+        }
+
+        if (element.addEventListener && !oldSchool) {
+            element.addEventListener(type, handler, !!useCapture);
+        } else {
+            var ontype = 'on' + type;
+            var old_handler = element[ontype]; // can be undefined
+            element[ontype] = makeHandler(element, handler, old_handler);
+        }
+    };
+
+    function makeHandler(element, new_handler, old_handlers) {
+        var handler = function (event) {
+            event = event || fixEvent(window.event);
+
+            // this basically happens in firefox whenever another script
+            // overwrites the onload callback and doesn't pass the event
+            // object to previously defined callbacks.  All the browsers
+            // that don't define window.event implement addEventListener
+            // so the dom_loaded handler will still be fired as usual.
+            if (!event) {
+                return undefined
+            }
+
+            var ret = true;
+            var old_result, new_result;
+
+            if (_.isFunction(old_handlers)) {
+                old_result = old_handlers(event);
+            }
+            new_result = new_handler.call(element, event);
+
+            if (false === old_result || false === new_result) {
+                ret = false;
+            }
+
+            return ret
+        };
+
+        return handler
+    }
+
+    function fixEvent(event) {
+        if (event) {
+            event.preventDefault = fixEvent.preventDefault;
+            event.stopPropagation = fixEvent.stopPropagation;
+        }
+        return event
+    }
+    fixEvent.preventDefault = function () {
+        this.returnValue = false;
+    };
+    fixEvent.stopPropagation = function () {
+        this.cancelBubble = true;
+    };
+
+    return register_event
+})();
+
+_.info = {
+    campaignParams: function () {
+        var campaign_keywords = 'utm_source utm_medium utm_campaign utm_content utm_term gclid'.split(' '),
+            kw = '',
+            params = {};
+        _.each(campaign_keywords, function (kwkey) {
+            kw = _.getQueryParam(document$1.URL, kwkey);
+            if (kw.length) {
+                params[kwkey] = kw;
+            }
+        });
+
+        return params
+    },
+
+    searchEngine: function (referrer) {
+        if (referrer.search('https?://(.*)google.([^/?]*)') === 0) {
+            return 'google'
+        } else if (referrer.search('https?://(.*)bing.com') === 0) {
+            return 'bing'
+        } else if (referrer.search('https?://(.*)yahoo.com') === 0) {
+            return 'yahoo'
+        } else if (referrer.search('https?://(.*)duckduckgo.com') === 0) {
+            return 'duckduckgo'
+        } else {
+            return null
+        }
+    },
+
+    searchInfo: function (referrer) {
+        var search = _.info.searchEngine(referrer),
+            param = search != 'yahoo' ? 'q' : 'p',
+            ret = {};
+
+        if (search !== null) {
+            ret['$search_engine'] = search;
+
+            var keyword = _.getQueryParam(referrer, param);
+            if (keyword.length) {
+                ret['ph_keyword'] = keyword;
+            }
+        }
+
+        return ret
+    },
+
+    /**
+     * This function detects which browser is running this script.
+     * The order of the checks are important since many user agents
+     * include key words used in later checks.
+     */
+    browser: function (user_agent, vendor, opera) {
+        vendor = vendor || ''; // vendor is undefined for at least IE9
+        if (opera || _.includes(user_agent, ' OPR/')) {
+            if (_.includes(user_agent, 'Mini')) {
+                return 'Opera Mini'
+            }
+            return 'Opera'
+        } else if (/(BlackBerry|PlayBook|BB10)/i.test(user_agent)) {
+            return 'BlackBerry'
+        } else if (_.includes(user_agent, 'IEMobile') || _.includes(user_agent, 'WPDesktop')) {
+            return 'Internet Explorer Mobile'
+        } else if (_.includes(user_agent, 'SamsungBrowser/')) {
+            // https://developer.samsung.com/internet/user-agent-string-format
+            return 'Samsung Internet'
+        } else if (_.includes(user_agent, 'Edge') || _.includes(user_agent, 'Edg/')) {
+            return 'Microsoft Edge'
+        } else if (_.includes(user_agent, 'FBIOS')) {
+            return 'Facebook Mobile'
+        } else if (_.includes(user_agent, 'Chrome')) {
+            return 'Chrome'
+        } else if (_.includes(user_agent, 'CriOS')) {
+            return 'Chrome iOS'
+        } else if (_.includes(user_agent, 'UCWEB') || _.includes(user_agent, 'UCBrowser')) {
+            return 'UC Browser'
+        } else if (_.includes(user_agent, 'FxiOS')) {
+            return 'Firefox iOS'
+        } else if (_.includes(vendor, 'Apple')) {
+            if (_.includes(user_agent, 'Mobile')) {
+                return 'Mobile Safari'
+            }
+            return 'Safari'
+        } else if (_.includes(user_agent, 'Android')) {
+            return 'Android Mobile'
+        } else if (_.includes(user_agent, 'Konqueror')) {
+            return 'Konqueror'
+        } else if (_.includes(user_agent, 'Firefox')) {
+            return 'Firefox'
+        } else if (_.includes(user_agent, 'MSIE') || _.includes(user_agent, 'Trident/')) {
+            return 'Internet Explorer'
+        } else if (_.includes(user_agent, 'Gecko')) {
+            return 'Mozilla'
+        } else {
+            return ''
+        }
+    },
+
+    /**
+     * This function detects which browser version is running this script,
+     * parsing major and minor version (e.g., 42.1). User agent strings from:
+     * http://www.useragentstring.com/pages/useragentstring.php
+     */
+    browserVersion: function (userAgent, vendor, opera) {
+        var browser = _.info.browser(userAgent, vendor, opera);
+        var versionRegexs = {
+            'Internet Explorer Mobile': /rv:(\d+(\.\d+)?)/,
+            'Microsoft Edge': /Edge?\/(\d+(\.\d+)?)/,
+            Chrome: /Chrome\/(\d+(\.\d+)?)/,
+            'Chrome iOS': /CriOS\/(\d+(\.\d+)?)/,
+            'UC Browser': /(UCBrowser|UCWEB)\/(\d+(\.\d+)?)/,
+            Safari: /Version\/(\d+(\.\d+)?)/,
+            'Mobile Safari': /Version\/(\d+(\.\d+)?)/,
+            Opera: /(Opera|OPR)\/(\d+(\.\d+)?)/,
+            Firefox: /Firefox\/(\d+(\.\d+)?)/,
+            'Firefox iOS': /FxiOS\/(\d+(\.\d+)?)/,
+            Konqueror: /Konqueror:(\d+(\.\d+)?)/,
+            BlackBerry: /BlackBerry (\d+(\.\d+)?)/,
+            'Android Mobile': /android\s(\d+(\.\d+)?)/,
+            'Samsung Internet': /SamsungBrowser\/(\d+(\.\d+)?)/,
+            'Internet Explorer': /(rv:|MSIE )(\d+(\.\d+)?)/,
+            Mozilla: /rv:(\d+(\.\d+)?)/,
+        };
+        var regex = versionRegexs[browser];
+        if (regex === undefined) {
+            return null
+        }
+        var matches = userAgent.match(regex);
+        if (!matches) {
+            return null
+        }
+        return parseFloat(matches[matches.length - 2])
+    },
+
+    os: function () {
+        var a = userAgent;
+        if (/Windows/i.test(a)) {
+            if (/Phone/.test(a) || /WPDesktop/.test(a)) {
+                return 'Windows Phone'
+            }
+            return 'Windows'
+        } else if (/(iPhone|iPad|iPod)/.test(a)) {
+            return 'iOS'
+        } else if (/Android/.test(a)) {
+            return 'Android'
+        } else if (/(BlackBerry|PlayBook|BB10)/i.test(a)) {
+            return 'BlackBerry'
+        } else if (/Mac/i.test(a)) {
+            return 'Mac OS X'
+        } else if (/Linux/.test(a)) {
+            return 'Linux'
+        } else if (/CrOS/.test(a)) {
+            return 'Chrome OS'
+        } else {
+            return ''
+        }
+    },
+
+    device: function (user_agent) {
+        if (/Windows Phone/i.test(user_agent) || /WPDesktop/.test(user_agent)) {
+            return 'Windows Phone'
+        } else if (/iPad/.test(user_agent)) {
+            return 'iPad'
+        } else if (/iPod/.test(user_agent)) {
+            return 'iPod Touch'
+        } else if (/iPhone/.test(user_agent)) {
+            return 'iPhone'
+        } else if (/(BlackBerry|PlayBook|BB10)/i.test(user_agent)) {
+            return 'BlackBerry'
+        } else if (/Android/.test(user_agent) && !/Mobile/.test(user_agent)) {
+            return 'Android Tablet'
+        } else if (/Android/.test(user_agent)) {
+            return 'Android'
+        } else {
+            return ''
+        }
+    },
+
+    deviceType: function (user_agent) {
+        const device = this.device(user_agent);
+        if (device === 'iPad' || device === 'Android Tablet') {
+            return 'Tablet'
+        } else if (device) {
+            return 'Mobile'
+        } else {
+            return 'Desktop'
+        }
+    },
+
+    referringDomain: function (referrer) {
+        var split = referrer.split('/');
+        if (split.length >= 3) {
+            return split[2]
+        }
+        return ''
+    },
+
+    properties: function () {
+        return _.extend(
+            _.strip_empty_properties({
+                $os: _.info.os(),
+                $browser: _.info.browser(userAgent, navigator$1.vendor, window.opera),
+                $device: _.info.device(userAgent),
+                $device_type: _.info.deviceType(userAgent),
+            }),
+            {
+                $current_url: window.location.href,
+                $host: window.location.host,
+                $pathname: window.location.pathname,
+                $browser_version: _.info.browserVersion(userAgent, navigator$1.vendor, window.opera),
+                $screen_height: window.screen.height,
+                $screen_width: window.screen.width,
+                $viewport_height: window.innerHeight,
+                $viewport_width: window.innerWidth,
+                $lib: 'web',
+                $lib_version: Config$1.LIB_VERSION,
+                $insert_id: Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10),
+                $time: _.timestamp() / 1000, // epoch time in seconds
+            }
+        )
+    },
+
+    people_properties: function () {
+        return _.extend(
+            _.strip_empty_properties({
+                $os: _.info.os(),
+                $browser: _.info.browser(userAgent, navigator$1.vendor, window.opera),
+            }),
+            {
+                $browser_version: _.info.browserVersion(userAgent, navigator$1.vendor, window.opera),
+            }
+        )
+    },
+};
+
+// EXPORTS (for closure compiler)
+_['isObject'] = _.isObject;
+_['isBlockedUA'] = _.isBlockedUA;
+_['isEmptyObject'] = _.isEmptyObject;
+_['info'] = _.info;
+_['info']['device'] = _.info.device;
+_['info']['browser'] = _.info.browser;
+_['info']['browserVersion'] = _.info.browserVersion;
+_['info']['properties'] = _.info.properties;
+
+var DOMAIN_MATCH_REGEX = /[a-z0-9][a-z0-9-]+\.[a-z.]{2,6}$/i;
+
+// Methods partially borrowed from quirksmode.org/js/cookies.html
+const cookieStore = {
+    get: function (name) {
+        try {
+            var nameEQ = name + '=';
+            var ca = document.cookie.split(';');
+            for (var i = 0; i < ca.length; i++) {
+                var c = ca[i];
+                while (c.charAt(0) == ' ') {
+                    c = c.substring(1, c.length);
+                }
+                if (c.indexOf(nameEQ) === 0) {
+                    return decodeURIComponent(c.substring(nameEQ.length, c.length))
+                }
+            }
+        } catch (err) {}
+        return null
+    },
+
+    parse: function (name) {
+        var cookie;
+        try {
+            cookie = JSON.parse(cookieStore.get(name)) || {};
+        } catch (err) {
+            // noop
+        }
+        return cookie
+    },
+
+    set: function (name, value, days, cross_subdomain, is_secure) {
+        try {
+            var cdomain = '',
+                expires = '',
+                secure = '';
+
+            if (cross_subdomain) {
+                var matches = document.location.hostname.match(DOMAIN_MATCH_REGEX),
+                    domain = matches ? matches[0] : '';
+
+                cdomain = domain ? '; domain=.' + domain : '';
+            }
+
+            if (days) {
+                var date = new Date();
+                date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+                expires = '; expires=' + date.toGMTString();
+            }
+
+            if (is_secure) {
+                secure = '; secure';
+            }
+
+            var new_cookie_val =
+                name + '=' + encodeURIComponent(JSON.stringify(value)) + expires + '; path=/' + cdomain + secure;
+            document.cookie = new_cookie_val;
+            return new_cookie_val
+        } catch (err) {
+            return
+        }
+    },
+
+    remove: function (name, cross_subdomain) {
+        try {
+            cookieStore.set(name, '', -1, cross_subdomain);
+        } catch (err) {
+            return
+        }
+    },
+};
+
+var _localStorage_supported = null;
+const localStore = {
+    is_supported: function () {
+        if (_localStorage_supported !== null) {
+            return _localStorage_supported
+        }
+
+        var supported = true;
+        if (window) {
+            try {
+                var key = '__mplssupport__',
+                    val = 'xyz';
+                localStore.set(key, val);
+                if (localStore.get(key) !== '"xyz"') {
+                    supported = false;
+                }
+                localStore.remove(key);
+            } catch (err) {
+                supported = false;
+            }
+        } else {
+            supported = false;
+        }
+
+        _localStorage_supported = supported;
+        return supported
+    },
+
+    error: function (msg) {
+    },
+
+    get: function (name) {
+        try {
+            return window.localStorage.getItem(name)
+        } catch (err) {
+            localStore.error(err);
+        }
+        return null
+    },
+
+    parse: function (name) {
+        try {
+            return JSON.parse(localStore.get(name)) || {}
+        } catch (err) {
+            // noop
+        }
+        return null
+    },
+
+    set: function (name, value) {
+        try {
+            window.localStorage.setItem(name, JSON.stringify(value));
+        } catch (err) {
+            localStore.error(err);
+        }
+    },
+
+    remove: function (name) {
+        try {
+            window.localStorage.removeItem(name);
+        } catch (err) {
+            localStore.error(err);
+        }
+    },
+};
+
+// Use localstorage for most data but still use cookie for distinct_id
+// This solves issues with cookies having too much data in them causing headers too large
+// Also makes sure we don't have to send a ton of data to the server
+const localPlusCookieStore = {
+    ...localStore,
+    parse: function (name) {
+        try {
+            let extend = {};
+            try {
+                // See if there's a cookie stored with data.
+                extend = cookieStore.parse(name) || {};
+                if (extend['distinct_id']) {
+                    cookieStore.set(name, { distinct_id: extend['distinct_id'] });
+                }
+            } catch (err) {}
+            const value = _.extend(extend, JSON.parse(localStore.get(name) || '{}'));
+            localStore.set(name, value);
+            return value
+        } catch (err) {
+            // noop
+        }
+        return null
+    },
+
+    set: function (name, value) {
+        try {
+            localStore.set(name, value);
+            if (value.distinct_id) {
+                cookieStore.set(name, { distinct_id: value.distinct_id });
+            }
+        } catch (err) {
+            localStore.error(err);
+        }
+    },
+
+    remove: function (name) {
+        try {
+            window.localStorage.removeItem(name);
+            cookieStore.remove(name);
+        } catch (err) {
+            localStore.error(err);
+        }
+    },
+};
+
+const memoryStorage = {};
+
+// Storage that only lasts the length of the pageview if we don't want to use cookies
+const memoryStore = {
+    is_supported: function () {
+        return true
+    },
+
+    error: function (msg) {
+    },
+
+    parse: function (name) {
+        return memoryStorage[name] || null
+    },
+
+    set: function (name, value) {
+        memoryStorage[name] = value;
+    },
+
+    remove: function (name) {
+        delete memoryStorage[name];
+    },
+};
+
+// Storage that only lasts the length of a tab/window. Survives page refreshes
+const sessionStore = {
+    sessionStorageSupported: null,
+    is_supported: function () {
+        if (sessionStore.sessionStorageSupported !== null) {
+            return sessionStore.sessionStorageSupported
+        }
+        sessionStore.sessionStorageSupported = true;
+        if (window) {
+            try {
+                let key = '__support__',
+                    val = 'xyz';
+                sessionStore.set(key, val);
+                if (sessionStore.get(key) !== '"xyz"') {
+                    sessionStore.sessionStorageSupported = false;
+                }
+                sessionStore.remove(key);
+            } catch (err) {
+                sessionStore.sessionStorageSupported = false;
+            }
+        } else {
+            sessionStore.sessionStorageSupported = false;
+        }
+        return sessionStore.sessionStorageSupported
+    },
+    error: function (msg) {
+        if (Config.DEBUG) ;
+    },
+
+    get: function (name) {
+        try {
+            return window.sessionStorage.getItem(name)
+        } catch (err) {
+            sessionStore.error(err);
+        }
+        return null
+    },
+
+    parse: function (name) {
+        try {
+            return JSON.parse(sessionStore.get(name)) || null
+        } catch (err) {
+            // noop
+        }
+        return null
+    },
+
+    set: function (name, value) {
+        try {
+            window.sessionStorage.setItem(name, JSON.stringify(value));
+        } catch (err) {
+            sessionStore.error(err);
+        }
+    },
+
+    remove: function (name) {
+        try {
+            window.sessionStorage.removeItem(name);
+        } catch (err) {
+            sessionStore.error(err);
+        }
+    },
+};
+
+/* eslint camelcase: "off" */
+
+/*
+ * 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';
+/** @const */ var CAMPAIGN_IDS_KEY = '__cmpns';
+/** @const */ var EVENT_TIMERS_KEY = '__timers';
+/** @const */ var SESSION_RECORDING_ENABLED = '$session_recording_enabled';
+/** @const */ var SESSION_ID = '$sesid';
+/** @const */ var ENABLED_FEATURE_FLAGS = '$enabled_feature_flags';
+/** @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,
+    CAMPAIGN_IDS_KEY,
+    EVENT_TIMERS_KEY,
+    SESSION_RECORDING_ENABLED,
+    SESSION_ID,
+    ENABLED_FEATURE_FLAGS,
+];
+
+/**
+ * UserMaven Persistence Object
+ * @constructor
+ */
+var UserMavenPersistence = function (config) {
+    // clean chars that aren't accepted by the http spec for cookie values
+    // https://datatracker.ietf.org/doc/html/rfc2616#section-2.2
+    let token = '';
+
+    if (config['token']) {
+        token = config['token'].replace(/\+/g, 'PL').replace(/\//g, 'SL').replace(/=/g, 'EQ');
+    }
+
+    this['props'] = {};
+    this.campaign_params_saved = false;
+
+    if (config['persistence_name']) {
+        this.name = 'um_' + config['persistence_name'];
+    } else {
+        this.name = 'um_' + token + '_usermaven';
+    }
+
+    var storage_type = config['persistence'];
+    if (storage_type !== 'cookie' && storage_type.indexOf('localStorage') === -1 && storage_type !== 'memory') {
+        console$1.critical('Unknown persistence type ' + storage_type + '; falling back to cookie');
+        storage_type = config['persistence'] = 'cookie';
+    }
+    if (storage_type === 'localStorage' && localStore.is_supported()) {
+        this.storage = localStore;
+    } else if (storage_type === 'localStorage+cookie' && localPlusCookieStore.is_supported()) {
+        this.storage = localPlusCookieStore;
+    } else if (storage_type === 'memory') {
+        this.storage = memoryStore;
+    } else {
+        this.storage = cookieStore;
+    }
+
+    this.load();
+    this.update_config(config);
+    this.save();
+};
+
+UserMavenPersistence.prototype.properties = function () {
+    var p = {};
+    // Filter out reserved properties
+    _.each(this['props'], function (v, k) {
+        if (k === ENABLED_FEATURE_FLAGS && typeof v === 'object') {
+            var keys = Object.keys(v);
+            for (var i = 0; i < keys.length; i++) {
+                p[`$feature/${keys[i]}`] = v[keys[i]];
+            }
+        } else if (!_.include(RESERVED_PROPERTIES, k)) {
+            p[k] = v;
+        }
+    });
+    return p
+};
+
+UserMavenPersistence.prototype.load = function () {
+    if (this.disabled) {
+        return
+    }
+
+    var entry = this.storage.parse(this.name);
+
+    if (entry) {
+        this['props'] = _.extend({}, entry);
+    }
+};
+
+UserMavenPersistence.prototype.save = function () {
+    if (this.disabled) {
+        return
+    }
+    this.storage.set(this.name, this['props'], this.expire_days, this.cross_subdomain, this.secure);
+};
+
+UserMavenPersistence.prototype.remove = function () {
+    // remove both domain and subdomain cookies
+    this.storage.remove(this.name, false);
+    this.storage.remove(this.name, true);
+};
+
+// removes the storage entry and deletes all loaded data
+// forced name for tests
+UserMavenPersistence.prototype.clear = function () {
+    this.remove();
+    this['props'] = {};
+};
+
+/**
+ * @param {Object} props
+ * @param {*=} default_value
+ * @param {number=} days
+ */
+UserMavenPersistence.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;
+
+        _.each(
+            props,
+            function (val, prop) {
+                if (!this['props'].hasOwnProperty(prop) || this['props'][prop] === default_value) {
+                    this['props'][prop] = val;
+                }
+            },
+            this
+        );
+
+        this.save();
+
+        return true
+    }
+    return false
+};
+
+/**
+ * @param {Object} props
+ * @param {number=} days
+ */
+UserMavenPersistence.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
+    }
+    return false
+};
+
+UserMavenPersistence.prototype.unregister = function (prop) {
+    if (prop in this['props']) {
+        delete this['props'][prop];
+        this.save();
+    }
+};
+
+UserMavenPersistence.prototype.update_campaign_params = function () {
+    if (!this.campaign_params_saved) {
+        this.register(_.info.campaignParams());
+        this.campaign_params_saved = true;
+    }
+};
+
+UserMavenPersistence.prototype.update_search_keyword = function (referrer) {
+    this.register(_.info.searchInfo(referrer));
+};
+
+// EXPORTED METHOD, we test this directly.
+UserMavenPersistence.prototype.update_referrer_info = function (referrer) {
+    // If referrer doesn't exist, we want to note the fact that it was type-in traffic.
+    // Register once, so first touch
+    this.register_once(
+        {
+            $initial_referrer: referrer || '$direct',
+            $initial_referring_domain: _.info.referringDomain(referrer) || '$direct',
+        },
+        ''
+    );
+    // Register the current referrer but override if it's different, hence register
+    this.register({
+        $referrer: referrer || this['props']['$referrer'] || '$direct',
+        $referring_domain: _.info.referringDomain(referrer) || this['props']['$referring_domain'] || '$direct',
+    });
+};
+
+UserMavenPersistence.prototype.get_referrer_info = function () {
+    return _.strip_empty_properties({
+        $initial_referrer: this['props']['$initial_referrer'],
+        $initial_referring_domain: this['props']['$initial_referring_domain'],
+    })
+};
+
+// safely fills the passed in object with stored properties,
+// does not override any properties defined in both
+// returns the passed in object
+UserMavenPersistence.prototype.safe_merge = function (props) {
+    _.each(this['props'], function (val, prop) {
+        if (!(prop in props)) {
+            props[prop] = val;
+        }
+    });
+
+    return props
+};
+
+UserMavenPersistence.prototype.update_config = function (config) {
+    this.default_expiry = this.expire_days = config['cookie_expiration'];
+    this.set_disabled(config['disable_persistence']);
+    this.set_cross_subdomain(config['cross_subdomain_cookie']);
+    this.set_secure(config['secure_cookie']);
+};
+
+UserMavenPersistence.prototype.set_disabled = function (disabled) {
+    this.disabled = disabled;
+    if (this.disabled) {
+        this.remove();
+    } else {
+        this.save();
+    }
+};
+
+UserMavenPersistence.prototype.set_cross_subdomain = function (cross_subdomain) {
+    if (cross_subdomain !== this.cross_subdomain) {
+        this.cross_subdomain = cross_subdomain;
+        this.remove();
+        this.save();
+    }
+};
+
+UserMavenPersistence.prototype.get_cross_subdomain = function () {
+    return this.cross_subdomain
+};
+
+UserMavenPersistence.prototype.set_secure = function (secure) {
+    if (secure !== this.secure) {
+        this.secure = secure ? true : false;
+        this.remove();
+        this.save();
+    }
+};
+
+UserMavenPersistence.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();
+};
+
+UserMavenPersistence.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
+};
+
+// import { INCREMENTAL_SNAPSHOT_EVENT_TYPE, MUTATION_SOURCE_TYPE } from './extensions/sessionrecording'
+
+const SESSION_CHANGE_THRESHOLD = 30 * 60 * 1000; // 30 mins
+/* const SESSION_CHANGE_THRESHOLD = 1 * 60 * 1000 // 1 min */
+
+class SessionIdManager {
+    constructor(config, persistence) {
+        this.persistence = persistence;
+
+        if (config['persistence_name']) {
+            this.window_id_storage_key = 'um_' + config['persistence_name'] + '_window_id';
+        } else {
+            this.window_id_storage_key = 'um_' + config['token'] + '_window_id';
+        }
+    }
+
+    // Note: this tries to store the windowId in sessionStorage. SessionStorage is unique to the current window/tab,
+    // and persists page loads/reloads. So it's uniquely suited for storing the windowId. This function also respects
+    // when persistence is disabled (by user config) and when sessionStorage is not supported (it *should* be supported on all browsers),
+    // and in that case, it falls back to memory (which sadly, won't persist page loads)
+    _setWindowId(windowId) {
+        if (windowId !== this.windowId) {
+            this.windowId = windowId;
+            if (!this.persistence.disabled && sessionStore.is_supported()) {
+                sessionStore.set(this.window_id_storage_key, windowId);
+            }
+        }
+    }
+
+    _getWindowId() {
+        if (this.windowId) {
+            return this.windowId
+        }
+        if (!this.persistence.disabled && sessionStore.is_supported()) {
+            return sessionStore.parse(this.window_id_storage_key)
+        }
+        return null
+    }
+
+    // Note: 'this.persistence.register' can be disabled in the config.
+    // In that case, this works by storing sessionId and the timestamp in memory.
+    _setSessionId(sessionId, timestamp) {
+        if (sessionId !== this.sessionId || timestamp !== this.timestamp) {
+            this.timestamp = timestamp;
+            this.sessionId = sessionId;
+            this.persistence.register({ [SESSION_ID]: [timestamp, sessionId] });
+        }
+    }
+
+    _getSessionId() {
+        if (this.sessionId && this.timestamp) {
+            return [this.timestamp, this.sessionId]
+        }
+        return this.persistence['props'][SESSION_ID] || [0, null]
+    }
+
+    // Resets the session id by setting it to null. On the subsequent call to getSessionAndWindowId,
+    // new ids will be generated.
+    resetSessionId() {
+        this._setSessionId(null, null);
+    }
+
+    getSessionAndWindowId(timestamp = null, recordingEvent = false) {
+        // Some recording events are triggered by non-user events (e.g. "X minutes ago" text updating on the screen).
+        // We don't want to update the session and window ids in these cases. These events are designated by event
+        // type -> incremental update, and source -> mutation.
+        /* const isUserInteraction = !(
+            recordingEvent &&
+            recordingEvent.type === INCREMENTAL_SNAPSHOT_EVENT_TYPE &&
+            recordingEvent.data?.source === MUTATION_SOURCE_TYPE
+        ) */
+
+        const isUserInteraction = true;
+
+        timestamp = timestamp || new Date().getTime();
+
+        let [lastTimestamp, sessionId] = this._getSessionId();
+        let windowId = this._getWindowId();
+
+        if (!sessionId || (Math.abs(timestamp - lastTimestamp) > SESSION_CHANGE_THRESHOLD)) {
+            sessionId = _.UUID();
+            windowId = _.UUID();
+        } else if (!windowId) {
+            windowId = _.UUID();
+        }
+
+        const newTimestamp = lastTimestamp === 0 || isUserInteraction ? timestamp : lastTimestamp;
+
+        this._setWindowId(windowId);
+        this._setSessionId(sessionId, newTimestamp);
+
+        return {
+            sessionId: sessionId,
+            windowId: windowId,
+        }
+    }
+}
+
 var VERSION_INFO = {
     env: 'production',
-    date: '2022-01-09T16:15:00.168Z',
-    version: '1.0.0'
+    date: '2022-02-18T12:44:44.465Z',
+    version: '1.0.4'
 };
 var USERMAVEN_VERSION = "".concat(VERSION_INFO.version, "/").concat(VERSION_INFO.env, "@").concat(VERSION_INFO.date);
 var beaconTransport = function (url, json) {
@@ -397,7 +1893,17 @@ var UsermavenClientImpl = /** @class */ (function () {
     };
     UsermavenClientImpl.prototype.getCtx = function () {
         var now = new Date();
-        return __assign({ event_id: '', user: __assign({ anonymous_id: this.anonymousId }, this.userProperties), ids: this._getIds(), user_agent: navigator.userAgent, utc_time: reformatDate(now.toISOString()), local_tz_offset: now.getTimezoneOffset(), referer: document.referrer, url: window.location.href, page_title: document.title, doc_path: document.location.pathname, doc_host: document.location.hostname, doc_search: window.location.search, screen_resolution: screen.width + 'x' + screen.height, vp_size: Math.max(document.documentElement.clientWidth || 0, window.innerWidth || 0) + 'x' + Math.max(document.documentElement.clientHeight || 0, window.innerHeight || 0), user_language: navigator.language, doc_encoding: document.characterSet }, getDataFromParams(parseQuery()));
+        var _a = this.sessionManager.getSessionAndWindowId(), sessionId = _a.sessionId, windowId = _a.windowId;
+        // extract company details from identity payload
+        var user = __assign({ anonymous_id: this.anonymousId }, this.userProperties);
+        var company = user['company'] || {};
+        delete user['company'];
+        var payload = __assign({ event_id: '', session_id: sessionId, window_id: windowId, user: user, ids: this._getIds(), user_agent: navigator.userAgent, utc_time: reformatDate(now.toISOString()), local_tz_offset: now.getTimezoneOffset(), referer: document.referrer, url: window.location.href, page_title: document.title, doc_path: document.location.pathname, doc_host: document.location.hostname, doc_search: window.location.search, screen_resolution: screen.width + 'x' + screen.height, vp_size: Math.max(document.documentElement.clientWidth || 0, window.innerWidth || 0) + 'x' + Math.max(document.documentElement.clientHeight || 0, window.innerHeight || 0), user_language: navigator.language, doc_encoding: document.characterSet }, getDataFromParams(parseQuery()));
+        // id and name attributes will be checked on backend
+        if (Object.keys(company).length) {
+            payload['company'] = company;
+        }
+        return payload;
     };
     UsermavenClientImpl.prototype._getIds = function () {
         var cookies = getCookies(false);
@@ -417,7 +1923,7 @@ var UsermavenClientImpl = /** @class */ (function () {
         getLogger().debug('track event of type', type, data);
         var e = this.makeEvent(type, this.compatMode ?
             'eventn' :
-            'jitsu', payload || {});
+            'usermaven', payload || {});
         return this.sendJson(e);
     };
     UsermavenClientImpl.prototype.init = function (options) {
@@ -478,6 +1984,7 @@ var UsermavenClientImpl = /** @class */ (function () {
             }
             getLogger().debug('Restored persistent properties', this.permanentProperties);
         }
+        this.manageSession(options);
         if (options.capture_3rd_party_cookies === false) {
             this._3pCookies = {};
         }
@@ -570,6 +2077,29 @@ var UsermavenClientImpl = /** @class */ (function () {
         if (this.propsPersistance && persist) {
             this.propsPersistance.save(this.permanentProperties);
         }
+        if (this.sessionManager) {
+            this.sessionManager.resetSessionId();
+        }
+    };
+    /**
+     * Manage session capability
+     * @param options
+     */
+    UsermavenClientImpl.prototype.manageSession = function (options) {
+        getLogger().debug('Options', options);
+        var defaultConfig = {
+            persistence: options ? options.persistence || 'cookie' : 'cookie',
+            persistence_name: options ? options.persistence_name || 'session' : 'session',
+        };
+        // TODO: Default session name would be session_
+        this.config = _.extend(defaultConfig, this.config || {}, {
+            token: this.apiKey,
+        });
+        getLogger().debug('Default Configuration', this.config);
+        this.persistence = new UserMavenPersistence(this.config);
+        getLogger().debug('Persistence Configuration', this.persistence);
+        this.sessionManager = new SessionIdManager(this.config, this.persistence);
+        getLogger().debug('Session Configuration', this.sessionManager);
     };
     return UsermavenClientImpl;
 }());