@leanbase.com/js 0.1.1 → 0.1.3

package/dist/leanbase.iife.js

@@ -102,8 +102,8 @@ var leanbase = (function () {
      * @license Apache-2.0
      * @copyright 2021-2023 LiosK
      * @packageDocumentation
-     */ const DIGITS = "0123456789abcdef";
-    class UUID {
+     */ const DIGITS$1 = "0123456789abcdef";
+    let UUID$1 = class UUID {
         constructor(bytes){
             this.bytes = bytes;
         }
@@ -164,8 +164,8 @@ var leanbase = (function () {
         toString() {
             let text = "";
             for(let i = 0; i < this.bytes.length; i++){
-                text += DIGITS.charAt(this.bytes[i] >>> 4);
-                text += DIGITS.charAt(0xf & this.bytes[i]);
+                text += DIGITS$1.charAt(this.bytes[i] >>> 4);
+                text += DIGITS$1.charAt(0xf & this.bytes[i]);
                 if (3 === i || 5 === i || 7 === i || 9 === i) text += "-";
             }
             return text;
@@ -173,8 +173,8 @@ var leanbase = (function () {
         toHex() {
             let text = "";
             for(let i = 0; i < this.bytes.length; i++){
-                text += DIGITS.charAt(this.bytes[i] >>> 4);
-                text += DIGITS.charAt(0xf & this.bytes[i]);
+                text += DIGITS$1.charAt(this.bytes[i] >>> 4);
+                text += DIGITS$1.charAt(0xf & this.bytes[i]);
             }
             return text;
         }
@@ -206,8 +206,8 @@ var leanbase = (function () {
             }
             return 0;
         }
-    }
-    class V7Generator {
+    };
+    let V7Generator$1 = class V7Generator {
         constructor(randomNumberGenerator){
             this.timestamp = 0;
             this.counter = 0;
@@ -242,7 +242,7 @@ var leanbase = (function () {
                     this.resetCounter();
                 }
             }
-            return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & 2 ** 30 - 1, this.random.nextUint32());
+            return UUID$1.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & 2 ** 30 - 1, this.random.nextUint32());
         }
         resetCounter() {
             this.counter = 0x400 * this.random.nextUint32() + (0x3ff & this.random.nextUint32());
@@ -251,15 +251,15 @@ var leanbase = (function () {
             const bytes = new Uint8Array(Uint32Array.of(this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32()).buffer);
             bytes[6] = 0x40 | bytes[6] >>> 4;
             bytes[8] = 0x80 | bytes[8] >>> 2;
-            return UUID.ofInner(bytes);
+            return UUID$1.ofInner(bytes);
         }
-    }
+    };
     const getDefaultRandom = ()=>({
             nextUint32: ()=>0x10000 * Math.trunc(0x10000 * Math.random()) + Math.trunc(0x10000 * Math.random())
         });
-    let defaultGenerator;
-    const uuidv7 = ()=>uuidv7obj().toString();
-    const uuidv7obj = ()=>(defaultGenerator || (defaultGenerator = new V7Generator())).generate();
+    let defaultGenerator$1;
+    const uuidv7$1 = ()=>uuidv7obj$1().toString();
+    const uuidv7obj$1 = ()=>(defaultGenerator$1 || (defaultGenerator$1 = new V7Generator$1())).generate();
 
     var types_PostHogPersistedProperty = /*#__PURE__*/ function(PostHogPersistedProperty) {
         PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
@@ -295,19 +295,58 @@ var leanbase = (function () {
         return Compression;
     }({});
 
+    function includes(str, needle) {
+        return -1 !== str.indexOf(needle);
+    }
+    const trim = function(str) {
+        return str.trim();
+    };
+    const stripLeadingDollar = function(s) {
+        return s.replace(/^\$/, '');
+    };
+
     const nativeIsArray = Array.isArray;
     const ObjProto = Object.prototype;
+    const type_utils_hasOwnProperty = ObjProto.hasOwnProperty;
     const type_utils_toString = ObjProto.toString;
     const isArray = nativeIsArray || function(obj) {
         return '[object Array]' === type_utils_toString.call(obj);
     };
     const isFunction = (x)=>'function' == typeof x;
+    const isObject = (x)=>x === Object(x) && !isArray(x);
+    const isEmptyObject = (x)=>{
+        if (isObject(x)) {
+            for(const key in x)if (type_utils_hasOwnProperty.call(x, key)) return false;
+            return true;
+        }
+        return false;
+    };
+    const isUndefined = (x)=>void 0 === x;
+    const isString = (x)=>'[object String]' == type_utils_toString.call(x);
+    const isEmptyString = (x)=>isString(x) && 0 === x.trim().length;
     const isNull = (x)=>null === x;
+    const isNullish = (x)=>isUndefined(x) || isNull(x);
+    const isNumber = (x)=>'[object Number]' == type_utils_toString.call(x);
+    const isBoolean = (x)=>'[object Boolean]' === type_utils_toString.call(x);
+    const isFormData = (x)=>x instanceof FormData;
     const isPlainError = (x)=>x instanceof Error;
 
+    function clampToRange(value, min, max, logger, fallbackValue) {
+        if (isNumber(value)) if (value > max) {
+            logger.warn(' cannot be  greater than max: ' + max + '. Using max value instead.');
+            return max;
+        } else {
+            if (!(value < min)) return value;
+            logger.warn(' cannot be less than min: ' + min + '. Using min value instead.');
+            return min;
+        }
+        logger.warn(' must be a number. using max or fallback. max: ' + max + ', fallback: ' + fallbackValue);
+        return clampToRange(max, min, max, logger);
+    }
+
     class PromiseQueue {
         add(promise) {
-            const promiseUUID = uuidv7();
+            const promiseUUID = uuidv7$1();
             this.promiseByIds[promiseUUID] = promise;
             promise.catch(()=>{}).finally(()=>{
                 delete this.promiseByIds[promiseUUID];
@@ -906,7 +945,7 @@ var leanbase = (function () {
                 library: this.getLibraryId(),
                 library_version: this.getLibraryVersion(),
                 timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
-                uuid: options?.uuid ? options.uuid : uuidv7()
+                uuid: options?.uuid ? options.uuid : uuidv7$1()
             };
             const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
             if (addGeoipDisableProperty) {
@@ -1169,7 +1208,7 @@ var leanbase = (function () {
             const sessionLastDif = now - sessionLastTimestamp;
             const sessionStartDif = now - sessionStartTimestamp;
             if (!sessionId || sessionLastDif > 1000 * this._sessionExpirationTimeSeconds || sessionStartDif > 1000 * this._sessionMaxLengthSeconds) {
-                sessionId = uuidv7();
+                sessionId = uuidv7$1();
                 this.setPersistedProperty(types_PostHogPersistedProperty.SessionId, sessionId);
                 this.setPersistedProperty(types_PostHogPersistedProperty.SessionStartTimestamp, now);
             }
@@ -1187,7 +1226,7 @@ var leanbase = (function () {
             if (!this._isInitialized) return '';
             let anonId = this.getPersistedProperty(types_PostHogPersistedProperty.AnonymousId);
             if (!anonId) {
-                anonId = uuidv7();
+                anonId = uuidv7$1();
                 this.setPersistedProperty(types_PostHogPersistedProperty.AnonymousId, anonId);
             }
             return anonId;
@@ -1593,173 +1632,3093 @@ var leanbase = (function () {
         }
     }
 
-    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 (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 (isNullish(obj)) {
+        return;
+      }
+      if (isArray(obj)) {
+        return eachArray(obj, iterator, thisArg);
+      }
+      if (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 (type_utils_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 (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 (isString(v) && v.length > 0 || 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 (!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 (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 (isString(value) && !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
+    types_PostHogPersistedProperty.Queue, types_PostHogPersistedProperty.FeatureFlagDetails, types_PostHogPersistedProperty.FlagsEndpointWasHit, types_PostHogPersistedProperty.AnonymousId, types_PostHogPersistedProperty.RemoteConfig, types_PostHogPersistedProperty.Surveys, types_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);
         }
       },
       error: (...args) => {
         if (typeof console !== 'undefined') {
-          // eslint-disable-next-line no-console
           console.error(PREFIX, ...args);
         }
+      },
+      critical: (...args) => {
+        if (typeof console !== 'undefined') {
+          console.error(PREFIX, 'CRITICAL:', ...args);
+        }
       }
     };
 
-    class Leanbase extends PostHogCore {
-      constructor(apiKey, options) {
-        // Leanbase defaults
-        const leanbaseOptions = {
-          host: 'https://i.leanbase.co',
-          ...options
-        };
-        super(apiKey, leanbaseOptions);
-        this._storage = new Map();
-        this._storageKey = `leanbase_${apiKey}`;
-        // Load from localStorage if available
-        if (typeof window !== 'undefined' && window.localStorage) {
-          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);
-              });
-            }
-          } catch (err) {
-            logger.warn('Failed to load persisted data', err);
-          }
-        }
-        logger.info('Leanbase initialized', {
-          apiKey,
-          host: leanbaseOptions.host
-        });
-        // Preload feature flags if not explicitly disabled
-        if (options?.preloadFeatureFlags !== false) {
-          this.reloadFeatureFlags();
+    /**
+     * 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 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');
         }
       }
-      // PostHogCore abstract methods
-      fetch(url, options) {
-        const fetchFn = getFetch();
-        if (!fetchFn) {
-          return Promise.reject(new Error('Fetch API is not available in this environment.'));
+      /**
+       * 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 += '-';
+          }
         }
-        return fetchFn(url, options);
+        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;
       }
-      getLibraryId() {
-        return 'leanbase';
+      /** Creates an object from `this`. */
+      clone() {
+        return new UUID(this.bytes.slice(0));
       }
-      getLibraryVersion() {
-        return version;
+      /** Returns true if `this` is equivalent to `other`. */
+      equals(other) {
+        return this.compareTo(other) === 0;
       }
-      getCustomUserAgent() {
-        return;
+      /**
+       * 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;
       }
-      getPersistedProperty(key) {
-        return this._storage.get(key);
+    }
+    /** Encapsulates the monotonic counter state. */
+    class V7Generator {
+      constructor() {
+        this._timestamp = 0;
+        this._counter = 0;
+        this._random = new DefaultRandom();
       }
-      setPersistedProperty(key, value) {
-        if (isNull(value)) {
-          this._storage.delete(key);
+      /**
+       * 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 (!isUndefined(value)) {
+          return value;
         } else {
-          this._storage.set(key, value);
+          // reset state and resume
+          this._timestamp = 0;
+          const valueAfterReset = this.generateOrAbort();
+          if (isUndefined(valueAfterReset)) {
+            throw new Error('Could not generate UUID after timestamp reset');
+          }
+          return valueAfterReset;
         }
-        // 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);
+      }
+      /**
+       * 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());
       }
-      // Public API: leanbase.capture()
-      capture(event, properties, options) {
-        super.capture(event, properties, options);
+      /** Initializes the counter at a 42-bit random integer. */
+      _resetCounter() {
+        this._counter = this._random.nextUint32() * 0x400 + (this._random.nextUint32() & 0x3ff);
       }
-      // Public API: leanbase.identify()
-      identify(distinctId, properties, options) {
-        super.identify(distinctId, properties, options);
+    }
+    /** 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');
       }
-      // Cleanup
-      destroy() {
-        // Future: cleanup autocapture and session recording
-        this._storage.clear();
+      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 && !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();
 
-    const api = {
-      _instance: null,
-      _queue: [],
-      init(apiKey, options) {
-        this._instance = new Leanbase(apiKey, options);
-        // Flush queued calls
-        const q = this._queue;
-        this._queue = [];
-        for (const {
-          fn,
-          args
-        } of q) {
-          // @ts-expect-error dynamic dispatch to API methods
-          this[fn](...args);
+    // 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);
       },
-      capture(...args) {
-        if (this._instance) {
-          this._instance.capture(...args);
-        } else {
-          this._queue.push({
-            fn: 'capture',
-            args
-          });
+      _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;
       },
-      identify(...args) {
-        if (this._instance) {
-          this._instance.identify(...args);
+      _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 (!isNull(_localStorage_supported)) {
+          return _localStorage_supported;
+        }
+        let supported = true;
+        if (!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 {
-          this._queue.push({
-            fn: 'identify',
-            args
+          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);
         }
       },
-      group(...args) {
-        if (this._instance && isFunction(this._instance.group)) {
-          this._instance.group(...args);
+      _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 (!isNull(sessionStorageSupported)) {
+          return sessionStorageSupported;
+        }
+        sessionStorageSupported = true;
+        if (!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 {
-          this._queue.push({
-            fn: 'group',
-            args
-          });
+          sessionStorageSupported = false;
         }
+        return sessionStorageSupported;
       },
-      alias(...args) {
-        if (this._instance && isFunction(this._instance.alias)) {
-          this._instance.alias(...args);
+      _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 (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 (!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 (!isArray(keyValuePair)) {
+          continue;
+        } else if (maskedParams.includes(keyValuePair[0])) {
+          paramStrings.push(keyValuePair[0] + '=' + mask);
         } else {
-          this._queue.push({
-            fn: 'alias',
-            args
-          });
+          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 includes(userAgent, SAFARI) && !includes(userAgent, CHROME) && !includes(userAgent, ANDROID);
+    }
+    const safariCheck = (ua, vendor) => vendor && 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 (includes(user_agent, ' OPR/') && includes(user_agent, 'Mini')) {
+        return OPERA_MINI;
+      } else if (includes(user_agent, ' OPR/')) {
+        return OPERA;
+      } else if (BLACKBERRY_REGEX.test(user_agent)) {
+        return BLACKBERRY;
+      } else if (includes(user_agent, 'IE' + MOBILE) || includes(user_agent, 'WPDesktop')) {
+        return INTERNET_EXPLORER_MOBILE;
+      }
+      // https://developer.samsung.com/internet/user-agent-string-format
+      else if (includes(user_agent, SAMSUNG_BROWSER)) {
+        return SAMSUNG_INTERNET;
+      } else if (includes(user_agent, EDGE) || includes(user_agent, 'Edg/')) {
+        return MICROSOFT_EDGE;
+      } else if (includes(user_agent, 'FBIOS')) {
+        return FACEBOOK + ' ' + MOBILE;
+      } else if (includes(user_agent, 'UCWEB') || includes(user_agent, 'UCBrowser')) {
+        return 'UC Browser';
+      } else if (includes(user_agent, 'CriOS')) {
+        return CHROME_IOS; // why not just Chrome?
+      } else if (includes(user_agent, 'CrMo')) {
+        return CHROME;
+      } else if (includes(user_agent, CHROME)) {
+        return CHROME;
+      } else if (includes(user_agent, ANDROID) && includes(user_agent, SAFARI)) {
+        return ANDROID_MOBILE;
+      } else if (includes(user_agent, 'FxiOS')) {
+        return FIREFOX_IOS;
+      } else if (includes(user_agent.toLowerCase(), KONQUEROR.toLowerCase())) {
+        return KONQUEROR;
+      } else if (safariCheck(user_agent, vendor)) {
+        return includes(user_agent, MOBILE) ? MOBILE_SAFARI : SAFARI;
+      } else if (includes(user_agent, FIREFOX)) {
+        return FIREFOX;
+      } else if (includes(user_agent, 'MSIE') || includes(user_agent, 'Trident/')) {
+        return INTERNET_EXPLORER;
+      } else if (includes(user_agent, 'Gecko')) {
+        return 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 (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 = 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 && (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 (!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_${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 && 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 (isObject(props)) {
+          if (isUndefined(default_value)) {
+            default_value = 'None';
+          }
+          this._expire_days = 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 (isObject(props)) {
+          this._expire_days = 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 (!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_' + 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 (!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 ? 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 (isNullish(s)) {
+        return null;
+      }
+      return 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 trim(elText);
+    }
+    function getEventTarget(e) {
+      // https://developer.mozilla.org/en-US/docs/Web/API/Event/target#Compatibility_notes
+      if (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 (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;
+        }
+      }
+      // 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 (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 (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 (includes(classes, 'ph-sensitive') || includes(classes, 'ph-no-capture')) {
+          return false;
+        }
+      }
+      if (includes(getClassNames(el), 'ph-include')) {
+        return true;
+      }
+      // don't include hidden or password fields
+      const type = el.type || '';
+      if (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 (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 (isNullish(value)) {
+        return false;
+      }
+      if (isString(value)) {
+        value = trim(value);
+        // check to see if input value looks like a credit card number
+        // see: https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9781449327453/ch04s20.html
+        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 (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 (isArray(attr_class)) {
+        return attr_class;
+      } else {
+        return splitClassString(attr_class);
+      }
+    }
+
+    // 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 (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
+        };
+      }
+      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 = 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 {
+            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 (isNull(memoryDisabled) && !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 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 (!isUndefined(maxScrollHeight) && !isUndefined(lastScrollY) && !isUndefined(maxScrollY) && !isUndefined(maxContentHeight) && !isUndefined(lastContentY) && !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 : clampToRange(lastScrollY / maxScrollHeight, 0, 1, logger);
+            const maxScrollPercentage = maxScrollHeight <= 1 ? 1 : clampToRange(maxScrollY / maxScrollHeight, 0, 1, logger);
+            const lastContentPercentage = maxContentHeight <= 1 ? 1 : clampToRange(lastContentY / maxContentHeight, 0, 1, logger);
+            const maxContentPercentage = maxContentHeight <= 1 ? 1 : 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 = 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;
+            }
+          }
+          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;
+        }
+      } 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 PostHogCore {
+      constructor(token, config) {
+        const mergedConfig = extend(defaultConfig(), config || {}, {
+          token
+        });
+        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);
+      }
+      fetch(url, options) {
+        const fetchFn = getFetch();
+        if (!fetchFn) {
+          return Promise.reject(new Error('Fetch API is not available in this environment.'));
+        }
+        return fetchFn(url, options);
+      }
+      setConfig(config) {
+        const oldConfig = {
+          ...this.config
+        };
+        if (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 Config.LIB_VERSION;
+      }
+      getCustomUserAgent() {
+        return;
+      }
+      getPersistedProperty(key) {
+        return this.persistence?.get_property(key);
+      }
+      setPersistedProperty(key, value) {
+        this.persistence?.set_property(key, value);
+      }
+      calculateEventProperties(eventName, eventProperties, timestamp, uuid, readOnly) {
+        if (!this.persistence || !this.sessionPersistence) {
+          return eventProperties;
+        }
+        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 (!(isString(properties['distinct_id']) || isNumber(properties['distinct_id'])) || 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 (!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 (isEmptyObject(setOnceProperties)) {
+          return undefined;
+        }
+        return setOnceProperties;
+      }
+      capture(event, properties, options) {
+        if (!this.isLoaded || !this.sessionPersistence || !this.persistence) {
+          return;
+        }
+        if (isUndefined(event) || !isString(event)) {
+          logger.error('No event name provided to posthog.capture');
+          return;
+        }
+        if (properties?.$current_url && !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 (!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 (!isEmptyObject(finalSet)) {
+          this.setPersonPropertiesForFlags(finalSet);
+        }
+        super.capture(data.event, data.properties, options);
+      }
+      identify(distinctId, properties, options) {
+        super.identify(distinctId, properties, options);
+      }
+      destroy() {
+        this.persistence?.clear();
+      }
+    }
+
+    const api = {
+      _instance: null,
+      _queue: [],
+      init(apiKey, options) {
+        this._instance = new Leanbase(apiKey, options);
+        const q = this._queue;
+        this._queue = [];
+        for (const {
+          fn,
+          args
+        } of q) {
+          // @ts-expect-error dynamic dispatch to API methods
+          this[fn](...args);
+        }
+      },
+      capture(...args) {
+        if (this._instance) {
+          return this._instance.capture(...args);
+        }
+        this._queue.push({
+          fn: 'capture',
+          args
+        });
+      },
+      captureException(...args) {
+        if (this._instance) {
+          return this._instance.captureException(...args);
+        }
+        this._queue.push({
+          fn: 'captureException',
+          args
+        });
+      },
+      identify(...args) {
+        if (this._instance) {
+          return this._instance.identify(...args);
+        }
+        this._queue.push({
+          fn: 'identify',
+          args
+        });
+      },
+      group(...args) {
+        if (this._instance) {
+          return this._instance.group(...args);
+        }
+        this._queue.push({
+          fn: 'group',
+          args
+        });
+      },
+      alias(...args) {
+        if (this._instance) {
+          return this._instance.alias(...args);
+        }
+        this._queue.push({
+          fn: 'alias',
+          args
+        });
       },
       reset() {
         this._instance?.reset();