@leanbase.com/js 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -2,65 +2,2854 @@
 
 var core = require('@posthog/core');
 
-const version = '0.1.1';
+const breaker = {};
+const ArrayProto = Array.prototype;
+const nativeForEach = ArrayProto.forEach;
+const nativeIndexOf = ArrayProto.indexOf;
+const win = typeof window !== 'undefined' ? window : undefined;
+const global = typeof globalThis !== 'undefined' ? globalThis : win;
+const navigator$1 = global?.navigator;
+const document = global?.document;
+const location = global?.location;
+global?.fetch;
+global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : undefined;
+global?.AbortController;
+const userAgent = navigator$1?.userAgent;
+function eachArray(obj, iterator, thisArg) {
+  if (core.isArray(obj)) {
+    if (nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, thisArg);
+    } else if ('length' in obj && obj.length === +obj.length) {
+      for (let i = 0, l = obj.length; i < l; i++) {
+        if (i in obj && iterator.call(thisArg, obj[i], i) === breaker) {
+          return;
+        }
+      }
+    }
+  }
+}
+/**
+ * @param {*=} obj
+ * @param {function(...*)=} iterator
+ * @param {Object=} thisArg
+ */
+function each(obj, iterator, thisArg) {
+  if (core.isNullish(obj)) {
+    return;
+  }
+  if (core.isArray(obj)) {
+    return eachArray(obj, iterator, thisArg);
+  }
+  if (core.isFormData(obj)) {
+    for (const pair of obj.entries()) {
+      if (iterator.call(thisArg, pair[1], pair[0]) === breaker) {
+        return;
+      }
+    }
+    return;
+  }
+  for (const key in obj) {
+    if (core.hasOwnProperty.call(obj, key)) {
+      if (iterator.call(thisArg, obj[key], key) === breaker) {
+        return;
+      }
+    }
+  }
+}
+const extend = function (obj, ...args) {
+  eachArray(args, function (source) {
+    for (const prop in source) {
+      if (source[prop] !== void 0) {
+        obj[prop] = source[prop];
+      }
+    }
+  });
+  return obj;
+};
+const extendArray = function (obj, ...args) {
+  eachArray(args, function (source) {
+    eachArray(source, function (item) {
+      obj.push(item);
+    });
+  });
+  return obj;
+};
+const include = function (obj, target) {
+  let found = false;
+  if (core.isNull(obj)) {
+    return found;
+  }
+  if (nativeIndexOf && obj.indexOf === nativeIndexOf) {
+    return obj.indexOf(target) != -1;
+  }
+  each(obj, function (value) {
+    if (found || (found = value === target)) {
+      return breaker;
+    }
+    return;
+  });
+  return found;
+};
+/**
+ * Object.entries() polyfill
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
+ */
+function entries(obj) {
+  const ownProps = Object.keys(obj);
+  let i = ownProps.length;
+  const resArray = new Array(i); // preallocate the Array
+  while (i--) {
+    resArray[i] = [ownProps[i], obj[ownProps[i]]];
+  }
+  return resArray;
+}
+function addEventListener(element, event, callback, options) {
+  const {
+    capture = false,
+    passive = true
+  } = options ?? {};
+  // This is the only place where we are allowed to call this function
+  // because the whole idea is that we should be calling this instead of the built-in one
+  // eslint-disable-next-line posthog-js/no-add-event-listener
+  element?.addEventListener(event, callback, {
+    capture,
+    passive
+  });
+}
+const stripEmptyProperties = function (p) {
+  const ret = {};
+  each(p, function (v, k) {
+    if (core.isString(v) && v.length > 0 || core.isNumber(v)) {
+      ret[k] = v;
+    }
+  });
+  return ret;
+};
+const EXCLUDED_FROM_CROSS_SUBDOMAIN_COOKIE = ['herokuapp.com', 'vercel.app', 'netlify.app'];
+function isCrossDomainCookie(documentLocation) {
+  const hostname = documentLocation?.hostname;
+  if (!core.isString(hostname)) {
+    return false;
+  }
+  // split and slice isn't a great way to match arbitrary domains,
+  // but it's good enough for ensuring we only match herokuapp.com when it is the TLD
+  // for the hostname
+  const lastTwoParts = hostname.split('.').slice(-2).join('.');
+  for (const excluded of EXCLUDED_FROM_CROSS_SUBDOMAIN_COOKIE) {
+    if (lastTwoParts === excluded) {
+      return false;
+    }
+  }
+  return true;
+}
+/**
+ * Deep copies an object.
+ * It handles cycles by replacing all references to them with `undefined`
+ * Also supports customizing native values
+ *
+ * @param value
+ * @param customizer
+ * @returns {{}|undefined|*}
+ */
+function deepCircularCopy(value, customizer) {
+  const COPY_IN_PROGRESS_SET = new Set();
+  function internalDeepCircularCopy(value, key) {
+    if (value !== Object(value)) return customizer ? customizer(value, key) : value; // primitive value
+    if (COPY_IN_PROGRESS_SET.has(value)) return undefined;
+    COPY_IN_PROGRESS_SET.add(value);
+    let result;
+    if (core.isArray(value)) {
+      result = [];
+      eachArray(value, it => {
+        result.push(internalDeepCircularCopy(it));
+      });
+    } else {
+      result = {};
+      each(value, (val, key) => {
+        if (!COPY_IN_PROGRESS_SET.has(val)) {
+          result[key] = internalDeepCircularCopy(val, key);
+        }
+      });
+    }
+    return result;
+  }
+  return internalDeepCircularCopy(value);
+}
+function copyAndTruncateStrings(object, maxStringLength) {
+  return deepCircularCopy(object, value => {
+    if (core.isString(value) && !core.isNull(maxStringLength)) {
+      return value.slice(0, maxStringLength);
+    }
+    return value;
+  });
+}
+
+/*
+ * Constants
+ */
+/* PROPERTY KEYS */
+// This key is deprecated, but we want to check for it to see whether aliasing is allowed.
+const PEOPLE_DISTINCT_ID_KEY = '$people_distinct_id';
+const DISTINCT_ID = 'distinct_id';
+const ALIAS_ID_KEY = '__alias';
+const CAMPAIGN_IDS_KEY = '__cmpns';
+const EVENT_TIMERS_KEY = '__timers';
+const AUTOCAPTURE_DISABLED_SERVER_SIDE = '$autocapture_disabled_server_side';
+const HEATMAPS_ENABLED_SERVER_SIDE = '$heatmaps_enabled_server_side';
+const ERROR_TRACKING_SUPPRESSION_RULES = '$error_tracking_suppression_rules';
+// @deprecated can be removed along with eager loaded replay
+const SESSION_RECORDING_ENABLED_SERVER_SIDE = '$session_recording_enabled_server_side';
+const SESSION_ID = '$sesid';
+const SESSION_RECORDING_IS_SAMPLED = '$session_is_sampled';
+const ENABLED_FEATURE_FLAGS = '$enabled_feature_flags';
+const PERSISTENCE_EARLY_ACCESS_FEATURES = '$early_access_features';
+const PERSISTENCE_FEATURE_FLAG_DETAILS = '$feature_flag_details';
+const STORED_PERSON_PROPERTIES_KEY = '$stored_person_properties';
+const STORED_GROUP_PROPERTIES_KEY = '$stored_group_properties';
+const SURVEYS = '$surveys';
+const FLAG_CALL_REPORTED = '$flag_call_reported';
+const USER_STATE = '$user_state';
+const CLIENT_SESSION_PROPS = '$client_session_props';
+const CAPTURE_RATE_LIMIT = '$capture_rate_limit';
+/** @deprecated Delete this when INITIAL_PERSON_INFO has been around for long enough to ignore backwards compat */
+const INITIAL_CAMPAIGN_PARAMS = '$initial_campaign_params';
+/** @deprecated Delete this when INITIAL_PERSON_INFO has been around for long enough to ignore backwards compat */
+const INITIAL_REFERRER_INFO = '$initial_referrer_info';
+const INITIAL_PERSON_INFO = '$initial_person_info';
+const ENABLE_PERSON_PROCESSING = '$epp';
+const COOKIELESS_MODE_FLAG_PROPERTY = '$cookieless_mode';
+// These are properties that are reserved and will not be automatically included in events
+const PERSISTENCE_RESERVED_PROPERTIES = [PEOPLE_DISTINCT_ID_KEY, ALIAS_ID_KEY, CAMPAIGN_IDS_KEY, EVENT_TIMERS_KEY, SESSION_RECORDING_ENABLED_SERVER_SIDE, HEATMAPS_ENABLED_SERVER_SIDE, SESSION_ID, ENABLED_FEATURE_FLAGS, ERROR_TRACKING_SUPPRESSION_RULES, USER_STATE, PERSISTENCE_EARLY_ACCESS_FEATURES, PERSISTENCE_FEATURE_FLAG_DETAILS, STORED_GROUP_PROPERTIES_KEY, STORED_PERSON_PROPERTIES_KEY, SURVEYS, FLAG_CALL_REPORTED, CLIENT_SESSION_PROPS, CAPTURE_RATE_LIMIT, INITIAL_CAMPAIGN_PARAMS, INITIAL_REFERRER_INFO, ENABLE_PERSON_PROCESSING, INITIAL_PERSON_INFO,
+// Ignore posthog persisted properties
+core.PostHogPersistedProperty.Queue, core.PostHogPersistedProperty.FeatureFlagDetails, core.PostHogPersistedProperty.FlagsEndpointWasHit, core.PostHogPersistedProperty.AnonymousId, core.PostHogPersistedProperty.RemoteConfig, core.PostHogPersistedProperty.Surveys, core.PostHogPersistedProperty.FeatureFlags];
 
-// Simple logger with [Leanbase] prefix
+/* eslint-disable no-console */
 const PREFIX = '[Leanbase]';
 const logger = {
   info: (...args) => {
     if (typeof console !== 'undefined') {
-      // eslint-disable-next-line no-console
       console.log(PREFIX, ...args);
     }
-  },
-  warn: (...args) => {
-    if (typeof console !== 'undefined') {
-      // eslint-disable-next-line no-console
-      console.warn(PREFIX, ...args);
+  },
+  warn: (...args) => {
+    if (typeof console !== 'undefined') {
+      console.warn(PREFIX, ...args);
+    }
+  },
+  error: (...args) => {
+    if (typeof console !== 'undefined') {
+      console.error(PREFIX, ...args);
+    }
+  },
+  critical: (...args) => {
+    if (typeof console !== 'undefined') {
+      console.error(PREFIX, 'CRITICAL:', ...args);
+    }
+  }
+};
+
+/**
+ * uuidv7: An experimental implementation of the proposed UUID Version 7
+ *
+ * @license Apache-2.0
+ * @copyright 2021-2023 LiosK
+ * @packageDocumentation
+ *
+ * from https://github.com/LiosK/uuidv7/blob/e501462ea3d23241de13192ceae726956f9b3b7d/src/index.ts
+ */
+// polyfill for IE11
+if (!Math.trunc) {
+  Math.trunc = function (v) {
+    return v < 0 ? Math.ceil(v) : Math.floor(v);
+  };
+}
+// polyfill for IE11
+if (!Number.isInteger) {
+  Number.isInteger = function (value) {
+    return core.isNumber(value) && isFinite(value) && Math.floor(value) === value;
+  };
+}
+const DIGITS = '0123456789abcdef';
+/** Represents a UUID as a 16-byte byte array. */
+class UUID {
+  /** @param bytes - The 16-byte byte array representation. */
+  constructor(bytes) {
+    this.bytes = bytes;
+    if (bytes.length !== 16) {
+      throw new TypeError('not 128-bit length');
+    }
+  }
+  /**
+   * Builds a byte array from UUIDv7 field values.
+   *
+   * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
+   * @param randA - A 12-bit `rand_a` field value.
+   * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
+   * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
+   */
+  static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
+    if (!Number.isInteger(unixTsMs) || !Number.isInteger(randA) || !Number.isInteger(randBHi) || !Number.isInteger(randBLo) || unixTsMs < 0 || randA < 0 || randBHi < 0 || randBLo < 0 || unixTsMs > 281474976710655 || randA > 0xfff || randBHi > 1073741823 || randBLo > 4294967295) {
+      throw new RangeError('invalid field value');
+    }
+    const bytes = new Uint8Array(16);
+    bytes[0] = unixTsMs / 2 ** 40;
+    bytes[1] = unixTsMs / 2 ** 32;
+    bytes[2] = unixTsMs / 2 ** 24;
+    bytes[3] = unixTsMs / 2 ** 16;
+    bytes[4] = unixTsMs / 2 ** 8;
+    bytes[5] = unixTsMs;
+    bytes[6] = 0x70 | randA >>> 8;
+    bytes[7] = randA;
+    bytes[8] = 0x80 | randBHi >>> 24;
+    bytes[9] = randBHi >>> 16;
+    bytes[10] = randBHi >>> 8;
+    bytes[11] = randBHi;
+    bytes[12] = randBLo >>> 24;
+    bytes[13] = randBLo >>> 16;
+    bytes[14] = randBLo >>> 8;
+    bytes[15] = randBLo;
+    return new UUID(bytes);
+  }
+  /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
+  toString() {
+    let text = '';
+    for (let i = 0; i < this.bytes.length; i++) {
+      text = text + DIGITS.charAt(this.bytes[i] >>> 4) + DIGITS.charAt(this.bytes[i] & 0xf);
+      if (i === 3 || i === 5 || i === 7 || i === 9) {
+        text += '-';
+      }
+    }
+    if (text.length !== 36) {
+      // We saw one customer whose bundling code was mangling the UUID generation
+      // rather than accept a bad UUID, we throw an error here.
+      throw new Error('Invalid UUIDv7 was generated');
+    }
+    return text;
+  }
+  /** Creates an object from `this`. */
+  clone() {
+    return new UUID(this.bytes.slice(0));
+  }
+  /** Returns true if `this` is equivalent to `other`. */
+  equals(other) {
+    return this.compareTo(other) === 0;
+  }
+  /**
+   * Returns a negative integer, zero, or positive integer if `this` is less
+   * than, equal to, or greater than `other`, respectively.
+   */
+  compareTo(other) {
+    for (let i = 0; i < 16; i++) {
+      const diff = this.bytes[i] - other.bytes[i];
+      if (diff !== 0) {
+        return Math.sign(diff);
+      }
+    }
+    return 0;
+  }
+}
+/** Encapsulates the monotonic counter state. */
+class V7Generator {
+  constructor() {
+    this._timestamp = 0;
+    this._counter = 0;
+    this._random = new DefaultRandom();
+  }
+  /**
+   * Generates a new UUIDv7 object from the current timestamp, or resets the
+   * generator upon significant timestamp rollback.
+   *
+   * This method returns monotonically increasing UUIDs unless the up-to-date
+   * timestamp is significantly (by ten seconds or more) smaller than the one
+   * embedded in the immediately preceding UUID. If such a significant clock
+   * rollback is detected, this method resets the generator and returns a new
+   * UUID based on the current timestamp.
+   */
+  generate() {
+    const value = this.generateOrAbort();
+    if (!core.isUndefined(value)) {
+      return value;
+    } else {
+      // reset state and resume
+      this._timestamp = 0;
+      const valueAfterReset = this.generateOrAbort();
+      if (core.isUndefined(valueAfterReset)) {
+        throw new Error('Could not generate UUID after timestamp reset');
+      }
+      return valueAfterReset;
+    }
+  }
+  /**
+   * Generates a new UUIDv7 object from the current timestamp, or returns
+   * `undefined` upon significant timestamp rollback.
+   *
+   * This method returns monotonically increasing UUIDs unless the up-to-date
+   * timestamp is significantly (by ten seconds or more) smaller than the one
+   * embedded in the immediately preceding UUID. If such a significant clock
+   * rollback is detected, this method aborts and returns `undefined`.
+   */
+  generateOrAbort() {
+    const MAX_COUNTER = 4398046511103;
+    const ROLLBACK_ALLOWANCE = 10000; // 10 seconds
+    const ts = Date.now();
+    if (ts > this._timestamp) {
+      this._timestamp = ts;
+      this._resetCounter();
+    } else if (ts + ROLLBACK_ALLOWANCE > this._timestamp) {
+      // go on with previous timestamp if new one is not much smaller
+      this._counter++;
+      if (this._counter > MAX_COUNTER) {
+        // increment timestamp at counter overflow
+        this._timestamp++;
+        this._resetCounter();
+      }
+    } else {
+      // abort if clock went backwards to unbearable extent
+      return undefined;
+    }
+    return UUID.fromFieldsV7(this._timestamp, Math.trunc(this._counter / 2 ** 30), this._counter & 2 ** 30 - 1, this._random.nextUint32());
+  }
+  /** Initializes the counter at a 42-bit random integer. */
+  _resetCounter() {
+    this._counter = this._random.nextUint32() * 0x400 + (this._random.nextUint32() & 0x3ff);
+  }
+}
+/** Stores `crypto.getRandomValues()` available in the environment. */
+let getRandomValues = buffer => {
+  // fall back on Math.random() unless the flag is set to true
+  // TRICKY: don't use the isUndefined method here as can't pass the reference
+  if (typeof UUIDV7_DENY_WEAK_RNG !== 'undefined' && UUIDV7_DENY_WEAK_RNG) {
+    throw new Error('no cryptographically strong RNG available');
+  }
+  for (let i = 0; i < buffer.length; i++) {
+    buffer[i] = Math.trunc(Math.random() * 65536) * 65536 + Math.trunc(Math.random() * 65536);
+  }
+  return buffer;
+};
+// detect Web Crypto API
+if (win && !core.isUndefined(win.crypto) && crypto.getRandomValues) {
+  getRandomValues = buffer => crypto.getRandomValues(buffer);
+}
+/**
+ * Wraps `crypto.getRandomValues()` and compatibles to enable buffering; this
+ * uses a small buffer by default to avoid unbearable throughput decline in some
+ * environments as well as the waste of time and space for unused values.
+ */
+class DefaultRandom {
+  constructor() {
+    this._buffer = new Uint32Array(8);
+    this._cursor = Infinity;
+  }
+  nextUint32() {
+    if (this._cursor >= this._buffer.length) {
+      getRandomValues(this._buffer);
+      this._cursor = 0;
+    }
+    return this._buffer[this._cursor++];
+  }
+}
+let defaultGenerator;
+/**
+ * Generates a UUIDv7 string.
+ *
+ * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+ * ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
+ */
+const uuidv7 = () => uuidv7obj().toString();
+/** Generates a UUIDv7 object. */
+const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
+
+// we store the discovered subdomain in memory because it might be read multiple times
+let firstNonPublicSubDomain = '';
+/**
+ * Browsers don't offer a way to check if something is a public suffix
+ * e.g. `.com.au`, `.io`, `.org.uk`
+ *
+ * But they do reject cookies set on public suffixes
+ * Setting a cookie on `.co.uk` would mean it was sent for every `.co.uk` site visited
+ *
+ * So, we can use this to check if a domain is a public suffix
+ * by trying to set a cookie on a subdomain of the provided hostname
+ * until the browser accepts it
+ *
+ * inspired by https://github.com/AngusFu/browser-root-domain
+ */
+function seekFirstNonPublicSubDomain(hostname, cookieJar = document) {
+  if (firstNonPublicSubDomain) {
+    return firstNonPublicSubDomain;
+  }
+  if (!cookieJar) {
+    return '';
+  }
+  if (['localhost', '127.0.0.1'].includes(hostname)) return '';
+  const list = hostname.split('.');
+  let len = Math.min(list.length, 8); // paranoia - we know this number should be small
+  const key = 'dmn_chk_' + uuidv7();
+  while (!firstNonPublicSubDomain && len--) {
+    const candidate = list.slice(len).join('.');
+    const candidateCookieValue = key + '=1;domain=.' + candidate + ';path=/';
+    // try to set cookie, include a short expiry in seconds since we'll check immediately
+    cookieJar.cookie = candidateCookieValue + ';max-age=3';
+    if (cookieJar.cookie.includes(key)) {
+      // the cookie was accepted by the browser, remove the test cookie
+      cookieJar.cookie = candidateCookieValue + ';max-age=0';
+      firstNonPublicSubDomain = candidate;
+    }
+  }
+  return firstNonPublicSubDomain;
+}
+const DOMAIN_MATCH_REGEX = /[a-z0-9][a-z0-9-]+\.[a-z]{2,}$/i;
+const originalCookieDomainFn = hostname => {
+  const matches = hostname.match(DOMAIN_MATCH_REGEX);
+  return matches ? matches[0] : '';
+};
+function chooseCookieDomain(hostname, cross_subdomain) {
+  if (cross_subdomain) {
+    // NOTE: Could we use this for cross domain tracking?
+    let matchedSubDomain = seekFirstNonPublicSubDomain(hostname);
+    if (!matchedSubDomain) {
+      const originalMatch = originalCookieDomainFn(hostname);
+      if (originalMatch !== matchedSubDomain) {
+        logger.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain);
+      }
+      matchedSubDomain = originalMatch;
+    }
+    return matchedSubDomain ? '; domain=.' + matchedSubDomain : '';
+  }
+  return '';
+}
+// Methods partially borrowed from quirksmode.org/js/cookies.html
+const cookieStore = {
+  _is_supported: () => !!document,
+  _error: function (msg) {
+    logger.error('cookieStore error: ' + msg);
+  },
+  _get: function (name) {
+    if (!document) {
+      return;
+    }
+    try {
+      const nameEQ = name + '=';
+      const ca = document.cookie.split(';').filter(x => x.length);
+      for (let i = 0; i < ca.length; i++) {
+        let 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 {}
+    return null;
+  },
+  _parse: function (name) {
+    let cookie;
+    try {
+      cookie = JSON.parse(cookieStore._get(name)) || {};
+    } catch {
+      // noop
+    }
+    return cookie;
+  },
+  _set: function (name, value, days, cross_subdomain, is_secure) {
+    if (!document) {
+      return;
+    }
+    try {
+      let expires = '',
+        secure = '';
+      const cdomain = chooseCookieDomain(document.location.hostname, cross_subdomain);
+      if (days) {
+        const date = new Date();
+        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+        expires = '; expires=' + date.toUTCString();
+      }
+      if (is_secure) {
+        secure = '; secure';
+      }
+      const new_cookie_val = name + '=' + encodeURIComponent(JSON.stringify(value)) + expires + '; SameSite=Lax; path=/' + cdomain + secure;
+      // 4096 bytes is the size at which some browsers (e.g. firefox) will not store a cookie, warn slightly before that
+      if (new_cookie_val.length > 4096 * 0.9) {
+        logger.warn('cookieStore warning: large cookie, len=' + new_cookie_val.length);
+      }
+      document.cookie = new_cookie_val;
+      return new_cookie_val;
+    } catch {
+      return;
+    }
+  },
+  _remove: function (name, cross_subdomain) {
+    if (!document?.cookie) {
+      return;
+    }
+    try {
+      cookieStore._set(name, '', -1, cross_subdomain);
+    } catch {
+      return;
+    }
+  }
+};
+let _localStorage_supported = null;
+const localStore = {
+  _is_supported: function () {
+    if (!core.isNull(_localStorage_supported)) {
+      return _localStorage_supported;
+    }
+    let supported = true;
+    if (!core.isUndefined(win)) {
+      try {
+        const key = '__mplssupport__',
+          val = 'xyz';
+        localStore._set(key, val);
+        if (localStore._get(key) !== '"xyz"') {
+          supported = false;
+        }
+        localStore._remove(key);
+      } catch {
+        supported = false;
+      }
+    } else {
+      supported = false;
+    }
+    if (!supported) {
+      logger.error('localStorage unsupported; falling back to cookie store');
+    }
+    _localStorage_supported = supported;
+    return supported;
+  },
+  _error: function (msg) {
+    logger.error('localStorage error: ' + msg);
+  },
+  _get: function (name) {
+    try {
+      return win?.localStorage.getItem(name);
+    } catch (err) {
+      localStore._error(err);
+    }
+    return null;
+  },
+  _parse: function (name) {
+    try {
+      return JSON.parse(localStore._get(name)) || {};
+    } catch {
+      // noop
+    }
+    return null;
+  },
+  _set: function (name, value) {
+    try {
+      win?.localStorage.setItem(name, JSON.stringify(value));
+    } catch (err) {
+      localStore._error(err);
+    }
+  },
+  _remove: function (name) {
+    try {
+      win?.localStorage.removeItem(name);
+    } catch (err) {
+      localStore._error(err);
+    }
+  }
+};
+// Use localstorage for most data but still use cookie for COOKIE_PERSISTED_PROPERTIES
+// This solves issues with cookies having too much data in them causing headers too large
+// Also makes sure we don't have to send a ton of data to the server
+const COOKIE_PERSISTED_PROPERTIES = [DISTINCT_ID, SESSION_ID, SESSION_RECORDING_IS_SAMPLED, ENABLE_PERSON_PROCESSING, INITIAL_PERSON_INFO];
+const localPlusCookieStore = {
+  ...localStore,
+  _parse: function (name) {
+    try {
+      let cookieProperties = {};
+      try {
+        // See if there's a cookie stored with data.
+        cookieProperties = cookieStore._parse(name) || {};
+      } catch {}
+      const value = extend(cookieProperties, JSON.parse(localStore._get(name) || '{}'));
+      localStore._set(name, value);
+      return value;
+    } catch {
+      // noop
+    }
+    return null;
+  },
+  _set: function (name, value, days, cross_subdomain, is_secure, debug) {
+    try {
+      localStore._set(name, value, undefined, undefined, debug);
+      const cookiePersistedProperties = {};
+      COOKIE_PERSISTED_PROPERTIES.forEach(key => {
+        if (value[key]) {
+          cookiePersistedProperties[key] = value[key];
+        }
+      });
+      if (Object.keys(cookiePersistedProperties).length) {
+        cookieStore._set(name, cookiePersistedProperties, days, cross_subdomain, is_secure, debug);
+      }
+    } catch (err) {
+      localStore._error(err);
+    }
+  },
+  _remove: function (name, cross_subdomain) {
+    try {
+      win?.localStorage.removeItem(name);
+      cookieStore._remove(name, cross_subdomain);
+    } catch (err) {
+      localStore._error(err);
+    }
+  }
+};
+const memoryStorage = {};
+// Storage that only lasts the length of the pageview if we don't want to use cookies
+const memoryStore = {
+  _is_supported: function () {
+    return true;
+  },
+  _error: function (msg) {
+    logger.error('memoryStorage error: ' + msg);
+  },
+  _get: function (name) {
+    return memoryStorage[name] || null;
+  },
+  _parse: function (name) {
+    return memoryStorage[name] || null;
+  },
+  _set: function (name, value) {
+    memoryStorage[name] = value;
+  },
+  _remove: function (name) {
+    delete memoryStorage[name];
+  }
+};
+let sessionStorageSupported = null;
+// Storage that only lasts the length of a tab/window. Survives page refreshes
+const sessionStore = {
+  _is_supported: function () {
+    if (!core.isNull(sessionStorageSupported)) {
+      return sessionStorageSupported;
+    }
+    sessionStorageSupported = true;
+    if (!core.isUndefined(win)) {
+      try {
+        const key = '__support__',
+          val = 'xyz';
+        sessionStore._set(key, val);
+        if (sessionStore._get(key) !== '"xyz"') {
+          sessionStorageSupported = false;
+        }
+        sessionStore._remove(key);
+      } catch {
+        sessionStorageSupported = false;
+      }
+    } else {
+      sessionStorageSupported = false;
+    }
+    return sessionStorageSupported;
+  },
+  _error: function (msg) {
+    logger.error('sessionStorage error: ', msg);
+  },
+  _get: function (name) {
+    try {
+      return win?.sessionStorage.getItem(name);
+    } catch (err) {
+      sessionStore._error(err);
+    }
+    return null;
+  },
+  _parse: function (name) {
+    try {
+      return JSON.parse(sessionStore._get(name)) || null;
+    } catch {
+      // noop
+    }
+    return null;
+  },
+  _set: function (name, value) {
+    try {
+      win?.sessionStorage.setItem(name, JSON.stringify(value));
+    } catch (err) {
+      sessionStore._error(err);
+    }
+  },
+  _remove: function (name) {
+    try {
+      win?.sessionStorage.removeItem(name);
+    } catch (err) {
+      sessionStore._error(err);
+    }
+  }
+};
+
+/**
+ * IE11 doesn't support `new URL`
+ * so we can create an anchor element and use that to parse the URL
+ * there's a lot of overlap between HTMLHyperlinkElementUtils and URL
+ * meaning useful properties like `pathname` are available on both
+ */
+const convertToURL = url => {
+  const location = document?.createElement('a');
+  if (core.isUndefined(location)) {
+    return null;
+  }
+  location.href = url;
+  return location;
+};
+// NOTE: Once we get rid of IE11/op_mini we can start using URLSearchParams
+const getQueryParam = function (url, param) {
+  const withoutHash = url.split('#')[0] || '';
+  // Split only on the first ? to sort problem out for those with multiple ?s
+  // and then remove them
+  const queryParams = withoutHash.split(/\?(.*)/)[1] || '';
+  const cleanedQueryParams = queryParams.replace(/^\?+/g, '');
+  const queryParts = cleanedQueryParams.split('&');
+  let keyValuePair;
+  for (let i = 0; i < queryParts.length; i++) {
+    const parts = queryParts[i].split('=');
+    if (parts[0] === param) {
+      keyValuePair = parts;
+      break;
+    }
+  }
+  if (!core.isArray(keyValuePair) || keyValuePair.length < 2) {
+    return '';
+  } else {
+    let result = keyValuePair[1];
+    try {
+      result = decodeURIComponent(result);
+    } catch {
+      logger.error('Skipping decoding for malformed query param: ' + result);
+    }
+    return result.replace(/\+/g, ' ');
+  }
+};
+// replace any query params in the url with the provided mask value. Tries to keep the URL as instant as possible,
+// including preserving malformed text in most cases
+const maskQueryParams = function (url, maskedParams, mask) {
+  if (!url || !maskedParams || !maskedParams.length) {
+    return url;
+  }
+  const splitHash = url.split('#');
+  const withoutHash = splitHash[0] || '';
+  const hash = splitHash[1];
+  const splitQuery = withoutHash.split('?');
+  const queryString = splitQuery[1];
+  const urlWithoutQueryAndHash = splitQuery[0];
+  const queryParts = (queryString || '').split('&');
+  // use an array of strings rather than an object to preserve ordering and duplicates
+  const paramStrings = [];
+  for (let i = 0; i < queryParts.length; i++) {
+    const keyValuePair = queryParts[i].split('=');
+    if (!core.isArray(keyValuePair)) {
+      continue;
+    } else if (maskedParams.includes(keyValuePair[0])) {
+      paramStrings.push(keyValuePair[0] + '=' + mask);
+    } else {
+      paramStrings.push(queryParts[i]);
+    }
+  }
+  let result = urlWithoutQueryAndHash;
+  if (queryString != null) {
+    result += '?' + paramStrings.join('&');
+  }
+  if (hash != null) {
+    result += '#' + hash;
+  }
+  return result;
+};
+
+/**
+ * this device detection code is (at time of writing) about 3% of the size of the entire library
+ * this is mostly because the identifiers user in regexes and results can't be minified away since
+ * they have meaning
+ *
+ * so, there are some pre-uglifying choices in the code to help reduce the size
+ * e.g. many repeated strings are stored as variables and then old-fashioned concatenated together
+ *
+ * TL;DR here be dragons
+ */
+const FACEBOOK = 'Facebook';
+const MOBILE = 'Mobile';
+const IOS = 'iOS';
+const ANDROID = 'Android';
+const TABLET = 'Tablet';
+const ANDROID_TABLET = ANDROID + ' ' + TABLET;
+const IPAD = 'iPad';
+const APPLE = 'Apple';
+const APPLE_WATCH = APPLE + ' Watch';
+const SAFARI = 'Safari';
+const BLACKBERRY = 'BlackBerry';
+const SAMSUNG = 'Samsung';
+const SAMSUNG_BROWSER = SAMSUNG + 'Browser';
+const SAMSUNG_INTERNET = SAMSUNG + ' Internet';
+const CHROME = 'Chrome';
+const CHROME_OS = CHROME + ' OS';
+const CHROME_IOS = CHROME + ' ' + IOS;
+const INTERNET_EXPLORER = 'Internet Explorer';
+const INTERNET_EXPLORER_MOBILE = INTERNET_EXPLORER + ' ' + MOBILE;
+const OPERA = 'Opera';
+const OPERA_MINI = OPERA + ' Mini';
+const EDGE = 'Edge';
+const MICROSOFT_EDGE = 'Microsoft ' + EDGE;
+const FIREFOX = 'Firefox';
+const FIREFOX_IOS = FIREFOX + ' ' + IOS;
+const NINTENDO = 'Nintendo';
+const PLAYSTATION = 'PlayStation';
+const XBOX = 'Xbox';
+const ANDROID_MOBILE = ANDROID + ' ' + MOBILE;
+const MOBILE_SAFARI = MOBILE + ' ' + SAFARI;
+const WINDOWS = 'Windows';
+const WINDOWS_PHONE = WINDOWS + ' Phone';
+const NOKIA = 'Nokia';
+const OUYA = 'Ouya';
+const GENERIC = 'Generic';
+const GENERIC_MOBILE = GENERIC + ' ' + MOBILE.toLowerCase();
+const GENERIC_TABLET = GENERIC + ' ' + TABLET.toLowerCase();
+const KONQUEROR = 'Konqueror';
+const BROWSER_VERSION_REGEX_SUFFIX = '(\\d+(\\.\\d+)?)';
+const DEFAULT_BROWSER_VERSION_REGEX = new RegExp('Version/' + BROWSER_VERSION_REGEX_SUFFIX);
+const XBOX_REGEX = new RegExp(XBOX, 'i');
+const PLAYSTATION_REGEX = new RegExp(PLAYSTATION + ' \\w+', 'i');
+const NINTENDO_REGEX = new RegExp(NINTENDO + ' \\w+', 'i');
+const BLACKBERRY_REGEX = new RegExp(BLACKBERRY + '|PlayBook|BB10', 'i');
+const windowsVersionMap = {
+  'NT3.51': 'NT 3.11',
+  'NT4.0': 'NT 4.0',
+  '5.0': '2000',
+  '5.1': 'XP',
+  '5.2': 'XP',
+  '6.0': 'Vista',
+  '6.1': '7',
+  '6.2': '8',
+  '6.3': '8.1',
+  '6.4': '10',
+  '10.0': '10'
+};
+/**
+ * Safari detection turns out to be complicated. For e.g. https://stackoverflow.com/a/29696509
+ * We can be slightly loose because some options have been ruled out (e.g. firefox on iOS)
+ * before this check is made
+ */
+function isSafari(userAgent) {
+  return core.includes(userAgent, SAFARI) && !core.includes(userAgent, CHROME) && !core.includes(userAgent, ANDROID);
+}
+const safariCheck = (ua, vendor) => vendor && core.includes(vendor, APPLE) || isSafari(ua);
+/**
+ * This function detects which browser is running this script.
+ * The order of the checks are important since many user agents
+ * include keywords used in later checks.
+ */
+const detectBrowser = function (user_agent, vendor) {
+  vendor = vendor || ''; // vendor is undefined for at least IE9
+  if (core.includes(user_agent, ' OPR/') && core.includes(user_agent, 'Mini')) {
+    return OPERA_MINI;
+  } else if (core.includes(user_agent, ' OPR/')) {
+    return OPERA;
+  } else if (BLACKBERRY_REGEX.test(user_agent)) {
+    return BLACKBERRY;
+  } else if (core.includes(user_agent, 'IE' + MOBILE) || core.includes(user_agent, 'WPDesktop')) {
+    return INTERNET_EXPLORER_MOBILE;
+  }
+  // https://developer.samsung.com/internet/user-agent-string-format
+  else if (core.includes(user_agent, SAMSUNG_BROWSER)) {
+    return SAMSUNG_INTERNET;
+  } else if (core.includes(user_agent, EDGE) || core.includes(user_agent, 'Edg/')) {
+    return MICROSOFT_EDGE;
+  } else if (core.includes(user_agent, 'FBIOS')) {
+    return FACEBOOK + ' ' + MOBILE;
+  } else if (core.includes(user_agent, 'UCWEB') || core.includes(user_agent, 'UCBrowser')) {
+    return 'UC Browser';
+  } else if (core.includes(user_agent, 'CriOS')) {
+    return CHROME_IOS; // why not just Chrome?
+  } else if (core.includes(user_agent, 'CrMo')) {
+    return CHROME;
+  } else if (core.includes(user_agent, CHROME)) {
+    return CHROME;
+  } else if (core.includes(user_agent, ANDROID) && core.includes(user_agent, SAFARI)) {
+    return ANDROID_MOBILE;
+  } else if (core.includes(user_agent, 'FxiOS')) {
+    return FIREFOX_IOS;
+  } else if (core.includes(user_agent.toLowerCase(), KONQUEROR.toLowerCase())) {
+    return KONQUEROR;
+  } else if (safariCheck(user_agent, vendor)) {
+    return core.includes(user_agent, MOBILE) ? MOBILE_SAFARI : SAFARI;
+  } else if (core.includes(user_agent, FIREFOX)) {
+    return FIREFOX;
+  } else if (core.includes(user_agent, 'MSIE') || core.includes(user_agent, 'Trident/')) {
+    return INTERNET_EXPLORER;
+  } else if (core.includes(user_agent, 'Gecko')) {
+    return FIREFOX;
+  }
+  return '';
+};
+const versionRegexes = {
+  [INTERNET_EXPLORER_MOBILE]: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [MICROSOFT_EDGE]: [new RegExp(EDGE + '?\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [CHROME]: [new RegExp('(' + CHROME + '|CrMo)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [CHROME_IOS]: [new RegExp('CriOS\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  'UC Browser': [new RegExp('(UCBrowser|UCWEB)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],
+  [MOBILE_SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],
+  [OPERA]: [new RegExp('(' + OPERA + '|OPR)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [FIREFOX]: [new RegExp(FIREFOX + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [FIREFOX_IOS]: [new RegExp('FxiOS\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [KONQUEROR]: [new RegExp('Konqueror[:/]?' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],
+  // not every blackberry user agent has the version after the name
+  [BLACKBERRY]: [new RegExp(BLACKBERRY + ' ' + BROWSER_VERSION_REGEX_SUFFIX), DEFAULT_BROWSER_VERSION_REGEX],
+  [ANDROID_MOBILE]: [new RegExp('android\\s' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],
+  [SAMSUNG_INTERNET]: [new RegExp(SAMSUNG_BROWSER + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+  [INTERNET_EXPLORER]: [new RegExp('(rv:|MSIE )' + BROWSER_VERSION_REGEX_SUFFIX)],
+  Mozilla: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)]
+};
+/**
+ * This function detects which browser version is running this script,
+ * parsing major and minor version (e.g., 42.1). User agent strings from:
+ * http://www.useragentstring.com/pages/useragentstring.php
+ *
+ * `navigator.vendor` is passed in and used to help with detecting certain browsers
+ * NB `navigator.vendor` is deprecated and not present in every browser
+ */
+const detectBrowserVersion = function (userAgent, vendor) {
+  const browser = detectBrowser(userAgent, vendor);
+  const regexes = versionRegexes[browser];
+  if (core.isUndefined(regexes)) {
+    return null;
+  }
+  for (let i = 0; i < regexes.length; i++) {
+    const regex = regexes[i];
+    const matches = userAgent.match(regex);
+    if (matches) {
+      return parseFloat(matches[matches.length - 2]);
+    }
+  }
+  return null;
+};
+// to avoid repeating regexes or calling them twice, we have an array of matches
+// the first regex that matches uses its matcher function to return the result
+const osMatchers = [[new RegExp(XBOX + '; ' + XBOX + ' (.*?)[);]', 'i'), match => {
+  return [XBOX, match && match[1] || ''];
+}], [new RegExp(NINTENDO, 'i'), [NINTENDO, '']], [new RegExp(PLAYSTATION, 'i'), [PLAYSTATION, '']], [BLACKBERRY_REGEX, [BLACKBERRY, '']], [new RegExp(WINDOWS, 'i'), (_, user_agent) => {
+  if (/Phone/.test(user_agent) || /WPDesktop/.test(user_agent)) {
+    return [WINDOWS_PHONE, ''];
+  }
+  // not all JS versions support negative lookbehind, so we need two checks here
+  if (new RegExp(MOBILE).test(user_agent) && !/IEMobile\b/.test(user_agent)) {
+    return [WINDOWS + ' ' + MOBILE, ''];
+  }
+  const match = /Windows NT ([0-9.]+)/i.exec(user_agent);
+  if (match && match[1]) {
+    const version = match[1];
+    let osVersion = windowsVersionMap[version] || '';
+    if (/arm/i.test(user_agent)) {
+      osVersion = 'RT';
+    }
+    return [WINDOWS, osVersion];
+  }
+  return [WINDOWS, ''];
+}], [/((iPhone|iPad|iPod).*?OS (\d+)_(\d+)_?(\d+)?|iPhone)/, match => {
+  if (match && match[3]) {
+    const versionParts = [match[3], match[4], match[5] || '0'];
+    return [IOS, versionParts.join('.')];
+  }
+  return [IOS, ''];
+}], [/(watch.*\/(\d+\.\d+\.\d+)|watch os,(\d+\.\d+),)/i, match => {
+  // e.g. Watch4,3/5.3.8 (16U680)
+  let version = '';
+  if (match && match.length >= 3) {
+    version = core.isUndefined(match[2]) ? match[3] : match[2];
+  }
+  return ['watchOS', version];
+}], [new RegExp('(' + ANDROID + ' (\\d+)\\.(\\d+)\\.?(\\d+)?|' + ANDROID + ')', 'i'), match => {
+  if (match && match[2]) {
+    const versionParts = [match[2], match[3], match[4] || '0'];
+    return [ANDROID, versionParts.join('.')];
+  }
+  return [ANDROID, ''];
+}], [/Mac OS X (\d+)[_.](\d+)[_.]?(\d+)?/i, match => {
+  const result = ['Mac OS X', ''];
+  if (match && match[1]) {
+    const versionParts = [match[1], match[2], match[3] || '0'];
+    result[1] = versionParts.join('.');
+  }
+  return result;
+}], [/Mac/i,
+// mop up a few non-standard UAs that should match mac
+['Mac OS X', '']], [/CrOS/, [CHROME_OS, '']], [/Linux|debian/i, ['Linux', '']]];
+const detectOS = function (user_agent) {
+  for (let i = 0; i < osMatchers.length; i++) {
+    const [rgex, resultOrFn] = osMatchers[i];
+    const match = rgex.exec(user_agent);
+    const result = match && (core.isFunction(resultOrFn) ? resultOrFn(match, user_agent) : resultOrFn);
+    if (result) {
+      return result;
+    }
+  }
+  return ['', ''];
+};
+const detectDevice = function (user_agent) {
+  if (NINTENDO_REGEX.test(user_agent)) {
+    return NINTENDO;
+  } else if (PLAYSTATION_REGEX.test(user_agent)) {
+    return PLAYSTATION;
+  } else if (XBOX_REGEX.test(user_agent)) {
+    return XBOX;
+  } else if (new RegExp(OUYA, 'i').test(user_agent)) {
+    return OUYA;
+  } else if (new RegExp('(' + WINDOWS_PHONE + '|WPDesktop)', 'i').test(user_agent)) {
+    return WINDOWS_PHONE;
+  } else if (/iPad/.test(user_agent)) {
+    return IPAD;
+  } else if (/iPod/.test(user_agent)) {
+    return 'iPod Touch';
+  } else if (/iPhone/.test(user_agent)) {
+    return 'iPhone';
+  } else if (/(watch)(?: ?os[,/]|\d,\d\/)[\d.]+/i.test(user_agent)) {
+    return APPLE_WATCH;
+  } else if (BLACKBERRY_REGEX.test(user_agent)) {
+    return BLACKBERRY;
+  } else if (/(kobo)\s(ereader|touch)/i.test(user_agent)) {
+    return 'Kobo';
+  } else if (new RegExp(NOKIA, 'i').test(user_agent)) {
+    return NOKIA;
+  } else if (
+  // Kindle Fire without Silk / Echo Show
+  /(kf[a-z]{2}wi|aeo[c-r]{2})( bui|\))/i.test(user_agent) ||
+  // Kindle Fire HD
+  /(kf[a-z]+)( bui|\)).+silk\//i.test(user_agent)) {
+    return 'Kindle Fire';
+  } else if (/(Android|ZTE)/i.test(user_agent)) {
+    if (!new RegExp(MOBILE).test(user_agent) || /(9138B|TB782B|Nexus [97]|pixel c|HUAWEISHT|BTV|noble nook|smart ultra 6)/i.test(user_agent)) {
+      if (/pixel[\daxl ]{1,6}/i.test(user_agent) && !/pixel c/i.test(user_agent) || /(huaweimed-al00|tah-|APA|SM-G92|i980|zte|U304AA)/i.test(user_agent) || /lmy47v/i.test(user_agent) && !/QTAQZ3/i.test(user_agent)) {
+        return ANDROID;
+      }
+      return ANDROID_TABLET;
+    } else {
+      return ANDROID;
+    }
+  } else if (new RegExp('(pda|' + MOBILE + ')', 'i').test(user_agent)) {
+    return GENERIC_MOBILE;
+  } else if (new RegExp(TABLET, 'i').test(user_agent) && !new RegExp(TABLET + ' pc', 'i').test(user_agent)) {
+    return GENERIC_TABLET;
+  } else {
+    return '';
+  }
+};
+const detectDeviceType = function (user_agent) {
+  const device = detectDevice(user_agent);
+  if (device === IPAD || device === ANDROID_TABLET || device === 'Kobo' || device === 'Kindle Fire' || device === GENERIC_TABLET) {
+    return TABLET;
+  } else if (device === NINTENDO || device === XBOX || device === PLAYSTATION || device === OUYA) {
+    return 'Console';
+  } else if (device === APPLE_WATCH) {
+    return 'Wearable';
+  } else if (device) {
+    return MOBILE;
+  } else {
+    return 'Desktop';
+  }
+};
+
+var version = "0.1.3";
+var packageInfo = {
+	version: version};
+
+const Config = {
+  LIB_VERSION: packageInfo.version
+};
+
+const URL_REGEX_PREFIX = 'https?://(.*)';
+// CAMPAIGN_PARAMS and EVENT_TO_PERSON_PROPERTIES should be kept in sync with
+// https://github.com/PostHog/posthog/blob/master/plugin-server/src/utils/db/utils.ts#L60
+// The list of campaign parameters that could be considered personal data under e.g. GDPR.
+// These can be masked in URLs and properties before being sent to posthog.
+const PERSONAL_DATA_CAMPAIGN_PARAMS = ['gclid',
+// google ads
+'gclsrc',
+// google ads 360
+'dclid',
+// google display ads
+'gbraid',
+// google ads, web to app
+'wbraid',
+// google ads, app to web
+'fbclid',
+// facebook
+'msclkid',
+// microsoft
+'twclid',
+// twitter
+'li_fat_id',
+// linkedin
+'igshid',
+// instagram
+'ttclid',
+// tiktok
+'rdt_cid',
+// reddit
+'epik',
+// pinterest
+'qclid',
+// quora
+'sccid',
+// snapchat
+'irclid',
+// impact
+'_kx' // klaviyo
+];
+const CAMPAIGN_PARAMS = extendArray(['utm_source', 'utm_medium', 'utm_campaign', 'utm_content', 'utm_term', 'gad_source',
+// google ads source
+'mc_cid' // mailchimp campaign id
+], PERSONAL_DATA_CAMPAIGN_PARAMS);
+const MASKED = '<masked>';
+// Campaign params that can be read from the cookie store
+const COOKIE_CAMPAIGN_PARAMS = ['li_fat_id' // linkedin
+];
+function getCampaignParams(customTrackedParams, maskPersonalDataProperties, customPersonalDataProperties) {
+  if (!document) {
+    return {};
+  }
+  const paramsToMask = maskPersonalDataProperties ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || []) : [];
+  // Initially get campaign params from the URL
+  const urlCampaignParams = _getCampaignParamsFromUrl(maskQueryParams(document.URL, paramsToMask, MASKED), customTrackedParams);
+  // But we can also get some of them from the cookie store
+  // For example: https://learn.microsoft.com/en-us/linkedin/marketing/conversions/enabling-first-party-cookies?view=li-lms-2025-05#reading-li_fat_id-from-cookies
+  const cookieCampaignParams = _getCampaignParamsFromCookie();
+  // Prefer the values found in the urlCampaignParams if possible
+  // `extend` will override the values if found in the second argument
+  return extend(cookieCampaignParams, urlCampaignParams);
+}
+function _getCampaignParamsFromUrl(url, customParams) {
+  const campaign_keywords = CAMPAIGN_PARAMS.concat(customParams || []);
+  const params = {};
+  each(campaign_keywords, function (kwkey) {
+    const kw = getQueryParam(url, kwkey);
+    params[kwkey] = kw ? kw : null;
+  });
+  return params;
+}
+function _getCampaignParamsFromCookie() {
+  const params = {};
+  each(COOKIE_CAMPAIGN_PARAMS, function (kwkey) {
+    const kw = cookieStore._get(kwkey);
+    params[kwkey] = kw ? kw : null;
+  });
+  return params;
+}
+function _getSearchEngine(referrer) {
+  if (!referrer) {
+    return null;
+  } else {
+    if (referrer.search(URL_REGEX_PREFIX + 'google.([^/?]*)') === 0) {
+      return 'google';
+    } else if (referrer.search(URL_REGEX_PREFIX + 'bing.com') === 0) {
+      return 'bing';
+    } else if (referrer.search(URL_REGEX_PREFIX + 'yahoo.com') === 0) {
+      return 'yahoo';
+    } else if (referrer.search(URL_REGEX_PREFIX + 'duckduckgo.com') === 0) {
+      return 'duckduckgo';
+    } else {
+      return null;
+    }
+  }
+}
+function _getSearchInfoFromReferrer(referrer) {
+  const search = _getSearchEngine(referrer);
+  const param = search != 'yahoo' ? 'q' : 'p';
+  const ret = {};
+  if (!core.isNull(search)) {
+    ret['$search_engine'] = search;
+    const keyword = document ? getQueryParam(document.referrer, param) : '';
+    if (keyword.length) {
+      ret['ph_keyword'] = keyword;
+    }
+  }
+  return ret;
+}
+function getSearchInfo() {
+  const referrer = document?.referrer;
+  if (!referrer) {
+    return {};
+  }
+  return _getSearchInfoFromReferrer(referrer);
+}
+function getBrowserLanguage() {
+  return navigator.language ||
+  // Any modern browser
+  navigator.userLanguage // IE11
+  ;
+}
+function getBrowserLanguagePrefix() {
+  const lang = getBrowserLanguage();
+  return typeof lang === 'string' ? lang.split('-')[0] : undefined;
+}
+function getReferrer() {
+  return document?.referrer || '$direct';
+}
+function getReferringDomain() {
+  if (!document?.referrer) {
+    return '$direct';
+  }
+  return convertToURL(document.referrer)?.host || '$direct';
+}
+function getReferrerInfo() {
+  return {
+    $referrer: getReferrer(),
+    $referring_domain: getReferringDomain()
+  };
+}
+function getPersonInfo(maskPersonalDataProperties, customPersonalDataProperties) {
+  const paramsToMask = maskPersonalDataProperties ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || []) : [];
+  const url = location?.href.substring(0, 1000);
+  // we're being a bit more economical with bytes here because this is stored in the cookie
+  return {
+    r: getReferrer().substring(0, 1000),
+    u: url ? maskQueryParams(url, paramsToMask, MASKED) : undefined
+  };
+}
+function getPersonPropsFromInfo(info) {
+  const {
+    r: referrer,
+    u: url
+  } = info;
+  const referring_domain = referrer == null ? undefined : referrer == '$direct' ? '$direct' : convertToURL(referrer)?.host;
+  const props = {
+    $referrer: referrer,
+    $referring_domain: referring_domain
+  };
+  if (url) {
+    props['$current_url'] = url;
+    const location = convertToURL(url);
+    props['$host'] = location?.host;
+    props['$pathname'] = location?.pathname;
+    const campaignParams = _getCampaignParamsFromUrl(url);
+    extend(props, campaignParams);
+  }
+  if (referrer) {
+    const searchInfo = _getSearchInfoFromReferrer(referrer);
+    extend(props, searchInfo);
+  }
+  return props;
+}
+function getInitialPersonPropsFromInfo(info) {
+  const personProps = getPersonPropsFromInfo(info);
+  const props = {};
+  each(personProps, function (val, key) {
+    props[`$initial_${core.stripLeadingDollar(key)}`] = val;
+  });
+  return props;
+}
+function getTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return undefined;
+  }
+}
+function getTimezoneOffset() {
+  try {
+    return new Date().getTimezoneOffset();
+  } catch {
+    return undefined;
+  }
+}
+function getEventProperties(maskPersonalDataProperties, customPersonalDataProperties) {
+  if (!userAgent) {
+    return {};
+  }
+  const paramsToMask = maskPersonalDataProperties ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || []) : [];
+  const [os_name, os_version] = detectOS(userAgent);
+  return extend(stripEmptyProperties({
+    $os: os_name,
+    $os_version: os_version,
+    $browser: detectBrowser(userAgent, navigator.vendor),
+    $device: detectDevice(userAgent),
+    $device_type: detectDeviceType(userAgent),
+    $timezone: getTimezone(),
+    $timezone_offset: getTimezoneOffset()
+  }), {
+    $current_url: maskQueryParams(location?.href, paramsToMask, MASKED),
+    $host: location?.host,
+    $pathname: location?.pathname,
+    $raw_user_agent: userAgent.length > 1000 ? userAgent.substring(0, 997) + '...' : userAgent,
+    $browser_version: detectBrowserVersion(userAgent, navigator.vendor),
+    $browser_language: getBrowserLanguage(),
+    $browser_language_prefix: getBrowserLanguagePrefix(),
+    $screen_height: win?.screen.height,
+    $screen_width: win?.screen.width,
+    $viewport_height: win?.innerHeight,
+    $viewport_width: win?.innerWidth,
+    $lib: 'web',
+    $lib_version: Config.LIB_VERSION,
+    $insert_id: Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10),
+    $time: Date.now() / 1000 // epoch time in seconds
+  });
+}
+
+/* eslint camelcase: "off" */
+const CASE_INSENSITIVE_PERSISTENCE_TYPES = ['cookie', 'localstorage', 'localstorage+cookie', 'sessionstorage', 'memory'];
+const parseName = config => {
+  let token = '';
+  if (config['token']) {
+    token = config['token'].replace(/\+/g, 'PL').replace(/\//g, 'SL').replace(/=/g, 'EQ');
+  }
+  if (config['persistence_name']) {
+    return config['persistence_name'];
+  }
+  return 'leanbase_' + token;
+};
+/**
+ * Leanbase Persistence Object
+ * @constructor
+ */
+class LeanbasePersistence {
+  /**
+   * @param {LeanbaseConfig} config initial PostHog configuration
+   * @param {boolean=} isDisabled should persistence be disabled (e.g. because of consent management)
+   */
+  constructor(config, isDisabled) {
+    this._config = config;
+    this.props = {};
+    this._campaign_params_saved = false;
+    this._name = parseName(config);
+    this._storage = this._buildStorage(config);
+    this.load();
+    if (config.debug) {
+      logger.info('Persistence loaded', config['persistence'], {
+        ...this.props
+      });
+    }
+    this.update_config(config, config, isDisabled);
+    this.save();
+  }
+  /**
+   * Returns whether persistence is disabled. Only available in SDKs > 1.257.1. Do not use on extensions, otherwise
+   * it'll break backwards compatibility for any version before 1.257.1.
+   */
+  isDisabled() {
+    return !!this._disabled;
+  }
+  _buildStorage(config) {
+    if (CASE_INSENSITIVE_PERSISTENCE_TYPES.indexOf(config['persistence'].toLowerCase()) === -1) {
+      logger.info('Unknown persistence type ' + config['persistence'] + '; falling back to localStorage+cookie');
+      config['persistence'] = 'localStorage+cookie';
+    }
+    let store;
+    const storage_type = config['persistence'].toLowerCase();
+    if (storage_type === 'localstorage' && localStore._is_supported()) {
+      store = localStore;
+    } else if (storage_type === 'localstorage+cookie' && localPlusCookieStore._is_supported()) {
+      store = localPlusCookieStore;
+    } else if (storage_type === 'sessionstorage' && sessionStore._is_supported()) {
+      store = sessionStore;
+    } else if (storage_type === 'memory') {
+      store = memoryStore;
+    } else if (storage_type === 'cookie') {
+      store = cookieStore;
+    } else if (localPlusCookieStore._is_supported()) {
+      store = localPlusCookieStore;
+    } else {
+      store = cookieStore;
+    }
+    return store;
+  }
+  properties() {
+    const p = {};
+    // Filter out reserved properties
+    each(this.props, function (v, k) {
+      if (k === ENABLED_FEATURE_FLAGS && core.isObject(v)) {
+        const keys = Object.keys(v);
+        for (let i = 0; i < keys.length; i++) {
+          p[`$feature/${keys[i]}`] = v[keys[i]];
+        }
+      } else if (!include(PERSISTENCE_RESERVED_PROPERTIES, k)) {
+        p[k] = v;
+      }
+    });
+    return p;
+  }
+  load() {
+    if (this._disabled) {
+      return;
+    }
+    const entry = this._storage._parse(this._name);
+    if (entry) {
+      this.props = extend({}, entry);
+    }
+  }
+  /**
+   * NOTE: Saving frequently causes issues with Recordings and Consent Management Platform (CMP) tools which
+   * observe cookie changes, and modify their UI, often causing infinite loops.
+   * As such callers of this should ideally check that the data has changed beforehand
+   */
+  save() {
+    if (this._disabled) {
+      return;
+    }
+    this._storage._set(this._name, this.props, this._expire_days, this._cross_subdomain, this._secure, this._config.debug);
+  }
+  remove() {
+    this._storage._remove(this._name, false);
+    this._storage._remove(this._name, true);
+  }
+  clear() {
+    this.remove();
+    this.props = {};
+  }
+  /**
+   * @param {Object} props
+   * @param {*=} default_value
+   * @param {number=} days
+   */
+  register_once(props, default_value, days) {
+    if (core.isObject(props)) {
+      if (core.isUndefined(default_value)) {
+        default_value = 'None';
+      }
+      this._expire_days = core.isUndefined(days) ? this._default_expiry : days;
+      let hasChanges = false;
+      each(props, (val, prop) => {
+        if (!this.props.hasOwnProperty(prop) || this.props[prop] === default_value) {
+          this.props[prop] = val;
+          hasChanges = true;
+        }
+      });
+      if (hasChanges) {
+        this.save();
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * @param {Object} props
+   * @param {number=} days
+   */
+  register(props, days) {
+    if (core.isObject(props)) {
+      this._expire_days = core.isUndefined(days) ? this._default_expiry : days;
+      let hasChanges = false;
+      each(props, (val, prop) => {
+        if (props.hasOwnProperty(prop) && this.props[prop] !== val) {
+          this.props[prop] = val;
+          hasChanges = true;
+        }
+      });
+      if (hasChanges) {
+        this.save();
+        return true;
+      }
+    }
+    return false;
+  }
+  unregister(prop) {
+    if (prop in this.props) {
+      delete this.props[prop];
+      this.save();
+    }
+  }
+  update_campaign_params() {
+    if (!this._campaign_params_saved) {
+      const campaignParams = getCampaignParams(this._config.custom_campaign_params, this._config.mask_personal_data_properties, this._config.custom_personal_data_properties);
+      if (!core.isEmptyObject(stripEmptyProperties(campaignParams))) {
+        this.register(campaignParams);
+      }
+      this._campaign_params_saved = true;
+    }
+  }
+  update_search_keyword() {
+    this.register(getSearchInfo());
+  }
+  update_referrer_info() {
+    this.register_once(getReferrerInfo(), undefined);
+  }
+  set_initial_person_info() {
+    if (this.props[INITIAL_CAMPAIGN_PARAMS] || this.props[INITIAL_REFERRER_INFO]) {
+      return;
+    }
+    this.register_once({
+      [INITIAL_PERSON_INFO]: getPersonInfo(this._config.mask_personal_data_properties, this._config.custom_personal_data_properties)
+    }, undefined);
+  }
+  get_initial_props() {
+    const p = {};
+    each([INITIAL_REFERRER_INFO, INITIAL_CAMPAIGN_PARAMS], key => {
+      const initialReferrerInfo = this.props[key];
+      if (initialReferrerInfo) {
+        each(initialReferrerInfo, function (v, k) {
+          p['$initial_' + core.stripLeadingDollar(k)] = v;
+        });
+      }
+    });
+    const initialPersonInfo = this.props[INITIAL_PERSON_INFO];
+    if (initialPersonInfo) {
+      const initialPersonProps = getInitialPersonPropsFromInfo(initialPersonInfo);
+      extend(p, initialPersonProps);
+    }
+    return p;
+  }
+  safe_merge(props) {
+    each(this.props, function (val, prop) {
+      if (!(prop in props)) {
+        props[prop] = val;
+      }
+    });
+    return props;
+  }
+  update_config(config, oldConfig, isDisabled) {
+    this._default_expiry = this._expire_days = config['cookie_expiration'];
+    this.set_disabled(config['disable_persistence'] || !!isDisabled);
+    this.set_cross_subdomain(config['cross_subdomain_cookie']);
+    this.set_secure(config['secure_cookie']);
+    if (config.persistence !== oldConfig.persistence) {
+      const newStore = this._buildStorage(config);
+      const props = this.props;
+      this.clear();
+      this._storage = newStore;
+      this.props = props;
+      this.save();
+    }
+  }
+  set_disabled(disabled) {
+    this._disabled = disabled;
+    if (this._disabled) {
+      return this.remove();
+    }
+    this.save();
+  }
+  set_cross_subdomain(cross_subdomain) {
+    if (cross_subdomain !== this._cross_subdomain) {
+      this._cross_subdomain = cross_subdomain;
+      this.remove();
+      this.save();
+    }
+  }
+  set_secure(secure) {
+    if (secure !== this._secure) {
+      this._secure = secure;
+      this.remove();
+      this.save();
+    }
+  }
+  set_event_timer(event_name, timestamp) {
+    const timers = this.props[EVENT_TIMERS_KEY] || {};
+    timers[event_name] = timestamp;
+    this.props[EVENT_TIMERS_KEY] = timers;
+    this.save();
+  }
+  remove_event_timer(event_name) {
+    const timers = this.props[EVENT_TIMERS_KEY] || {};
+    const timestamp = timers[event_name];
+    if (!core.isUndefined(timestamp)) {
+      delete this.props[EVENT_TIMERS_KEY][event_name];
+      this.save();
+    }
+    return timestamp;
+  }
+  get_property(prop) {
+    return this.props[prop];
+  }
+  set_property(prop, to) {
+    this.props[prop] = to;
+    this.save();
+  }
+}
+
+/*
+ * Check whether an element has nodeType Node.ELEMENT_NODE
+ * @param {Element} el - element to check
+ * @returns {boolean} whether el is of the correct nodeType
+ */
+function isElementNode(el) {
+  return !!el && el.nodeType === 1; // Node.ELEMENT_NODE - use integer constant for browser portability
+}
+/*
+ * Check whether an element is of a given tag type.
+ * Due to potential reference discrepancies (such as the webcomponents.js polyfill),
+ * we want to match tagNames instead of specific references because something like
+ * element === document.body won't always work because element might not be a native
+ * element.
+ * @param {Element} el - element to check
+ * @param {string} tag - tag name (e.g., "div")
+ * @returns {boolean} whether el is of the given tag type
+ */
+function isTag(el, tag) {
+  return !!el && !!el.tagName && el.tagName.toLowerCase() === tag.toLowerCase();
+}
+/*
+ * Check whether an element has nodeType Node.TEXT_NODE
+ * @param {Element} el - element to check
+ * @returns {boolean} whether el is of the correct nodeType
+ */
+function isTextNode(el) {
+  return !!el && el.nodeType === 3; // Node.TEXT_NODE - use integer constant for browser portability
+}
+/*
+ * Check whether an element has nodeType Node.DOCUMENT_FRAGMENT_NODE
+ * @param {Element} el - element to check
+ * @returns {boolean} whether el is of the correct nodeType
+ */
+function isDocumentFragment(el) {
+  return !!el && el.nodeType === 11; // Node.DOCUMENT_FRAGMENT_NODE - use integer constant for browser portability
+}
+
+function splitClassString(s) {
+  return s ? core.trim(s).split(/\s+/) : [];
+}
+function checkForURLMatches(urlsList) {
+  const url = window?.location.href;
+  return !!(url && urlsList && urlsList.some(regex => url.match(regex)));
+}
+/*
+ * Get the className of an element, accounting for edge cases where element.className is an object
+ *
+ * Because this is a string it can contain unexpected characters
+ * So, this method safely splits the className and returns that array.
+ */
+function getClassNames(el) {
+  let className = '';
+  switch (typeof el.className) {
+    case 'string':
+      className = el.className;
+      break;
+    // TODO: when is this ever used?
+    case 'object':
+      // handle cases where className might be SVGAnimatedString or some other type
+      className = (el.className && 'baseVal' in el.className ? el.className.baseVal : null) || el.getAttribute('class') || '';
+      break;
+    default:
+      className = '';
+  }
+  return splitClassString(className);
+}
+function makeSafeText(s) {
+  if (core.isNullish(s)) {
+    return null;
+  }
+  return core.trim(s)
+  // scrub potentially sensitive values
+  .split(/(\s+)/).filter(s => shouldCaptureValue(s)).join('')
+  // normalize whitespace
+  .replace(/[\r\n]/g, ' ').replace(/[ ]+/g, ' ')
+  // truncate
+  .substring(0, 255);
+}
+/*
+ * 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) {
+  let elText = '';
+  if (shouldCaptureElement(el) && !isSensitiveElement(el) && el.childNodes && el.childNodes.length) {
+    each(el.childNodes, function (child) {
+      if (isTextNode(child) && child.textContent) {
+        elText += makeSafeText(child.textContent) ?? '';
+      }
+    });
+  }
+  return core.trim(elText);
+}
+function getEventTarget(e) {
+  // https://developer.mozilla.org/en-US/docs/Web/API/Event/target#Compatibility_notes
+  if (core.isUndefined(e.target)) {
+    return e.srcElement || null;
+  } else {
+    if (e.target?.shadowRoot) {
+      return e.composedPath()[0] || null;
+    }
+    return e.target || null;
+  }
+}
+const autocaptureCompatibleElements = ['a', 'button', 'form', 'input', 'select', 'textarea', 'label'];
+/*
+ if there is no config, then all elements are allowed
+ if there is a config, and there is an allow list, then only elements in the allow list are allowed
+ assumes that some other code is checking this element's parents
+ */
+function checkIfElementTreePassesElementAllowList(elements, autocaptureConfig) {
+  const allowlist = autocaptureConfig?.element_allowlist;
+  if (core.isUndefined(allowlist)) {
+    // everything is allowed, when there is no allow list
+    return true;
+  }
+  // check each element in the tree
+  // if any of the elements are in the allow list, then the tree is allowed
+  for (const el of elements) {
+    if (allowlist.some(elementType => el.tagName.toLowerCase() === elementType)) {
+      return true;
     }
-  },
-  error: (...args) => {
-    if (typeof console !== 'undefined') {
-      // eslint-disable-next-line no-console
-      console.error(PREFIX, ...args);
+  }
+  // otherwise there is an allow list and this element tree didn't match it
+  return false;
+}
+/*
+ if there is no selector list (i.e. it is undefined), then any elements matches
+ if there is an empty list, then no elements match
+ if there is a selector list, then check it against each element provided
+ */
+function checkIfElementsMatchCSSSelector(elements, selectorList) {
+  if (core.isUndefined(selectorList)) {
+    // everything is allowed, when there is no selector list
+    return true;
+  }
+  for (const el of elements) {
+    if (selectorList.some(selector => el.matches(selector))) {
+      return true;
+    }
+  }
+  return false;
+}
+function getParentElement(curEl) {
+  const parentNode = curEl.parentNode;
+  if (!parentNode || !isElementNode(parentNode)) return false;
+  return parentNode;
+}
+// autocapture check will already filter for ph-no-capture,
+// but we include it here to protect against future changes accidentally removing that check
+const DEFAULT_RAGE_CLICK_IGNORE_LIST = ['.ph-no-rageclick', '.ph-no-capture'];
+function shouldCaptureRageclick(el, _config) {
+  if (!window || cannotCheckForAutocapture(el)) {
+    return false;
+  }
+  let selectorIgnoreList;
+  if (core.isBoolean(_config)) {
+    selectorIgnoreList = _config ? DEFAULT_RAGE_CLICK_IGNORE_LIST : false;
+  } else {
+    selectorIgnoreList = _config?.css_selector_ignorelist ?? DEFAULT_RAGE_CLICK_IGNORE_LIST;
+  }
+  if (selectorIgnoreList === false) {
+    return false;
+  }
+  const {
+    targetElementList
+  } = getElementAndParentsForElement(el, false);
+  // we don't capture if we match the ignore list
+  return !checkIfElementsMatchCSSSelector(targetElementList, selectorIgnoreList);
+}
+const cannotCheckForAutocapture = el => {
+  return !el || isTag(el, 'html') || !isElementNode(el);
+};
+const getElementAndParentsForElement = (el, captureOnAnyElement) => {
+  if (!window || cannotCheckForAutocapture(el)) {
+    return {
+      parentIsUsefulElement: false,
+      targetElementList: []
+    };
+  }
+  let parentIsUsefulElement = false;
+  const targetElementList = [el];
+  let curEl = el;
+  while (curEl.parentNode && !isTag(curEl, 'body')) {
+    // If element is a shadow root, we skip it
+    if (isDocumentFragment(curEl.parentNode)) {
+      targetElementList.push(curEl.parentNode.host);
+      curEl = curEl.parentNode.host;
+      continue;
+    }
+    const parentNode = getParentElement(curEl);
+    if (!parentNode) break;
+    if (captureOnAnyElement || autocaptureCompatibleElements.indexOf(parentNode.tagName.toLowerCase()) > -1) {
+      parentIsUsefulElement = true;
+    } else {
+      const compStyles = window.getComputedStyle(parentNode);
+      if (compStyles && compStyles.getPropertyValue('cursor') === 'pointer') {
+        parentIsUsefulElement = true;
+      }
     }
+    targetElementList.push(parentNode);
+    curEl = parentNode;
   }
+  return {
+    parentIsUsefulElement,
+    targetElementList
+  };
 };
+/*
+ * Check whether a DOM event should be "captured" or if it may contain sensitive data
+ * using a variety of heuristics.
+ * @param {Element} el - element to check
+ * @param {Event} event - event to check
+ * @param {Object} autocaptureConfig - autocapture config
+ * @param {boolean} captureOnAnyElement - whether to capture on any element, clipboard autocapture doesn't restrict to "clickable" elements
+ * @param {string[]} allowedEventTypes - event types to capture, normally just 'click', but some autocapture types react to different events, some elements have fixed events (e.g., form has "submit")
+ * @returns {boolean} whether the event should be captured
+ */
+function shouldCaptureDomEvent(el, event, autocaptureConfig = undefined, captureOnAnyElement, allowedEventTypes) {
+  if (!window || cannotCheckForAutocapture(el)) {
+    return false;
+  }
+  if (autocaptureConfig?.url_allowlist) {
+    // if the current URL is not in the allow list, don't capture
+    if (!checkForURLMatches(autocaptureConfig.url_allowlist)) {
+      return false;
+    }
+  }
+  if (autocaptureConfig?.url_ignorelist) {
+    // if the current URL is in the ignore list, don't capture
+    if (checkForURLMatches(autocaptureConfig.url_ignorelist)) {
+      return false;
+    }
+  }
+  if (autocaptureConfig?.dom_event_allowlist) {
+    const allowlist = autocaptureConfig.dom_event_allowlist;
+    if (allowlist && !allowlist.some(eventType => event.type === eventType)) {
+      return false;
+    }
+  }
+  const {
+    parentIsUsefulElement,
+    targetElementList
+  } = getElementAndParentsForElement(el, captureOnAnyElement);
+  if (!checkIfElementTreePassesElementAllowList(targetElementList, autocaptureConfig)) {
+    return false;
+  }
+  if (!checkIfElementsMatchCSSSelector(targetElementList, autocaptureConfig?.css_selector_allowlist)) {
+    return false;
+  }
+  const compStyles = window.getComputedStyle(el);
+  if (compStyles && compStyles.getPropertyValue('cursor') === 'pointer' && event.type === 'click') {
+    return true;
+  }
+  const tag = el.tagName.toLowerCase();
+  switch (tag) {
+    case 'html':
+      return false;
+    case 'form':
+      return (allowedEventTypes || ['submit']).indexOf(event.type) >= 0;
+    case 'input':
+    case 'select':
+    case 'textarea':
+      return (allowedEventTypes || ['change', 'click']).indexOf(event.type) >= 0;
+    default:
+      if (parentIsUsefulElement) return (allowedEventTypes || ['click']).indexOf(event.type) >= 0;
+      return (allowedEventTypes || ['click']).indexOf(event.type) >= 0 && (autocaptureCompatibleElements.indexOf(tag) > -1 || el.getAttribute('contenteditable') === 'true');
+  }
+}
+/*
+ * Check whether a DOM element should be "captured" or if it may contain sensitive data
+ * using a variety of heuristics.
+ * @param {Element} el - element to check
+ * @returns {boolean} whether the element should be captured
+ */
+function shouldCaptureElement(el) {
+  for (let curEl = el; curEl.parentNode && !isTag(curEl, 'body'); curEl = curEl.parentNode) {
+    const classes = getClassNames(curEl);
+    if (core.includes(classes, 'ph-sensitive') || core.includes(classes, 'ph-no-capture')) {
+      return false;
+    }
+  }
+  if (core.includes(getClassNames(el), 'ph-include')) {
+    return true;
+  }
+  // don't include hidden or password fields
+  const type = el.type || '';
+  if (core.isString(type)) {
+    // 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
+  const 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 (core.isString(name)) {
+    // 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"]
+    const sensitiveNameRegex = /^cc|cardnum|ccnum|creditcard|csc|cvc|cvv|exp|pass|pwd|routing|seccode|securitycode|securitynum|socialsec|socsec|ssn/i;
+    if (sensitiveNameRegex.test(name.replace(/[^a-zA-Z0-9]/g, ''))) {
+      return false;
+    }
+  }
+  return true;
+}
+/*
+ * Check whether a DOM element is 'sensitive' and we should only capture limited data
+ * @param {Element} el - element to check
+ * @returns {boolean} whether the element should be captured
+ */
+function isSensitiveElement(el) {
+  // don't send data from inputs or similar elements since there will always be
+  // a risk of clientside javascript placing sensitive data in attributes
+  const allowedInputTypes = ['button', 'checkbox', 'submit', 'reset'];
+  if (isTag(el, 'input') && !allowedInputTypes.includes(el.type) || isTag(el, 'select') || isTag(el, 'textarea') || el.getAttribute('contenteditable') === 'true') {
+    return true;
+  }
+  return false;
+}
+// Define the core pattern for matching credit card numbers
+const coreCCPattern = `(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})`;
+// Create the Anchored version of the regex by adding '^' at the start and '$' at the end
+const anchoredCCRegex = new RegExp(`^(?:${coreCCPattern})$`);
+// The Unanchored version is essentially the core pattern, usable as is for partial matches
+const unanchoredCCRegex = new RegExp(coreCCPattern);
+// Define the core pattern for matching SSNs with optional dashes
+const coreSSNPattern = `\\d{3}-?\\d{2}-?\\d{4}`;
+// Create the Anchored version of the regex by adding '^' at the start and '$' at the end
+const anchoredSSNRegex = new RegExp(`^(${coreSSNPattern})$`);
+// The Unanchored version is essentially the core pattern itself, usable for partial matches
+const unanchoredSSNRegex = new RegExp(`(${coreSSNPattern})`);
+/*
+ * Check whether a string value should be "captured" or if it may contain sensitive data
+ * using a variety of heuristics.
+ * @param {string} value - string value to check
+ * @param {boolean} anchorRegexes - whether to anchor the regexes to the start and end of the string
+ * @returns {boolean} whether the element should be captured
+ */
+function shouldCaptureValue(value, anchorRegexes = true) {
+  if (core.isNullish(value)) {
+    return false;
+  }
+  if (core.isString(value)) {
+    value = core.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
+    const ccRegex = anchorRegexes ? anchoredCCRegex : unanchoredCCRegex;
+    if (ccRegex.test((value || '').replace(/[- ]/g, ''))) {
+      return false;
+    }
+    // check to see if input value looks like a social security number
+    const ssnRegex = anchorRegexes ? anchoredSSNRegex : unanchoredSSNRegex;
+    if (ssnRegex.test(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+/*
+ * Check whether an attribute name is an Angular style attr (either _ngcontent or _nghost)
+ * These update on each build and lead to noise in the element chain
+ * More details on the attributes here: https://angular.io/guide/view-encapsulation
+ * @param {string} attributeName - string value to check
+ * @returns {boolean} whether the element is an angular tag
+ */
+function isAngularStyleAttr(attributeName) {
+  if (core.isString(attributeName)) {
+    return attributeName.substring(0, 10) === '_ngcontent' || attributeName.substring(0, 7) === '_nghost';
+  }
+  return false;
+}
+/*
+ * Iterate through children of a target element looking for span tags
+ * and return the text content of the span tags, separated by spaces,
+ * along with the direct text content of the target element
+ * @param {Element} target - element to check
+ * @returns {string} text content of the target element and its child span tags
+ */
+function getDirectAndNestedSpanText(target) {
+  let text = getSafeText(target);
+  text = `${text} ${getNestedSpanText(target)}`.trim();
+  return shouldCaptureValue(text) ? text : '';
+}
+/*
+ * Iterate through children of a target element looking for span tags
+ * and return the text content of the span tags, separated by spaces
+ * @param {Element} target - element to check
+ * @returns {string} text content of span tags
+ */
+function getNestedSpanText(target) {
+  let text = '';
+  if (target && target.childNodes && target.childNodes.length) {
+    each(target.childNodes, function (child) {
+      if (child && child.tagName?.toLowerCase() === 'span') {
+        try {
+          const spanText = getSafeText(child);
+          text = `${text} ${spanText}`.trim();
+          if (child.childNodes && child.childNodes.length) {
+            text = `${text} ${getNestedSpanText(child)}`.trim();
+          }
+        } catch (e) {
+          logger.error('[AutoCapture]', e);
+        }
+      }
+    });
+  }
+  return text;
+}
+/*
+Back in the day storing events in Postgres we use Elements for autocapture events.
+Now we're using elements_chain. We used to do this parsing/processing during ingestion.
+This code is just copied over from ingestion, but we should optimize it
+to create elements_chain string directly.
+*/
+function getElementsChainString(elements) {
+  return elementsToString(extractElements(elements));
+}
+function escapeQuotes(input) {
+  return input.replace(/"|\\"/g, '\\"');
+}
+function elementsToString(elements) {
+  const ret = elements.map(element => {
+    let el_string = '';
+    if (element.tag_name) {
+      el_string += element.tag_name;
+    }
+    if (element.attr_class) {
+      element.attr_class.sort();
+      for (const single_class of element.attr_class) {
+        el_string += `.${single_class.replace(/"/g, '')}`;
+      }
+    }
+    const attributes = {
+      ...(element.text ? {
+        text: element.text
+      } : {}),
+      'nth-child': element.nth_child ?? 0,
+      'nth-of-type': element.nth_of_type ?? 0,
+      ...(element.href ? {
+        href: element.href
+      } : {}),
+      ...(element.attr_id ? {
+        attr_id: element.attr_id
+      } : {}),
+      ...element.attributes
+    };
+    const sortedAttributes = {};
+    entries(attributes).sort(([a], [b]) => a.localeCompare(b)).forEach(([key, value]) => sortedAttributes[escapeQuotes(key.toString())] = escapeQuotes(value.toString()));
+    el_string += ':';
+    el_string += entries(sortedAttributes).map(([key, value]) => `${key}="${value}"`).join('');
+    return el_string;
+  });
+  return ret.join(';');
+}
+function extractElements(elements) {
+  return elements.map(el => {
+    const response = {
+      text: el['$el_text']?.slice(0, 400),
+      tag_name: el['tag_name'],
+      href: el['attr__href']?.slice(0, 2048),
+      attr_class: extractAttrClass(el),
+      attr_id: el['attr__id'],
+      nth_child: el['nth_child'],
+      nth_of_type: el['nth_of_type'],
+      attributes: {}
+    };
+    entries(el).filter(([key]) => key.indexOf('attr__') === 0).forEach(([key, value]) => response.attributes[key] = value);
+    return response;
+  });
+}
+function extractAttrClass(el) {
+  const attr_class = el['attr__class'];
+  if (!attr_class) {
+    return undefined;
+  } else if (core.isArray(attr_class)) {
+    return attr_class;
+  } else {
+    return splitClassString(attr_class);
+  }
+}
 
-class Leanbase extends core.PostHogCore {
-  constructor(apiKey, options) {
-    // Leanbase defaults
-    const leanbaseOptions = {
-      host: 'https://i.leanbase.co',
-      ...options
+// Naive rage click implementation: If mouse has not moved further than RAGE_CLICK_THRESHOLD_PX
+// over RAGE_CLICK_CLICK_COUNT clicks with max RAGE_CLICK_TIMEOUT_MS between clicks, it's
+// counted as a rage click
+const RAGE_CLICK_THRESHOLD_PX = 30;
+const RAGE_CLICK_TIMEOUT_MS = 1000;
+const RAGE_CLICK_CLICK_COUNT = 3;
+class RageClick {
+  constructor() {
+    this.clicks = [];
+  }
+  isRageClick(x, y, timestamp) {
+    const lastClick = this.clicks[this.clicks.length - 1];
+    if (lastClick && Math.abs(x - lastClick.x) + Math.abs(y - lastClick.y) < RAGE_CLICK_THRESHOLD_PX && timestamp - lastClick.timestamp < RAGE_CLICK_TIMEOUT_MS) {
+      this.clicks.push({
+        x,
+        y,
+        timestamp
+      });
+      if (this.clicks.length === RAGE_CLICK_CLICK_COUNT) {
+        return true;
+      }
+    } else {
+      this.clicks = [{
+        x,
+        y,
+        timestamp
+      }];
+    }
+    return false;
+  }
+}
+
+const COPY_AUTOCAPTURE_EVENT = '$copy_autocapture';
+var Compression;
+(function (Compression) {
+  Compression["GZipJS"] = "gzip-js";
+  Compression["Base64"] = "base64";
+})(Compression || (Compression = {}));
+
+function limitText(length, text) {
+  if (text.length > length) {
+    return text.slice(0, length) + '...';
+  }
+  return text;
+}
+function getAugmentPropertiesFromElement(elem) {
+  const shouldCaptureEl = shouldCaptureElement(elem);
+  if (!shouldCaptureEl) {
+    return {};
+  }
+  const props = {};
+  each(elem.attributes, function (attr) {
+    if (attr.name && attr.name.indexOf('data-ph-capture-attribute') === 0) {
+      const propertyKey = attr.name.replace('data-ph-capture-attribute-', '');
+      const propertyValue = attr.value;
+      if (propertyKey && propertyValue && shouldCaptureValue(propertyValue)) {
+        props[propertyKey] = propertyValue;
+      }
+    }
+  });
+  return props;
+}
+function previousElementSibling(el) {
+  if (el.previousElementSibling) {
+    return el.previousElementSibling;
+  }
+  let _el = el;
+  do {
+    _el = _el.previousSibling; // resolves to ChildNode->Node, which is Element's parent class
+  } while (_el && !isElementNode(_el));
+  return _el;
+}
+function getDefaultProperties(eventType) {
+  return {
+    $event_type: eventType,
+    $ce_version: 1
+  };
+}
+function getPropertiesFromElement(elem, maskAllAttributes, maskText, elementAttributeIgnorelist) {
+  const tag_name = elem.tagName.toLowerCase();
+  const props = {
+    tag_name: tag_name
+  };
+  if (autocaptureCompatibleElements.indexOf(tag_name) > -1 && !maskText) {
+    if (tag_name.toLowerCase() === 'a' || tag_name.toLowerCase() === 'button') {
+      props['$el_text'] = limitText(1024, getDirectAndNestedSpanText(elem));
+    } else {
+      props['$el_text'] = limitText(1024, getSafeText(elem));
+    }
+  }
+  const classes = getClassNames(elem);
+  if (classes.length > 0) props['classes'] = classes.filter(function (c) {
+    return c !== '';
+  });
+  // capture the deny list here because this not-a-class class makes it tricky to use this.config in the function below
+  each(elem.attributes, function (attr) {
+    // Only capture attributes we know are safe
+    if (isSensitiveElement(elem) && ['name', 'id', 'class', 'aria-label'].indexOf(attr.name) === -1) return;
+    if (elementAttributeIgnorelist?.includes(attr.name)) return;
+    if (!maskAllAttributes && shouldCaptureValue(attr.value) && !isAngularStyleAttr(attr.name)) {
+      let value = attr.value;
+      if (attr.name === 'class') {
+        // html attributes can _technically_ contain linebreaks,
+        // but we're very intolerant of them in the class string,
+        // so we strip them.
+        value = splitClassString(value).join(' ');
+      }
+      props['attr__' + attr.name] = limitText(1024, value);
+    }
+  });
+  let nthChild = 1;
+  let nthOfType = 1;
+  let currentElem = elem;
+  while (currentElem = 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;
+}
+function autocapturePropertiesForElement(target, {
+  e,
+  maskAllElementAttributes,
+  maskAllText,
+  elementAttributeIgnoreList,
+  elementsChainAsString
+}) {
+  const targetElementList = [target];
+  let 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;
+  }
+  const elementsJson = [];
+  const autocaptureAugmentProperties = {};
+  let href = false;
+  let explicitNoCapture = false;
+  each(targetElementList, el => {
+    const shouldCaptureEl = shouldCaptureElement(el);
+    // if the element or a parent element is an anchor tag
+    // include the href as a property
+    if (el.tagName.toLowerCase() === 'a') {
+      href = el.getAttribute('href');
+      href = shouldCaptureEl && href && shouldCaptureValue(href) && href;
+    }
+    // allow users to programmatically prevent capturing of elements by adding class 'ph-no-capture'
+    const classes = getClassNames(el);
+    if (core.includes(classes, 'ph-no-capture')) {
+      explicitNoCapture = true;
+    }
+    elementsJson.push(getPropertiesFromElement(el, maskAllElementAttributes, maskAllText, elementAttributeIgnoreList));
+    const augmentProperties = getAugmentPropertiesFromElement(el);
+    extend(autocaptureAugmentProperties, augmentProperties);
+  });
+  if (explicitNoCapture) {
+    return {
+      props: {},
+      explicitNoCapture
     };
-    super(apiKey, leanbaseOptions);
-    this._storage = new Map();
-    this._storageKey = `leanbase_${apiKey}`;
-    // Load from localStorage if available
-    if (typeof window !== 'undefined' && window.localStorage) {
+  }
+  if (!maskAllText) {
+    // if the element is a button or anchor tag get the span text from any
+    // children and include it as/with the text property on the parent element
+    if (target.tagName.toLowerCase() === 'a' || target.tagName.toLowerCase() === 'button') {
+      elementsJson[0]['$el_text'] = getDirectAndNestedSpanText(target);
+    } else {
+      elementsJson[0]['$el_text'] = getSafeText(target);
+    }
+  }
+  let externalHref;
+  if (href) {
+    elementsJson[0]['attr__href'] = href;
+    const hrefHost = convertToURL(href)?.host;
+    const locationHost = win?.location?.host;
+    if (hrefHost && locationHost && hrefHost !== locationHost) {
+      externalHref = href;
+    }
+  }
+  const props = extend(getDefaultProperties(e.type),
+  // Sending "$elements" is deprecated. Only one client on US cloud uses this.
+  !elementsChainAsString ? {
+    $elements: elementsJson
+  } : {},
+  // Always send $elements_chain, as it's needed downstream in site app filtering
+  {
+    $elements_chain: getElementsChainString(elementsJson)
+  }, elementsJson[0]?.['$el_text'] ? {
+    $el_text: elementsJson[0]?.['$el_text']
+  } : {}, externalHref && e.type === 'click' ? {
+    $external_click_url: externalHref
+  } : {}, autocaptureAugmentProperties);
+  return {
+    props
+  };
+}
+class Autocapture {
+  constructor(instance) {
+    this._initialized = false;
+    this._isDisabledServerSide = null;
+    this.rageclicks = new RageClick();
+    this._elementsChainAsString = false;
+    this.instance = instance;
+    this._elementSelectors = null;
+  }
+  get _config() {
+    const config = core.isObject(this.instance.config.autocapture) ? this.instance.config.autocapture : {};
+    // precompile the regex
+    config.url_allowlist = config.url_allowlist?.map(url => new RegExp(url));
+    config.url_ignorelist = config.url_ignorelist?.map(url => new RegExp(url));
+    return config;
+  }
+  _addDomEventHandlers() {
+    if (!this.isBrowserSupported()) {
+      logger.info('Disabling Automatic Event Collection because this browser is not supported');
+      return;
+    }
+    if (!win || !document) {
+      return;
+    }
+    const handler = e => {
+      e = e || win?.event;
       try {
-        const stored = window.localStorage.getItem(this._storageKey);
-        if (stored) {
-          const parsed = JSON.parse(stored);
-          Object.entries(parsed).forEach(([key, value]) => {
-            this._storage.set(key, value);
-          });
+        this._captureEvent(e);
+      } catch (error) {
+        logger.error('Failed to capture event', error);
+      }
+    };
+    addEventListener(document, 'submit', handler, {
+      capture: true
+    });
+    addEventListener(document, 'change', handler, {
+      capture: true
+    });
+    addEventListener(document, 'click', handler, {
+      capture: true
+    });
+    if (this._config.capture_copied_text) {
+      const copiedTextHandler = e => {
+        e = e || win?.event;
+        this._captureEvent(e, COPY_AUTOCAPTURE_EVENT);
+      };
+      addEventListener(document, 'copy', copiedTextHandler, {
+        capture: true
+      });
+      addEventListener(document, 'cut', copiedTextHandler, {
+        capture: true
+      });
+    }
+  }
+  startIfEnabled() {
+    if (this.isEnabled && !this._initialized) {
+      this._addDomEventHandlers();
+      this._initialized = true;
+    }
+  }
+  onRemoteConfig(response) {
+    if (response.elementsChainAsString) {
+      this._elementsChainAsString = response.elementsChainAsString;
+    }
+    if (this.instance.persistence) {
+      this.instance.persistence.register({
+        [AUTOCAPTURE_DISABLED_SERVER_SIDE]: !!response['autocapture_opt_out']
+      });
+    }
+    this._isDisabledServerSide = !!response['autocapture_opt_out'];
+    this.startIfEnabled();
+  }
+  setElementSelectors(selectors) {
+    this._elementSelectors = selectors;
+  }
+  getElementSelectors(element) {
+    const elementSelectors = [];
+    this._elementSelectors?.forEach(selector => {
+      const matchedElements = document?.querySelectorAll(selector);
+      matchedElements?.forEach(matchedElement => {
+        if (element === matchedElement) {
+          elementSelectors.push(selector);
+        }
+      });
+    });
+    return elementSelectors;
+  }
+  get isEnabled() {
+    const persistedServerDisabled = this.instance.persistence?.props[AUTOCAPTURE_DISABLED_SERVER_SIDE];
+    const memoryDisabled = this._isDisabledServerSide;
+    if (core.isNull(memoryDisabled) && !core.isBoolean(persistedServerDisabled)) {
+      return false;
+    }
+    const disabledServer = this._isDisabledServerSide ?? !!persistedServerDisabled;
+    const disabledClient = !this.instance.config.autocapture;
+    return !disabledClient && !disabledServer;
+  }
+  _captureEvent(e, eventName = '$autocapture') {
+    if (!this.isEnabled) {
+      return;
+    }
+    /*** Don't mess with this code without running IE8 tests on it ***/
+    let target = getEventTarget(e);
+    if (isTextNode(target)) {
+      // defeat Safari bug (see: http://www.quirksmode.org/js/events_properties.html)
+      target = target.parentNode || null;
+    }
+    if (eventName === '$autocapture' && e.type === 'click' && e instanceof MouseEvent) {
+      if (!!this.instance.config.rageclick && this.rageclicks?.isRageClick(e.clientX, e.clientY, new Date().getTime())) {
+        if (shouldCaptureRageclick(target, this.instance.config.rageclick)) {
+          this._captureEvent(e, '$rageclick');
+        }
+      }
+    }
+    const isCopyAutocapture = eventName === COPY_AUTOCAPTURE_EVENT;
+    if (target && shouldCaptureDomEvent(target, e, this._config,
+    // mostly this method cares about the target element, but in the case of copy events,
+    // we want some of the work this check does without insisting on the target element's type
+    isCopyAutocapture,
+    // we also don't want to restrict copy checks to clicks,
+    // so we pass that knowledge in here, rather than add the logic inside the check
+    isCopyAutocapture ? ['copy', 'cut'] : undefined)) {
+      const {
+        props,
+        explicitNoCapture
+      } = autocapturePropertiesForElement(target, {
+        e,
+        maskAllElementAttributes: this.instance.config.mask_all_element_attributes,
+        maskAllText: this.instance.config.mask_all_text,
+        elementAttributeIgnoreList: this._config.element_attribute_ignorelist,
+        elementsChainAsString: this._elementsChainAsString
+      });
+      if (explicitNoCapture) {
+        return false;
+      }
+      const elementSelectors = this.getElementSelectors(target);
+      if (elementSelectors && elementSelectors.length > 0) {
+        props['$element_selectors'] = elementSelectors;
+      }
+      if (eventName === COPY_AUTOCAPTURE_EVENT) {
+        // you can't read the data from the clipboard event,
+        // but you can guess that you can read it from the window's current selection
+        const selectedContent = makeSafeText(win?.getSelection()?.toString());
+        const clipType = e.type || 'clipboard';
+        if (!selectedContent) {
+          return false;
+        }
+        props['$selected_content'] = selectedContent;
+        props['$copy_type'] = clipType;
+      }
+      this.instance.capture(eventName, props);
+      return true;
+    }
+  }
+  isBrowserSupported() {
+    return core.isFunction(document?.querySelectorAll);
+  }
+}
+
+// This keeps track of the PageView state (such as the previous PageView's path, timestamp, id, and scroll properties).
+// We store the state in memory, which means that for non-SPA sites, the state will be lost on page reload. This means
+// that non-SPA sites should always send a $pageleave event on any navigation, before the page unloads. For SPA sites,
+// they only need to send a $pageleave event when the user navigates away from the site, as the information is not lost
+// on an internal navigation, and is included as the $prev_pageview_ properties in the next $pageview event.
+// Practically, this means that to find the scroll properties for a given pageview, you need to find the event where
+// event name is $pageview or $pageleave and where $prev_pageview_id matches the original pageview event's id.
+class PageViewManager {
+  constructor(instance) {
+    this._instance = instance;
+  }
+  doPageView(timestamp, pageViewId) {
+    const response = this._previousPageViewProperties(timestamp, pageViewId);
+    // On a pageview we reset the contexts
+    this._currentPageview = {
+      pathname: win?.location.pathname ?? '',
+      pageViewId,
+      timestamp
+    };
+    this._instance.scrollManager.resetContext();
+    return response;
+  }
+  doPageLeave(timestamp) {
+    return this._previousPageViewProperties(timestamp, this._currentPageview?.pageViewId);
+  }
+  doEvent() {
+    return {
+      $pageview_id: this._currentPageview?.pageViewId
+    };
+  }
+  _previousPageViewProperties(timestamp, pageviewId) {
+    const previousPageView = this._currentPageview;
+    if (!previousPageView) {
+      return {
+        $pageview_id: pageviewId
+      };
+    }
+    let properties = {
+      $pageview_id: pageviewId,
+      $prev_pageview_id: previousPageView.pageViewId
+    };
+    const scrollContext = this._instance.scrollManager.getContext();
+    if (scrollContext && !this._instance.config.disable_scroll_properties) {
+      let {
+        maxScrollHeight,
+        lastScrollY,
+        maxScrollY,
+        maxContentHeight,
+        lastContentY,
+        maxContentY
+      } = scrollContext;
+      if (!core.isUndefined(maxScrollHeight) && !core.isUndefined(lastScrollY) && !core.isUndefined(maxScrollY) && !core.isUndefined(maxContentHeight) && !core.isUndefined(lastContentY) && !core.isUndefined(maxContentY)) {
+        // Use ceil, so that e.g. scrolling 999.5px of a 1000px page is considered 100% scrolled
+        maxScrollHeight = Math.ceil(maxScrollHeight);
+        lastScrollY = Math.ceil(lastScrollY);
+        maxScrollY = Math.ceil(maxScrollY);
+        maxContentHeight = Math.ceil(maxContentHeight);
+        lastContentY = Math.ceil(lastContentY);
+        maxContentY = Math.ceil(maxContentY);
+        // if the maximum scroll height is near 0, then the percentage is 1
+        const lastScrollPercentage = maxScrollHeight <= 1 ? 1 : core.clampToRange(lastScrollY / maxScrollHeight, 0, 1, logger);
+        const maxScrollPercentage = maxScrollHeight <= 1 ? 1 : core.clampToRange(maxScrollY / maxScrollHeight, 0, 1, logger);
+        const lastContentPercentage = maxContentHeight <= 1 ? 1 : core.clampToRange(lastContentY / maxContentHeight, 0, 1, logger);
+        const maxContentPercentage = maxContentHeight <= 1 ? 1 : core.clampToRange(maxContentY / maxContentHeight, 0, 1, logger);
+        properties = extend(properties, {
+          $prev_pageview_last_scroll: lastScrollY,
+          $prev_pageview_last_scroll_percentage: lastScrollPercentage,
+          $prev_pageview_max_scroll: maxScrollY,
+          $prev_pageview_max_scroll_percentage: maxScrollPercentage,
+          $prev_pageview_last_content: lastContentY,
+          $prev_pageview_last_content_percentage: lastContentPercentage,
+          $prev_pageview_max_content: maxContentY,
+          $prev_pageview_max_content_percentage: maxContentPercentage
+        });
+      }
+    }
+    if (previousPageView.pathname) {
+      properties.$prev_pageview_pathname = previousPageView.pathname;
+    }
+    if (previousPageView.timestamp) {
+      // Use seconds, for consistency with our other duration-related properties like $duration
+      properties.$prev_pageview_duration = (timestamp.getTime() - previousPageView.timestamp.getTime()) / 1000;
+    }
+    return properties;
+  }
+}
+
+// This class is responsible for tracking scroll events and maintaining the scroll context
+class ScrollManager {
+  constructor(_instance) {
+    this._instance = _instance;
+    this._updateScrollData = () => {
+      if (!this._context) {
+        this._context = {};
+      }
+      const el = this.scrollElement();
+      const scrollY = this.scrollY();
+      const scrollHeight = el ? Math.max(0, el.scrollHeight - el.clientHeight) : 0;
+      const contentY = scrollY + (el?.clientHeight || 0);
+      const contentHeight = el?.scrollHeight || 0;
+      this._context.lastScrollY = Math.ceil(scrollY);
+      this._context.maxScrollY = Math.max(scrollY, this._context.maxScrollY ?? 0);
+      this._context.maxScrollHeight = Math.max(scrollHeight, this._context.maxScrollHeight ?? 0);
+      this._context.lastContentY = contentY;
+      this._context.maxContentY = Math.max(contentY, this._context.maxContentY ?? 0);
+      this._context.maxContentHeight = Math.max(contentHeight, this._context.maxContentHeight ?? 0);
+    };
+  }
+  getContext() {
+    return this._context;
+  }
+  resetContext() {
+    const ctx = this._context;
+    // update the scroll properties for the new page, but wait until the next tick
+    // of the event loop
+    setTimeout(this._updateScrollData, 0);
+    return ctx;
+  }
+  // `capture: true` is required to get scroll events for other scrollable elements
+  // on the page, not just the window
+  // see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#usecapture
+  startMeasuringScrollPosition() {
+    addEventListener(win, 'scroll', this._updateScrollData, {
+      capture: true
+    });
+    addEventListener(win, 'scrollend', this._updateScrollData, {
+      capture: true
+    });
+    addEventListener(win, 'resize', this._updateScrollData);
+  }
+  scrollElement() {
+    if (this._instance.config.scroll_root_selector) {
+      const selectors = core.isArray(this._instance.config.scroll_root_selector) ? this._instance.config.scroll_root_selector : [this._instance.config.scroll_root_selector];
+      for (const selector of selectors) {
+        const element = win?.document.querySelector(selector);
+        if (element) {
+          return element;
         }
-      } catch (err) {
-        logger.warn('Failed to load persisted data', err);
       }
+      return undefined;
+    } else {
+      return win?.document.documentElement;
+    }
+  }
+  scrollY() {
+    if (this._instance.config.scroll_root_selector) {
+      const element = this.scrollElement();
+      return element && element.scrollTop || 0;
+    } else {
+      return win ? win.scrollY || win.pageYOffset || win.document.documentElement.scrollTop || 0 : 0;
+    }
+  }
+  scrollX() {
+    if (this._instance.config.scroll_root_selector) {
+      const element = this.scrollElement();
+      return element && element.scrollLeft || 0;
+    } else {
+      return win ? win.scrollX || win.pageXOffset || win.document.documentElement.scrollLeft || 0 : 0;
+    }
+  }
+}
+
+const DEFAULT_BLOCKED_UA_STRS = [
+// Random assortment of bots
+'amazonbot', 'amazonproductbot', 'app.hypefactors.com',
+// Buck, but "buck" is too short to be safe to block (https://app.hypefactors.com/media-monitoring/about.htm)
+'applebot', 'archive.org_bot', 'awariobot', 'backlinksextendedbot', 'baiduspider', 'bingbot', 'bingpreview', 'chrome-lighthouse', 'dataforseobot', 'deepscan', 'duckduckbot', 'facebookexternal', 'facebookcatalog', 'http://yandex.com/bots', 'hubspot', 'ia_archiver', 'leikibot', 'linkedinbot', 'meta-externalagent', 'mj12bot', 'msnbot', 'nessus', 'petalbot', 'pinterest', 'prerender', 'rogerbot', 'screaming frog', 'sebot-wa', 'sitebulb', 'slackbot', 'slurp', 'trendictionbot', 'turnitin', 'twitterbot', 'vercel-screenshot', 'vercelbot', 'yahoo! slurp', 'yandexbot', 'zoombot',
+// Bot-like words, maybe we should block `bot` entirely?
+'bot.htm', 'bot.php', '(bot;', 'bot/', 'crawler',
+// Ahrefs: https://ahrefs.com/seo/glossary/ahrefsbot
+'ahrefsbot', 'ahrefssiteaudit',
+// Semrush bots: https://www.semrush.com/bot/
+'semrushbot', 'siteauditbot', 'splitsignalbot',
+// AI Crawlers
+'gptbot', 'oai-searchbot', 'chatgpt-user', 'perplexitybot',
+// Uptime-like stuff
+'better uptime bot', 'sentryuptimebot', 'uptimerobot',
+// headless browsers
+'headlesschrome', 'cypress',
+// we don't block electron here, as many customers use posthog-js in electron apps
+// a whole bunch of goog-specific crawlers
+// https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers
+'google-hoteladsverifier', 'adsbot-google', 'apis-google', 'duplexweb-google', 'feedfetcher-google', 'google favicon', 'google web preview', 'google-read-aloud', 'googlebot', 'googleother', 'google-cloudvertexbot', 'googleweblight', 'mediapartners-google', 'storebot-google', 'google-inspectiontool', 'bytespider'];
+/**
+ * Block various web spiders from executing our JS and sending false capturing data
+ */
+const isBlockedUA = function (ua, customBlockedUserAgents) {
+  if (!ua) {
+    return false;
+  }
+  const uaLower = ua.toLowerCase();
+  return DEFAULT_BLOCKED_UA_STRS.concat(customBlockedUserAgents || []).some(blockedUA => {
+    const blockedUaLower = blockedUA.toLowerCase();
+    // can't use includes because IE 11 :/
+    return uaLower.indexOf(blockedUaLower) !== -1;
+  });
+};
+const isLikelyBot = function (navigator, customBlockedUserAgents) {
+  if (!navigator) {
+    return false;
+  }
+  const ua = navigator.userAgent;
+  if (ua) {
+    if (isBlockedUA(ua, customBlockedUserAgents)) {
+      return true;
+    }
+  }
+  try {
+    // eslint-disable-next-line compat/compat
+    const uaData = navigator?.userAgentData;
+    if (uaData?.brands && uaData.brands.some(brandObj => isBlockedUA(brandObj?.brand, customBlockedUserAgents))) {
+      return true;
     }
-    logger.info('Leanbase initialized', {
-      apiKey,
-      host: leanbaseOptions.host
+  } catch {
+    // ignore the error, we were using experimental browser features
+  }
+  return !!navigator.webdriver;
+  // There's some more enhancements we could make in this area, e.g. it's possible to check if Chrome dev tools are
+  // open, which will detect some bots that are trying to mask themselves and might get past the checks above.
+  // However, this would give false positives for actual humans who have dev tools open.
+  // We could also use the data in navigator.userAgentData.getHighEntropyValues() to detect bots, but we should wait
+  // until this stops being experimental. The MDN docs imply that this might eventually require user permission.
+  // See https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUAData/getHighEntropyValues
+  // It would be very bad if posthog-js caused a permission prompt to appear on every page load.
+};
+
+const defaultConfig = () => ({
+  host: 'https://i.leanbase.co',
+  token: '',
+  autocapture: true,
+  rageclick: true,
+  persistence: 'localStorage+cookie',
+  capture_pageview: 'history_change',
+  capture_pageleave: 'if_capture_pageview',
+  persistence_name: '',
+  mask_all_element_attributes: false,
+  cookie_expiration: 365,
+  cross_subdomain_cookie: isCrossDomainCookie(document?.location),
+  custom_campaign_params: [],
+  custom_personal_data_properties: [],
+  disable_persistence: false,
+  mask_personal_data_properties: false,
+  secure_cookie: window?.location?.protocol === 'https:',
+  mask_all_text: false,
+  bootstrap: {},
+  session_idle_timeout_seconds: 30 * 60,
+  save_campaign_params: true,
+  save_referrer: true,
+  opt_out_useragent_filter: false,
+  properties_string_max_length: 65535,
+  loaded: () => {}
+});
+class Leanbase extends core.PostHogCore {
+  constructor(token, config) {
+    const mergedConfig = extend(defaultConfig(), config || {}, {
+      token
     });
-    // Preload feature flags if not explicitly disabled
-    if (options?.preloadFeatureFlags !== false) {
+    super(token, mergedConfig);
+    this.personProcessingSetOncePropertiesSent = false;
+    this.isLoaded = false;
+    this.config = mergedConfig;
+    this.visibilityStateListener = null;
+    this.initialPageviewCaptured = false;
+    this.scrollManager = new ScrollManager(this);
+    this.pageViewManager = new PageViewManager(this);
+    this.init(token, mergedConfig);
+  }
+  init(token, config) {
+    this.setConfig(extend(defaultConfig(), config, {
+      token
+    }));
+    this.isLoaded = true;
+    this.persistence = new LeanbasePersistence(this.config);
+    this.replayAutocapture = new Autocapture(this);
+    this.replayAutocapture.startIfEnabled();
+    if (this.config.preloadFeatureFlags !== false) {
       this.reloadFeatureFlags();
     }
+    this.config.loaded?.(this);
+    if (this.config.capture_pageview) {
+      setTimeout(() => {
+        if (this.config.cookieless_mode === 'always') {
+          this.captureInitialPageview();
+        }
+      }, 1);
+    }
+    addEventListener(document, 'DOMContentLoaded', () => {
+      this.loadRemoteConfig();
+    });
+    addEventListener(window, 'onpagehide' in self ? 'pagehide' : 'unload', this.capturePageLeave.bind(this), {
+      passive: false
+    });
+  }
+  captureInitialPageview() {
+    if (!document) {
+      return;
+    }
+    if (document.visibilityState !== 'visible') {
+      if (!this.visibilityStateListener) {
+        this.visibilityStateListener = this.captureInitialPageview.bind(this);
+        addEventListener(document, 'visibilitychange', this.visibilityStateListener);
+      }
+      return;
+    }
+    if (!this.initialPageviewCaptured) {
+      this.initialPageviewCaptured = true;
+      this.capture('$pageview', {
+        title: document.title
+      });
+      if (this.visibilityStateListener) {
+        document.removeEventListener('visibilitychange', this.visibilityStateListener);
+        this.visibilityStateListener = null;
+      }
+    }
+  }
+  capturePageLeave() {
+    const {
+      capture_pageleave,
+      capture_pageview
+    } = this.config;
+    if (capture_pageleave === true || capture_pageleave === 'if_capture_pageview' && (capture_pageview === true || capture_pageview === 'history_change')) {
+      this.capture('$pageleave');
+    }
+  }
+  async loadRemoteConfig() {
+    if (!this.isRemoteConfigLoaded) {
+      const remoteConfig = await this.reloadRemoteConfigAsync();
+      if (remoteConfig) {
+        this.onRemoteConfig(remoteConfig);
+      }
+    }
+  }
+  onRemoteConfig(config) {
+    if (!(document && document.body)) {
+      setTimeout(() => {
+        this.onRemoteConfig(config);
+      }, 500);
+      return;
+    }
+    this.isRemoteConfigLoaded = true;
+    this.replayAutocapture?.onRemoteConfig(config);
   }
-  // PostHogCore abstract methods
   fetch(url, options) {
     const fetchFn = core.getFetch();
     if (!fetchFn) {
@@ -68,49 +2857,176 @@ class Leanbase extends core.PostHogCore {
     }
     return fetchFn(url, options);
   }
+  setConfig(config) {
+    const oldConfig = {
+      ...this.config
+    };
+    if (core.isObject(config)) {
+      extend(this.config, config);
+      this.persistence?.update_config(this.config, oldConfig);
+      this.replayAutocapture?.startIfEnabled();
+    }
+    const isTempStorage = this.config.persistence === 'sessionStorage' || this.config.persistence === 'memory';
+    this.sessionPersistence = isTempStorage ? this.persistence : new LeanbasePersistence({
+      ...this.config,
+      persistence: 'sessionStorage'
+    });
+  }
   getLibraryId() {
     return 'leanbase';
   }
   getLibraryVersion() {
-    return version;
+    return Config.LIB_VERSION;
   }
   getCustomUserAgent() {
     return;
   }
   getPersistedProperty(key) {
-    return this._storage.get(key);
+    return this.persistence?.get_property(key);
   }
   setPersistedProperty(key, value) {
-    if (core.isNull(value)) {
-      this._storage.delete(key);
-    } else {
-      this._storage.set(key, value);
+    this.persistence?.set_property(key, value);
+  }
+  calculateEventProperties(eventName, eventProperties, timestamp, uuid, readOnly) {
+    if (!this.persistence || !this.sessionPersistence) {
+      return eventProperties;
     }
-    // Persist to localStorage if available
-    if (typeof window !== 'undefined' && window.localStorage) {
-      try {
-        const obj = {};
-        this._storage.forEach((v, k) => {
-          obj[k] = v;
-        });
-        window.localStorage.setItem(this._storageKey, JSON.stringify(obj));
-      } catch (err) {
-        logger.warn('Failed to persist data', err);
+    timestamp = timestamp || new Date();
+    const startTimestamp = readOnly ? undefined : this.persistence?.remove_event_timer(eventName);
+    let properties = {
+      ...eventProperties
+    };
+    properties['token'] = this.config.token;
+    if (this.config.cookieless_mode == 'always' || this.config.cookieless_mode == 'on_reject') {
+      properties[COOKIELESS_MODE_FLAG_PROPERTY] = true;
+    }
+    if (eventName === '$snapshot') {
+      const persistenceProps = {
+        ...this.persistence.properties()
+      };
+      properties['distinct_id'] = persistenceProps.distinct_id;
+      if (!(core.isString(properties['distinct_id']) || core.isNumber(properties['distinct_id'])) || core.isEmptyString(properties['distinct_id'])) {
+        logger.error('Invalid distinct_id for replay event. This indicates a bug in your implementation');
       }
+      return properties;
+    }
+    const infoProperties = getEventProperties(this.config.mask_personal_data_properties, this.config.custom_personal_data_properties);
+    if (this.sessionManager) {
+      const {
+        sessionId,
+        windowId
+      } = this.sessionManager.checkAndGetSessionAndWindowId(readOnly, timestamp.getTime());
+      properties['$session_id'] = sessionId;
+      properties['$window_id'] = windowId;
+    }
+    if (this.sessionPropsManager) {
+      extend(properties, this.sessionPropsManager.getSessionProps());
+    }
+    let pageviewProperties = this.pageViewManager.doEvent();
+    if (eventName === '$pageview' && !readOnly) {
+      pageviewProperties = this.pageViewManager.doPageView(timestamp, uuid);
+    }
+    if (eventName === '$pageleave' && !readOnly) {
+      pageviewProperties = this.pageViewManager.doPageLeave(timestamp);
+    }
+    properties = extend(properties, pageviewProperties);
+    if (eventName === '$pageview' && document) {
+      properties['title'] = document.title;
+    }
+    if (!core.isUndefined(startTimestamp)) {
+      const duration_in_ms = timestamp.getTime() - startTimestamp;
+      properties['$duration'] = parseFloat((duration_in_ms / 1000).toFixed(3));
+    }
+    if (userAgent && this.config.opt_out_useragent_filter) {
+      properties['$browser_type'] = isLikelyBot(navigator$1, []) ? 'bot' : 'browser';
+    }
+    properties = extend({}, infoProperties, this.persistence.properties(), this.sessionPersistence.properties(), properties);
+    properties['$is_identified'] = this.isIdentified();
+    return properties;
+  }
+  isIdentified() {
+    return this.persistence?.get_property(USER_STATE) === 'identified' || this.sessionPersistence?.get_property(USER_STATE) === 'identified';
+  }
+  /**
+   * Add additional set_once properties to the event when creating a person profile. This allows us to create the
+   * profile with mostly-accurate properties, despite earlier events not setting them. We do this by storing them in
+   * persistence.
+   * @param dataSetOnce
+   */
+  calculateSetOnceProperties(dataSetOnce) {
+    if (!this.persistence) {
+      return dataSetOnce;
+    }
+    if (this.personProcessingSetOncePropertiesSent) {
+      return dataSetOnce;
+    }
+    const initialProps = this.persistence.get_initial_props();
+    const sessionProps = this.sessionPropsManager?.getSetOnceProps();
+    const setOnceProperties = extend({}, initialProps, sessionProps || {}, dataSetOnce || {});
+    this.personProcessingSetOncePropertiesSent = true;
+    if (core.isEmptyObject(setOnceProperties)) {
+      return undefined;
     }
+    return setOnceProperties;
   }
-  // Public API: leanbase.capture()
   capture(event, properties, options) {
-    super.capture(event, properties, options);
+    if (!this.isLoaded || !this.sessionPersistence || !this.persistence) {
+      return;
+    }
+    if (core.isUndefined(event) || !core.isString(event)) {
+      logger.error('No event name provided to posthog.capture');
+      return;
+    }
+    if (properties?.$current_url && !core.isString(properties?.$current_url)) {
+      logger.error('Invalid `$current_url` property provided to `posthog.capture`. Input must be a string. Ignoring provided value.');
+      delete properties?.$current_url;
+    }
+    this.sessionPersistence.update_search_keyword();
+    if (this.config.save_campaign_params) {
+      this.sessionPersistence.update_campaign_params();
+    }
+    if (this.config.save_referrer) {
+      this.sessionPersistence.update_referrer_info();
+    }
+    if (this.config.save_campaign_params || this.config.save_referrer) {
+      this.persistence.set_initial_person_info();
+    }
+    const systemTime = new Date();
+    const timestamp = options?.timestamp || systemTime;
+    const uuid = uuidv7();
+    let data = {
+      uuid,
+      event,
+      properties: this.calculateEventProperties(event, properties || {}, timestamp, uuid)
+    };
+    const setProperties = options?.$set;
+    if (setProperties) {
+      data.$set = options?.$set;
+    }
+    const setOnceProperties = this.calculateSetOnceProperties(options?.$set_once);
+    if (setOnceProperties) {
+      data.$set_once = setOnceProperties;
+    }
+    data = copyAndTruncateStrings(data, options?._noTruncate ? null : this.config.properties_string_max_length);
+    data.timestamp = timestamp;
+    if (!core.isUndefined(options?.timestamp)) {
+      data.properties['$event_time_override_provided'] = true;
+      data.properties['$event_time_override_system_time'] = systemTime;
+    }
+    const finalSet = {
+      ...data.properties['$set'],
+      ...data['$set']
+    };
+    if (!core.isEmptyObject(finalSet)) {
+      this.setPersonPropertiesForFlags(finalSet);
+    }
+    super.capture(data.event, data.properties, options);
   }
-  // Public API: leanbase.identify()
   identify(distinctId, properties, options) {
     super.identify(distinctId, properties, options);
   }
-  // Cleanup
   destroy() {
-    // Future: cleanup autocapture and session recording
-    this._storage.clear();
+    this.persistence?.clear();
   }
 }