@usermaven/nextjs 1.4.1-rc.59 → 1.4.1

package/lib/index.es.js

@@ -1,1398 +1,2659 @@
 import * as React from 'react';
-import { createContext, useContext, useCallback, useEffect, useState } from 'react';
+import { createContext, useContext, useCallback, useEffect } from 'react';
+import { useRouter } from 'next/router';
 
 const UsermavenContext = createContext(null);
 
-const UsermavenProvider = function ({ children, client }) {
+const JitsuProvider = function ({ children, client }) {
     const Context = UsermavenContext;
     return React.createElement(Context.Provider, { value: client }, children);
 };
 
-var v = /* @__PURE__ */ ((s) => (s[s.DEBUG = 0] = "DEBUG", s[s.INFO = 1] = "INFO", s[s.WARN = 2] = "WARN", s[s.ERROR = 3] = "ERROR", s))(v || {});
-class J {
-  constructor(e) {
-    this.level = e;
-  }
-  debug(e, ...t) {
-    this.level <= 0 && console.debug("[Usermaven Debug]:", e, ...t);
-  }
-  info(e, ...t) {
-    this.level <= 1 && console.info("[Usermaven Info]:", e, ...t);
-  }
-  warn(e, ...t) {
-    this.level <= 2 && console.warn("[Usermaven Warning]:", e, ...t);
-  }
-  error(e, ...t) {
-    this.level <= 3 && console.error("[Usermaven Error]:", e, ...t);
-  }
+/******************************************************************************
+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 h(s = 0) {
-  return new J(s);
+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;
 }
-const I = {
-  logLevel: v.ERROR,
-  useBeaconApi: !1,
-  forceUseFetch: !1,
-  trackingHost: "t.usermaven.com",
-  autocapture: !1,
-  rageClick: !1,
-  formTracking: !1,
-  autoPageview: !1,
-  disableEventPersistence: !1,
-  gaHook: !1,
-  segmentHook: !1,
-  randomizeUrl: !1,
-  capture3rdPartyCookies: ["_ga", "_fbp", "_ym_uid", "ajs_user_id", "ajs_anonymous_id"],
-  idMethod: "cookie",
-  ipPolicy: "keep",
-  cookiePolicy: "keep",
-  minSendTimeout: 0,
-  maxSendTimeout: 2e3,
-  maxSendAttempts: 4,
-  propertiesStringMaxLength: null,
-  propertyBlacklist: [],
-  crossDomainLinking: !0,
-  maskAllText: !1,
-  maskAllElementAttributes: !1
-};
-class Q {
-  constructor(e) {
-    this.domain = e, this.cookieDomain = this.getCookieDomain(), console.log(this.cookieDomain);
-  }
-  set(e, t, i = 365, n = !0, r = !1) {
-    console.log("Setting cookie", e, t, i, n, r);
-    const o = /* @__PURE__ */ new Date();
-    o.setTime(o.getTime() + i * 24 * 60 * 60 * 1e3);
-    const c = `expires=${o.toUTCString()}`, l = n ? "; Secure" : "", a = r ? "; HttpOnly" : "";
-    document.cookie = `${e}=${t};${c};path=/;domain=${this.cookieDomain}${l}${a}`;
-  }
-  get(e) {
-    const t = e + "=", i = document.cookie.split(";");
-    for (let n = 0; n < i.length; n++) {
-      let r = i[n].trim();
-      if (r.indexOf(t) === 0)
-        return decodeURIComponent(r.substring(t.length));
+function setDebugVar(name, val) {
+    if (!isWindowAvailable()) {
+        return;
     }
-    return null;
-  }
-  delete(e, t = "/") {
-    document.cookie = `${e}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=${t};domain=${this.cookieDomain}`;
-  }
-  getCookieDomain() {
-    return typeof window > "u" || this.domain ? this.domain || "" : this.extractRoot(window.location.hostname);
-  }
-  extractRoot(e) {
-    if (this.isIpAddress(e) || e === "localhost")
-      return e;
-    let t = this.extractTopLevelDomain(e);
-    return t || (t = this.extractRootDomain(e)), "." + t;
-  }
-  isIpAddress(e) {
-    const t = e.split(".");
-    return t.length === 4 && t.every((i) => !isNaN(Number(i)));
-  }
-  extractHostname(e) {
-    let t;
-    return e.indexOf("//") > -1 ? t = e.split("/")[2] : t = e.split("/")[0], t = t.split(":")[0], t = t.split("?")[0], t;
-  }
-  extractRootDomain(e) {
-    let t = this.extractHostname(e);
-    const i = t.split("."), n = i.length;
-    return n > 2 && (i[n - 1].length == 2 ? (t = i[n - 2] + "." + i[n - 1], i[n - 2].length == 2 && (t = i[n - 3] + "." + t)) : t = i[n - 2] + "." + i[n - 1]), t;
-  }
-  extractTopLevelDomain(e) {
-    const t = /[a-z0-9][a-z0-9-]+\.[a-z.]{2,6}$/i, i = e.match(t);
-    return i ? i[0] : "";
-  }
+    var win = window;
+    if (!win.__usermavenDebug) {
+        win.__usermavenDebug = {};
+    }
+    win.__usermavenDebug[name] = val;
 }
-const W = Object.prototype, X = W.hasOwnProperty, K = Array.prototype, b = K.forEach, $ = {};
-function Z(s, e, t) {
-  if (Array.isArray(s)) {
-    if (b && s.forEach === b)
-      s.forEach(e, t);
-    else if ("length" in s && s.length === +s.length) {
-      for (let i = 0, n = s.length; i < n; i++)
-        if (i in s && e.call(t, s[i], i) === $)
-          return;
+/**
+ * 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;
 }
-const T = function(s) {
-  return s.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
-}, G = function(s) {
-  for (const e in s)
-    typeof s[e] == "function" && (s[e] = s[e].bind(s));
-};
-function A(s, e, t) {
-  if (s != null) {
-    if (b && Array.isArray(s) && s.forEach === b)
-      s.forEach(e, t);
-    else if ("length" in s && s.length === +s.length) {
-      for (let i = 0, n = s.length; i < n; i++)
-        if (i in s && e.call(t, s[i], i) === $)
-          return;
-    } else
-      for (const i in s)
-        if (X.call(s, i) && e.call(t, s[i], i) === $)
-          return;
+
+
+/**
+ * @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;
 }
-const Y = function(s, ...e) {
-  return Z(e, function(t) {
-    for (const i in t)
-      t[i] !== void 0 && (s[i] = t[i]);
-  }), s;
-};
-function _(s, e) {
-  return s.indexOf(e) !== -1;
+
+// 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 '';
+    }
 }
-const D = function(s) {
-  try {
-    return /^\s*\bfunction\b/.test(s);
-  } catch {
-    return !1;
-  }
-}, j = function(s) {
-  return s === void 0;
-}, p = function() {
-  const s = function(i, n, r, o, c) {
-    if (!i) {
-      h().error("No valid element provided to register_event");
-      return;
-    }
-    if (i.addEventListener && !o)
-      i.addEventListener(n, r, !!c);
+
+// 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 {
-      const l = "on" + n, a = i[l];
-      i[l] = e(i, r, a);
+        hostname = url.split('/')[0];
     }
-  };
-  function e(i, n, r) {
-    return function(o) {
-      if (o = o || t(window.event), !o)
-        return;
-      let c = !0, l;
-      D(r) && (l = r(o));
-      const a = n.call(i, o);
-      return (l === !1 || a === !1) && (c = !1), c;
-    };
-  }
-  function t(i) {
-    return i && (i.preventDefault = t.preventDefault, i.stopPropagation = t.stopPropagation), i;
-  }
-  return t.preventDefault = function() {
-    this.returnValue = !1;
-  }, t.stopPropagation = function() {
-    this.cancelBubble = !0;
-  }, s;
-}(), ee = function(s) {
-  return function(...e) {
-    try {
-      return s.apply(this, e);
-    } catch (t) {
-      h().error("Implementation error. Please turn on debug and contact support@usermaven.com.", t);
-    }
-  };
-}, F = function(s) {
-  for (const e in s)
-    typeof s[e] == "function" && (s[e] = ee(s[e]));
-};
-function R(s) {
-  for (let e in s)
-    (s[e] === "" || s[e] === null || s[e] === void 0 || typeof s[e] == "object" && Object.keys(s[e]).length === 0) && delete s[e];
-  return s;
+    //find & remove port number
+    hostname = hostname.split(':')[0];
+    //find & remove "?"
+    hostname = hostname.split('?')[0];
+    return hostname;
 }
-function u() {
-  try {
-    return typeof window < "u" && window.document !== void 0 && window.document.createElement !== void 0;
-  } catch {
-    return h().warn("window is not available"), !1;
-  }
+// 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 f(s = 5) {
-  const e = new Uint8Array(s);
-  return crypto.getRandomValues(e), Array.from(e, (t) => t.toString(36).padStart(2, "0")).join("").slice(0, s);
+function copyAttributes(source, target) {
+    return Array.from(source.attributes).forEach(function (attribute) {
+        target.setAttribute(attribute.nodeName, attribute.nodeValue);
+    });
 }
-function te(s) {
-  return s.replace(
-    /([-_][a-z])/g,
-    (e) => e.toUpperCase().replace("-", "").replace("_", "")
-  );
+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]);
+    }
 }
-function S(s) {
-  return typeof s != "object" || s === null ? s : Array.isArray(s) ? s.map(S) : Object.keys(s).reduce((e, t) => {
-    const i = te(t);
-    return e[i] = S(s[t]), e;
-  }, {});
+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;
 }
-function E(s) {
-  switch (typeof s.className) {
-    case "string":
-      return s.className;
-    case "object":
-      return ("baseVal" in s.className ? s.className.baseVal : null) || s.getAttribute("class") || "";
-    default:
-      return "";
-  }
+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;
+                }
+            }
+        }
+    }
 }
-function N(s) {
-  let e = "";
-  return M(s) && !q(s) && s.childNodes && s.childNodes.length && A(s.childNodes, function(t) {
-    z(t) && t.textContent && (e += T(t.textContent).split(/(\s+)/).filter(x).join("").replace(/[\r\n]/g, " ").replace(/[ ]+/g, " ").substring(0, 255));
-  }), T(e);
+// 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;
+                }
+            }
+        }
+    }
 }
-function H(s) {
-  return !!s && s.nodeType === 1;
+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;
 }
-function d(s, e) {
-  return !!s && !!s.tagName && s.tagName.toLowerCase() === e.toLowerCase();
+// 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;
 }
-function z(s) {
-  return !!s && s.nodeType === 3;
+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 B(s) {
-  return !!s && s.nodeType === 11;
+// 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;
 }
-const C = ["a", "button", "form", "input", "select", "textarea", "label"];
-function ie(s, e) {
-  if (!s || d(s, "html") || !H(s) || s.classList && s.classList.contains("um-no-capture"))
-    return !1;
-  let t = !1;
-  const i = [s];
-  let n = !0, r = s;
-  for (; r.parentNode && !d(r, "body"); ) {
-    if (B(r.parentNode)) {
-      i.push(r.parentNode.host), r = r.parentNode.host;
-      continue;
-    }
-    if (n = r.parentNode || !1, !n) break;
-    if (C.indexOf(n.tagName.toLowerCase()) > -1)
-      t = !0;
-    else {
-      const l = window.getComputedStyle(n);
-      l && l.getPropertyValue("cursor") === "pointer" && (t = !0);
+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];
+        }
     }
-    i.push(n), r = n;
-  }
-  const o = window.getComputedStyle(s);
-  if (o && o.getPropertyValue("cursor") === "pointer" && e.type === "click")
-    return !0;
-  const c = s.tagName.toLowerCase();
-  switch (c) {
-    case "html":
-      return !1;
-    case "form":
-      return e.type === "submit";
-    case "input":
-      return e.type === "change" || e.type === "click";
-    case "select":
-    case "textarea":
-      return e.type === "change" || e.type === "click";
-    default:
-      return t ? e.type === "click" : e.type === "click" && (C.indexOf(c) > -1 || s.getAttribute("contenteditable") === "true");
-  }
+    return obj;
 }
-function M(s) {
-  if (!s || !H(s))
-    return !1;
-  if (typeof s.hasAttribute == "function") {
-    if (s.hasAttribute(w.FORCE_CAPTURE_ATTR))
-      return !0;
-    if (s.hasAttribute(w.PREVENT_CAPTURE_ATTR))
-      return !1;
-  }
-  let e = s;
-  for (; e && e.parentElement && !d(e, "body"); ) {
-    const n = E(e).split(" ");
-    if (_(n, "ph-sensitive") || _(n, "ph-no-capture"))
-      return !1;
-    e = e.parentElement;
-  }
-  if (_(E(s).split(" "), "ph-include"))
-    return !0;
-  const t = s.type;
-  if (typeof t == "string")
-    switch (t.toLowerCase()) {
-      case "hidden":
-      case "password":
-        return !1;
-    }
-  const i = s.name || s.id || "";
-  return !(typeof i == "string" && /^cc|cardnum|ccnum|creditcard|csc|cvc|cvv|exp|pass|pwd|routing|seccode|securitycode|securitynum|socialsec|socsec|ssn/i.test(i.replace(/[^a-zA-Z0-9]/g, "")));
+
+/*
+ * 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 '';
+    }
 }
-function q(s) {
-  const e = ["button", "checkbox", "submit", "reset"];
-  return !!(d(s, "input") && !e.includes(s.type) || d(s, "select") || d(s, "textarea") || s.getAttribute("contenteditable") === "true");
+/*
+ * 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);
 }
-function x(s) {
-  return !(s === null || j(s) || typeof s == "string" && (s = T(s), /^(?:(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}))$/.test((s || "").replace(/[- ]/g, "")) || /(^\d{3}-?\d{2}-?\d{4}$)/.test(s)));
+/*
+ * 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
 }
-function se(s) {
-  return typeof s == "string" ? s.substring(0, 10) === "_ngcontent" || s.substring(0, 7) === "_nghost" : !1;
+/*
+ * 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();
 }
-function P() {
-  return f(10);
+/*
+ * 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
 }
-function ne(s) {
-  return /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(String(s).toLowerCase());
+/*
+ * 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
 }
-function re(s, e) {
-  let t;
-  return function(...i) {
-    const n = () => {
-      clearTimeout(t), s(...i);
-    };
-    clearTimeout(t), t = setTimeout(n, e);
-  };
+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'));
+    }
 }
-function oe(s) {
-  const e = {}, t = s.replace(/^\?/, "").split("&");
-  for (let i = 0; i < t.length; i++) {
-    const n = t[i].split("=");
-    n[0] !== "" && (e[decodeURIComponent(n[0])] = decodeURIComponent(n[1] || ""));
-  }
-  return e;
+/*
+ * 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;
 }
-function O(s) {
-  return typeof s == "string" || s instanceof String;
+/*
+ * 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;
 }
-function k(s) {
-  return s !== null && typeof s == "object" && s.constructor === Object;
+/*
+ * 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;
 }
-function ae(s) {
-  if (s === null)
-    return v.ERROR;
-  const e = s.toUpperCase(), t = v[e];
-  return t || t === 0 ? t : v.ERROR;
+/*
+ * 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;
 }
-class ce {
-  constructor(e) {
-    this.maxScrollDepth = 0, this.milestones = [25, 50, 75, 90], this.lastScrollDepth = 0, this.client = e, this.documentElement = document.documentElement, this.debouncedHandleScroll = re(this.handleScroll.bind(this), 250), this.initializeEventListener();
-  }
-  initializeEventListener() {
-    window.addEventListener("scroll", this.debouncedHandleScroll);
-  }
-  track() {
-    const e = this.getScrollDepth();
-    e > this.lastScrollDepth && (this.lastScrollDepth = e, this.checkMilestones(e));
-  }
-  send(e = "$scroll") {
-    const t = {
-      percent: this.lastScrollDepth,
-      window_height: this.getWindowHeight(),
-      document_height: this.getDocumentHeight(),
-      scroll_distance: this.getScrollDistance()
-    };
-    this.client.track(e, t);
-  }
-  handleScroll() {
-    this.track();
-  }
-  getScrollDepth() {
-    const e = this.getWindowHeight(), t = this.getDocumentHeight(), i = this.getScrollDistance(), n = t - e;
-    return Math.min(100, Math.floor(i / n * 100));
-  }
-  getWindowHeight() {
-    return window.innerHeight || this.documentElement.clientHeight || document.body.clientHeight || 0;
-  }
-  getDocumentHeight() {
-    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
-    );
-  }
-  getScrollDistance() {
-    return window.pageYOffset || this.documentElement.scrollTop || document.body.scrollTop || 0;
-  }
-  checkMilestones(e) {
-    this.milestones.filter((i) => e >= i).forEach((i) => {
-      this.send(), this.milestones = this.milestones.filter((n) => n !== i);
-    });
-  }
-}
-const y = class y {
-  constructor(e, t, i = h()) {
-    this.logger = i, this.scrollDepth = null, this.client = e, this.options = t, this.scrollDepth = new ce(e), G(this), F(this);
-  }
-  init() {
-    if (!(document && document.body)) {
-      this.logger.debug("Document not ready yet, trying again in 500 milliseconds..."), setTimeout(() => this.init(), 500);
-      return;
+
+// 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;
     }
-    this.addDomEventHandlers();
-  }
-  addDomEventHandlers() {
-    const e = (t) => {
-      t = t || window.event, this.captureEvent(t);
+    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 }];
+        }
     };
-    p(document, "submit", e, !1, !0), p(document, "change", e, !1, !0), p(document, "click", e, !1, !0), p(document, "visibilitychange", e, !1, !0), p(document, "scroll", e, !1, !0), p(window, "popstate", e, !1, !0);
-  }
-  isPageRefresh() {
-    if ("PerformanceNavigationTiming" in window) {
-      const e = performance.getEntriesByType("navigation");
-      if (e.length > 0)
-        return e[0].type === "reload";
-    }
-    return performance.navigation && performance.navigation.type === 1;
-  }
-  captureEvent(e) {
-    var i, n;
-    let t = this.getEventTarget(e);
-    if (z(t) && (t = t.parentNode || null), e.type === "scroll")
-      return (i = this.scrollDepth) == null || i.track(), !0;
-    if (e.type === "visibilitychange" && document.visibilityState === "hidden" || e.type === "popstate")
-      return this.isPageRefresh() || (n = this.scrollDepth) == null || n.send(), !0;
-    if (t && this.shouldCaptureElement(t, e)) {
-      const r = this.getElementList(t), o = this.getElementsJson(r, e), c = Y(
-        this.getDefaultProperties(e.type),
-        {
-          $elements: o
-        }
-      );
-      return this.client.track("$autocapture", c), !0;
+    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;
     }
-  }
-  shouldCaptureElement(e, t) {
-    return !e || typeof e.hasAttribute != "function" ? !1 : e.hasAttribute(y.FORCE_CAPTURE_ATTR) ? !0 : e.hasAttribute(y.PREVENT_CAPTURE_ATTR) ? !1 : ie(e, t);
-  }
-  getEventTarget(e) {
-    var t;
-    return typeof e.target > "u" ? e.srcElement || null : (t = e.target) != null && t.shadowRoot ? e.composedPath()[0] || null : e.target || null;
-  }
-  getElementList(e) {
-    const t = [e];
-    let i = e;
-    for (; i.parentNode && !d(i, "body"); )
-      B(i.parentNode) ? (t.push(i.parentNode.host), i = i.parentNode.host) : (t.push(i.parentNode), i = i.parentNode);
-    return t;
-  }
-  getElementsJson(e, t) {
-    const i = [];
-    let n = null, r = !1;
-    return A(e, (o) => {
-      if (d(o, "a")) {
-        const l = o.getAttribute("href");
-        l !== null && M(o) && x(l) && (n = l);
-      }
-      const c = E(o).split(" ");
-      _(c, "ph-no-capture") && (r = !0), i.push(this.getPropertiesFromElement(o));
-    }), this.options.maskAllText || (i[0].$el_text = this.sanitizeText(N(e[0]))), n !== null && (i[0].attr__href = n), r ? [] : i;
-  }
-  getPropertiesFromElement(e) {
-    const t = {
-      tag_name: e.tagName.toLowerCase()
-    };
-    C.indexOf(t.tag_name) > -1 && !this.options.maskAllText && (t.$el_text = this.sanitizeText(N(e)));
-    const i = E(e);
-    i.length > 0 && (t.classes = i.split(" ").filter((c) => c !== "")), A(e.attributes, (c) => {
-      q(e) && ["name", "id", "class"].indexOf(c.name) === -1 || !this.options.maskAllElementAttributes && x(c.value) && !se(c.name) && (t["attr__" + c.name] = this.sanitizeAttributeValue(c.name, c.value));
-    });
-    let n = 1, r = 1, o = e;
-    for (; o = this.previousElementSibling(o); )
-      n++, o.tagName === e.tagName && r++;
-    return t.nth_child = n, t.nth_of_type = r, t;
-  }
-  previousElementSibling(e) {
-    if (e.previousElementSibling)
-      return e.previousElementSibling;
-    do
-      e = e.previousSibling;
-    while (e && !H(e));
-    return e;
-  }
-  getDefaultProperties(e) {
-    return {
-      $event_type: e,
-      $ce_version: 1
+    /**
+     * 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;
+        }
     };
-  }
-  // Input sanitization and XSS prevention methods
-  sanitizeText(e) {
-    e = e.replace(/<[^>]*?>/g, ""), e = this.encodeHtml(e);
-    const t = this.options.propertiesStringMaxLength || 255;
-    return e.length > t && (e = e.substring(0, t) + "..."), e;
-  }
-  sanitizeUrl(e) {
-    if (!e) return "";
-    try {
-      const t = new URL(e, window.location.href);
-      return t.protocol !== "http:" && t.protocol !== "https:" ? "" : encodeURI(t.toString());
-    } catch {
-      return this.encodeHtml(e);
-    }
-  }
-  sanitizeAttributeValue(e, t) {
-    switch (e.toLowerCase()) {
-      case "href":
-      case "src":
-        return this.sanitizeUrl(t);
-      default:
-        return this.encodeHtml(t);
+    /**
+     * 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();
+        }
     }
-  }
-  encodeHtml(e) {
-    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-  }
-  static enabledForProject(e, t = 10, i = 10) {
-    if (!e)
-      return !1;
-    let n = 0;
-    for (let r = 0; r < e.length; r++)
-      n += e.charCodeAt(r);
-    return n % t < i;
-  }
-  static isBrowserSupported() {
-    return D(document.querySelectorAll);
-  }
+    /**
+     * 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-12T08:10:12.563Z',
+    version: '1.4.1'
 };
-y.FORCE_CAPTURE_ATTR = "data-um-force-capture", y.PREVENT_CAPTURE_ATTR = "data-um-no-capture";
-let w = y;
-class le {
-  constructor(e) {
-    this.client = e, this.lastPageUrl = window.location.href, this.trackInitialPageview(), this.initializePageviewTracking();
-  }
-  trackInitialPageview() {
-    this.trackPageview();
-  }
-  initializePageviewTracking() {
-    window.addEventListener("popstate", this.handlePageview.bind(this));
-    const e = history.pushState;
-    history.pushState = (...t) => {
-      e.apply(history, t), this.handlePageview();
-    }, window.addEventListener("hashchange", this.handlePageview.bind(this)), setInterval(this.checkForUrlChange.bind(this), 1e3);
-  }
-  handlePageview() {
-    this.trackPageview();
-  }
-  checkForUrlChange() {
-    window.location.href !== this.lastPageUrl && this.trackPageview();
-  }
-  trackPageview() {
-    const e = window.location.href;
-    e !== this.lastPageUrl && (this.lastPageUrl = e, this.client.track("pageview", {
-      url: e,
-      referrer: document.referrer,
-      title: document.title
-    }));
-  }
-}
-class ue {
-  constructor(e, t, i = h()) {
-    this.trackingHost = e, this.logger = i, this.config = t;
-  }
-  async send(e) {
-    const t = this.config.key, i = this.constructUrl(t), n = new Blob([JSON.stringify(e)], { type: "application/json" });
-    if (navigator.sendBeacon(i, n))
-      this.logger.debug(`Successfully queued ${e.length} event(s) via Beacon API`);
-    else
-      throw new Error("Failed to queue events via Beacon API");
-  }
-  constructUrl(e) {
-    const t = this.config.cookiePolicy !== "keep" ? `&cookie_policy=${this.config.cookiePolicy}` : "", i = this.config.ipPolicy !== "keep" ? `&ip_policy=${this.config.ipPolicy}` : "", n = u() ? "/api/v1/event" : "/api/v1/s2s/event";
-    return this.config.randomizeUrl ? `${this.trackingHost}/api.${f()}?p_${f()}=${e}${t}${i}` : `${this.trackingHost}${n}?token=${e}${t}${i}`;
-  }
-  // Note: Beacon API doesn't support custom headers, so we can't use them here.
-  // If custom headers are crucial, you might want to fall back to XHR or Fetch in those cases.
-}
-class L {
-  constructor(e, t, i = h()) {
-    this.trackingHost = e, this.logger = i, this.config = t;
-  }
-  async send(e) {
-    const t = this.config.key, i = this.constructUrl(t), n = JSON.stringify(e), r = {
-      "Content-Type": "application/json",
-      ...this.getCustomHeaders()
-    }, o = await fetch(i, {
-      method: "POST",
-      headers: r,
-      body: n
-    });
-    if (!o.ok)
-      throw new Error(`HTTP error! status: ${o.status}`);
-    this.logger.debug(`Successfully sent ${e.length} event(s)`), this.postHandle(o.status, await o.text());
-  }
-  constructUrl(e) {
-    const t = this.config.cookiePolicy !== "keep" ? `&cookie_policy=${this.config.cookiePolicy}` : "", i = this.config.ipPolicy !== "keep" ? `&ip_policy=${this.config.ipPolicy}` : "", n = u() ? "/api/v1/event" : "/api/v1/s2s/event";
-    return this.config.randomizeUrl ? `${this.trackingHost}/api.${f()}?p_${f()}=${e}${t}${i}` : `${this.trackingHost}${n}?token=${e}${t}${i}`;
-  }
-  getCustomHeaders() {
-    return typeof this.config.customHeaders == "function" ? this.config.customHeaders() : this.config.customHeaders ? this.config.customHeaders : {};
-  }
-  postHandle(e, t) {
-    this.logger.debug(`Response received. Status: ${e}, Body: ${t}`);
-  }
-}
-class he {
-  constructor(e, t, i = h()) {
-    this.trackingHost = e, this.logger = i, this.config = t;
-  }
-  send(e) {
-    return new Promise((t, i) => {
-      const n = new XMLHttpRequest(), r = this.config.key, o = this.constructUrl(r);
-      n.open("POST", o, !0), n.setRequestHeader("Content-Type", "application/json");
-      const c = this.getCustomHeaders();
-      Object.keys(c).forEach((l) => {
-        n.setRequestHeader(l, c[l]);
-      }), n.onload = () => {
-        n.status >= 200 && n.status < 300 ? (this.logger.debug(`Successfully sent ${e.length} event(s)`), t()) : i(new Error(`HTTP error! status: ${n.status}`));
-      }, n.onerror = () => {
-        i(new Error("Network error"));
-      }, n.send(JSON.stringify(e));
-    });
-  }
-  constructUrl(e) {
-    const t = this.config.cookiePolicy !== "keep" ? `&cookie_policy=${this.config.cookiePolicy}` : "", i = this.config.ipPolicy !== "keep" ? `&ip_policy=${this.config.ipPolicy}` : "", n = u() ? "/api/v1/event" : "/api/v1/s2s/event";
-    return this.config.randomizeUrl ? `${this.trackingHost}/api.${f()}?p_${f()}=${e}${t}${i}` : `${this.trackingHost}${n}?token=${e}${t}${i}`;
-  }
-  getCustomHeaders() {
-    return typeof this.config.customHeaders == "function" ? this.config.customHeaders() : this.config.customHeaders ? this.config.customHeaders : {};
-  }
-  postHandle(e, t) {
-    this.logger.debug(`Response received. Status: ${e}, Body: ${t}`);
-  }
-}
-class V {
-  constructor(e, t) {
-    this.storage = {}, this.prefix = `usermaven_${e}_`, this.load(), this.logger = t || h();
-  }
-  set(e, t) {
-    this.storage[e] = t, this.save();
-  }
-  get(e) {
-    return this.storage[e];
-  }
-  remove(e) {
-    delete this.storage[e], this.save();
-  }
-  clear() {
-    this.storage = {}, this.save();
-  }
-  save() {
-    if (!u()) {
-      this.logger.warn("localStorage is not available in this environment");
-      return;
+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;
+        }
     }
-    try {
-      localStorage.setItem(this.prefix + "data", JSON.stringify(this.storage));
-    } catch (e) {
-      this.logger.error("Error saving to localStorage:", e);
+}
+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;
     }
-  }
-  load() {
-    if (!u()) {
-      this.logger.warn("localStorage is not available in this environment");
-      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;
     }
-    try {
-      const e = localStorage.getItem(this.prefix + "data");
-      e && (this.storage = JSON.parse(e));
-    } catch (e) {
-      this.logger.error("Error loading from localStorage:", e);
+    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;
 }
-class ge {
-  constructor() {
-    this.storage = {};
-  }
-  set(e, t) {
-    this.storage[e] = t;
-  }
-  get(e) {
-    return this.storage[e];
-  }
-  remove(e) {
-    delete this.storage[e];
-  }
-  save() {
-  }
-  clear() {
-    this.storage = {};
-  }
+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;
 }
-class U {
-  // Default to true for server-side
-  constructor(e, t = 3, i = 1e3, n = 10, r = 1e3, o = h()) {
-    this.transport = e, this.maxRetries = t, this.retryInterval = i, this.batchSize = n, this.batchInterval = r, this.logger = o, this.queue = [], this.processing = !1, this.batchTimeoutId = null, this.isOnline = !0, this.persistence = new V("offline_queue"), u() && (this.isOnline = navigator.onLine, this.loadQueueFromStorage(), this.initNetworkListeners(), this.scheduleBatch());
-  }
-  add(e) {
-    const t = { payload: e, retries: 0, timestamp: Date.now() };
-    this.queue.push(t), u() ? this.saveQueueToStorage() : this.processBatch();
-  }
-  initNetworkListeners() {
-    u() && (window.addEventListener("online", () => {
-      this.isOnline = !0, this.processBatch();
-    }), window.addEventListener("offline", () => {
-      this.isOnline = !1;
-    }));
-  }
-  scheduleBatch() {
-    u() && (this.batchTimeoutId !== null && clearTimeout(this.batchTimeoutId), this.batchTimeoutId = window.setTimeout(() => this.processBatch(), this.batchInterval));
-  }
-  async processBatch() {
-    if ((!u() || this.isOnline) && !this.processing && this.queue.length > 0) {
-      this.processing = !0;
-      const e = this.queue.splice(0, this.batchSize), t = e.map((i) => i.payload);
-      try {
-        await this.transport.send(t), this.logger.debug(`Successfully sent batch of ${e.length} payloads`), u() && this.saveQueueToStorage();
-      } catch (i) {
-        this.logger.error("Failed to send batch", i), await this.handleBatchFailure(e);
-      }
-      this.processing = !1;
-    }
-    u() && this.scheduleBatch();
-  }
-  async handleBatchFailure(e) {
-    for (const t of e)
-      t.retries < this.maxRetries ? (t.retries++, this.queue.unshift(t), this.logger.warn(`Retry attempt ${t.retries} for payload`)) : this.logger.error("Max retries reached, discarding payload", t.payload);
-    u() && (this.saveQueueToStorage(), await new Promise((t) => setTimeout(t, this.retryInterval)));
-  }
-  loadQueueFromStorage() {
-    if (u()) {
-      const e = this.persistence.get("queue");
-      e && (this.queue = JSON.parse(e));
+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);
+        }
     }
-  }
-  saveQueueToStorage() {
-    u() && this.persistence.set("queue", JSON.stringify(this.queue));
-  }
+    return str;
 }
-class de {
-  constructor(e) {
-    this.clicks = [], this.threshold = 3, this.timeWindow = 2e3, this.distanceThreshold = 30, this.client = e, this.initializeEventListener(), F(this);
-  }
-  initializeEventListener() {
-    document.addEventListener("click", this.handleClick.bind(this));
-  }
-  handleClick(e) {
-    const t = e.target;
-    this.shouldCaptureElement(t) && this.click(e.clientX, e.clientY, Date.now());
-  }
-  shouldCaptureElement(e) {
-    return !e.closest(".um-no-capture");
-  }
-  click(e, t, i) {
-    const n = { x: e, y: t, timestamp: i };
-    this.clicks.push(n), this.clicks = this.clicks.filter((r) => i - r.timestamp < this.timeWindow), this.clicks.length >= this.threshold && this.checkRageClick();
-  }
-  checkRageClick() {
-    const e = this.clicks[0], i = (this.clicks[this.clicks.length - 1].timestamp - e.timestamp) / 1e3;
-    this.clicks.every((r, o) => {
-      if (o === 0) return !0;
-      const c = this.clicks[o - 1];
-      return Math.sqrt(Math.pow(r.x - c.x, 2) + Math.pow(r.y - c.y, 2)) < this.distanceThreshold;
-    }) && this.sendRageClickEvent(i);
-  }
-  sendRageClickEvent(e) {
-    const t = this.clicks[this.clicks.length - 1];
-    document.elementFromPoint(t.x, t.y) && this.client.track("$rage_click", {
-      no_of_clicks: this.clicks.length,
-      time: e.toFixed(2)
-    }), this.clicks = [];
-  }
+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: "",
+            };
+        },
+    };
 }
-class fe {
-  constructor(e, t, i = h()) {
-    this.trackingHost = e, this.logger = i, this.config = t;
-  }
-  async send(e) {
-    const t = this.config.key, i = new (void 0)(this.constructUrl(t)), n = {
-      hostname: i.hostname,
-      port: 443,
-      path: `${i.pathname}${i.search}`,
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.getCustomHeaders()
-      }
-    };
-    return new Promise((r, o) => {
-      const c = (void 0)(n, (l) => {
-        l.on("data", (a) => {
-        }), l.on("end", () => {
-          const a = l.statusCode || 0;
-          a >= 200 && a < 300 ? (this.logger.debug(`Successfully sent ${e.length} event(s)`), r()) : o(new Error(`HTTP error! status: ${a}`));
+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);
         });
-      });
-      c.on("error", (l) => {
-        o(l);
-      }), c.write(JSON.stringify(e)), c.end();
-    });
-  }
-  constructUrl(e) {
-    const t = this.config.cookiePolicy !== "keep" ? `&cookie_policy=${this.config.cookiePolicy}` : "", i = this.config.ipPolicy !== "keep" ? `&ip_policy=${this.config.ipPolicy}` : "";
-    return `${this.trackingHost}/api/v1/s2s/event?token=${e}${t}${i}`;
-  }
-  getCustomHeaders() {
-    return typeof this.config.customHeaders == "function" ? this.config.customHeaders() : this.config.customHeaders ? this.config.customHeaders : {};
-  }
-}
-class m {
-  constructor(e, t = "all", i = {}) {
-    this.instance = e, this.trackingType = t, this.options = i, document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", this.initialize.bind(this)) : this.initialize();
-  }
-  initialize() {
-    this.trackingType !== "none" && this.setupFormTracking();
-  }
-  setupFormTracking() {
-    var e;
-    this.formElements = this.trackingType === "tagged" ? document.querySelectorAll("form[data-um-form]") : document.querySelectorAll("form"), (e = this.formElements) == null || e.forEach((t) => {
-      t.addEventListener("submit", this.handleFormSubmit.bind(this));
-    });
-  }
-  handleFormSubmit(e) {
-    const t = e.target, i = this._getFormDetails(t);
-    this.instance.track("$form", R(i)), this.options.trackFieldChanges && this.trackFieldChanges(t);
-  }
-  trackFieldChanges(e) {
-    e.querySelectorAll("input, select, textarea").forEach((i) => {
-      i.addEventListener("change", (n) => {
-        const r = this._getFieldProps(n.target, 0);
-        this.instance.track("$form_field_change", R(r));
-      });
+        req.send(jsonPayload);
+        getLogger().debug("sending json", jsonPayload);
     });
-  }
-  static getInstance(e, t = "all", i = {}) {
-    return m.instance || (m.instance = new m(e, t, i)), m.instance;
-  }
-  _getFormDetails(e) {
-    const t = {
-      form_id: e.id,
-      form_name: e.name || "",
-      form_action: e.action,
-      form_method: e.method,
-      form_class: e.className,
-      form_attributes: this._getElementAttributes(e)
-    }, i = e.querySelectorAll("input, select, textarea");
-    return Array.from(i).filter((r) => !r.classList.contains("um-no-capture")).forEach((r, o) => {
-      const c = this._getFieldProps(r, o);
-      Object.assign(t, c);
-    }), t;
-  }
-  _getFieldProps(e, t) {
-    const i = Object.keys(e.dataset).length ? JSON.stringify(e.dataset) : void 0, n = this.getSafeText(e);
-    return {
-      [`field_${t + 1}_tag`]: e.tagName.toLowerCase(),
-      [`field_${t + 1}_type`]: e instanceof HTMLInputElement ? e.type : void 0,
-      [`field_${t + 1}_data_attributes`]: i,
-      [`field_${t + 1}_id`]: e.id,
-      [`field_${t + 1}_value`]: n,
-      [`field_${t + 1}_class`]: e.className,
-      [`field_${t + 1}_name`]: e.name,
-      [`field_${t + 1}_attributes`]: this._getElementAttributes(e)
+};
+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*/];
+                }
+            });
+        });
     };
-  }
-  _getElementAttributes(e) {
-    const t = {};
-    for (let i = 0; i < e.attributes.length; i++) {
-      const n = e.attributes[i];
-      n.name !== "value" && !n.name.startsWith("data-") && (t[n.name] = n.value);
-    }
-    return t;
-  }
-  getSafeText(e) {
-    let t = "";
-    return "value" in e && e.type !== "password" ? t = e.value : e.hasChildNodes() ? t = Array.from(e.childNodes).filter(
-      (n) => n.nodeType === Node.TEXT_NODE
-    ).map((n) => n.textContent).join("") : t = e.textContent || "", this._scrubPotentiallySensitiveValues(t);
-  }
-  _scrubPotentiallySensitiveValues(e) {
-    return this._shouldCaptureValue(e) ? e : "<redacted>";
-  }
-  _shouldCaptureValue(e) {
-    return !(this._isNullish(e) || this._isString(e) && (e = this._trim(e), /^(?:(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}))$/.test((e || "").replace(/[- ]/g, "")) || /(^\d{3}-?\d{2}-?\d{4}$)/.test(e)));
-  }
-  _isNullish(e) {
-    return e == null;
-  }
-  _isString(e) {
-    return typeof e == "string" || e instanceof String;
-  }
-  _trim(e) {
-    if (typeof String.prototype.trim == "function")
-      return e.trim();
-    let t = 0, i = e.length - 1;
-    const n = [
-      " ",
-      `
-`,
-      "\r",
-      "	",
-      "\f",
-      "\v",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      " ",
-      "\u2028",
-      "\u2029",
-      " ",
-      " ",
-      "　"
-    ].join("");
-    for (; t <= i && n.indexOf(e[t]) > -1; )
-      t++;
-    for (; i >= t && n.indexOf(e[i]) > -1; )
-      i--;
-    return e.slice(t, i + 1);
-  }
-}
-class pe {
-  constructor(e) {
-    this.config = this.mergeConfig(e, I), this.logger = h(this.config.logLevel), this.namespace = e.namespace || "usermaven", this.transport = this.initializeTransport(this.config), this.persistence = this.initializePersistence(), this.retryQueue = new U(
-      this.transport,
-      this.config.maxSendAttempts || 3,
-      this.config.minSendTimeout || 1e3,
-      10,
-      200,
-      // Reduced interval to .2 second
-      this.logger
-    ), u() && this.initializeBrowserFeatures(), this.anonymousId = this.getOrCreateAnonymousId(), this.logger.info(`Usermaven client initialized for namespace: ${this.namespace}`);
-  }
-  initializeBrowserFeatures() {
-    if (this.cookieManager = new Q(this.config.cookieDomain), this.config.autocapture && w.enabledForProject(this.config.key) && (this.autoCapture = new w(this, this.config, this.logger), this.autoCapture.init()), this.config.formTracking) {
-      const e = this.config.formTracking === !0 ? "all" : this.config.formTracking;
-      this.formTracking = m.getInstance(this, e || "none", {
-        trackFieldChanges: !1
-      });
-    }
-    this.config.autoPageview && (this.pageviewTracking = new le(this)), this.config.crossDomainLinking && this.manageCrossDomainLinking(), this.config.rageClick && (this.rageClick = new de(this)), this.setupPageLeaveTracking();
-  }
-  /**
-   * Recursively merge the provided configuration with the existing defaultConfig
-   * @param config
-   * @param defaultConfig
-   */
-  mergeConfig(e, t) {
-    const i = JSON.parse(JSON.stringify(e));
-    let n = { ...t, ...i };
-    return Object.keys(t).forEach((r) => {
-      k(t[r]) && (n[r] = this.mergeConfig(e[r], t[r]));
-    }), n;
-  }
-  init(e) {
-    this.config = { ...this.config, ...e }, this.logger = h(this.config.logLevel), this.namespace = e.namespace || this.namespace, this.transport = this.initializeTransport(e), this.persistence = this.initializePersistence(), this.retryQueue = new U(
-      this.transport,
-      this.config.maxSendAttempts || 3,
-      this.config.minSendTimeout || 1e3,
-      10,
-      250,
-      // Reduced interval to .25 second
-      this.logger
-    ), u() && this.initializeBrowserFeatures(), this.anonymousId = this.getOrCreateAnonymousId(), this.logger.info(`Usermaven client reinitialized for namespace: ${this.namespace}`);
-  }
-  manageCrossDomainLinking() {
-    if (!this.config.crossDomainLinking || !this.config.domains)
-      return;
-    const e = this.config.domains.split(",").map((i) => i.trim()), t = this.config.cookieName || `${this.namespace}_id_${this.config.key}`;
-    document.addEventListener("click", (i) => {
-      var c;
-      const n = this.findClosestLink(i.target);
-      if (!n) return;
-      const r = n.getAttribute("href");
-      if (!r || !r.startsWith("http")) return;
-      const o = new URL(r);
-      if (o.hostname !== window.location.hostname && e.includes(o.hostname)) {
-        const l = (c = this.cookieManager) == null ? void 0 : c.get(t);
-        l && (o.searchParams.append("_um", l), n.setAttribute("href", o.toString()));
-      }
-    }), this.logger.debug("Cross-domain linking initialized");
-  }
-  findClosestLink(e) {
-    for (; e && e.tagName !== "A"; )
-      e = e.parentElement;
-    return e;
-  }
-  initializeTransport(e) {
-    if (!u())
-      return new fe(e.trackingHost, e);
-    const t = "XMLHttpRequest" in window, i = typeof fetch < "u", n = typeof navigator < "u" && "sendBeacon" in navigator;
-    if (e.useBeaconApi && n)
-      return new ue(e.trackingHost, e, this.logger);
-    if (e.forceUseFetch && i)
-      return new L(e.trackingHost, e, this.logger);
-    if (t)
-      return new he(e.trackingHost, e, this.logger);
-    if (i)
-      return new L(e.trackingHost, e, this.logger);
-    throw new Error("No suitable transport method available");
-  }
-  initializePersistence() {
-    return this.config.disableEventPersistence || !u() ? new ge() : new V(`${this.namespace}_${this.config.key}`, this.logger);
-  }
-  getOrCreateAnonymousId() {
-    var i, n;
-    if (!u())
-      return P();
-    if (this.config.privacyPolicy === "strict" || this.config.cookiePolicy === "strict")
-      return this.generateFingerprint();
-    const e = this.config.cookieName || `${this.namespace}_id_${this.config.key}`;
-    let t = (i = this.cookieManager) == null ? void 0 : i.get(e);
-    if (!t) {
-      if (this.config.crossDomainLinking) {
-        const c = new URLSearchParams(window.location.search).get("_um"), a = window.location.hash.substring(1).split("~"), g = a.length > 1 ? a[1] : void 0;
-        t = c || g || P();
-      }
-      t || (t = P());
-      const r = 365 * 10;
-      (n = this.cookieManager) == null || n.set(e, t, r, document.location.protocol !== "http:", !1);
-    }
-    return t;
-  }
-  generateFingerprint() {
-    const e = navigator.userAgent, t = `${screen.width}x${screen.height}`, i = screen.colorDepth, n = Intl.DateTimeFormat().resolvedOptions().timeZone, r = `${e}|${t}|${i}|${n}`;
-    return this.hashString(r);
-  }
-  hashString(e) {
-    let t = 0;
-    for (let i = 0; i < e.length; i++) {
-      const n = e.charCodeAt(i);
-      t = (t << 5) - t + n, t = t & t;
-    }
-    return t.toString(36);
-  }
-  async id(e, t = !1) {
-    if (!k(e))
-      throw new Error("User data must be an object");
-    if (e.email && !ne(e.email))
-      throw new Error("Invalid email provided");
-    if (!e.id || !O(e.id))
-      throw new Error("User ID must be a string");
-    const i = e.id;
-    if (this.persistence.set("userId", i), this.persistence.set("userProps", e), !t) {
-      const n = {
-        ...e,
-        anonymous_id: this.anonymousId
-      };
-      await this.track("user_identify", n);
-    }
-    this.logger.info("User identified:", e);
-  }
-  track(e, t, i = !1) {
-    this.trackInternal(e, t, i);
-  }
-  trackInternal(e, t, i = !1) {
-    if (!O(e))
-      throw new Error("Event name must be a string");
-    if (t !== void 0 && (typeof t != "object" || t === null || Array.isArray(t)))
-      throw new Error("Event payload must be a non-null object and not an array");
-    const n = this.createEventPayload(e, t);
-    try {
-      if (i) {
-        this.transport.send(n), this.logger.debug(`Event sent: ${e}`, [n]);
-        return;
-      }
-      this.retryQueue.add(n), this.logger.debug(`Event tracked: ${e}`, [n]);
-    } catch (r) {
-      throw this.logger.error(`Failed to track event: ${e}`, r), new Error(`Failed to track event: ${e}`);
-    }
-  }
-  rawTrack(e) {
-    if (!k(e))
-      throw new Error("Event payload must be an object");
-    this.track("raw", e);
-  }
-  async group(e, t = !1) {
-    if (!k(e))
-      throw new Error("Company properties must be an object");
-    if (!e.id || !e.name || !e.created_at)
-      throw new Error("Company properties must include id, name, and created_at");
-    this.persistence.set("companyProps", e), t || await this.track("group", e), this.logger.info("Company identified:", e);
-  }
-  createEventPayload(e, t) {
-    const i = this.persistence.get("userProps") || {}, n = this.persistence.get("companyProps") || void 0, r = this.persistence.get("userId"), o = this.persistence.get("global_props") || {}, c = this.persistence.get(`props_${e}`) || {};
-    let l = t || {};
-    const a = {
-      event_id: "",
-      user: {
-        anonymous_id: this.anonymousId,
-        id: r,
-        ...i
-      },
-      ...n && { company: n },
-      ids: this.getThirdPartyIds(),
-      utc_time: (/* @__PURE__ */ new Date()).toISOString(),
-      local_tz_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
-      api_key: this.config.key,
-      src: "usermaven",
-      event_type: e,
-      namespace: this.namespace,
-      ...o,
-      ...c
-    };
-    if (e === "$autocapture") {
-      const g = this.processAutocaptureAttributes(t || {});
-      a.autocapture_attributes = g;
-    } else
-      Array.isArray(this.config.propertyBlacklist) && this.config.propertyBlacklist.forEach((g) => {
-        delete l[g];
-      }), a.event_attributes = l;
-    return u() && (a.referer = document.referrer, a.url = window.location.href, a.page_title = document.title, a.doc_path = window.location.pathname, a.doc_host = window.location.hostname, a.doc_search = window.location.search, a.screen_resolution = `${window.screen.width}x${window.screen.height}`, a.vp_size = `${window.innerWidth}x${window.innerHeight}`, a.user_agent = navigator.userAgent, a.user_language = navigator.language, a.doc_encoding = document.characterSet, a.utm = this.getUtmParams()), a;
-  }
-  processAutocaptureAttributes(e) {
-    let t = {};
-    const i = e.$elements || [];
-    return i.length && (t = { ...i[0] }), t.el_text = t.$el_text || "", t.event_type = e.$event_type || "", ["$ce_version", "$event_type", "$initial_referrer", "$initial_referring_domain", "$referrer", "$referring_domain", "$elements"].forEach((n) => {
-      delete t[n];
-    }), delete t.$el_text, delete t.nth_child, delete t.nth_of_type, t;
-  }
-  getCookie(e) {
-    var t;
-    return ((t = this.cookieManager) == null ? void 0 : t.get(e)) || null;
-  }
-  getThirdPartyIds() {
-    const e = {};
-    if (u()) {
-      const t = this.getCookie("_fbp");
-      t && (e.fbp = t);
+};
+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" ;
     }
-    return e;
-  }
-  getUtmParams() {
-    const e = {}, t = oe(window.location.search);
-    return ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"].forEach((n) => {
-      t[n] && (e[n.replace("utm_", "")] = t[n]);
-    }), e;
-  }
-  pageview() {
-    u() ? this.track("pageview", {
-      url: window.location.href,
-      referrer: document.referrer,
-      title: document.title
-    }, !0) : this.logger.warn("Pageview tracking is not available in server-side environments");
-  }
-  setupPageLeaveTracking() {
-    if (!u()) return;
-    let e = !1, t = !1;
-    const i = () => {
-      !e && !t && (e = !0, this.track("$pageleave", {
-        url: window.location.href,
-        referrer: document.referrer,
-        title: document.title
-      }));
-    };
-    window.addEventListener("beforeunload", (r) => {
-      t = !0, setTimeout(() => {
-        t = !1;
-      }, 100);
-    }), document.addEventListener("visibilitychange", () => {
-      document.visibilityState === "hidden" && !t && i();
-    });
-    const n = history.pushState;
-    history.pushState = function() {
-      return i(), n.apply(this, arguments);
-    }, window.addEventListener("popstate", i);
-  }
-  getConfig() {
-    return this.config;
-  }
-  getLogger() {
-    return this.logger;
-  }
-  async reset(e = !1) {
-    if (this.persistence.clear(), e && this.cookieManager) {
-      const t = this.config.cookieName || `${this.namespace}_id_${this.config.key}`;
-      this.cookieManager.delete(t), this.anonymousId = this.getOrCreateAnonymousId();
+    // 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({ anonymous_id: this.cookiePolicy !== "strict"
+                    ? env.getAnonymousId({
+                        name: this.idCookieName,
+                        domain: this.cookieDomain,
+                        crossDomainLinking: this.crossDomainLinking,
+                    })
+                    : "" }, user), 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);
     }
-    this.logger.info("core state reset", { resetAnonId: e, namespace: this.namespace });
-  }
-  set(e, t) {
-    if (!k(e))
-      throw new Error("Properties must be an object");
-    const i = t == null ? void 0 : t.eventType, n = (t == null ? void 0 : t.persist) ?? !0;
-    if (i) {
-      let r = this.persistence.get(`props_${i}`) || {};
-      r = { ...r, ...e }, this.persistence.set(`props_${i}`, r);
-    } else {
-      let r = this.persistence.get("global_props") || {};
-      r = { ...r, ...e }, this.persistence.set("global_props", r);
-    }
-    n && this.persistence.save(), this.logger.debug("Properties set", {
-      properties: e,
-      eventType: i || "global",
-      persist: n
-    });
-  }
-  setUserId(e) {
-    this.persistence.set("userId", e);
-    let t = this.persistence.get("userProps") || {};
-    t.id = e, this.persistence.set("userProps", t), this.persistence.save();
-  }
-  unset(e, t) {
-    const i = t == null ? void 0 : t.eventType, n = (t == null ? void 0 : t.persist) ?? !0;
-    if (i) {
-      let r = this.persistence.get(`props_${i}`) || {};
-      delete r[e], this.persistence.set(`props_${i}`, r);
-    } else {
-      let r = this.persistence.get("global_props") || {};
-      delete r[e], this.persistence.set("global_props", r);
-    }
-    n && this.persistence.save(), this.logger.debug(`Property unset: ${e}`, `Event type: ${i || "global"}`);
-  }
-}
-function me(s) {
-  const e = JSON.parse(JSON.stringify(s)), t = S(e), i = { ...I, ...t };
-  if (!i.key)
-    throw new Error("API key is required!");
-  if (!i.trackingHost)
-    throw new Error("Tracking host is required!");
-  return new pe(i);
+    addEventListener('hashchange', page);
 }
-function ye(s) {
-  var n;
-  const e = {
-    key: s.getAttribute("data-key") || void 0,
-    trackingHost: s.getAttribute("data-tracking-host") || "https://events.usermaven.com",
-    logLevel: ae(s.getAttribute("data-log-level")),
-    autocapture: s.getAttribute("data-autocapture") === "true",
-    formTracking: s.getAttribute("data-form-tracking") === "true" ? "all" : !1,
-    autoPageview: s.getAttribute("data-auto-pageview") === "true",
-    useBeaconApi: s.getAttribute("data-use-beacon-api") === "true",
-    forceUseFetch: s.getAttribute("data-force-use-fetch") === "true",
-    gaHook: s.getAttribute("data-ga-hook") === "true",
-    segmentHook: s.getAttribute("data-segment-hook") === "true",
-    randomizeUrl: s.getAttribute("data-randomize-url") === "true",
-    capture3rdPartyCookies: s.getAttribute("data-capture-3rd-party-cookies") === "false" ? !1 : void 0,
-    idMethod: s.getAttribute("data-id-method") || void 0,
-    privacyPolicy: s.getAttribute("data-privacy-policy") === "strict" ? "strict" : void 0,
-    ipPolicy: s.getAttribute("data-ip-policy") || void 0,
-    cookiePolicy: s.getAttribute("data-cookie-policy") || void 0,
-    minSendTimeout: parseInt(s.getAttribute("data-min-send-timeout") || "", 10) || void 0,
-    maxSendTimeout: parseInt(s.getAttribute("data-max-send-timeout") || "", 10) || void 0,
-    maxSendAttempts: parseInt(s.getAttribute("data-max-send-attempts") || "", 10) || void 0,
-    propertiesStringMaxLength: parseInt(s.getAttribute("data-properties-string-max-length") || "", 10) || null,
-    propertyBlacklist: ((n = s.getAttribute("data-property-blacklist")) == null ? void 0 : n.split(",")) || void 0,
-    exclude: s.getAttribute("data-exclude") || void 0,
-    namespace: s.getAttribute("data-namespace") || void 0,
-    crossDomainLinking: s.getAttribute("data-cross-domain-linking") !== "false",
-    domains: s.getAttribute("data-domains") || void 0,
-    maskAllText: s.getAttribute("data-mask-all-text") === "true",
-    maskAllElementAttributes: s.getAttribute("data-mask-all-element-attributes") === "true"
-  }, t = me(e), i = e.namespace || "usermaven";
-  u() && t.pageview(), we(i, t);
-}
-function we(s, e) {
-  let t = !1;
-  const i = [], n = [];
-  function r() {
-    for (; i.length > 0; ) {
-      const a = i.shift();
-      a && window[s].apply(null, a);
+function interceptSegmentCalls(t) {
+    var win = window;
+    if (!win.analytics) {
+        win.analytics = [];
     }
-  }
-  function o() {
-    n.forEach((a) => a()), n.length = 0;
-  }
-  window[s] = function(...a) {
-    const g = a[0];
-    if (g === "onLoad") {
-      typeof a[1] == "function" && (t ? a[1]() : n.push(a[1]));
-      return;
-    }
-    if (!t) {
-      i.push(a);
-      return;
-    }
-    if (typeof e[g] == "function")
-      return e[g].apply(e, a.slice(1));
-    console.error(`Method ${g} not found on UsermavenClient`);
-  };
-  const c = `${s}Q`, l = window[c] || [];
-  for (window[c] = l, l.push = function(...a) {
-    return window[s].apply(null, a), Array.prototype.push.apply(this, a);
-  }, setTimeout(() => {
-    t = !0, r(), o(), console.log(`Usermaven client for namespace ${s} is ready`);
-  }, 0); l.length > 0; ) {
-    const a = l.shift();
-    a && i.push(a);
-  }
+    t.interceptAnalytics(win.analytics);
 }
-u() && function(s, e) {
-  const t = s.currentScript;
-  function i() {
-    t && t.src.includes("lib.js") && ye(t);
-  }
-  typeof e < "u" && (s.readyState === "loading" ? s.addEventListener("DOMContentLoaded", i) : i());
-}(document, window);
 
 function createClient(params) {
-    return me(params);
+    return usermavenClient(params);
 }
 
 function useUsermaven() {
     const client = useContext(UsermavenContext);
     if (!client) {
-        throw new Error("Before calling useUsermaven() hook, please wrap your component into <UsermavenProvider />. Read more in http://jitsu.com/docs/sending-data/js-sdk/react");
+        throw new Error("Before calling useUsermaven() hook, please wrap your component into <JitsuProvider />. Read more in https://usermaven.com/docs/integrations/next");
     }
     const id = useCallback((userData, doNotSendEvent) => client === null || client === void 0 ? void 0 : client.id(userData, doNotSendEvent), [client]);
     const trackPageView = useCallback(() => client === null || client === void 0 ? void 0 : client.track('pageview'), [client]);
     const track = useCallback((typeName, payload) => client === null || client === void 0 ? void 0 : client.track(typeName, payload), [client]);
     const rawTrack = useCallback((payload) => client === null || client === void 0 ? void 0 : client.rawTrack(payload), [client]);
-    const set = useCallback((properties, opts) => client === null || client === void 0 ? void 0 : client.set(properties, opts), [client]);
-    const unset = useCallback((propertyName, opts) => client === null || client === void 0 ? void 0 : client.unset(propertyName, opts), [client]);
+    const interceptAnalytics = useCallback((analytics) => client === null || client === void 0 ? void 0 : client.interceptAnalytics(analytics), [client]);
     return Object.assign(Object.assign({}, client), { id,
         track,
         trackPageView,
         rawTrack,
-        set,
-        unset });
+        interceptAnalytics });
 }
 
-function useUrlChange() {
-    const [url, setUrl] = useState('');
+function usePageView(usermaven, opts = {}) {
+    const router = useRouter();
     useEffect(() => {
-        setUrl(window.location.href);
-        const handleUrlChange = () => {
-            setUrl(window.location.href);
-        };
-        window.addEventListener('popstate', handleUrlChange);
-        const originalPushState = window.history.pushState;
-        const originalReplaceState = window.history.replaceState;
-        window.history.pushState = function () {
-            originalPushState.apply(this, arguments);
-            handleUrlChange();
-        };
-        window.history.replaceState = function () {
-            originalReplaceState.apply(this, arguments);
-            handleUrlChange();
+        const handleRouteChange = () => {
+            if (opts.before) {
+                opts.before(usermaven);
+            }
+            usermaven.track((opts === null || opts === void 0 ? void 0 : opts.typeName) || 'pageview', opts.payload);
         };
+        handleRouteChange();
+        router.events.on('routeChangeComplete', handleRouteChange);
         return () => {
-            window.removeEventListener('popstate', handleUrlChange);
-            window.history.pushState = originalPushState;
-            window.history.replaceState = originalReplaceState;
+            router.events.off('routeChangeComplete', handleRouteChange);
         };
-    }, []);
-    return url;
-}
-function usePageView(usermaven, opts = {}) {
-    const url = useUrlChange();
-    const trackPageView = useCallback(() => {
-        if (typeof window === 'undefined') {
-            return;
-        }
-        if (opts.before) {
-            opts.before(usermaven);
-        }
-        usermaven.track((opts === null || opts === void 0 ? void 0 : opts.typeName) || 'pageview', Object.assign(Object.assign({}, opts.payload), { url: window.location.href, path: window.location.pathname, referrer: document.referrer, title: document.title }));
-    }, [usermaven, opts.before, opts.typeName, opts.payload]);
-    useEffect(() => {
-        if (url) {
-            trackPageView();
-        }
-    }, [url, trackPageView]);
+    }, [router.events, usermaven.track, opts.payload, opts.before]);
     return usermaven;
 }
 
@@ -1617,4 +2878,4 @@ function middlewareEnv(req, res, opts = {}) {
     };
 }
 
-export { UsermavenContext, UsermavenProvider, createClient, middlewareEnv, usePageView, useUsermaven };
+export { UsermavenContext, JitsuProvider as UsermavenProvider, createClient, middlewareEnv, usePageView, useUsermaven };