@usermaven/sdk-js 1.0.5 → 1.0.6

package/dist/npm/usermaven.es.js

@@ -24,6 +24,56 @@ var __assign = function() {
     return __assign.apply(this, arguments);
 };
 
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
 function __spreadArray(to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -34,6 +84,159 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
+var LogLevels = {
+    DEBUG: { name: "DEBUG", severity: 10 },
+    INFO: { name: "INFO", severity: 100 },
+    WARN: { name: "WARN", severity: 1000 },
+    ERROR: { name: "ERROR", severity: 10000 },
+    NONE: { name: "NONE", severity: 10000 }
+};
+var rootLogger = null;
+/**
+ * Create logger or return cached instance
+ */
+function getLogger() {
+    if (rootLogger) {
+        return rootLogger;
+    }
+    else {
+        return rootLogger = createLogger();
+    }
+}
+function setRootLogLevel(logLevelName) {
+    var logLevel = LogLevels[logLevelName.toLocaleUpperCase()];
+    if (!logLevel) {
+        console.warn("Can't find log level with name ".concat(logLevelName.toLocaleUpperCase(), ", defaulting to INFO"));
+        logLevel = LogLevels.INFO;
+    }
+    rootLogger = createLogger(logLevel);
+    return rootLogger;
+}
+function setDebugVar(name, val) {
+    if (!isWindowAvailable()) {
+        return;
+    }
+    var win = window;
+    if (!win.__usermavenDebug) {
+        win.__usermavenDebug = {};
+    }
+    win.__usermavenDebug[name] = val;
+}
+/**
+ * Creates a loggger with given log-level
+ * @param logLevel
+ */
+function createLogger(logLevel) {
+    var globalLogLevel = isWindowAvailable() && window['__eventNLogLevel'];
+    var minLogLevel = LogLevels.WARN;
+    if (globalLogLevel) {
+        var level = LogLevels[globalLogLevel.toUpperCase()];
+        if (level && level > 0) {
+            minLogLevel = level;
+        }
+    }
+    else if (logLevel) {
+        minLogLevel = logLevel;
+    }
+    var logger = { minLogLevel: minLogLevel };
+    Object.values(LogLevels).forEach(function (_a) {
+        var name = _a.name, severity = _a.severity;
+        logger[name.toLowerCase()] = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (severity >= minLogLevel.severity && args.length > 0) {
+                var message = args[0];
+                var msgArgs = args.splice(1);
+                var msgFormatted = "[J-".concat(name, "] ").concat(message);
+                if (name === 'DEBUG' || name === 'INFO') {
+                    console.log.apply(console, __spreadArray([msgFormatted], msgArgs, false));
+                }
+                else if (name === 'WARN') {
+                    console.warn.apply(console, __spreadArray([msgFormatted], msgArgs, false));
+                }
+                else {
+                    console.error.apply(console, __spreadArray([msgFormatted], msgArgs, false));
+                }
+            }
+        };
+    });
+    setDebugVar("logger", logger);
+    return logger;
+}
+
+/**
+ * Checks if global variable 'window' is available. If it's available,
+ * code runs in browser environment
+ */
+
+function isWindowAvailable(warnMsg = undefined) {
+  let windowAvailable = !!globalThis.window;
+  if (!windowAvailable && warnMsg) {
+    getLogger().warn(warnMsg);
+  }
+  return windowAvailable;
+}
+
+
+/**
+ * @param msg
+ * @return {Window}
+ */
+function requireWindow(msg = undefined) {
+  if (!isWindowAvailable()) {
+    throw new Error(msg || "window' is not available. Seems like this code runs outside browser environment. It shouldn't happen")
+  }
+  return window;
+}
+
+function serializeCookie(name, val, opt) {
+    var _a;
+    if (opt === void 0) { opt = {}; }
+    var enc = encodeURIComponent;
+    var value = enc(val);
+    var str = name + "=" + value;
+    str += "; Path=" + ((_a = opt.path) !== null && _a !== void 0 ? _a : "/");
+    if (opt.maxAge) {
+        str += "; Max-Age=" + Math.floor(opt.maxAge);
+    }
+    if (opt.domain) {
+        str += "; Domain=" + opt.domain;
+    }
+    if (opt.expires) {
+        str += "; Expires=" + opt.expires.toUTCString();
+    }
+    if (opt.httpOnly) {
+        str += "; HttpOnly";
+    }
+    if (opt.secure) {
+        str += "; Secure";
+    }
+    if (opt.sameSite) {
+        var sameSite = typeof opt.sameSite === "string"
+            ? opt.sameSite.toLowerCase()
+            : opt.sameSite;
+        switch (sameSite) {
+            case true:
+                str += "; SameSite=Strict";
+                break;
+            case "lax":
+                str += "; SameSite=Lax";
+                break;
+            case "strict":
+                str += "; SameSite=Strict";
+                break;
+            case "none":
+                str += "; SameSite=None";
+                break;
+            default:
+                throw new TypeError("option sameSite is invalid");
+        }
+    }
+    return str;
+}
+
 // Courtesy: https://stackoverflow.com/a/23945027
 function extractHostname(url) {
     var hostname;
@@ -67,24 +270,55 @@ var extractRootDomain = function (url) {
     return domain;
 };
 var getCookieDomain = function () {
-    return ".".concat(extractRootDomain(location.hostname)); // .localhost
-    // return location.hostname.replace('www.', '');
+    if (isWindowAvailable()) {
+        return ".".concat(extractRootDomain(location.hostname)); // .localhost
+        // return window.location.hostname.replace("www.", "");
+    }
+    return undefined;
 };
 var cookieParsingCache;
-var getCookies = function (useCache) {
-    if (useCache === void 0) { useCache = false; }
-    if (useCache && cookieParsingCache) {
-        return cookieParsingCache;
+function parseCookieString(cookieStr) {
+    if (!cookieStr) {
+        return {};
     }
     var res = {};
-    var cookies = document.cookie.split(';');
+    var cookies = cookieStr.split(";");
     for (var i = 0; i < cookies.length; i++) {
         var cookie = cookies[i];
-        var idx = cookie.indexOf('=');
+        var idx = cookie.indexOf("=");
         if (idx > 0) {
             res[cookie.substr(i > 0 ? 1 : 0, i > 0 ? idx - 1 : idx)] = cookie.substr(idx + 1);
         }
     }
+    return res;
+}
+function copyAttributes(source, target) {
+    return Array.from(source.attributes).forEach(function (attribute) {
+        target.setAttribute(attribute.nodeName, attribute.nodeValue);
+    });
+}
+function insertAndExecute(element, html) {
+    element.innerHTML = html;
+    var scripts = element.getElementsByTagName("script");
+    var index;
+    for (index = scripts.length - 1; index >= 0; index--) {
+        var script = scripts[index];
+        var tag = document.createElement("script");
+        copyAttributes(script, tag);
+        if (script.innerHTML) {
+            tag.innerHTML = script.innerHTML;
+        }
+        tag.setAttribute("data-usermaven-tag-id", element.id);
+        document.getElementsByTagName("head")[0].appendChild(tag);
+        scripts[index].parentNode.removeChild(scripts[index]);
+    }
+}
+var getCookies = function (useCache) {
+    if (useCache === void 0) { useCache = false; }
+    if (useCache && cookieParsingCache) {
+        return cookieParsingCache;
+    }
+    var res = parseCookieString(document.cookie);
     cookieParsingCache = res;
     return res;
 };
@@ -92,24 +326,30 @@ var getCookie = function (name) {
     if (!name) {
         return null;
     }
-    return decodeURIComponent(document.cookie.replace(new RegExp("(?:(?:^|.*;)\\s*" + encodeURIComponent(name).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=\\s*([^;]*).*$)|^.*$"), "$1")) || null;
+    return (decodeURIComponent(requireWindow().document.cookie.replace(new RegExp("(?:(?:^|.*;)\\s*" +
+        encodeURIComponent(name).replace(/[\-\.\+\*]/g, "\\$&") +
+        "\\s*\\=\\s*([^;]*).*$)|^.*$"), "$1")) || null);
 };
-var setCookie = function (name, value, expire, domain, secure) {
-    var expireString = expire === Infinity ? " expires=Fri, 31 Dec 9999 23:59:59 GMT" : "; max-age=" + expire;
-    document.cookie = encodeURIComponent(name) + "=" + value + "; path=/;" + expireString + (domain ? "; domain=" + domain : "") + (secure ? "; secure" : "");
+var setCookie = function (name, value, opts) {
+    if (opts === void 0) { opts = {}; }
+    requireWindow().document.cookie = serializeCookie(name, value, opts);
 };
-var deleteCookie = function (name) {
-    document.cookie = name + '= ; expires = Thu, 01 Jan 1970 00:00:00 GMT';
+var deleteCookie = function (name, path) {
+    if (path === void 0) { path = "/"; }
+    document.cookie = name + "= ; expires = Thu, 01 Jan 1970 00:00:00 GMT" + (path ? ("; path = " + path) : "");
 };
 var generateId = function () { return Math.random().toString(36).substring(2, 12); };
 var generateRandom = function () { return Math.random().toString(36).substring(2, 7); };
 var parseQuery = function (qs) {
-    var queryString = qs || window.location.search.substring(1);
+    if (!qs) {
+        return {};
+    }
+    var queryString = qs.length > 0 && qs.charAt(0) === "?" ? qs.substring(1) : qs;
     var query = {};
-    var pairs = (queryString[0] === '?' ? queryString.substr(1) : queryString).split('&');
+    var pairs = (queryString[0] === "?" ? queryString.substr(1) : queryString).split("&");
     for (var i = 0; i < pairs.length; i++) {
-        var pair = pairs[i].split('=');
-        query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || '');
+        var pair = pairs[i].split("=");
+        query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || "");
     }
     return query;
 };
@@ -128,7 +368,7 @@ var CLICK_IDS = {
 var getDataFromParams = function (params) {
     var result = {
         utm: {},
-        click_id: {}
+        click_id: {},
     };
     for (var name in params) {
         if (!params.hasOwnProperty(name)) {
@@ -147,14 +387,14 @@ var getDataFromParams = function (params) {
 };
 //2020-08-24T13:42:16.439Z -> 2020-08-24T13:42:16.439123Z
 var reformatDate = function (strDate) {
-    var end = strDate.split('.')[1];
+    var end = strDate.split(".")[1];
     if (!end) {
         return strDate;
     }
     if (end.length >= 7) {
         return strDate;
     }
-    return strDate.slice(0, -1) + '0'.repeat(7 - end.length) + 'Z';
+    return strDate.slice(0, -1) + "0".repeat(7 - end.length) + "Z";
 };
 function endsWith(str, suffix) {
     return str.indexOf(suffix, str.length - suffix.length) !== -1;
@@ -171,85 +411,6 @@ var getHostWithProtocol = function (host) {
     }
 };
 
-var LogLevels = {
-    DEBUG: { name: "DEBUG", severity: 10 },
-    INFO: { name: "INFO", severity: 100 },
-    WARN: { name: "WARN", severity: 1000 },
-    ERROR: { name: "ERROR", severity: 10000 },
-    NONE: { name: "NONE", severity: 10000 }
-};
-var rootLogger = null;
-/**
- * Create logger or return cached instance
- */
-function getLogger() {
-    if (rootLogger) {
-        return rootLogger;
-    }
-    else {
-        return rootLogger = createLogger();
-    }
-}
-function setRootLogLevel(logLevelName) {
-    var logLevel = LogLevels[logLevelName.toLocaleUpperCase()];
-    if (!logLevel) {
-        console.warn("Can't find log level with name ".concat(logLevelName.toLocaleUpperCase(), ", defaulting to INFO"));
-        logLevel = LogLevels.INFO;
-    }
-    rootLogger = createLogger(logLevel);
-    return rootLogger;
-}
-function setDebugVar(name, val) {
-    var win = window;
-    if (!win.__usermavenDebug) {
-        win.__usermavenDebug = {};
-    }
-    win.__usermavenDebug[name] = val;
-}
-/**
- * Creates a loggger with given log-level
- * @param logLevel
- */
-function createLogger(logLevel) {
-    var globalLogLevel = window['__eventNLogLevel'];
-    var minLogLevel = LogLevels.WARN;
-    if (globalLogLevel) {
-        var level = LogLevels[globalLogLevel.toUpperCase()];
-        if (level && level > 0) {
-            minLogLevel = level;
-        }
-    }
-    else if (logLevel) {
-        minLogLevel = logLevel;
-    }
-    var logger = { minLogLevel: minLogLevel };
-    Object.values(LogLevels).forEach(function (_a) {
-        var name = _a.name, severity = _a.severity;
-        logger[name.toLowerCase()] = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (severity >= minLogLevel.severity && args.length > 0) {
-                var message = args[0];
-                var msgArgs = args.splice(1);
-                var msgFormatted = "[J-".concat(name, "] ").concat(message);
-                if (name === 'DEBUG' || name === 'INFO') {
-                    console.log.apply(console, __spreadArray([msgFormatted], msgArgs, false));
-                }
-                else if (name === 'WARN') {
-                    console.warn.apply(console, __spreadArray([msgFormatted], msgArgs, false));
-                }
-                else {
-                    console.error.apply(console, __spreadArray([msgFormatted], msgArgs, false));
-                }
-            }
-        };
-    });
-    setDebugVar("logger", logger);
-    return logger;
-}
-
 var Config$1 = {
     DEBUG: false,
     LIB_VERSION: '1.0.0',
@@ -895,7 +1056,7 @@ _.info = {
 
             var keyword = _.getQueryParam(referrer, param);
             if (keyword.length) {
-                ret['ph_keyword'] = keyword;
+                ret['um_keyword'] = keyword;
             }
         }
 
@@ -1648,14 +1809,12 @@ UserMavenPersistence.prototype.remove_event_timer = function (event_name) {
     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;
+        this.session_change_threshold = config['persistence_time'] || 1800; // 30 mins
+        // this.session_change_threshold = config['persistence_time'] || 60 // 1 min
+        this.session_change_threshold *= 1000;
 
         if (config['persistence_name']) {
             this.window_id_storage_key = 'um_' + config['persistence_name'] + '_window_id';
@@ -1714,6 +1873,9 @@ class SessionIdManager {
         // 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.
+        if (this.persistence.disabled) {
+            return {}
+        }
         /* const isUserInteraction = !(
             recordingEvent &&
             recordingEvent.type === INCREMENTAL_SNAPSHOT_EVENT_TYPE &&
@@ -1727,7 +1889,7 @@ class SessionIdManager {
         let [lastTimestamp, sessionId] = this._getSessionId();
         let windowId = this._getWindowId();
 
-        if (!sessionId || (Math.abs(timestamp - lastTimestamp) > SESSION_CHANGE_THRESHOLD)) {
+        if (!sessionId || (Math.abs(timestamp - lastTimestamp) > this.session_change_threshold)) {
             sessionId = _.UUID();
             windowId = _.UUID();
         } else if (!windowId) {
@@ -1738,47 +1900,625 @@ class SessionIdManager {
 
         this._setWindowId(windowId);
         this._setSessionId(sessionId, newTimestamp);
-
         return {
-            sessionId: sessionId,
-            windowId: windowId,
+            session_id: sessionId,
+            window_id: windowId,
         }
     }
 }
 
+/*
+ * Get the className of an element, accounting for edge cases where element.className is an object
+ * @param {Element} el - element to get the className of
+ * @returns {string} the element's class
+ */
+function getClassName(el) {
+    switch (typeof el.className) {
+        case 'string':
+            return el.className
+        case 'object': // handle cases where className might be SVGAnimatedString or some other type
+            return el.className.baseVal || el.getAttribute('class') || ''
+        default:
+            // future proof
+            return ''
+    }
+}
+
+/*
+ * Get the direct text content of an element, protecting against sensitive data collection.
+ * Concats textContent of each of the element's text node children; this avoids potential
+ * collection of sensitive data that could happen if we used element.textContent and the
+ * element had sensitive child elements, since element.textContent includes child content.
+ * Scrubs values that look like they could be sensitive (i.e. cc or ssn number).
+ * @param {Element} el - element to get the text of
+ * @returns {string} the element's direct text content
+ */
+function getSafeText(el) {
+    var elText = '';
+
+    if (shouldCaptureElement(el) && !isSensitiveElement(el) && el.childNodes && el.childNodes.length) {
+        _.each(el.childNodes, function (child) {
+            if (isTextNode(child) && child.textContent) {
+                elText += _.trim(child.textContent)
+                    // scrub potentially sensitive values
+                    .split(/(\s+)/)
+                    .filter(shouldCaptureValue)
+                    .join('')
+                    // normalize whitespace
+                    .replace(/[\r\n]/g, ' ')
+                    .replace(/[ ]+/g, ' ')
+                    // truncate
+                    .substring(0, 255);
+            }
+        });
+    }
+
+    return _.trim(elText)
+}
+
+/*
+ * Check whether an element has nodeType Node.ELEMENT_NODE
+ * @param {Element} el - element to check
+ * @returns {boolean} whether el is of the correct nodeType
+ */
+function isElementNode(el) {
+    return el && el.nodeType === 1 // Node.ELEMENT_NODE - use integer constant for browser portability
+}
+
+/*
+ * Check whether an element is of a given tag type.
+ * Due to potential reference discrepancies (such as the webcomponents.js polyfill),
+ * we want to match tagNames instead of specific references because something like
+ * element === document.body won't always work because element might not be a native
+ * element.
+ * @param {Element} el - element to check
+ * @param {string} tag - tag name (e.g., "div")
+ * @returns {boolean} whether el is of the given tag type
+ */
+function isTag(el, tag) {
+    return el && el.tagName && el.tagName.toLowerCase() === tag.toLowerCase()
+}
+
+/*
+ * Check whether an element has nodeType Node.TEXT_NODE
+ * @param {Element} el - element to check
+ * @returns {boolean} whether el is of the correct nodeType
+ */
+function isTextNode(el) {
+    return el && el.nodeType === 3 // Node.TEXT_NODE - use integer constant for browser portability
+}
+
+var usefulElements = ['a', 'button', 'form', 'input', 'select', 'textarea', 'label'];
+/*
+ * Check whether a DOM event should be "captured" or if it may contain sentitive data
+ * using a variety of heuristics.
+ * @param {Element} el - element to check
+ * @param {Event} event - event to check
+ * @returns {boolean} whether the event should be captured
+ */
+function shouldCaptureDomEvent(el, event) {
+    if (!el || isTag(el, 'html') || !isElementNode(el)) {
+        return false
+    }
+
+    var parentIsUsefulElement = false;
+    var targetElementList = [el];
+    var parentNode = true;
+    var curEl = el;
+    while (curEl.parentNode && !isTag(curEl, 'body')) {
+        // If element is a shadow root, we skip it
+        if (curEl.parentNode.nodeType === 11) {
+            targetElementList.push(curEl.parentNode.host);
+            curEl = curEl.parentNode.host;
+            continue
+        }
+        parentNode = curEl.parentNode;
+        if (!parentNode) break
+        if (usefulElements.indexOf(parentNode.tagName.toLowerCase()) > -1) {
+            parentIsUsefulElement = true;
+        } else {
+            let compStyles = window.getComputedStyle(parentNode);
+            if (compStyles && compStyles.getPropertyValue('cursor') === 'pointer') {
+                parentIsUsefulElement = true;
+            }
+        }
+
+        targetElementList.push(parentNode);
+        curEl = parentNode;
+    }
+
+    let compStyles = window.getComputedStyle(el);
+    if (compStyles && compStyles.getPropertyValue('cursor') === 'pointer' && event.type === 'click') {
+        return true
+    }
+
+    var tag = el.tagName.toLowerCase();
+    switch (tag) {
+        case 'html':
+            return false
+        case 'form':
+            return event.type === 'submit'
+        case 'input':
+            return event.type === 'change' || event.type === 'click'
+        case 'select':
+        case 'textarea':
+            return event.type === 'change' || event.type === 'click'
+        default:
+            if (parentIsUsefulElement) return event.type === 'click'
+            return (
+                event.type === 'click' &&
+                (usefulElements.indexOf(tag) > -1 || el.getAttribute('contenteditable') === 'true')
+            )
+    }
+}
+
+/*
+ * Check whether a DOM element should be "captured" or if it may contain sentitive data
+ * using a variety of heuristics.
+ * @param {Element} el - element to check
+ * @returns {boolean} whether the element should be captured
+ */
+function shouldCaptureElement(el) {
+    for (var curEl = el; curEl.parentNode && !isTag(curEl, 'body'); curEl = curEl.parentNode) {
+        var classes = getClassName(curEl).split(' ');
+        if (_.includes(classes, 'um-sensitive') || _.includes(classes, 'um-no-capture')) {
+            return false
+        }
+    }
+
+    if (_.includes(getClassName(el).split(' '), 'um-include')) {
+        return true
+    }
+
+    // don't include hidden or password fields
+    var type = el.type || '';
+    if (typeof type === 'string') {
+        // it's possible for el.type to be a DOM element if el is a form with a child input[name="type"]
+        switch (type.toLowerCase()) {
+            case 'hidden':
+                return false
+            case 'password':
+                return false
+        }
+    }
+
+    // filter out data from fields that look like sensitive fields
+    var name = el.name || el.id || '';
+    if (typeof name === 'string') {
+        // it's possible for el.name or el.id to be a DOM element if el is a form with a child input[name="name"]
+        var sensitiveNameRegex = /^cc|cardnum|ccnum|creditcard|csc|cvc|cvv|exp|pass|pwd|routing|seccode|securitycode|securitynum|socialsec|socsec|ssn/i;
+        if (sensitiveNameRegex.test(name.replace(/[^a-zA-Z0-9]/g, ''))) {
+            return false
+        }
+    }
+
+    return true
+}
+
+/*
+ * Check whether a DOM element is 'sensitive' and we should only capture limited data
+ * @param {Element} el - element to check
+ * @returns {boolean} whether the element should be captured
+ */
+function isSensitiveElement(el) {
+    // don't send data from inputs or similar elements since there will always be
+    // a risk of clientside javascript placing sensitive data in attributes
+    const allowedInputTypes = ['button', 'checkbox', 'submit', 'reset'];
+    if (
+        (isTag(el, 'input') && !allowedInputTypes.includes(el.type)) ||
+        isTag(el, 'select') ||
+        isTag(el, 'textarea') ||
+        el.getAttribute('contenteditable') === 'true'
+    ) {
+        return true
+    }
+    return false
+}
+
+/*
+ * Check whether a string value should be "captured" or if it may contain sentitive data
+ * using a variety of heuristics.
+ * @param {string} value - string value to check
+ * @returns {boolean} whether the element should be captured
+ */
+function shouldCaptureValue(value) {
+    if (value === null || _.isUndefined(value)) {
+        return false
+    }
+
+    if (typeof value === 'string') {
+        value = _.trim(value);
+
+        // check to see if input value looks like a credit card number
+        // see: https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9781449327453/ch04s20.html
+        var ccRegex = /^(?:(4[0-9]{12}(?:[0-9]{3})?)|(5[1-5][0-9]{14})|(6(?:011|5[0-9]{2})[0-9]{12})|(3[47][0-9]{13})|(3(?:0[0-5]|[68][0-9])[0-9]{11})|((?:2131|1800|35[0-9]{3})[0-9]{11}))$/;
+        if (ccRegex.test((value || '').replace(/[- ]/g, ''))) {
+            return false
+        }
+
+        // check to see if input value looks like a social security number
+        var ssnRegex = /(^\d{3}-?\d{2}-?\d{4}$)/;
+        if (ssnRegex.test(value)) {
+            return false
+        }
+    }
+
+    return true
+}
+
+/*
+ * Check whether an attribute name is an Angular style attr (either _ngcontent or _nghost)
+ * These update on each build and lead to noise in the element chain
+ * More details on the attributes here: https://angular.io/guide/view-encapsulation
+ * @param {string} attributeName - string value to check
+ * @returns {boolean} whether the element is an angular tag
+ */
+function isAngularStyleAttr(attributeName) {
+    if (typeof attributeName === 'string') {
+        return attributeName.substring(0, 10) === '_ngcontent' || attributeName.substring(0, 7) === '_nghost'
+    }
+    return false
+}
+
+// Naive rage click implementation: If mouse has not moved than RAGE_CLICK_THRESHOLD_PX
+// over RAGE_CLICK_CLICK_COUNT clicks with max RAGE_CLICK_TIMEOUT_MS between clicks, it's
+// counted as a rage click
+const RAGE_CLICK_THRESHOLD_PX = 30;
+const RAGE_CLICK_TIMEOUT_MS = 1000;
+const RAGE_CLICK_CLICK_COUNT = 3;
+
+class RageClick {
+    constructor(instance, enabled = instance.get_config('rageclick')) {
+        this.clicks = [];
+        this.instance = instance;
+        this.enabled = enabled;
+    }
+
+    click(x, y, timestamp) {
+        if (!this.enabled) {
+            return
+        }
+
+        const lastClick = this.clicks[this.clicks.length - 1];
+        if (
+            lastClick &&
+            Math.abs(x - lastClick.x) + Math.abs(y - lastClick.y) < RAGE_CLICK_THRESHOLD_PX &&
+            timestamp - lastClick.timestamp < RAGE_CLICK_TIMEOUT_MS
+        ) {
+            this.clicks.push({ x, y, timestamp });
+
+            if (this.clicks.length === RAGE_CLICK_CLICK_COUNT) {
+                this.instance.capture('$rageclick');
+            }
+        } else {
+            this.clicks = [{ x, y, timestamp }];
+        }
+    }
+}
+
+var autocapture = {
+    _initializedTokens: [],
+
+    _previousElementSibling: function (el) {
+        if (el.previousElementSibling) {
+            return el.previousElementSibling
+        } else {
+            do {
+                el = el.previousSibling;
+            } while (el && !isElementNode(el))
+            return el
+        }
+    },
+
+    _getPropertiesFromElement: function (elem, maskInputs, maskText) {
+        var tag_name = elem.tagName.toLowerCase();
+        var props = {
+            tag_name: tag_name,
+        };
+        if (usefulElements.indexOf(tag_name) > -1 && !maskText) {
+            props['$el_text'] = getSafeText(elem);
+        }
+
+        var classes = getClassName(elem);
+        if (classes.length > 0)
+            props['classes'] = classes.split(' ').filter(function (c) {
+                return c !== ''
+            });
+
+        _.each(elem.attributes, function (attr) {
+            // Only capture attributes we know are safe
+            if (isSensitiveElement(elem) && ['name', 'id', 'class'].indexOf(attr.name) === -1) return
+
+            if (!maskInputs && shouldCaptureValue(attr.value) && !isAngularStyleAttr(attr.name)) {
+                props['attr__' + attr.name] = attr.value;
+            }
+        });
+
+        var nthChild = 1;
+        var nthOfType = 1;
+        var currentElem = elem;
+        while ((currentElem = this._previousElementSibling(currentElem))) {
+            // eslint-disable-line no-cond-assign
+            nthChild++;
+            if (currentElem.tagName === elem.tagName) {
+                nthOfType++;
+            }
+        }
+        props['nth_child'] = nthChild;
+        props['nth_of_type'] = nthOfType;
+
+        return props
+    },
+
+    _getDefaultProperties: function (eventType) {
+        return {
+            $event_type: eventType,
+            $ce_version: 1,
+        }
+    },
+
+    _extractCustomPropertyValue: function (customProperty) {
+        var propValues = [];
+        _.each(document.querySelectorAll(customProperty['css_selector']), function (matchedElem) {
+            var value;
+
+            if (['input', 'select'].indexOf(matchedElem.tagName.toLowerCase()) > -1) {
+                value = matchedElem['value'];
+            } else if (matchedElem['textContent']) {
+                value = matchedElem['textContent'];
+            }
+
+            if (shouldCaptureValue(value)) {
+                propValues.push(value);
+            }
+        });
+        return propValues.join(', ')
+    },
+
+    _getCustomProperties: function (targetElementList) {
+        var props = {};
+        _.each(
+            this._customProperties,
+            function (customProperty) {
+                _.each(
+                    customProperty['event_selectors'],
+                    function (eventSelector) {
+                        var eventElements = document.querySelectorAll(eventSelector);
+                        _.each(
+                            eventElements,
+                            function (eventElement) {
+                                if (_.includes(targetElementList, eventElement) && shouldCaptureElement(eventElement)) {
+                                    props[customProperty['name']] = this._extractCustomPropertyValue(customProperty);
+                                }
+                            },
+                            this
+                        );
+                    },
+                    this
+                );
+            },
+            this
+        );
+        return props
+    },
+
+    _getEventTarget: function (e) {
+        // https://developer.mozilla.org/en-US/docs/Web/API/Event/target#Compatibility_notes
+        if (typeof e.target === 'undefined') {
+            return e.srcElement
+        } else {
+            if (e.target.shadowRoot) {
+                return e.composedPath()[0]
+            }
+            return e.target
+        }
+    },
+
+    _captureEvent: function (e, instance) {
+        /*** Don't mess with this code without running IE8 tests on it ***/
+        var target = this._getEventTarget(e);
+        if (isTextNode(target)) {
+            // defeat Safari bug (see: http://www.quirksmode.org/js/events_properties.html)
+            target = target.parentNode;
+        }
+
+        if (e.type === 'click') {
+            this.rageclicks.click(e.clientX, e.clientY, new Date().getTime());
+        }
+
+        if (shouldCaptureDomEvent(target, e)) {
+            var targetElementList = [target];
+            var curEl = target;
+            while (curEl.parentNode && !isTag(curEl, 'body')) {
+                if (curEl.parentNode.nodeType === 11) {
+                    targetElementList.push(curEl.parentNode.host);
+                    curEl = curEl.parentNode.host;
+                    continue
+                }
+                targetElementList.push(curEl.parentNode);
+                curEl = curEl.parentNode;
+            }
+
+            var elementsJson = [];
+            var href,
+                explicitNoCapture = false;
+            _.each(
+                targetElementList,
+                function (el) {
+                    var shouldCaptureEl = shouldCaptureElement(el);
+
+                    // if the element or a parent element is an anchor tag
+                    // include the href as a property
+                    if (el.tagName.toLowerCase() === 'a') {
+                        href = el.getAttribute('href');
+                        href = shouldCaptureEl && shouldCaptureValue(href) && href;
+                    }
+
+                    // allow users to programmatically prevent capturing of elements by adding class 'um-no-capture'
+                    var classes = getClassName(el).split(' ');
+                    if (_.includes(classes, 'um-no-capture')) {
+                        explicitNoCapture = true;
+                    }
+
+                    elementsJson.push(
+                        this._getPropertiesFromElement(
+                            el,
+                            instance.get_config('mask_all_element_attributes'),
+                            instance.get_config('mask_all_text')
+                        )
+                    );
+                },
+                this
+            );
+
+            if (!instance.get_config('mask_all_text')) {
+                elementsJson[0]['$el_text'] = getSafeText(target);
+            }
+
+            if (href) {
+                elementsJson[0]['attr__href'] = href;
+            }
+
+            if (explicitNoCapture) {
+                return false
+            }
+
+            var props = _.extend(
+                this._getDefaultProperties(e.type),
+                {
+                    $elements: elementsJson,
+                },
+                this._getCustomProperties(targetElementList)
+            );
+
+            instance.capture('$autocapture', props);
+            return true
+        }
+    },
+
+    // only reason is to stub for unit tests
+    // since you can't override window.location props
+    _navigate: function (href) {
+        window.location.href = href;
+    },
+
+    _addDomEventHandlers: function (instance) {
+        var handler = _.bind(function (e) {
+            e = e || window.event;
+            this._captureEvent(e, instance);
+        }, this);
+        _.register_event(document, 'submit', handler, false, true);
+        _.register_event(document, 'change', handler, false, true);
+        _.register_event(document, 'click', handler, false, true);
+    },
+
+    _customProperties: {},
+    init: function (instance) {
+        var token = instance.get_config('token');
+        console.log('Initializing autocapture for token "' + token + '"');
+        if (this._initializedTokens.indexOf(token) > -1) {
+            console.log('autocapture already initialized for token "' + token + '"');
+            return
+        }
+
+        this._initializedTokens.push(token);
+
+        if (instance.get_config('autocapture')) {
+            this._addDomEventHandlers(instance);
+        } else {
+            instance['__autocapture_enabled'] = false;
+        }
+
+        this.rageclicks = new RageClick(instance);
+    },
+
+    // this is a mechanism to ramp up CE with no server-side interaction.
+    // when CE is active, every page load results in a decide request. we
+    // need to gently ramp this up so we don't overload decide. this decides
+    // deterministically if CE is enabled for this project by modding the char
+    // value of the project token.
+    enabledForProject: function (token, numBuckets, numEnabledBuckets) {
+        numBuckets = !_.isUndefined(numBuckets) ? numBuckets : 10;
+        numEnabledBuckets = !_.isUndefined(numEnabledBuckets) ? numEnabledBuckets : 10;
+        var charCodeSum = 0;
+        for (var i = 0; i < token.length; i++) {
+            charCodeSum += token.charCodeAt(i);
+        }
+        return charCodeSum % numBuckets < numEnabledBuckets
+    },
+
+    isBrowserSupported: function () {
+        return _.isFunction(document.querySelectorAll)
+    },
+};
+
+_.bind_instance_methods(autocapture);
+_.safewrap_instance_methods(autocapture);
+
 var VERSION_INFO = {
     env: 'production',
-    date: '2022-03-29T11:24:13.204Z',
-    version: '1.0.5'
+    date: '2022-04-05T15:14:31.029Z',
+    version: '1.0.6'
 };
 var USERMAVEN_VERSION = "".concat(VERSION_INFO.version, "/").concat(VERSION_INFO.env, "@").concat(VERSION_INFO.date);
+var MAX_AGE_TEN_YEARS = 31622400 * 10;
 var beaconTransport = function (url, json) {
-    getLogger().debug('Sending beacon', json);
-    var blob = new Blob([json], { type: 'text/plain' });
+    getLogger().debug("Sending beacon", json);
+    var blob = new Blob([json], { type: "text/plain" });
     navigator.sendBeacon(url, blob);
     return Promise.resolve();
 };
+function tryFormat(string) {
+    if (typeof string === "string") {
+        try {
+            return JSON.stringify(JSON.parse(string), null, 2);
+        }
+        catch (e) {
+            return string;
+        }
+    }
+}
+var echoTransport = function (url, json) {
+    console.log("Jitsu client tried to send payload to ".concat(url), tryFormat(json));
+    return Promise.resolve();
+};
+// This is a hack to expire all cookies with non-root path left behind by invalid tracking.
+// TODO remove soon
+function expireNonRootCookies(name, path) {
+    if (path === void 0) { path = undefined; }
+    path = path !== null && path !== void 0 ? path : window.location.pathname;
+    if (path == "" || path == "/") {
+        return;
+    }
+    deleteCookie(name, path);
+    expireNonRootCookies(name, path.slice(0, path.lastIndexOf("/")));
+}
 var CookiePersistence = /** @class */ (function () {
     function CookiePersistence(cookieDomain, cookieName) {
         this.cookieDomain = cookieDomain;
         this.cookieName = cookieName;
     }
     CookiePersistence.prototype.save = function (props) {
-        setCookie(this.cookieName, encodeURIComponent(JSON.stringify(props)), Infinity, this.cookieDomain, document.location.protocol !== 'http:');
+        setCookie(this.cookieName, JSON.stringify(props), {
+            domain: this.cookieDomain,
+            secure: document.location.protocol !== "http:",
+            maxAge: MAX_AGE_TEN_YEARS,
+        });
     };
     CookiePersistence.prototype.restore = function () {
+        expireNonRootCookies(this.cookieName);
         var str = getCookie(this.cookieName);
         if (str) {
             try {
                 var parsed = JSON.parse(decodeURIComponent(str));
-                if (typeof parsed !== 'object') {
-                    getLogger().warn("Can't restore value of ".concat(this.cookieName, "@").concat(this.cookieDomain, ", expected to be object, but found ").concat(typeof parsed !== 'object', ": ").concat(parsed, ". Ignoring"));
+                if (typeof parsed !== "object") {
+                    getLogger().warn("Can't restore value of ".concat(this.cookieName, "@").concat(this.cookieDomain, ", expected to be object, but found ").concat(typeof parsed !== "object", ": ").concat(parsed, ". Ignoring"));
                     return undefined;
                 }
                 return parsed;
             }
             catch (e) {
-                getLogger().error('Failed to decode JSON from ' + str, e);
+                getLogger().error("Failed to decode JSON from " + str, e);
                 return undefined;
             }
         }
@@ -1792,8 +2532,7 @@ var CookiePersistence = /** @class */ (function () {
 var NoPersistence = /** @class */ (function () {
     function NoPersistence() {
     }
-    NoPersistence.prototype.save = function (props) {
-    };
+    NoPersistence.prototype.save = function (props) { };
     NoPersistence.prototype.restore = function () {
         return undefined;
     };
@@ -1806,116 +2545,370 @@ function usermavenClient(opts) {
     client.init(opts);
     return client;
 }
+var browserEnv = {
+    getSourceIp: function () { return undefined; },
+    describeClient: function () { return ({
+        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_agent: navigator.userAgent,
+        user_language: navigator.language,
+        doc_encoding: document.characterSet,
+    }); },
+    getAnonymousId: function (_a) {
+        var name = _a.name, domain = _a.domain;
+        expireNonRootCookies(name);
+        var idCookie = getCookie(name);
+        if (idCookie) {
+            getLogger().debug("Existing user id", idCookie);
+            return idCookie;
+        }
+        var newId = generateId();
+        getLogger().debug("New user id", newId);
+        setCookie(name, newId, {
+            domain: domain,
+            secure: document.location.protocol !== "http:",
+            maxAge: MAX_AGE_TEN_YEARS,
+        });
+        return newId;
+    },
+};
+function ensurePrefix(prefix, str) {
+    if (!str) {
+        return str;
+    }
+    return (str === null || str === void 0 ? void 0 : str.length) > 0 && str.indexOf(prefix) !== 0 ? prefix + str : str;
+}
+function cutPostfix(postfixes, str) {
+    for (var _i = 0, _a = typeof postfixes === "string"
+        ? [postfixes]
+        : postfixes; _i < _a.length; _i++) {
+        var postfix = _a[_i];
+        while (str && str.length > 0 && str.charAt(str.length - 1) === postfix) {
+            str = str.substring(0, str.length - 1);
+        }
+    }
+    return str;
+}
+function fetchApi(req, res, opts) {
+    if (opts === void 0) { opts = {}; }
+    return {
+        getAnonymousId: function (_a) {
+            var name = _a.name, domain = _a.domain;
+            if (opts === null || opts === void 0 ? void 0 : opts.disableCookies) {
+                return "";
+            }
+            var cookie = parseCookieString(req.headers["cookie"])[name];
+            if (!cookie) {
+                var cookieOpts = {
+                    maxAge: 31622400 * 10,
+                    httpOnly: false,
+                };
+                if (domain) {
+                    cookieOpts.domain = domain;
+                }
+                var newId = generateId();
+                res.headers.set("Set-Cookie", serializeCookie(name, newId, cookieOpts));
+                return newId;
+            }
+            else {
+                return cookie;
+            }
+        },
+        getSourceIp: function () {
+            var ip = req.headers["x-forwarded-for"] || req.headers["x-real-ip"] || req["ip"];
+            return ip && ip.split(",")[0].trim();
+        },
+        describeClient: function () {
+            var requestHost = req.headers.get("host") || req.headers.get("host");
+            var proto = cutPostfix([":", "/"], req.headers["x-forwarded-proto"] || req["nextUrl"]["protocol"] || "http");
+            while (proto && proto.length > 0 && proto.charAt(proto.length - 1)) {
+                proto = proto.substring(0, proto.length - 1);
+            }
+            var reqUrl = req.url || "/";
+            var queryPos = reqUrl.indexOf("?");
+            var path, query;
+            if (queryPos >= 0) {
+                path = reqUrl.substring(0, queryPos);
+                query = reqUrl.substring(queryPos + 1);
+            }
+            else {
+                path = reqUrl;
+                query = undefined;
+            }
+            query = ensurePrefix(query, "?");
+            path = ensurePrefix(path, "/");
+            return {
+                doc_encoding: "",
+                doc_host: requestHost,
+                doc_path: reqUrl,
+                doc_search: query,
+                page_title: "",
+                referer: req.headers["referrer"],
+                screen_resolution: "",
+                url: "".concat(proto, "://").concat(requestHost).concat(path || "").concat(query || ""),
+                user_agent: req.headers["user-agent"],
+                user_language: req.headers["accept-language"] &&
+                    req.headers["accept-language"].split(",")[0],
+                vp_size: "",
+            };
+        },
+    };
+}
+function httpApi(req, res, opts) {
+    if (opts === void 0) { opts = {}; }
+    var header = function (req, name) {
+        var vals = req.headers[name.toLowerCase()];
+        if (!vals) {
+            return undefined;
+        }
+        if (typeof vals === "string") {
+            return vals;
+        }
+        else if (vals.length > 0) {
+            return vals.join(",");
+        }
+    };
+    return {
+        getAnonymousId: function (_a) {
+            var name = _a.name, domain = _a.domain;
+            if (opts === null || opts === void 0 ? void 0 : opts.disableCookies) {
+                return "";
+            }
+            var cookie = parseCookieString(req.headers["cookie"])[name];
+            if (!cookie) {
+                var cookieOpts = {
+                    maxAge: 31622400 * 10,
+                    httpOnly: false,
+                };
+                if (domain) {
+                    cookieOpts.domain = domain;
+                }
+                var newId = generateId();
+                res.setHeader("Set-Cookie", serializeCookie(name, newId, cookieOpts));
+                return newId;
+            }
+            else {
+                return cookie;
+            }
+        },
+        getSourceIp: function () {
+            var ip = header(req, "x-forwarded-for") ||
+                header(req, "x-real-ip") ||
+                req.socket.remoteAddress;
+            return ip && ip.split(",")[0].trim();
+        },
+        describeClient: function () {
+            var url = req.url
+                ? new URL(req.url, req.url.startsWith("http") ? undefined : "http://localhost")
+                : {};
+            var requestHost = header(req, "x-forwarded-host") || header(req, "host") || url.hostname;
+            var proto = cutPostfix([":", "/"], header(req, "x-forwarded-proto") || url.protocol);
+            var query = ensurePrefix("?", url.search);
+            var path = ensurePrefix("/", url.pathname);
+            return {
+                doc_encoding: "",
+                doc_host: requestHost,
+                doc_path: req.url,
+                doc_search: query,
+                page_title: "",
+                referer: header(req, "referrer"),
+                screen_resolution: "",
+                url: "".concat(proto, "://").concat(requestHost).concat(path || "").concat(query || ""),
+                user_agent: req.headers["user-agent"],
+                user_language: req.headers["accept-language"] &&
+                    req.headers["accept-language"].split(",")[0],
+                vp_size: "",
+            };
+        },
+    };
+}
+var emptyEnv = {
+    getSourceIp: function () { return undefined; },
+    describeClient: function () { return ({}); },
+    getAnonymousId: function () { return ""; },
+};
+/**
+ * Dictionary of supported environments
+ */
+var envs = {
+    httpApi: httpApi,
+    nextjsApi: httpApi,
+    // fetchApi: fetchApi,
+    // nextjsMiddleware: fetchApi,
+    browser: function () { return browserEnv; },
+    express: httpApi,
+    empty: function () { return emptyEnv; },
+};
+var xmlHttpTransport = function (url, jsonPayload, additionalHeaders, handler) {
+    if (handler === void 0) { handler = function (code, body) { }; }
+    var req = new window.XMLHttpRequest();
+    return new Promise(function (resolve, reject) {
+        req.onerror = function (e) {
+            getLogger().error("Failed to send", jsonPayload, e);
+            handler(-1, {});
+            reject(new Error("Failed to send JSON. See console logs"));
+        };
+        req.onload = function () {
+            if (req.status !== 200) {
+                handler(req.status, {});
+                getLogger().warn("Failed to send data to ".concat(url, " (#").concat(req.status, " - ").concat(req.statusText, ")"), jsonPayload);
+                reject(new Error("Failed to send JSON. Error code: ".concat(req.status, ". See logs for details")));
+            }
+            else {
+                handler(req.status, req.responseText);
+            }
+            resolve();
+        };
+        req.open("POST", url);
+        req.setRequestHeader("Content-Type", "application/json");
+        Object.entries(additionalHeaders || {}).forEach(function (_a) {
+            var key = _a[0], val = _a[1];
+            return req.setRequestHeader(key, val);
+        });
+        req.send(jsonPayload);
+        getLogger().debug("sending json", jsonPayload);
+    });
+};
+var fetchTransport = function (fetch) {
+    return function (url, jsonPayload, additionalHeaders, handler) {
+        if (handler === void 0) { handler = function (code, body) { }; }
+        return __awaiter(void 0, void 0, void 0, function () {
+            var res, e_1, resJson;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fetch(url, {
+                                method: "POST",
+                                headers: __assign({ Accept: "application/json", "Content-Type": "application/json" }, (additionalHeaders || {})),
+                                body: jsonPayload,
+                            })];
+                    case 1:
+                        res = _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_1 = _a.sent();
+                        getLogger().error("Failed to send", jsonPayload, e_1);
+                        handler(-1, {});
+                        throw new Error("Failed to send JSON. See console logs");
+                    case 3:
+                        if (res.status !== 200) {
+                            getLogger().warn("Failed to send data to ".concat(url, " (#").concat(res.status, " - ").concat(res.statusText, ")"), jsonPayload);
+                            throw new Error("Failed to send JSON. Error code: ".concat(res.status, ". See logs for details"));
+                        }
+                        return [4 /*yield*/, res.json()];
+                    case 4:
+                        resJson = _a.sent();
+                        handler(res.status, resJson);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+};
 var UsermavenClientImpl = /** @class */ (function () {
     function UsermavenClientImpl() {
-        this.anonymousId = '';
         this.userProperties = {};
-        this.permanentProperties = { globalProps: {}, propsPerEvent: {} };
-        this.cookieDomain = '';
-        this.trackingHost = '';
-        this.idCookieName = '';
+        this.permanentProperties = {
+            globalProps: {},
+            propsPerEvent: {},
+        };
+        this.cookieDomain = "";
+        this.trackingHost = "";
+        this.idCookieName = "";
         this.randomizeUrl = false;
-        this.apiKey = '';
+        this.apiKey = "";
         this.initialized = false;
         this._3pCookies = {};
-        this.cookiePolicy = 'keep';
-        this.ipPolicy = 'keep';
+        this.cookiePolicy = "keep";
+        this.ipPolicy = "keep";
         this.beaconApi = false;
-    }
+        this.transport = xmlHttpTransport;
+        this.customHeaders = function () { return ({}); };
+        this.__autocapture_enabled = false;
+    }
+    // private anonymousId: string = '';
+    // Used for session + autocapture
+    UsermavenClientImpl.prototype.get_config = function (prop_name) {
+        return this.config ? this.config[prop_name] : null;
+    };
     UsermavenClientImpl.prototype.id = function (props, doNotSendEvent) {
         this.userProperties = __assign(__assign({}, this.userProperties), props);
-        getLogger().debug('Usermaven user identified', props);
+        getLogger().debug("Usermaven user identified", props);
         if (this.userIdPersistence) {
             this.userIdPersistence.save(props);
         }
         else {
-            getLogger().warn('Id() is called before initialization');
+            getLogger().warn("Id() is called before initialization");
         }
         if (!doNotSendEvent) {
-            return this.track('user_identify', {});
+            return this.track("user_identify", {});
         }
         else {
             return Promise.resolve();
         }
     };
     UsermavenClientImpl.prototype.rawTrack = function (payload) {
-        this.sendJson(payload);
-    };
-    UsermavenClientImpl.prototype.getAnonymousId = function () {
-        var idCookie = getCookie(this.idCookieName);
-        if (idCookie) {
-            getLogger().debug('Existing user id', idCookie);
-            return idCookie;
-        }
-        var newId = generateId();
-        getLogger().debug('New user id', newId);
-        setCookie(this.idCookieName, newId, Infinity, this.cookieDomain, document.location.protocol !== 'http:');
-        return newId;
+        return this.sendJson(payload);
     };
     UsermavenClientImpl.prototype.makeEvent = function (event_type, src, payload) {
         var _a;
+        var env = payload.env, payloadData = __rest(payload, ["env"]);
+        if (!env) {
+            env = isWindowAvailable() ? envs.browser() : envs.empty();
+        }
         this.restoreId();
-        var context = this.getCtx();
+        var context = this.getCtx(env);
         var persistentProps = __assign(__assign({}, this.permanentProperties.globalProps), ((_a = this.permanentProperties.propsPerEvent[event_type]) !== null && _a !== void 0 ? _a : {}));
-        var base = __assign({ api_key: this.apiKey, src: src, event_type: event_type }, payload);
-        return this.compatMode ? __assign(__assign(__assign({}, persistentProps), { eventn_ctx: context }), base) : __assign(__assign(__assign({}, persistentProps), context), base);
+        var base = __assign({ api_key: this.apiKey, src: src, event_type: event_type }, payloadData);
+        var sourceIp = env.getSourceIp();
+        if (sourceIp) {
+            base["source_ip"] = sourceIp;
+        }
+        return this.compatMode
+            ? __assign(__assign(__assign({}, persistentProps), { eventn_ctx: context }), base) : __assign(__assign(__assign({}, persistentProps), context), base);
     };
     UsermavenClientImpl.prototype._send3p = function (sourceType, object, type) {
-        var eventType = '3rdparty';
-        if (type && type !== '') {
+        var eventType = "3rdparty";
+        if (type && type !== "") {
             eventType = type;
         }
         var e = this.makeEvent(eventType, sourceType, {
-            src_payload: object
+            src_payload: object,
         });
         return this.sendJson(e);
     };
     UsermavenClientImpl.prototype.sendJson = function (json) {
-        var cookiePolicy = this.cookiePolicy !== 'keep' ? "&cookie_policy=".concat(this.cookiePolicy) : '';
-        var ipPolicy = this.ipPolicy !== 'keep' ? "&ip_policy=".concat(this.ipPolicy) : '';
-        var url = "".concat(this.trackingHost, "/api/v1/event?token=").concat(this.apiKey).concat(cookiePolicy).concat(ipPolicy);
+        var _this = this;
+        var cookiePolicy = this.cookiePolicy !== "keep" ? "&cookie_policy=".concat(this.cookiePolicy) : "";
+        var ipPolicy = this.ipPolicy !== "keep" ? "&ip_policy=".concat(this.ipPolicy) : "";
+        var urlPrefix = isWindowAvailable() ? "/api/v1/event" : "/api/v1/s2s/event";
+        var url = "".concat(this.trackingHost).concat(urlPrefix, "?token=").concat(this.apiKey).concat(cookiePolicy).concat(ipPolicy);
         if (this.randomizeUrl) {
             url = "".concat(this.trackingHost, "/api.").concat(generateRandom(), "?p_").concat(generateRandom(), "=").concat(this.apiKey).concat(cookiePolicy).concat(ipPolicy);
         }
         var jsonString = JSON.stringify(json);
-        if (this.beaconApi) {
-            return beaconTransport(url, jsonString);
-        }
-        else {
-            return this.xmlHttpReqTransport(url, jsonString);
-        }
-    };
-    UsermavenClientImpl.prototype.xmlHttpReqTransport = function (url, json) {
-        var _this = this;
-        var req = new XMLHttpRequest();
-        return new Promise(function (resolve, reject) {
-            req.onerror = function (e) {
-                getLogger().error('Failed to send', json, e);
-                _this.postHandle(-1, {});
-                reject(new Error("Failed to send JSON. See console logs"));
-            };
-            req.onload = function () {
-                _this.postHandle(req.status, req.response);
-                if (req.status !== 200) {
-                    getLogger().warn("Failed to send data to ".concat(url, " (#").concat(req.status, " - ").concat(req.statusText, ")"), json);
-                    reject(new Error("Failed to send JSON. Error code: ".concat(req.status, ". See logs for details")));
-                }
-                resolve();
-            };
-            req.open('POST', url);
-            req.setRequestHeader('Content-Type', 'application/json');
-            req.send(json);
-            getLogger().debug('sending json', json);
+        getLogger().debug("Sending payload to ".concat(url), jsonString);
+        return this.transport(url, jsonString, this.customHeaders(), function (code, body) {
+            return _this.postHandle(code, body);
         });
     };
     UsermavenClientImpl.prototype.postHandle = function (status, response) {
-        if (this.cookiePolicy === 'strict' || this.cookiePolicy === 'comply') {
+        if (this.cookiePolicy === "strict" || this.cookiePolicy === "comply") {
             if (status === 200) {
                 var data = response;
-                if (typeof response === 'string') {
+                if (typeof response === "string") {
                     data = JSON.parse(response);
                 }
-                if (!data['delete_cookie']) {
+                if (!data["delete_cookie"]) {
                     return;
                 }
             }
@@ -1923,15 +2916,45 @@ var UsermavenClientImpl = /** @class */ (function () {
             this.propsPersistance.delete();
             deleteCookie(this.idCookieName);
         }
+        if (status === 200) {
+            var data = response;
+            if (typeof response === "string" && response.length > 0) {
+                data = JSON.parse(response);
+                var extras = data["jitsu_sdk_extras"];
+                if (extras && extras.length > 0) {
+                    var isWindow = isWindowAvailable();
+                    if (!isWindow) {
+                        getLogger().error("Tags destination supported only in browser environment");
+                    }
+                    else {
+                        for (var _i = 0, extras_1 = extras; _i < extras_1.length; _i++) {
+                            var _a = extras_1[_i], type = _a.type, id = _a.id, value = _a.value;
+                            if (type === "tag") {
+                                var tag = document.createElement("div");
+                                tag.id = id;
+                                insertAndExecute(tag, value);
+                                if (tag.childElementCount > 0) {
+                                    document.body.appendChild(tag);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
     };
-    UsermavenClientImpl.prototype.getCtx = function () {
+    UsermavenClientImpl.prototype.getCtx = function (env) {
         var now = new Date();
-        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()));
+        var props = env.describeClient() || {};
+        var _a = this.sessionManager.getSessionAndWindowId(), session_id = _a.session_id, window_id = _a.window_id;
+        var company = this.userProperties['company'] || {};
+        delete this.userProperties['company'];
+        var payload = __assign(__assign({ event_id: "", session_id: session_id, window_id: window_id, user: __assign({ anonymous_id: this.cookiePolicy !== "strict"
+                    ? env.getAnonymousId({
+                        name: this.idCookieName,
+                        domain: this.cookieDomain,
+                    })
+                    : "" }, this.userProperties), ids: this._getIds(), utc_time: reformatDate(now.toISOString()), local_tz_offset: now.getTimezoneOffset() }, props), getDataFromParams(parseQuery(props.doc_search)));
         // id and name attributes will be checked on backend
         if (Object.keys(company).length) {
             payload['company'] = company;
@@ -1939,74 +2962,104 @@ var UsermavenClientImpl = /** @class */ (function () {
         return payload;
     };
     UsermavenClientImpl.prototype._getIds = function () {
+        if (!isWindowAvailable()) {
+            return {};
+        }
         var cookies = getCookies(false);
         var res = {};
         for (var _i = 0, _a = Object.entries(cookies); _i < _a.length; _i++) {
             var _b = _a[_i], key = _b[0], value = _b[1];
             if (this._3pCookies[key]) {
-                res[key.charAt(0) == '_' ?
-                    key.substr(1) :
-                    key] = value;
+                res[key.charAt(0) == "_" ? key.substr(1) : key] = value;
             }
         }
         return res;
     };
     UsermavenClientImpl.prototype.track = function (type, payload) {
         var data = payload || {};
-        getLogger().debug('track event of type', type, data);
-        var e = this.makeEvent(type, this.compatMode ?
-            'eventn' :
-            'usermaven', payload || {});
+        getLogger().debug("track event of type", type, data);
+        var e = this.makeEvent(type, this.compatMode ? "eventn" : "usermaven", payload || {});
         return this.sendJson(e);
     };
     UsermavenClientImpl.prototype.init = function (options) {
         var _this = this;
         var _a, _b;
+        if (isWindowAvailable() && !options.force_use_fetch) {
+            if (options.fetch) {
+                getLogger().warn("Custom fetch implementation is provided to Usermaven. However, it will be ignored since Usermaven runs in browser");
+            }
+            this.transport = this.beaconApi ? beaconTransport : xmlHttpTransport;
+        }
+        else {
+            if (!options.fetch && !globalThis.fetch) {
+                throw new Error("Usermaven runs in Node environment. However, neither UsermavenOptions.fetch is provided, nor global fetch function is defined. \n" +
+                    "Please, provide custom fetch implementation. You can get it via node-fetch package");
+            }
+            this.transport = fetchTransport(options.fetch || globalThis.fetch);
+        }
+        if (options.custom_headers &&
+            typeof options.custom_headers === "function") {
+            this.customHeaders = options.custom_headers;
+        }
+        else if (options.custom_headers) {
+            this.customHeaders = function () {
+                return options.custom_headers;
+            };
+        }
+        if (options.tracking_host === "echo") {
+            getLogger().warn('jitsuClient is configured with "echo" transport. Outgoing requests will be written to console');
+            this.transport = echoTransport;
+        }
         if (options.ip_policy) {
             this.ipPolicy = options.ip_policy;
         }
         if (options.cookie_policy) {
             this.cookiePolicy = options.cookie_policy;
         }
-        if (options.privacy_policy === 'strict') {
-            this.ipPolicy = 'strict';
-            this.cookiePolicy = 'strict';
+        if (options.privacy_policy === "strict") {
+            this.ipPolicy = "strict";
+            this.cookiePolicy = "strict";
         }
         if (options.use_beacon_api && navigator.sendBeacon) {
             this.beaconApi = true;
         }
         //can't handle delete cookie response when beacon api
-        if (this.cookiePolicy === 'comply' && this.beaconApi) {
-            this.cookiePolicy = 'strict';
+        if (this.cookiePolicy === "comply" && this.beaconApi) {
+            this.cookiePolicy = "strict";
         }
         if (options.log_level) {
             setRootLogLevel(options.log_level);
         }
         this.initialOptions = options;
-        getLogger().debug('Initializing Usermaven Tracker tracker', options, USERMAVEN_VERSION);
+        getLogger().debug("Initializing Usemaven Tracker tracker", options, USERMAVEN_VERSION);
         if (!options.key) {
-            getLogger().error('Can\'t initialize Usermaven, key property is not set');
+            getLogger().error("Can't initialize Usemaven, key property is not set");
             return;
         }
-        this.compatMode = options.compat_mode === undefined ?
-            defaultCompatMode :
-            !!options.compat_mode;
+        this.compatMode =
+            options.compat_mode === undefined
+                ? defaultCompatMode
+                : !!options.compat_mode;
         this.cookieDomain = options.cookie_domain || getCookieDomain();
-        this.trackingHost = getHostWithProtocol(options['tracking_host'] || 't.usermaven.com');
+        this.trackingHost = getHostWithProtocol(options["tracking_host"] || "t.usermaven.com");
         this.randomizeUrl = options.randomize_url || false;
-        this.idCookieName = options.cookie_name || '__eventn_id';
+        this.idCookieName = options.cookie_name || "__eventn_id";
         this.apiKey = options.key;
-        if (this.cookiePolicy === 'strict') {
+        if (this.cookiePolicy === "strict") {
             this.propsPersistance = new NoPersistence();
         }
         else {
-            this.propsPersistance = new CookiePersistence(this.cookieDomain, this.idCookieName + '_props');
+            this.propsPersistance = isWindowAvailable()
+                ? new CookiePersistence(this.cookieDomain, this.idCookieName + "_props")
+                : new NoPersistence();
         }
-        if (this.cookiePolicy === 'strict') {
+        if (this.cookiePolicy === "strict") {
             this.userIdPersistence = new NoPersistence();
         }
         else {
-            this.userIdPersistence = new CookiePersistence(this.cookieDomain, this.idCookieName + '_usr');
+            this.userIdPersistence = isWindowAvailable()
+                ? new CookiePersistence(this.cookieDomain, this.idCookieName + "_usr")
+                : new NoPersistence();
         }
         if (this.propsPersistance) {
             var restored = this.propsPersistance.restore();
@@ -2015,26 +3068,45 @@ var UsermavenClientImpl = /** @class */ (function () {
                 this.permanentProperties.globalProps = (_a = restored.globalProps) !== null && _a !== void 0 ? _a : {};
                 this.permanentProperties.propsPerEvent = (_b = restored.propsPerEvent) !== null && _b !== void 0 ? _b : {};
             }
-            getLogger().debug('Restored persistent properties', this.permanentProperties);
+            getLogger().debug("Restored persistent properties", this.permanentProperties);
         }
-        this.manageSession(options);
+        // Added these configuration for session management + autocapture
+        var defaultConfig = {
+            persistence: 'cookie',
+            persistence_name: 'session',
+            autocapture: false,
+            capture_pageview: true,
+            store_google: true,
+            save_referrer: true,
+            properties_string_max_length: null,
+            property_blacklist: [],
+            sanitize_properties: null
+        };
+        this.config = _.extend({}, defaultConfig, options || {}, this.config || {}, { token: this.apiKey });
+        getLogger().debug('Default Configuration', this.config);
+        this.manageSession(this.config);
+        this.manageAutoCapture(this.config);
         if (options.capture_3rd_party_cookies === false) {
             this._3pCookies = {};
         }
         else {
-            (options.capture_3rd_party_cookies || ['_ga', '_fbp', '_ym_uid', 'ajs_user_id', 'ajs_anonymous_id'])
-                .forEach(function (name) { return _this._3pCookies[name] = true; });
+            (options.capture_3rd_party_cookies || [
+                "_ga",
+                "_fbp",
+                "_ym_uid",
+                "ajs_user_id",
+                "ajs_anonymous_id",
+            ]).forEach(function (name) { return (_this._3pCookies[name] = true); });
         }
         if (options.ga_hook) {
-            getLogger().warn('GA event interceptor isn\'t supported anymore');
+            getLogger().warn("GA event interceptor isn't supported anymore");
         }
         if (options.segment_hook) {
             interceptSegmentCalls(this);
         }
-        if (this.cookiePolicy !== 'strict') {
-            this.anonymousId = this.getAnonymousId();
-        }
         this.initialized = true;
+        // Set up the window close event handler "unload"
+        window.addEventListener && window.addEventListener('unload', this._handle_unload.bind(this));
     };
     UsermavenClientImpl.prototype.interceptAnalytics = function (analytics) {
         var _this = this;
@@ -2042,11 +3114,13 @@ var UsermavenClientImpl = /** @class */ (function () {
             var _a;
             try {
                 var payload = __assign({}, chain.payload);
-                getLogger().debug('Intercepted segment payload', payload.obj);
-                var integration = chain.integrations['Segment.io'];
+                getLogger().debug("Intercepted segment payload", payload.obj);
+                var integration = chain.integrations["Segment.io"];
                 if (integration && integration.analytics) {
                     var analyticsOriginal = integration.analytics;
-                    if (typeof analyticsOriginal.user === 'function' && analyticsOriginal.user() && typeof analyticsOriginal.user().id === 'function') {
+                    if (typeof analyticsOriginal.user === "function" &&
+                        analyticsOriginal.user() &&
+                        typeof analyticsOriginal.user().id === "function") {
                         payload.obj.userId = analyticsOriginal.user().id();
                     }
                 }
@@ -2054,26 +3128,26 @@ var UsermavenClientImpl = /** @class */ (function () {
                     payload.obj.sentAt = payload.obj.timestamp;
                 }
                 var type = chain.payload.type();
-                if (type === 'track') {
+                if (type === "track") {
                     type = chain.payload.event();
                 }
-                _this._send3p('ajs', payload, type);
+                _this._send3p("ajs", payload, type);
             }
             catch (e) {
-                getLogger().warn('Failed to send an event', e);
+                getLogger().warn("Failed to send an event", e);
             }
             chain.next(chain.payload);
         };
-        if (typeof analytics.addSourceMiddleware === 'function') {
+        if (typeof analytics.addSourceMiddleware === "function") {
             //analytics is fully initialized
-            getLogger().debug('Analytics.js is initialized, calling addSourceMiddleware');
+            getLogger().debug("Analytics.js is initialized, calling addSourceMiddleware");
             analytics.addSourceMiddleware(interceptor);
         }
         else {
-            getLogger().debug('Analytics.js is not initialized, pushing addSourceMiddleware to callstack');
-            analytics.push(['addSourceMiddleware', interceptor]);
+            getLogger().debug("Analytics.js is not initialized, pushing addSourceMiddleware to callstack");
+            analytics.push(["addSourceMiddleware", interceptor]);
         }
-        analytics['__en_intercepted'] = true;
+        analytics["__en_intercepted"] = true;
     };
     UsermavenClientImpl.prototype.restoreId = function () {
         if (this.userIdPersistence) {
@@ -2099,6 +3173,7 @@ var UsermavenClientImpl = /** @class */ (function () {
         }
     };
     UsermavenClientImpl.prototype.unset = function (propertyName, opts) {
+        requireWindow();
         var eventType = opts === null || opts === void 0 ? void 0 : opts.eventType;
         var persist = (opts === null || opts === void 0 ? void 0 : opts.persist) === undefined || (opts === null || opts === void 0 ? void 0 : opts.persist);
         if (!eventType) {
@@ -2110,15 +3185,13 @@ 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);
         options = options || {};
         getLogger().debug('Options', options);
         // cross_subdomain_cookie: whether to keep cookie across domains and subdomains
@@ -2137,6 +3210,135 @@ var UsermavenClientImpl = /** @class */ (function () {
         this.sessionManager = new SessionIdManager(this.config, this.persistence);
         getLogger().debug('Session Configuration', this.sessionManager);
     };
+    /**
+     * Manage auto-capturing
+     * @param options
+     */
+    UsermavenClientImpl.prototype.manageAutoCapture = function (options) {
+        getLogger().debug("Auto Capture Status: ", this.config['autocapture']);
+        this.__autocapture_enabled = this.config['autocapture'];
+        if (!this.__autocapture_enabled) {
+            return;
+        }
+        var num_buckets = 100;
+        var num_enabled_buckets = 100;
+        if (!autocapture.enabledForProject(this.apiKey, num_buckets, num_enabled_buckets)) {
+            this.config['autocapture'] = false;
+            console.log('Not in active bucket: disabling Automatic Event Collection.');
+        }
+        else if (!autocapture.isBrowserSupported()) {
+            this.config['autocapture'] = false;
+            console.log('Disabling Automatic Event Collection because this browser is not supported');
+        }
+        else {
+            autocapture.init(this);
+        }
+    };
+    /**
+   * Capture an event. This is the most important and
+   * frequently used usermaven function.
+   *
+   * ### Usage:
+   *
+   *     // capture an event named 'Registered'
+   *     usermaven.capture('Registered', {'Gender': 'Male', 'Age': 21});
+   *
+   *     // capture an event using navigator.sendBeacon
+   *     usermaven.capture('Left page', {'duration_seconds': 35}, {transport: 'sendBeacon'});
+   *
+   * @param {String} event_name The name of the event. This can be anything the user does - 'Button Click', 'Sign Up', 'Item Purchased', etc.
+   * @param {Object} [properties] A set of properties to include with the event you're sending. These describe the user who did the event or details about the event itself.
+   * @param {Object} [options] Optional configuration for this capture request.
+   * @param {String} [options.transport] Transport method for network request ('XHR' or 'sendBeacon').
+   */
+    UsermavenClientImpl.prototype.capture = function (event_name, properties) {
+        if (properties === void 0) { properties = {}; }
+        if (!this.initialized) {
+            console.error('Trying to capture event before initialization');
+            return;
+        }
+        if (_.isUndefined(event_name) || typeof event_name !== 'string') {
+            console.error('No event name provided to posthog.capture');
+            return;
+        }
+        if (_.isBlockedUA(userAgent)) {
+            return;
+        }
+        var start_timestamp = this['persistence'].remove_event_timer(event_name);
+        // update persistence
+        this['persistence'].update_search_keyword(document.referrer);
+        if (this.get_config('store_google')) {
+            this['persistence'].update_campaign_params();
+        }
+        if (this.get_config('save_referrer')) {
+            this['persistence'].update_referrer_info(document.referrer);
+        }
+        var data = {
+            event: event_name + (properties['$event_type'] ? '_' + properties['$event_type'] : ''),
+            properties: this._calculate_event_properties(event_name, properties, start_timestamp),
+        };
+        data = _.copyAndTruncateStrings(data, this.get_config('properties_string_max_length'));
+        // this.track(data.event, data.properties)
+        this.track("$autocapture", data.properties);
+    };
+    UsermavenClientImpl.prototype._calculate_event_properties = function (event_name, event_properties, start_timestamp) {
+        var _a, _b;
+        // set defaults
+        var properties = event_properties || {};
+        if (event_name === '$snapshot') {
+            return properties;
+        }
+        // set $duration if time_event was previously called for this event
+        if (!_.isUndefined(start_timestamp)) {
+            var duration_in_ms = new Date().getTime() - start_timestamp;
+            properties['$duration'] = parseFloat((duration_in_ms / 1000).toFixed(3));
+        }
+        // note: extend writes to the first object, so lets make sure we
+        // don't write to the persistence properties object and info
+        // properties object by passing in a new object
+        // update properties with pageview info and super-properties
+        // exlude , _.info.properties()
+        properties = _.extend({}, this['persistence'].properties(), properties);
+        var property_blacklist = this.get_config('property_blacklist');
+        if (_.isArray(property_blacklist)) {
+            _.each(property_blacklist, function (blacklisted_prop) {
+                delete properties[blacklisted_prop];
+            });
+        }
+        else {
+            console.error('Invalid value for property_blacklist config: ' + property_blacklist);
+        }
+        var sanitize_properties = this.get_config('sanitize_properties');
+        if (sanitize_properties) {
+            properties = sanitize_properties(properties, event_name);
+        }
+        // assign first element from $elements only
+        var attributes = {};
+        var elements = properties['$elements'] || [];
+        if (elements.length) {
+            attributes = elements[0];
+        }
+        properties['autocapture_attributes'] = attributes;
+        properties['autocapture_attributes']["el_text"] = (_a = properties['autocapture_attributes']["$el_text"]) !== null && _a !== void 0 ? _a : "";
+        properties['autocapture_attributes']["event_type"] = (_b = properties["$event_type"]) !== null && _b !== void 0 ? _b : "";
+        delete properties['$ce_version'];
+        delete properties['$event_type'];
+        delete properties['$initial_referrer'];
+        delete properties['$initial_referring_domain'];
+        delete properties['$referrer'];
+        delete properties['$referring_domain'];
+        delete properties['$elements'];
+        // TODO: later remove this from the autotrack code.
+        delete properties['autocapture_attributes']["$el_text"];
+        delete properties['autocapture_attributes']["nth_child"];
+        delete properties['autocapture_attributes']["nth_of_type"];
+        return properties;
+    };
+    UsermavenClientImpl.prototype._handle_unload = function () {
+        if (this.get_config('capture_pageview')) {
+            this.capture('$pageleave');
+        }
+    };
     return UsermavenClientImpl;
 }());
 function interceptSegmentCalls(t) {
@@ -2147,4 +3349,4 @@ function interceptSegmentCalls(t) {
     t.interceptAnalytics(win.analytics);
 }
 
-export { usermavenClient };
+export { envs, fetchApi, httpApi, usermavenClient };