@usermaven/sdk-js 1.4.1-rc.62 → 1.4.2

package/dist/npm/usermaven.cjs.js

@@ -0,0 +1,2682 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+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 " + 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-" + name + "] " + 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) {
+  //here we check not only of window object is globally available, but also if it's not a fake one
+  //react-native do have a window object, but it's not a real one: https://stackoverflow.com/questions/49911424/what-does-the-variable-window-represent-in-react-native
+  const windowAvailable = !!globalThis.window && !!globalThis.window.document && !!globalThis.window.location;
+
+  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;
+}
+
+// Note: updated this method to test on staging (Ref:: https://github.com/PostHog/posthog-js/blob/master/src/storage.ts#L42)
+// Commented out some jitsu cookies setters that are not bring used in posthog-js
+function serializeCookie(name, val, opt) {
+    if (opt === void 0) { opt = {}; }
+    try {
+        var maxAge = opt.maxAge, domain = opt.domain, path = opt.path, expires = opt.expires, httpOnly = opt.httpOnly, secure = opt.secure, sameSite = opt.sameSite;
+        var new_cookie_val = name + "=" + encodeURIComponent(val);
+        if (domain) {
+            new_cookie_val += "; domain=" + domain;
+        }
+        if (path) {
+            new_cookie_val += "; path=" + path;
+        }
+        else {
+            new_cookie_val += "; path=/";
+        }
+        if (expires) {
+            new_cookie_val += "; expires=" + expires.toUTCString();
+        }
+        if (maxAge) {
+            new_cookie_val += "; max-age=" + maxAge;
+        }
+        if (httpOnly) {
+            new_cookie_val += "; httponly";
+        }
+        if (secure) {
+            new_cookie_val += "; secure";
+        }
+        if (sameSite) {
+            var sameSiteAttr = typeof sameSite === "string"
+                ? sameSite.toLowerCase()
+                : sameSite;
+            switch (sameSiteAttr) {
+                case true:
+                    new_cookie_val += "; SameSite=Strict";
+                    break;
+                case "lax":
+                    new_cookie_val += "; SameSite=Lax";
+                    break;
+                case "strict":
+                    new_cookie_val += "; SameSite=Strict";
+                    break;
+                case "none":
+                    new_cookie_val += "; SameSite=None";
+                    break;
+            }
+        }
+        else if (secure) {
+            /**
+             * SameSite=None - means that the browser sends the cookie with both cross-site and same-site requests.
+             * The Secure attribute must also be set when setting this value, like so SameSite=None; Secure.
+             * If Secure is missing an error will be logged.
+             *
+             * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value
+             */
+            new_cookie_val += "; SameSite=None";
+        }
+        return new_cookie_val;
+    }
+    catch (e) {
+        getLogger().error("serializeCookie", e);
+        return '';
+    }
+}
+
+// Courtesy: https://stackoverflow.com/a/23945027
+function extractHostname(url) {
+    var hostname;
+    //find & remove protocol (http, ftp, etc.) and get hostname
+    if (url.indexOf("//") > -1) {
+        hostname = url.split('/')[2];
+    }
+    else {
+        hostname = url.split('/')[0];
+    }
+    //find & remove port number
+    hostname = hostname.split(':')[0];
+    //find & remove "?"
+    hostname = hostname.split('?')[0];
+    return hostname;
+}
+// Warning: you can use this function to extract the "root" domain, but it will not be as accurate as using the psl package. 
+// https://www.npmjs.com/package/psl
+var extractRootDomain = function (url) {
+    var domain = extractHostname(url), splitArr = domain.split('.'), arrLen = splitArr.length;
+    // extracting the root domain here
+    // if there is a subdomain
+    if (arrLen > 2) {
+        if (splitArr[arrLen - 1].length == 2) {
+            // likely a ccTLD
+            domain = splitArr[arrLen - 2] + '.' + splitArr[arrLen - 1];
+            // if the second level domain is also two letters (like co.uk), include the next part up
+            if (splitArr[arrLen - 2].length == 2) {
+                domain = splitArr[arrLen - 3] + '.' + domain;
+            }
+        }
+        else {
+            // likely a gTLD
+            domain = splitArr[arrLen - 2] + '.' + splitArr[arrLen - 1];
+        }
+    }
+    return domain;
+};
+var extractTopLevelDomain = function (url) {
+    var DOMAIN_MATCH_REGEX = /[a-z0-9][a-z0-9-]+\.[a-z.]{2,6}$/i;
+    var matches = url.match(DOMAIN_MATCH_REGEX), domain = matches ? matches[0] : '';
+    return domain;
+};
+var extractRoot = function (url) {
+    var domainParts = url.split(".");
+    var domainLength = domainParts.length;
+    // Check if it's an IP address
+    if (domainLength === 4 && domainParts.every(function (part) { return !isNaN(part); })) {
+        return url;
+    }
+    var rootDomain = extractTopLevelDomain(url);
+    if (!rootDomain) { // If it's not a top level domain, use a fallback method
+        rootDomain = extractRootDomain(url);
+    }
+    return rootDomain;
+};
+var getCookieDomain = function () {
+    if (isWindowAvailable()) {
+        // const domain = window.location.hostname.replace("www.", "")
+        //
+        // // Check if subdomain is set, if yes, we remove the subdomain from the cookie domain and return the root domain with a leading dot
+        // // This is to ensure that cookies are set correctly for cross domain tracking
+        // const subdomain = domain.split('.')[0]
+        // if (subdomain) {
+        //   return '.' + extractRootDomain(domain)
+        // }
+        return extractRoot(window.location.hostname);
+    }
+    return undefined;
+};
+var cookieParsingCache;
+function parseCookieString(cookieStr) {
+    if (!cookieStr) {
+        return {};
+    }
+    var res = {};
+    var cookies = cookieStr.split(";");
+    for (var i = 0; i < cookies.length; i++) {
+        var cookie = cookies[i];
+        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;
+};
+// Methods partially borrowed from quirksmode.org/js/cookies.html
+var getCookie = function (name) {
+    if (!name) {
+        return null;
+    }
+    try {
+        var nameEQ = name + '=';
+        var ca = requireWindow().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) {
+        getLogger().error("getCookies", err);
+    }
+    return null;
+};
+var setCookie = function (name, value, opts) {
+    if (opts === void 0) { opts = {}; }
+    requireWindow().document.cookie = serializeCookie(name, value, opts);
+};
+var deleteCookie = function (name, path) {
+    if (path === void 0) { path = "/"; }
+    document.cookie = name + "= ; SameSite=Strict; expires = Thu, 01 Jan 1970 00:00:00 GMT" + (path ? ("; path = " + path) : "");
+};
+var generateId = function () { return Math.random().toString(36).substring(2, 12); };
+var getUmExclusionState = function () {
+    var state = "false";
+    if (typeof window !== 'undefined' && window.localStorage) {
+        state = localStorage.getItem("um_exclusion");
+    }
+    return state === undefined || state === null || state === "false" ? false : true;
+};
+var generateRandom = function () { return Math.random().toString(36).substring(2, 7); };
+var parseQuery = function (qs) {
+    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("&");
+    for (var i = 0; i < pairs.length; i++) {
+        var pair = pairs[i].split("=");
+        query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || "");
+    }
+    return query;
+};
+var UTM_TYPES = {
+    utm_source: "source",
+    utm_medium: "medium",
+    utm_campaign: "campaign",
+    utm_term: "term",
+    utm_content: "content"
+};
+var CLICK_IDS = {
+    gclid: true,
+    fbclid: true,
+    dclid: true
+};
+var getDataFromParams = function (params) {
+    var result = {
+        utm: {},
+        click_id: {},
+    };
+    for (var name in params) {
+        if (!params.hasOwnProperty(name)) {
+            continue;
+        }
+        var val = params[name];
+        var utm = UTM_TYPES[name];
+        if (utm) {
+            result.utm[utm] = val;
+        }
+        else if (CLICK_IDS[name]) {
+            result.click_id[name] = val;
+        }
+    }
+    return result;
+};
+//2020-08-24T13:42:16.439Z -> 2020-08-24T13:42:16.439123Z
+var reformatDate = function (strDate) {
+    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";
+};
+function endsWith(str, suffix) {
+    return str.indexOf(suffix, str.length - suffix.length) !== -1;
+}
+var getHostWithProtocol = function (host) {
+    while (endsWith(host, "/")) {
+        host = host.substr(0, host.length - 1);
+    }
+    if (host.indexOf("https://") === 0 || host.indexOf("http://") === 0) {
+        return host;
+    }
+    else {
+        return "https://" + host;
+    }
+};
+
+var MemoryQueue = /** @class */ (function () {
+    function MemoryQueue() {
+        this.queue = [];
+    }
+    MemoryQueue.prototype.flush = function () {
+        var queue = this.queue;
+        this.queue = [];
+        return queue;
+    };
+    MemoryQueue.prototype.push = function () {
+        var _a;
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            values[_i] = arguments[_i];
+        }
+        (_a = this.queue).push.apply(_a, values);
+    };
+    return MemoryQueue;
+}());
+var LocalStorageQueue = /** @class */ (function () {
+    function LocalStorageQueue(key) {
+        this.key = key;
+    }
+    LocalStorageQueue.prototype.flush = function () {
+        var queue = this.get();
+        if (queue.length) {
+            this.set([]);
+        }
+        return queue;
+    };
+    LocalStorageQueue.prototype.push = function () {
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            values[_i] = arguments[_i];
+        }
+        var queue = this.get();
+        queue.push.apply(queue, values);
+        this.set(queue);
+    };
+    LocalStorageQueue.prototype.set = function (queue) {
+        localStorage.setItem(this.key, JSON.stringify(queue));
+    };
+    LocalStorageQueue.prototype.get = function () {
+        var data = localStorage.getItem(this.key);
+        if (data !== null && data !== "") {
+            return JSON.parse(data);
+        }
+        return [];
+    };
+    return LocalStorageQueue;
+}());
+
+var ObjProto = Object.prototype;
+var toString = ObjProto.toString;
+var hasOwnProperty = ObjProto.hasOwnProperty;
+var ArrayProto = Array.prototype;
+var nativeForEach = ArrayProto.forEach, nativeIsArray = Array.isArray, breaker = {};
+var _isArray = nativeIsArray ||
+    function (obj) {
+        return toString.call(obj) === '[object Array]';
+    };
+function _eachArray(obj, iterator, thisArg) {
+    if (Array.isArray(obj)) {
+        if (nativeForEach && obj.forEach === nativeForEach) {
+            obj.forEach(iterator, thisArg);
+        }
+        else if ('length' in obj && obj.length === +obj.length) {
+            for (var i = 0, l = obj.length; i < l; i++) {
+                if (i in obj && iterator.call(thisArg, obj[i], i) === breaker) {
+                    return;
+                }
+            }
+        }
+    }
+}
+// Embed part of the Underscore Library
+var _trim = function (str) {
+    return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+};
+var _bind_instance_methods = function (obj) {
+    for (var func in obj) {
+        if (typeof obj[func] === 'function') {
+            obj[func] = obj[func].bind(obj);
+        }
+    }
+};
+/**
+ * @param {*=} obj
+ * @param {function(...*)=} iterator
+ * @param {Object=} thisArg
+ */
+function _each(obj, iterator, thisArg) {
+    if (obj === null || obj === undefined) {
+        return;
+    }
+    if (nativeForEach && Array.isArray(obj) && obj.forEach === nativeForEach) {
+        obj.forEach(iterator, thisArg);
+    }
+    else if ('length' in obj && obj.length === +obj.length) {
+        for (var i = 0, l = obj.length; i < l; i++) {
+            if (i in obj && iterator.call(thisArg, obj[i], i) === breaker) {
+                return;
+            }
+        }
+    }
+    else {
+        for (var key in obj) {
+            if (hasOwnProperty.call(obj, key)) {
+                if (iterator.call(thisArg, obj[key], key) === breaker) {
+                    return;
+                }
+            }
+        }
+    }
+}
+var _extend = function (obj) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    _eachArray(args, function (source) {
+        for (var prop in source) {
+            if (source[prop] !== void 0) {
+                obj[prop] = source[prop];
+            }
+        }
+    });
+    return obj;
+};
+function _includes(str, needle) {
+    return str.indexOf(needle) !== -1;
+}
+// from a comment on http://dbj.org/dbj/?p=286
+// fails on only one very rare and deliberate custom object:
+// let bomb = { toString : undefined, valueOf: function(o) { return "function BOMBA!"; }};
+var _isFunction = function (f) {
+    try {
+        return /^\s*\bfunction\b/.test(f);
+    }
+    catch (x) {
+        return false;
+    }
+};
+var _isUndefined = function (obj) {
+    return obj === void 0;
+};
+var _register_event = (function () {
+    // written by Dean Edwards, 2005
+    // with input from Tino Zijdel - crisp@xs4all.nl
+    // with input from Carl Sverre - mail@carlsverre.com
+    // with input from PostHog
+    // 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) {
+            getLogger().error('No valid element provided to register_event');
+            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) {
+        return 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;
+            if (_isFunction(old_handlers)) {
+                old_result = old_handlers(event);
+            }
+            var new_result = new_handler.call(element, event);
+            if (false === old_result || false === new_result) {
+                ret = false;
+            }
+            return ret;
+        };
+    }
+    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;
+})();
+var _safewrap = function (f) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            return f.apply(this, args);
+        }
+        catch (e) {
+            getLogger().error('Implementation error. Please turn on debug and contact support@usermaven.com.', e);
+            // if (Config.DEBUG) {
+            //     getLogger.critical(e)
+            // }
+        }
+    };
+};
+var _safewrap_instance_methods = function (obj) {
+    for (var func in obj) {
+        if (typeof obj[func] === 'function') {
+            obj[func] = _safewrap(obj[func]);
+        }
+    }
+};
+var COPY_IN_PROGRESS_ATTRIBUTE = typeof Symbol !== 'undefined' ? Symbol('__deepCircularCopyInProgress__') : '__deepCircularCopyInProgress__';
+/**
+ * Deep copies an object.
+ * It handles cycles by replacing all references to them with `undefined`
+ * Also supports customizing native values
+ *
+ * @param value
+ * @param customizer
+ * @param [key] if provided this is the object key associated with the value to be copied. It allows the customizer function to have context when it runs
+ * @returns {{}|undefined|*}
+ */
+function deepCircularCopy(value, customizer, key) {
+    if (value !== Object(value))
+        return customizer ? customizer(value, key) : value; // primitive value
+    if (value[COPY_IN_PROGRESS_ATTRIBUTE])
+        return undefined;
+    value[COPY_IN_PROGRESS_ATTRIBUTE] = true;
+    var result;
+    if (_isArray(value)) {
+        result = [];
+        _eachArray(value, function (it) {
+            result.push(deepCircularCopy(it, customizer));
+        });
+    }
+    else {
+        result = {};
+        _each(value, function (val, key) {
+            if (key !== COPY_IN_PROGRESS_ATTRIBUTE) {
+                result[key] = deepCircularCopy(val, customizer, key);
+            }
+        });
+    }
+    delete value[COPY_IN_PROGRESS_ATTRIBUTE];
+    return result;
+}
+var LONG_STRINGS_ALLOW_LIST = ['$performance_raw'];
+function _copyAndTruncateStrings(object, maxStringLength) {
+    return deepCircularCopy(object, function (value, key) {
+        if (key && LONG_STRINGS_ALLOW_LIST.indexOf(key) > -1) {
+            return value;
+        }
+        if (typeof value === 'string' && maxStringLength !== null) {
+            return value.slice(0, maxStringLength);
+        }
+        return value;
+    });
+}
+// Function to find the closest link element
+function _findClosestLink(element) {
+    while (element && element.tagName) {
+        if (element.tagName.toLowerCase() == 'a') {
+            return element;
+        }
+        element = element.parentNode;
+    }
+    return null;
+}
+function _cleanObject(obj) {
+    for (var propName in obj) {
+        if (obj[propName] === '' || obj[propName] === null || obj[propName] === undefined || (typeof obj[propName] === 'object' && Object.keys(obj[propName]).length === 0)) {
+            delete obj[propName];
+        }
+    }
+    return obj;
+}
+
+/*
+ * 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;
+        // TODO: when is this ever used?
+        case 'object': // handle cases where className might be SVGAnimatedString or some other type
+            return ('baseVal' in el.className ? el.className.baseVal : null) || 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
+}
+/*
+ * Check whether an element has nodeType Node.DOCUMENT_FRAGMENT_NODE
+ * @param {Element} el - element to check
+ * @returns {boolean} whether el is of the correct nodeType
+ */
+function isDocumentFragment(el) {
+    return !!el && el.nodeType === 11; // Node.DOCUMENT_FRAGMENT_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;
+    }
+    // Check if current element or any parent has um-no-capture class
+    var curEl = el;
+    while (curEl && !isTag(curEl, 'body')) {
+        if (curEl.classList && curEl.classList.contains('um-no-capture')) {
+            return false;
+        }
+        // Handle shadow DOM
+        if (curEl.parentNode && isDocumentFragment(curEl.parentNode)) {
+            curEl = curEl.parentNode.host;
+        }
+        else {
+            curEl = curEl.parentNode;
+        }
+    }
+    var parentIsUsefulElement = false;
+    curEl = el;
+    while (curEl && !isTag(curEl, 'body')) {
+        // Handle shadow DOM
+        if (curEl.parentNode && isDocumentFragment(curEl.parentNode)) {
+            curEl = curEl.parentNode.host;
+            if (curEl && usefulElements.indexOf(curEl.tagName.toLowerCase()) > -1) {
+                parentIsUsefulElement = true;
+            }
+            continue;
+        }
+        var parentNode = curEl.parentNode;
+        if (!parentNode)
+            break;
+        if (usefulElements.indexOf(parentNode.tagName.toLowerCase()) > -1) {
+            parentIsUsefulElement = true;
+        }
+        else {
+            var compStyles_1 = window.getComputedStyle(parentNode);
+            if (compStyles_1 && compStyles_1.getPropertyValue('cursor') === 'pointer') {
+                parentIsUsefulElement = true;
+            }
+        }
+        curEl = parentNode;
+    }
+    var 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, 'ph-sensitive') || _includes(classes, 'ph-no-capture')) {
+            return false;
+        }
+    }
+    if (_includes(getClassName(el).split(' '), 'ph-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 || '';
+    // See https://github.com/posthog/posthog-js/issues/165
+    // Under specific circumstances a bug caused .replace to be called on a DOM element
+    // instead of a string, removing the element from the page. Ensure this issue is mitigated.
+    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
+    var 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
+var RAGE_CLICK_THRESHOLD_PX = 30;
+var RAGE_CLICK_TIMEOUT_MS = 1000;
+var RAGE_CLICK_CLICK_COUNT = 3;
+var RageClick = /** @class */ (function () {
+    function RageClick(instance, enabled) {
+        if (enabled === void 0) { enabled = false; }
+        this.clicks = [];
+        this.instance = instance;
+        this.enabled = enabled;
+    }
+    RageClick.prototype.click = function (x, y, timestamp) {
+        if (!this.enabled) {
+            return;
+        }
+        var 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: x, y: y, timestamp: timestamp });
+            if (this.clicks.length === RAGE_CLICK_CLICK_COUNT) {
+                this.instance.capture('$rageclick');
+            }
+        }
+        else {
+            this.clicks = [{ x: x, y: y, timestamp: timestamp }];
+        }
+    };
+    return RageClick;
+}());
+
+/**
+ * Scroll extension to add scroll get scroll depth in percentage
+ */
+var ScrollDepth = /** @class */ (function () {
+    function ScrollDepth(instance) {
+        this.instance = instance;
+        this.lastScrollDepth = 0;
+        this.canSend = true;
+        this.documentElement = document.documentElement;
+    }
+    /**
+     * Track scroll depth
+     * @description this function will be called on every scroll event to track scroll depth
+     */
+    ScrollDepth.prototype.track = function () {
+        var scrollDepth = this.getScrollDepth();
+        // If scroll depth is greater than last scroll depth, then update last scroll depth
+        // We are doing this to only get the maximum scroll depth
+        if (scrollDepth > this.lastScrollDepth) {
+            this.lastScrollDepth = scrollDepth;
+            this.canSend = true;
+        }
+    };
+    /**
+     * Send scroll depth event
+     * @description this function will be when we want to send scroll depth event e.g. on page visibility change
+     */
+    ScrollDepth.prototype.send = function (eventType) {
+        if (eventType === void 0) { eventType = "$scroll"; }
+        if (!this.canSend) {
+            return;
+        }
+        // Creating payload
+        var props = {
+            percent: this.lastScrollDepth,
+            window_height: this.getWindowHeight(),
+            document_height: this.getDocumentHeight(),
+            scroll_distance: this.getScrollDistance()
+        };
+        // Sending event
+        this.instance.capture(eventType, props);
+        // Setting canSend to false, for avoiding sending multiple events
+        this.canSend = false;
+    };
+    /**
+     * Core method to get scroll depth
+     */
+    ScrollDepth.prototype.getScrollDepth = function () {
+        try {
+            // Get the height of the window and the document body
+            var winHeight = this.getWindowHeight();
+            var docHeight = this.getDocumentHeight();
+            // Get the current scroll position and the length of the track
+            var scrollTop = this.getScrollDistance();
+            var trackLength = docHeight - winHeight;
+            // Calculate the scroll depth as a percentage
+            return Math.min(100, Math.floor(scrollTop / trackLength * 100));
+        }
+        catch (e) {
+            return 0;
+        }
+    };
+    /**
+     * Core method to get window height
+     */
+    ScrollDepth.prototype.getWindowHeight = function () {
+        try {
+            return window.innerHeight || this.documentElement.clientHeight ||
+                document.body.clientHeight || 0;
+        }
+        catch (e) {
+            return 0;
+        }
+    };
+    /**
+     * Core method to get document height
+     */
+    ScrollDepth.prototype.getDocumentHeight = function () {
+        try {
+            return Math.max(document.body.scrollHeight || 0, this.documentElement.scrollHeight || 0, document.body.offsetHeight || 0, this.documentElement.offsetHeight || 0, document.body.clientHeight || 0, this.documentElement.clientHeight || 0);
+        }
+        catch (e) {
+            return 0;
+        }
+    };
+    /**
+     * Core method to get scroll distance
+     */
+    ScrollDepth.prototype.getScrollDistance = function () {
+        try {
+            return window.scrollY || window.pageYOffset || document.body.scrollTop ||
+                this.documentElement.scrollTop || 0;
+        }
+        catch (e) {
+            return 0;
+        }
+    };
+    return ScrollDepth;
+}());
+
+var autocapture = {
+    _initializedTokens: [],
+    _previousElementSibling: function (el) {
+        if (el.previousElementSibling) {
+            return el.previousElementSibling;
+        }
+        else {
+            var _el = el;
+            do {
+                _el = _el.previousSibling; // resolves to ChildNode->Node, which is Element's parent class
+            } 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(', ');
+    },
+    // TODO: delete custom_properties after changeless typescript refactor
+    _getCustomProperties: function (targetElementList) {
+        var _this = this;
+        var props = {}; // will be deleted
+        _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);
+                    }
+                });
+            });
+        });
+        return props;
+    },
+    _getEventTarget: function (e) {
+        var _a;
+        // https://developer.mozilla.org/en-US/docs/Web/API/Event/target#Compatibility_notes
+        if (typeof e.target === 'undefined') {
+            return e.srcElement || null;
+        }
+        else {
+            if ((_a = e.target) === null || _a === void 0 ? void 0 : _a.shadowRoot) {
+                return e.composedPath()[0] || null;
+            }
+            return e.target || null;
+        }
+    },
+    _captureEvent: function (e, instance, opts) {
+        var _this = this;
+        var _a;
+        /*** 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 || null);
+        }
+        // If type is 'scroll', track the scroll depth
+        if (e.type === 'scroll') {
+            this.scrollDepth.track();
+            return true;
+        }
+        // If type is visibilitychange and the page is about to be hidden, send a scroll depth event
+        if ((e.type === 'visibilitychange' && document.visibilityState === 'hidden') || e.type === 'popstate') {
+            this.scrollDepth.send();
+            return true;
+        }
+        if (e.type === 'click' && e instanceof MouseEvent) {
+            (_a = this.rageclicks) === null || _a === void 0 ? void 0 : _a.click(e.clientX, e.clientY, new Date().getTime());
+        }
+        if (target && shouldCaptureDomEvent(target, e)) {
+            var targetElementList = [target];
+            var curEl = target;
+            while (curEl.parentNode && !isTag(curEl, 'body')) {
+                if (isDocumentFragment(curEl.parentNode)) {
+                    targetElementList.push(curEl.parentNode.host);
+                    curEl = curEl.parentNode.host;
+                    continue;
+                }
+                targetElementList.push(curEl.parentNode);
+                curEl = curEl.parentNode;
+            }
+            var elementsJson_1 = [];
+            var href_1, explicitNoCapture_1 = 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_1 = el.getAttribute('href');
+                    href_1 = shouldCaptureEl && shouldCaptureValue(href_1) && href_1;
+                }
+                // allow users to programmatically prevent capturing of elements by adding class 'ph-no-capture'
+                var classes = getClassName(el).split(' ');
+                if (_includes(classes, 'ph-no-capture')) {
+                    explicitNoCapture_1 = true;
+                }
+                elementsJson_1.push(_this._getPropertiesFromElement(el, opts === null || opts === void 0 ? void 0 : opts.mask_all_element_attributes, opts === null || opts === void 0 ? void 0 : opts.mask_all_text));
+            });
+            if (!(opts === null || opts === void 0 ? void 0 : opts.mask_all_text)) {
+                elementsJson_1[0]['$el_text'] = getSafeText(target);
+            }
+            if (href_1) {
+                elementsJson_1[0]['attr__href'] = href_1;
+            }
+            if (explicitNoCapture_1) {
+                return false;
+            }
+            var props = _extend(this._getDefaultProperties(e.type), {
+                $elements: elementsJson_1,
+            }, 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, opts) {
+        var _this = this;
+        var handler = function (e) {
+            e = e || window.event;
+            _this._captureEvent(e, instance, opts);
+        };
+        _register_event(document, 'submit', handler, false, true);
+        _register_event(document, 'change', handler, false, true);
+        _register_event(document, 'click', handler, false, true);
+        _register_event(document, 'visibilitychange', handler, false, true);
+        _register_event(document, 'scroll', handler, false, true);
+        _register_event(window, 'popstate', handler, false, true);
+    },
+    _customProperties: [],
+    rageclicks: null,
+    scrollDepth: null,
+    opts: {},
+    init: function (instance, opts) {
+        var _this = this;
+        this.rageclicks = new RageClick(instance);
+        this.scrollDepth = new ScrollDepth(instance);
+        this.opts = opts;
+        if (!(document && document.body)) {
+            console.debug('document not ready yet, trying again in 500 milliseconds...');
+            setTimeout(function () {
+                _this.readyAutocapture(instance, opts);
+            }, 500);
+            return;
+        }
+        this.readyAutocapture(instance, opts);
+    },
+    readyAutocapture: function (instance, opts) {
+        this._addDomEventHandlers(instance, opts);
+    },
+    // 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) {
+        if (!token) {
+            return true;
+        }
+        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 FormTracking = /** @class */ (function () {
+    function FormTracking(instance, trackingType) {
+        if (trackingType === void 0) { trackingType = 'all'; }
+        this.instance = instance;
+        this.trackingType = trackingType;
+        // Wait for the DOM to be ready
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', this.track.bind(this));
+        }
+        else {
+            this.track();
+        }
+    }
+    /**
+     * Track form submit
+     * @description this function will be called on every form submit event to track form submit
+     */
+    FormTracking.prototype.track = function () {
+        var _this = this;
+        this.formElements = document.querySelectorAll('form');
+        if (this.trackingType === 'tagged') {
+            this.formElements = document.querySelectorAll('form[data-um-form]');
+        }
+        this.formElements.forEach(function (form) {
+            form.addEventListener('submit', function (event) {
+                var form = event.target;
+                var props = _this._getFormDetails(form);
+                _this.instance.capture('$form', _cleanObject(props));
+            });
+        });
+    };
+    FormTracking.getInstance = function (instance, trackingType) {
+        if (trackingType === void 0) { trackingType = 'all'; }
+        if (!FormTracking.instance) {
+            FormTracking.instance = new FormTracking(instance, trackingType);
+        }
+        return FormTracking.instance;
+    };
+    FormTracking.prototype._getFormDetails = function (form) {
+        var _this = this;
+        var formDetails = {
+            form_id: form.id,
+            form_name: form.name || '',
+            form_action: form.action,
+            form_method: form.method,
+        };
+        var formFields = form.querySelectorAll('input, select, textarea');
+        // ignore form fields with class um-no-capture
+        var filteredFormFields = Array.from(formFields).filter(function (field) { return !field.classList.contains('um-no-capture'); });
+        filteredFormFields.forEach(function (field, index) {
+            var fieldProps = _this._getFieldProps(field, index);
+            Object.assign(formDetails, fieldProps);
+        });
+        return formDetails;
+    };
+    FormTracking.prototype._getFieldProps = function (field, index) {
+        var _a;
+        var fieldDataAttributes = Object.keys(field.dataset).length ? JSON.stringify(field.dataset) : undefined;
+        var safeValue = this.getSafeText(field);
+        return _a = {},
+            _a["field_" + (index + 1) + "_tag"] = field.tagName.toLowerCase(),
+            _a["field_" + (index + 1) + "_type"] = field instanceof HTMLInputElement ? field.type : undefined,
+            _a["field_" + (index + 1) + "_data_attributes"] = fieldDataAttributes,
+            _a["field_" + (index + 1) + "_id"] = field.id,
+            _a["field_" + (index + 1) + "_value"] = safeValue,
+            _a["field_" + (index + 1) + "_class"] = field.className,
+            _a["field_" + (index + 1) + "_name"] = field.name,
+            _a;
+    };
+    FormTracking.prototype.getSafeText = function (element) {
+        var safeText = '';
+        if ('value' in element && element.type !== "password") {
+            safeText = element.value;
+        }
+        else if (element.hasChildNodes()) {
+            var textNodes = Array.from(element.childNodes).filter(function (node) { return node.nodeType === Node.TEXT_NODE; });
+            safeText = textNodes.map(function (node) { return node.textContent; }).join('');
+        }
+        else {
+            safeText = element.textContent || '';
+        }
+        return this._scrubPotentiallySensitiveValues(safeText);
+    };
+    FormTracking.prototype._scrubPotentiallySensitiveValues = function (text) {
+        if (!this._shouldCaptureValue(text)) {
+            return '<redacted>';
+        }
+        return text;
+    };
+    FormTracking.prototype._shouldCaptureValue = function (value) {
+        if (this._isNullish(value)) {
+            return false;
+        }
+        if (this._isString(value)) {
+            value = this._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;
+    };
+    FormTracking.prototype._isNullish = function (value) {
+        return value === null || value === undefined;
+    };
+    FormTracking.prototype._isString = function (value) {
+        return typeof value === 'string' || value instanceof String;
+    };
+    FormTracking.prototype._trim = function (value) {
+        return value.trim().replace(/^\s+|\s+$/g, '');
+    };
+    return FormTracking;
+}());
+
+var VERSION_INFO = {
+    env: 'production',
+    date: '2024-11-15T06:39:44.205Z',
+    version: '1.4.2'
+};
+var USERMAVEN_VERSION = VERSION_INFO.version + "/" + VERSION_INFO.env + "@" + 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" });
+    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.debug("Jitsu client tried to send payload to " + 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, 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 " + this.cookieName + "@" + this.cookieDomain + ", expected to be object, but found " + (typeof parsed !== "object") + ": " + parsed + ". Ignoring");
+                    return undefined;
+                }
+                return parsed;
+            }
+            catch (e) {
+                getLogger().error("Failed to decode JSON from " + str, e);
+                return undefined;
+            }
+        }
+        return undefined;
+    };
+    CookiePersistence.prototype.delete = function () {
+        deleteCookie(this.cookieName);
+    };
+    return CookiePersistence;
+}());
+var NoPersistence = /** @class */ (function () {
+    function NoPersistence() {
+    }
+    NoPersistence.prototype.save = function (props) {
+    };
+    NoPersistence.prototype.restore = function () {
+        return undefined;
+    };
+    NoPersistence.prototype.delete = function () {
+    };
+    return NoPersistence;
+}());
+var defaultCompatMode = false;
+function usermavenClient(opts) {
+    var client = new UsermavenClientImpl();
+    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, _b = _a.crossDomainLinking, crossDomainLinking = _b === void 0 ? true : _b;
+        expireNonRootCookies(name);
+        // Check if cross domain linking is enabled
+        if (crossDomainLinking) {
+            // Try to extract the '_um' parameter from query string and hash fragment (https://example.com#_um=1~abcde5~)
+            var urlParams = new URLSearchParams(window.location.search);
+            var queryId = urlParams.get('_um');
+            var urlHash = window.location.hash.substring(1);
+            var hashedValues = urlHash.split("~");
+            var fragmentId = hashedValues.length > 1 ? hashedValues[1] : undefined;
+            // If the '_um' parameter is set in both the query string and hash fragment,
+            // prioritize the one in query string
+            var crossDomainAnonymousId = queryId || fragmentId;
+            // If coming from another domain, use the ID from URL parameter
+            if (crossDomainAnonymousId) {
+                getLogger().debug("Existing user id from other domain", crossDomainAnonymousId);
+                // Check if the ID needs to be set as cookie
+                var currentCookie = getCookie(name);
+                if (!currentCookie || currentCookie !== crossDomainAnonymousId) {
+                    setCookie(name, crossDomainAnonymousId, {
+                        domain: domain,
+                        secure: document.location.protocol !== "http:",
+                        maxAge: MAX_AGE_TEN_YEARS,
+                    });
+                }
+                return crossDomainAnonymousId;
+            }
+        }
+        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: proto + "://" + requestHost + (path || "") + (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: proto + "://" + requestHost + (path || "") + (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 payload to " + url + ": " + ((e === null || e === void 0 ? void 0 : e.message) || "unknown error"), 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 " + url + " (#" + req.status + " - " + req.statusText + ")", jsonPayload);
+                reject(new Error("Failed to send JSON. Error code: " + 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, text, contentType, e_2;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.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 = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_1 = _c.sent();
+                        getLogger().error("Failed to send data to " + url + ": " + ((e_1 === null || e_1 === void 0 ? void 0 : e_1.message) || "unknown error"), jsonPayload, e_1);
+                        handler(-1, {});
+                        return [2 /*return*/];
+                    case 3:
+                        if (res.status !== 200) {
+                            getLogger().warn("Failed to send data to " + url + " (#" + res.status + " - " + res.statusText + ")", jsonPayload);
+                            handler(res.status, {});
+                            return [2 /*return*/];
+                        }
+                        resJson = {};
+                        text = "";
+                        contentType = (_b = (_a = res.headers) === null || _a === void 0 ? void 0 : _a.get('Content-Type')) !== null && _b !== void 0 ? _b : "";
+                        _c.label = 4;
+                    case 4:
+                        _c.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, res.text()];
+                    case 5:
+                        text = _c.sent();
+                        resJson = JSON.parse(text);
+                        return [3 /*break*/, 7];
+                    case 6:
+                        e_2 = _c.sent();
+                        getLogger().error("Failed to parse " + url + " response. Content-type: " + contentType + " text: " + text, e_2);
+                        return [3 /*break*/, 7];
+                    case 7:
+                        try {
+                            handler(res.status, resJson);
+                        }
+                        catch (e) {
+                            getLogger().error("Failed to handle " + url + " response. Content-type: " + contentType + " text: " + text, e);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+};
+var UsermavenClientImpl = /** @class */ (function () {
+    function UsermavenClientImpl() {
+        this.userProperties = {};
+        this.groupProperties = {};
+        this.permanentProperties = {
+            globalProps: {},
+            propsPerEvent: {},
+        };
+        this.cookieDomain = "";
+        this.trackingHost = "";
+        this.idCookieName = "";
+        this.randomizeUrl = false;
+        this.namespace = "usermaven";
+        this.crossDomainLinking = true;
+        this.formTracking = false;
+        this.domains = [];
+        this.apiKey = "";
+        this.initialized = false;
+        this._3pCookies = {};
+        this.cookiePolicy = "keep";
+        this.ipPolicy = "keep";
+        this.beaconApi = false;
+        this.transport = xmlHttpTransport;
+        this.customHeaders = function () { return ({}); };
+        this.queue = new MemoryQueue();
+        this.maxSendAttempts = 4;
+        this.retryTimeout = [500, 1e12];
+        this.flushing = false;
+        this.attempt = 1;
+        this.propertyBlacklist = [];
+        // public persistence?: UserMavenPersistence;
+        // public sessionManager?: SessionIdManager;
+        this.__autocapture_enabled = false;
+        this.__auto_pageview_enabled = false;
+        // private anonymousId: string = '';
+        // Fallback tracking host
+        this.trackingHostFallback = "https://events.usermaven.com" ;
+    }
+    // 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);
+        if (this.userIdPersistence) {
+            this.userIdPersistence.save(props);
+        }
+        else {
+            getLogger().warn("Id() is called before initialization");
+        }
+        if (!doNotSendEvent) {
+            return this.track("user_identify", {});
+        }
+        else {
+            return Promise.resolve();
+        }
+    };
+    UsermavenClientImpl.prototype.group = function (props, doNotSendEvent) {
+        this.groupProperties = __assign(__assign({}, this.groupProperties), props);
+        getLogger().debug("Usermaven group identified", props);
+        if (this.userIdPersistence) {
+            // Update the 'company' property in the user persistence
+            this.userIdPersistence.save({ company: props });
+        }
+        else {
+            getLogger().warn("Group() is called before initialization");
+        }
+        if (!doNotSendEvent) {
+            return this.track("group", {});
+        }
+        else {
+            return Promise.resolve();
+        }
+    };
+    UsermavenClientImpl.prototype.reset = function (resetAnonId) {
+        if (this.userIdPersistence) {
+            this.userIdPersistence.delete();
+        }
+        if (this.propsPersistance) {
+            this.propsPersistance.delete();
+        }
+        if (resetAnonId) {
+            var idCookie = getCookie(this.idCookieName);
+            if (idCookie) {
+                getLogger().debug("Removing id cookie", idCookie);
+                setCookie(this.idCookieName, "", {
+                    domain: this.cookieDomain,
+                    expires: new Date(0),
+                });
+            }
+        }
+        return Promise.resolve();
+    };
+    UsermavenClientImpl.prototype.rawTrack = function (payload) {
+        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(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 }, 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 !== "") {
+            eventType = type;
+        }
+        var e = this.makeEvent(eventType, sourceType, {
+            src_payload: object,
+        });
+        return this.sendJson(e);
+    };
+    UsermavenClientImpl.prototype.sendJson = function (json) {
+        return __awaiter(this, void 0, Promise, function () {
+            var umExclusionState;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        umExclusionState = getUmExclusionState();
+                        if (!!umExclusionState) return [3 /*break*/, 3];
+                        if (!(this.maxSendAttempts > 1)) return [3 /*break*/, 1];
+                        this.queue.push([json, 0]);
+                        this.scheduleFlush(0);
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.doSendJson(json)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UsermavenClientImpl.prototype.doSendJson = function (json) {
+        var _this = this;
+        var cookiePolicy = this.cookiePolicy !== "keep" ? "&cookie_policy=" + this.cookiePolicy : "";
+        var ipPolicy = this.ipPolicy !== "keep" ? "&ip_policy=" + this.ipPolicy : "";
+        var urlPrefix = isWindowAvailable() ? "/api/v1/event" : "/api/v1/s2s/event";
+        var url = "" + this.trackingHost + urlPrefix + "?token=" + this.apiKey + cookiePolicy + ipPolicy;
+        if (this.randomizeUrl) {
+            url = this.trackingHost + "/api." + generateRandom() + "?p_" + generateRandom() + "=" + this.apiKey + cookiePolicy + ipPolicy;
+        }
+        var jsonString = JSON.stringify(json);
+        getLogger().debug("Sending payload to " + url, json.length);
+        return this.transport(url, jsonString, this.customHeaders(), function (code, body) {
+            return _this.postHandle(code, body);
+        });
+    };
+    UsermavenClientImpl.prototype.scheduleFlush = function (timeout) {
+        var _this = this;
+        if (this.flushing) {
+            return;
+        }
+        this.flushing = true;
+        if (typeof timeout === "undefined") {
+            var random = Math.random() + 1;
+            var factor = Math.pow(2, this.attempt++);
+            timeout = Math.min(this.retryTimeout[0] * random * factor, this.retryTimeout[1]);
+        }
+        getLogger().debug("Scheduling event queue flush in " + timeout + " ms.");
+        setTimeout(function () { return _this.flush(); }, timeout);
+    };
+    UsermavenClientImpl.prototype.flush = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var queue;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (isWindowAvailable() && !window.navigator.onLine) {
+                            this.flushing = false;
+                            this.scheduleFlush();
+                        }
+                        queue = this.queue.flush();
+                        this.flushing = false;
+                        if (queue.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.doSendJson(queue.map(function (el) { return el[0]; }))];
+                    case 2:
+                        _b.sent();
+                        this.attempt = 1;
+                        getLogger().debug("Successfully flushed " + queue.length + " events from queue");
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _b.sent();
+                        // In case of failing custom domain (trackingHost), we will replace it with default domain (trackingHostFallback)
+                        if (this.trackingHost !== this.trackingHostFallback) {
+                            getLogger().debug("Using fallback tracking host " + this.trackingHostFallback + " instead of " + this.trackingHost + " on " + VERSION_INFO.env);
+                            this.trackingHost = this.trackingHostFallback;
+                        }
+                        queue = queue.map(function (el) { return [el[0], el[1] + 1]; }).filter(function (el) {
+                            if (el[1] >= _this.maxSendAttempts) {
+                                getLogger().error("Dropping queued event after " + el[1] + " attempts since max send attempts " + _this.maxSendAttempts + " reached. See logs for details");
+                                return false;
+                            }
+                            return true;
+                        });
+                        if (queue.length > 0) {
+                            (_a = this.queue).push.apply(_a, queue);
+                            this.scheduleFlush();
+                        }
+                        else {
+                            this.attempt = 1;
+                        }
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UsermavenClientImpl.prototype.postHandle = function (status, response) {
+        if (this.cookiePolicy === "strict" || this.cookiePolicy === "comply") {
+            if (status === 200) {
+                var data = response;
+                if (typeof response === "string") {
+                    data = JSON.parse(response);
+                }
+                if (!data["delete_cookie"]) {
+                    return;
+                }
+            }
+            this.userIdPersistence.delete();
+            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 (env) {
+        var now = new Date();
+        var props = env.describeClient() || {};
+        var user = __assign({}, this.userProperties);
+        var company = user['company'] || {};
+        delete user['company'];
+        var payload = __assign(__assign({ event_id: "", user: __assign(__assign({}, user), { anonymous_id: this.cookiePolicy !== "strict"
+                    ? env.getAnonymousId({
+                        name: this.idCookieName,
+                        domain: this.cookieDomain,
+                        crossDomainLinking: this.crossDomainLinking,
+                    })
+                    : "" }), 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;
+        }
+        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;
+            }
+        }
+        return res;
+    };
+    UsermavenClientImpl.prototype.pathMatches = function (wildcardPath, docUrl) {
+        var actualPath = new URL(docUrl).pathname;
+        return actualPath.match(new RegExp('^' + wildcardPath.trim().replace(/\*\*/g, '.*').replace(/([^\.])\*/g, '$1[^\\s\/]*') + '\/?$'));
+    };
+    UsermavenClientImpl.prototype.track = function (type, payload) {
+        var _this = this;
+        var data = payload || {};
+        getLogger().debug("track event of type", type, data);
+        var env = isWindowAvailable() ? envs.browser() : envs.empty();
+        var context = this.getCtx(env);
+        // Check if the page is not excluded.
+        if (this.config && this.config.exclude && this.config.exclude.length > 1 && (context === null || context === void 0 ? void 0 : context.url)) {
+            var excludeList = this.config.exclude.split(',');
+            // check if the current page is in the exclude list
+            if (excludeList.some(function (excludePage) { return _this.pathMatches(excludePage.trim(), context === null || context === void 0 ? void 0 : context.url); })) {
+                getLogger().debug("Page is excluded from tracking");
+                return;
+            }
+        }
+        var p = payload || {};
+        // All custom events and scroll event will have event_attributes
+        if (type !== "$autocapture" && type !== "user_identify" && type !== "pageview" && type !== "$pageleave") {
+            p = {
+                event_attributes: payload,
+            };
+        }
+        var e = this.makeEvent(type, this.compatMode ? "eventn" : "usermaven", p);
+        return this.sendJson(e);
+    };
+    UsermavenClientImpl.prototype.init = function (options) {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f;
+        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.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 (options.log_level) {
+            setRootLogLevel(options.log_level);
+        }
+        this.initialOptions = options;
+        getLogger().debug("Initializing Usemaven Tracker tracker", options, USERMAVEN_VERSION);
+        if (!options.key) {
+            getLogger().error("Can't initialize Usemaven, key property is not set");
+            return;
+        }
+        this.compatMode =
+            options.compat_mode === undefined
+                ? defaultCompatMode
+                : !!options.compat_mode;
+        this.cookieDomain = options.cookie_domain || getCookieDomain();
+        this.namespace = options.namespace || "usermaven";
+        this.crossDomainLinking = (_a = options.cross_domain_linking) !== null && _a !== void 0 ? _a : true;
+        this.formTracking = (_b = options.form_tracking) !== null && _b !== void 0 ? _b : false;
+        this.domains = options.domains ? (options.domains).split(',').map(function (domain) { return domain.trim(); }) : [];
+        this.trackingHost = getHostWithProtocol(options["tracking_host"] || "t.usermaven.com");
+        this.randomizeUrl = options.randomize_url || false;
+        this.apiKey = options.key;
+        this.__auto_pageview_enabled = options.auto_pageview || false;
+        this.idCookieName = options.cookie_name || "__eventn_id_" + options.key;
+        if (this.cookiePolicy === "strict") {
+            this.propsPersistance = new NoPersistence();
+        }
+        else {
+            this.propsPersistance = isWindowAvailable()
+                ? new CookiePersistence(this.cookieDomain, this.idCookieName + "_props")
+                : new NoPersistence();
+        }
+        if (this.cookiePolicy === "strict") {
+            this.userIdPersistence = new NoPersistence();
+        }
+        else {
+            this.userIdPersistence = isWindowAvailable()
+                ? new CookiePersistence(this.cookieDomain, this.idCookieName + "_usr")
+                : new NoPersistence();
+        }
+        if (this.propsPersistance) {
+            var restored = this.propsPersistance.restore();
+            if (restored) {
+                this.permanentProperties = restored;
+                this.permanentProperties.globalProps = (_c = restored.globalProps) !== null && _c !== void 0 ? _c : {};
+                this.permanentProperties.propsPerEvent = (_d = restored.propsPerEvent) !== null && _d !== void 0 ? _d : {};
+            }
+            getLogger().debug("Restored persistent properties", this.permanentProperties);
+        }
+        this.propertyBlacklist = options.property_blacklist && options.property_blacklist.length > 0 ? options.property_blacklist : [];
+        // // Added these configuration for session management + autocapture
+        var defaultConfig = {
+            autocapture: false,
+            properties_string_max_length: null,
+            property_blacklist: [],
+            sanitize_properties: null,
+            auto_pageview: false
+        };
+        this.config = _extend({}, defaultConfig, options || {}, this.config || {}, { token: this.apiKey });
+        getLogger().debug('Default Configuration', this.config);
+        // this.manageSession(this.config);
+        this.manageAutoCapture(this.config);
+        this.manageFormTracking(this.config);
+        this.manageCrossDomainLinking({
+            cross_domain_linking: this.crossDomainLinking,
+            domains: this.domains,
+            cookiePolicy: this.cookiePolicy
+        });
+        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); });
+        }
+        if (options.ga_hook) {
+            getLogger().warn("GA event interceptor isn't supported anymore");
+        }
+        if (options.segment_hook) {
+            interceptSegmentCalls(this);
+        }
+        if (isWindowAvailable()) {
+            if (!options.disable_event_persistence) {
+                this.queue = new LocalStorageQueue(this.namespace + "-event-queue");
+                this.scheduleFlush(0);
+            }
+            window.addEventListener("beforeunload", function () { return _this.flush(); });
+        }
+        if (this.__auto_pageview_enabled) {
+            enableAutoPageviews(this);
+        }
+        this.retryTimeout = [
+            (_e = options.min_send_timeout) !== null && _e !== void 0 ? _e : this.retryTimeout[0],
+            (_f = options.max_send_timeout) !== null && _f !== void 0 ? _f : this.retryTimeout[1],
+        ];
+        if (!!options.max_send_attempts) {
+            this.maxSendAttempts = options.max_send_attempts;
+        }
+        this.initialized = true;
+    };
+    UsermavenClientImpl.prototype.interceptAnalytics = function (analytics) {
+        var _this = this;
+        var interceptor = function (chain) {
+            var _a;
+            try {
+                var payload = __assign({}, chain.payload);
+                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") {
+                        payload.obj.userId = analyticsOriginal.user().id();
+                    }
+                }
+                if ((_a = payload === null || payload === void 0 ? void 0 : payload.obj) === null || _a === void 0 ? void 0 : _a.timestamp) {
+                    payload.obj.sentAt = payload.obj.timestamp;
+                }
+                var type = chain.payload.type();
+                if (type === "track") {
+                    type = chain.payload.event();
+                }
+                _this._send3p("ajs", payload, type);
+            }
+            catch (e) {
+                getLogger().warn("Failed to send an event", e);
+            }
+            chain.next(chain.payload);
+        };
+        if (typeof analytics.addSourceMiddleware === "function") {
+            //analytics is fully initialized
+            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]);
+        }
+        analytics["__en_intercepted"] = true;
+    };
+    UsermavenClientImpl.prototype.restoreId = function () {
+        if (this.userIdPersistence) {
+            var props = this.userIdPersistence.restore();
+            if (props) {
+                this.userProperties = __assign(__assign({}, props), this.userProperties);
+            }
+        }
+    };
+    UsermavenClientImpl.prototype.set = function (properties, opts) {
+        var _a;
+        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 !== undefined) {
+            var current = (_a = this.permanentProperties.propsPerEvent[eventType]) !== null && _a !== void 0 ? _a : {};
+            this.permanentProperties.propsPerEvent[eventType] = __assign(__assign({}, current), properties);
+        }
+        else {
+            this.permanentProperties.globalProps = __assign(__assign({}, this.permanentProperties.globalProps), properties);
+        }
+        if (this.propsPersistance && persist) {
+            this.propsPersistance.save(this.permanentProperties);
+        }
+    };
+    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) {
+            delete this.permanentProperties.globalProps[propertyName];
+        }
+        else if (this.permanentProperties.propsPerEvent[eventType]) {
+            delete this.permanentProperties.propsPerEvent[eventType][propertyName];
+        }
+        if (this.propsPersistance && persist) {
+            this.propsPersistance.save(this.permanentProperties);
+        }
+    };
+    UsermavenClientImpl.prototype.manageCrossDomainLinking = function (options) {
+        if (!isWindowAvailable() || !options.cross_domain_linking || options.domains.length === 0 || options.cookiePolicy === "strict") {
+            return false;
+        }
+        var cookieName = this.idCookieName;
+        var domains = options.domains || [];
+        // Listen for all clicks on the page
+        document.addEventListener('click', function (event) {
+            // Find the closest link
+            var target = _findClosestLink(event.target);
+            if (target) {
+                // Check if the link is pointing to a different domain
+                var href = (target === null || target === void 0 ? void 0 : target.hasAttribute('href')) ? target === null || target === void 0 ? void 0 : target.getAttribute('href') : '';
+                if (href && href.startsWith('http')) {
+                    var url = new URL(href);
+                    var cookie = getCookie(cookieName);
+                    // Skip the link if it's pointing to the current domain
+                    if (url.hostname === window.location.hostname) {
+                        return;
+                    }
+                    if (domains.includes(url.hostname) && cookie) {
+                        // Add the '_um' parameter to the URL
+                        url.searchParams.append('_um', cookie);
+                        target.setAttribute('href', url.toString());
+                    }
+                }
+            }
+        }, false);
+    };
+    /**
+     * Manage auto-capturing
+     * @param options
+     */
+    UsermavenClientImpl.prototype.manageAutoCapture = function (options) {
+        getLogger().debug("Auto Capture Status: ", this.config['autocapture']);
+        this.__autocapture_enabled = this.config['autocapture'] && isWindowAvailable();
+        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;
+            this.__autocapture_enabled = false;
+            getLogger().debug('Not in active bucket: disabling Automatic Event Collection.');
+        }
+        else if (!autocapture.isBrowserSupported()) {
+            this.config['autocapture'] = false;
+            this.__autocapture_enabled = false;
+            getLogger().debug('Disabling Automatic Event Collection because this browser is not supported');
+        }
+        else {
+            getLogger().debug('Autocapture enabled...');
+            autocapture.init(this, options);
+        }
+    };
+    /**
+     * Manage form tracking
+     */
+    UsermavenClientImpl.prototype.manageFormTracking = function (options) {
+        if (!isWindowAvailable() || !this.formTracking || this.formTracking === "none") {
+            return;
+        }
+        getLogger().debug('Form tracking enabled...');
+        // all and true are the same
+        var trackingType = this.formTracking === true ? 'all' : this.formTracking;
+        FormTracking.getInstance(this, trackingType).track();
+    };
+    /**
+     * Capture an event. This is the most important and
+     * frequently used usermaven function.
+     *
+     * ### Usage:
+     *     usermaven.capture('Registered', {'Gender': 'Male', 'Age': 21}, {});
+     *
+     * @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) {
+        var _a, _b;
+        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 usermaven.capture');
+            return;
+        }
+        // if (_.isBlockedUA(userAgent)) {
+        //   return
+        // }
+        var data = {
+            event: event_name + (properties['$event_type'] ? '_' + properties['$event_type'] : ''),
+            properties: this._calculate_event_properties(event_name, properties),
+        };
+        data = _copyAndTruncateStrings(data, this.get_config('properties_string_max_length'));
+        // send event if there is a tagname available
+        if ((_b = (_a = data.properties) === null || _a === void 0 ? void 0 : _a.autocapture_attributes) === null || _b === void 0 ? void 0 : _b.tag_name) {
+            this.track("$autocapture", data.properties);
+            // this.track(data.event, data.properties)
+        }
+        // send event if the event is $scroll
+        if (event_name === '$scroll') {
+            this.track(event_name, data.properties);
+        }
+        // send event if the event is $form
+        if (event_name === '$form') {
+            this.track(event_name, data.properties);
+        }
+    };
+    UsermavenClientImpl.prototype._calculate_event_properties = function (event_name, event_properties) {
+        var _a, _b;
+        // set defaults
+        var properties = event_properties || {};
+        if (event_name === '$snapshot' || event_name === '$scroll' || event_name === '$form') {
+            return properties;
+        }
+        if (_isArray(this.propertyBlacklist)) {
+            _each(this.propertyBlacklist, function (blacklisted_prop) {
+                delete properties[blacklisted_prop];
+            });
+        }
+        else {
+            console.error('Invalid value for property_blacklist config: ' + this.propertyBlacklist);
+        }
+        // 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 : "";
+        ['$ce_version', "$event_type", "$initial_referrer", "$initial_referring_domain", "$referrer", "$referring_domain", "$elements"].forEach(function (key) {
+            delete properties[key];
+        });
+        // 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;
+    };
+    return UsermavenClientImpl;
+}());
+function enableAutoPageviews(t) {
+    var page = function () { return t.track("pageview"); };
+    // Attach pushState and popState listeners
+    var originalPushState = history.pushState;
+    if (originalPushState) {
+        // eslint-disable-next-line functional/immutable-data
+        history.pushState = function (data, title, url) {
+            originalPushState.apply(this, [data, title, url]);
+            page();
+        };
+        addEventListener('popstate', page);
+    }
+    addEventListener('hashchange', page);
+}
+function interceptSegmentCalls(t) {
+    var win = window;
+    if (!win.analytics) {
+        win.analytics = [];
+    }
+    t.interceptAnalytics(win.analytics);
+}
+
+exports.envs = envs;
+exports.fetchApi = fetchApi;
+exports.httpApi = httpApi;
+exports.usermavenClient = usermavenClient;