posthog-js-lite 2.6.1 → 3.0.0-beta.1

package/lib/index.cjs.js

@@ -2,148 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-var extendStatics = function (d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b)
-            if (Object.prototype.hasOwnProperty.call(b, p))
-                d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-var __assign = function () {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s)
-                if (Object.prototype.hasOwnProperty.call(s, p))
-                    t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try {
-            step(generator.next(value));
-        }
-        catch (e) {
-            reject(e);
-        } }
-        function rejected(value) { try {
-            step(generator["throw"](value));
-        }
-        catch (e) {
-            reject(e);
-        } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function () { if (t[0] & 1)
-            throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f)
-            throw new TypeError("Generator is already executing.");
-        while (_)
-            try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-                    return t;
-                if (y = 0, t)
-                    op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0:
-                    case 1:
-                        t = op;
-                        break;
-                    case 4:
-                        _.label++;
-                        return { value: op[1], done: false };
-                    case 5:
-                        _.label++;
-                        y = op[1];
-                        op = [0];
-                        continue;
-                    case 7:
-                        op = _.ops.pop();
-                        _.trys.pop();
-                        continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                            _ = 0;
-                            continue;
-                        }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
-                            _.label = op[1];
-                            break;
-                        }
-                        if (op[0] === 6 && _.label < t[1]) {
-                            _.label = t[1];
-                            t = op;
-                            break;
-                        }
-                        if (t && _.label < t[2]) {
-                            _.label = t[2];
-                            _.ops.push(op);
-                            break;
-                        }
-                        if (t[2])
-                            _.ops.pop();
-                        _.trys.pop();
-                        continue;
-                }
-                op = body.call(thisArg, _);
-            }
-            catch (e) {
-                op = [6, e];
-                y = 0;
-            }
-            finally {
-                f = t = 0;
-            }
-        if (op[0] & 5)
-            throw op[1];
-        return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2)
-        for (var i = 0, l = from.length, ar; i < l; i++) {
-            if (ar || !(i in from)) {
-                if (!ar)
-                    ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-            }
-        }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
     PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
@@ -168,48 +26,27 @@ function assert(truthyValue, message) {
     }
 }
 function removeTrailingSlash(url) {
-    return url === null || url === void 0 ? void 0 : url.replace(/\/+$/, '');
+    return url?.replace(/\/+$/, '');
 }
-function retriable(fn, props) {
-    if (props === void 0) { props = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, retryCount, _b, retryDelay, _c, retryCheck, lastError, i, res, e_1;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    _a = props.retryCount, retryCount = _a === void 0 ? 3 : _a, _b = props.retryDelay, retryDelay = _b === void 0 ? 5000 : _b, _c = props.retryCheck, retryCheck = _c === void 0 ? function () { return true; } : _c;
-                    lastError = null;
-                    i = 0;
-                    _d.label = 1;
-                case 1:
-                    if (!(i < retryCount + 1)) return [3 /*break*/, 7];
-                    if (!(i > 0)) return [3 /*break*/, 3];
-                    // don't wait when it's the last try
-                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, retryDelay); })];
-                case 2:
-                    // don't wait when it's the last try
-                    _d.sent();
-                    _d.label = 3;
-                case 3:
-                    _d.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, fn()];
-                case 4:
-                    res = _d.sent();
-                    return [2 /*return*/, res];
-                case 5:
-                    e_1 = _d.sent();
-                    lastError = e_1;
-                    if (!retryCheck(e_1)) {
-                        throw e_1;
-                    }
-                    return [3 /*break*/, 6];
-                case 6:
-                    i++;
-                    return [3 /*break*/, 1];
-                case 7: throw lastError;
+async function retriable(fn, props) {
+    let lastError = null;
+    for (let i = 0; i < props.retryCount + 1; i++) {
+        if (i > 0) {
+            // don't wait when it's the last try
+            await new Promise((r) => setTimeout(r, props.retryDelay));
+        }
+        try {
+            const res = await fn();
+            return res;
+        }
+        catch (e) {
+            lastError = e;
+            if (!props.retryCheck(e)) {
+                throw e;
             }
-        });
-    });
+        }
+    }
+    throw lastError;
 }
 function currentTimestamp() {
     return new Date().getTime();
@@ -220,9 +57,9 @@ function currentISOTime() {
 function safeSetTimeout(fn, timeout) {
     // NOTE: we use this so rarely that it is totally fine to do `safeSetTimeout(fn, 0)``
     // rather than setImmediate.
-    var t = setTimeout(fn, timeout);
+    const t = setTimeout(fn, timeout);
     // We unref if available to prevent Node.js hanging on exit
-    (t === null || t === void 0 ? void 0 : t.unref) && (t === null || t === void 0 ? void 0 : t.unref());
+    t?.unref && t?.unref();
     return t;
 }
 
@@ -236,24 +73,24 @@ function safeSetTimeout(fn, timeout) {
 //
 // LZ-based compression algorithm, version 1.4.4
 // private property
-var f = String.fromCharCode;
-var keyStrBase64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-var baseReverseDic = {};
+const f = String.fromCharCode;
+const keyStrBase64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+const baseReverseDic = {};
 function getBaseValue(alphabet, character) {
     if (!baseReverseDic[alphabet]) {
         baseReverseDic[alphabet] = {};
-        for (var i = 0; i < alphabet.length; i++) {
+        for (let i = 0; i < alphabet.length; i++) {
             baseReverseDic[alphabet][alphabet.charAt(i)] = i;
         }
     }
     return baseReverseDic[alphabet][character];
 }
-var LZString = {
+const LZString = {
     compressToBase64: function (input) {
         if (input == null) {
             return '';
         }
-        var res = LZString._compress(input, 6, function (a) {
+        const res = LZString._compress(input, 6, function (a) {
             return keyStrBase64.charAt(a);
         });
         switch (res.length % 4 // To produce valid Base64
@@ -289,8 +126,8 @@ var LZString = {
         if (uncompressed == null) {
             return '';
         }
-        var context_dictionary = {}, context_dictionaryToCreate = {}, context_data = [];
-        var i, value, context_c = '', context_wc = '', context_w = '', context_enlargeIn = 2, // Compensate for the first entry which should not count
+        const context_dictionary = {}, context_dictionaryToCreate = {}, context_data = [];
+        let i, value, context_c = '', context_wc = '', context_w = '', context_enlargeIn = 2, // Compensate for the first entry which should not count
         context_dictSize = 3, context_numBits = 2, context_data_val = 0, context_data_position = 0, ii;
         for (ii = 0; ii < uncompressed.length; ii += 1) {
             context_c = uncompressed.charAt(ii);
@@ -514,8 +351,8 @@ var LZString = {
         });
     },
     _decompress: function (length, resetValue, getNextValue) {
-        var dictionary = [], result = [], data = { val: getNextValue(0), position: resetValue, index: 1 };
-        var enlargeIn = 4, dictSize = 4, numBits = 3, entry = '', i, w, bits, resb, maxpower, power, c;
+        const dictionary = [], result = [], data = { val: getNextValue(0), position: resetValue, index: 1 };
+        let enlargeIn = 4, dictSize = 4, numBits = 3, entry = '', i, w, bits, resb, maxpower, power, c;
         for (i = 0; i < 3; i += 1) {
             dictionary[i] = i;
         }
@@ -657,34 +494,32 @@ var LZString = {
     },
 };
 
-var SimpleEventEmitter = /** @class */ (function () {
-    function SimpleEventEmitter() {
+class SimpleEventEmitter {
+    constructor() {
         this.events = {};
         this.events = {};
     }
-    SimpleEventEmitter.prototype.on = function (event, listener) {
-        var _this = this;
+    on(event, listener) {
         if (!this.events[event]) {
             this.events[event] = [];
         }
         this.events[event].push(listener);
-        return function () {
-            _this.events[event] = _this.events[event].filter(function (x) { return x !== listener; });
+        return () => {
+            this.events[event] = this.events[event].filter((x) => x !== listener);
         };
-    };
-    SimpleEventEmitter.prototype.emit = function (event, payload) {
-        for (var _i = 0, _a = this.events[event] || []; _i < _a.length; _i++) {
-            var listener = _a[_i];
+    }
+    emit(event, payload) {
+        for (const listener of this.events[event] || []) {
             listener(payload);
         }
-        for (var _b = 0, _c = this.events['*'] || []; _b < _c.length; _b++) {
-            var listener = _c[_b];
+        for (const listener of this.events['*'] || []) {
             listener(event, payload);
         }
-    };
-    return SimpleEventEmitter;
-}());
+    }
+}
 
+// vendor from: https://github.com/LiosK/uuidv7/blob/f30b7a7faff73afbce0b27a46c638310f96912ba/src/index.ts
+// https://github.com/LiosK/uuidv7#license
 /**
  * uuidv7: An experimental implementation of the proposed UUID Version 7
  *
@@ -692,11 +527,11 @@ var SimpleEventEmitter = /** @class */ (function () {
  * @copyright 2021-2023 LiosK
  * @packageDocumentation
  */
-var DIGITS = "0123456789abcdef";
+const DIGITS = "0123456789abcdef";
 /** Represents a UUID as a 16-byte byte array. */
-var UUID = /** @class */ (function () {
+class UUID {
     /** @param bytes - The 16-byte byte array representation. */
-    function UUID(bytes) {
+    constructor(bytes) {
         this.bytes = bytes;
     }
     /**
@@ -708,14 +543,14 @@ var UUID = /** @class */ (function () {
      *
      * @throws TypeError if the length of the argument is not 16.
      */
-    UUID.ofInner = function (bytes) {
+    static ofInner(bytes) {
         if (bytes.length !== 16) {
             throw new TypeError("not 128-bit length");
         }
         else {
             return new UUID(bytes);
         }
-    };
+    }
     /**
      * Builds a byte array from UUIDv7 field values.
      *
@@ -725,7 +560,7 @@ var UUID = /** @class */ (function () {
      * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
      * @throws RangeError if any field value is out of the specified range.
      */
-    UUID.fromFieldsV7 = function (unixTsMs, randA, randBHi, randBLo) {
+    static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
         if (!Number.isInteger(unixTsMs) ||
             !Number.isInteger(randA) ||
             !Number.isInteger(randBHi) ||
@@ -740,12 +575,12 @@ var UUID = /** @class */ (function () {
             randBLo > 4294967295) {
             throw new RangeError("invalid field value");
         }
-        var bytes = new Uint8Array(16);
-        bytes[0] = unixTsMs / Math.pow(2, 40);
-        bytes[1] = unixTsMs / Math.pow(2, 32);
-        bytes[2] = unixTsMs / Math.pow(2, 24);
-        bytes[3] = unixTsMs / Math.pow(2, 16);
-        bytes[4] = unixTsMs / Math.pow(2, 8);
+        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;
@@ -758,7 +593,7 @@ var UUID = /** @class */ (function () {
         bytes[14] = randBLo >>> 8;
         bytes[15] = randBLo;
         return new UUID(bytes);
-    };
+    }
     /**
      * Builds a byte array from a string representation.
      *
@@ -773,33 +608,38 @@ var UUID = /** @class */ (function () {
      *
      * @throws SyntaxError if the argument could not parse as a valid UUID string.
      */
-    UUID.parse = function (uuid) {
-        var _a, _b, _c, _d;
-        var hex = undefined;
+    static parse(uuid) {
+        let hex = undefined;
         switch (uuid.length) {
             case 32:
-                hex = (_a = /^[0-9a-f]{32}$/i.exec(uuid)) === null || _a === void 0 ? void 0 : _a[0];
+                hex = /^[0-9a-f]{32}$/i.exec(uuid)?.[0];
                 break;
             case 36:
                 hex =
-                    (_b = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
-                        .exec(uuid)) === null || _b === void 0 ? void 0 : _b.slice(1, 6).join("");
+                    /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
+                        .exec(uuid)
+                        ?.slice(1, 6)
+                        .join("");
                 break;
             case 38:
                 hex =
-                    (_c = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i
-                        .exec(uuid)) === null || _c === void 0 ? void 0 : _c.slice(1, 6).join("");
+                    /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i
+                        .exec(uuid)
+                        ?.slice(1, 6)
+                        .join("");
                 break;
             case 45:
                 hex =
-                    (_d = /^urn:uuid:([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
-                        .exec(uuid)) === null || _d === void 0 ? void 0 : _d.slice(1, 6).join("");
+                    /^urn:uuid:([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
+                        .exec(uuid)
+                        ?.slice(1, 6)
+                        .join("");
                 break;
         }
         if (hex) {
-            var inner = new Uint8Array(16);
-            for (var i = 0; i < 16; i += 4) {
-                var n = parseInt(hex.substring(2 * i, 2 * i + 8), 16);
+            const inner = new Uint8Array(16);
+            for (let i = 0; i < 16; i += 4) {
+                const n = parseInt(hex.substring(2 * i, 2 * i + 8), 16);
                 inner[i + 0] = n >>> 24;
                 inner[i + 1] = n >>> 16;
                 inner[i + 2] = n >>> 8;
@@ -810,14 +650,14 @@ var UUID = /** @class */ (function () {
         else {
             throw new SyntaxError("could not parse UUID string");
         }
-    };
+    }
     /**
      * @returns The 8-4-4-4-12 canonical hexadecimal string representation
      * (`0189dcd5-5311-7d40-8db0-9496a2eef37b`).
      */
-    UUID.prototype.toString = function () {
-        var text = "";
-        for (var i = 0; i < this.bytes.length; i++) {
+    toString() {
+        let text = "";
+        for (let i = 0; i < this.bytes.length; i++) {
             text += DIGITS.charAt(this.bytes[i] >>> 4);
             text += DIGITS.charAt(this.bytes[i] & 0xf);
             if (i === 3 || i === 5 || i === 7 || i === 9) {
@@ -825,23 +665,23 @@ var UUID = /** @class */ (function () {
             }
         }
         return text;
-    };
+    }
     /**
      * @returns The 32-digit hexadecimal representation without hyphens
      * (`0189dcd553117d408db09496a2eef37b`).
      */
-    UUID.prototype.toHex = function () {
-        var text = "";
-        for (var i = 0; i < this.bytes.length; i++) {
+    toHex() {
+        let text = "";
+        for (let i = 0; i < this.bytes.length; i++) {
             text += DIGITS.charAt(this.bytes[i] >>> 4);
             text += DIGITS.charAt(this.bytes[i] & 0xf);
         }
         return text;
-    };
+    }
     /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
-    UUID.prototype.toJSON = function () {
+    toJSON() {
         return this.toString();
-    };
+    }
     /**
      * Reports the variant field value of the UUID or, if appropriate, "NIL" or
      * "MAX".
@@ -850,57 +690,56 @@ var UUID = /** @class */ (function () {
      * the Nil or Max UUID, although the Nil and Max UUIDs are technically
      * subsumed under the variants `0b0` and `0b111`, respectively.
      */
-    UUID.prototype.getVariant = function () {
-        var n = this.bytes[8] >>> 4;
+    getVariant() {
+        const n = this.bytes[8] >>> 4;
         if (n < 0) {
             throw new Error("unreachable");
         }
-        else if (n <= 7) {
-            return this.bytes.every(function (e) { return e === 0; }) ? "NIL" : "VAR_0";
+        else if (n <= 0b0111) {
+            return this.bytes.every((e) => e === 0) ? "NIL" : "VAR_0";
         }
-        else if (n <= 11) {
+        else if (n <= 0b1011) {
             return "VAR_10";
         }
-        else if (n <= 13) {
+        else if (n <= 0b1101) {
             return "VAR_110";
         }
-        else if (n <= 15) {
-            return this.bytes.every(function (e) { return e === 0xff; }) ? "MAX" : "VAR_RESERVED";
+        else if (n <= 0b1111) {
+            return this.bytes.every((e) => e === 0xff) ? "MAX" : "VAR_RESERVED";
         }
         else {
             throw new Error("unreachable");
         }
-    };
+    }
     /**
      * Returns the version field value of the UUID or `undefined` if the UUID does
      * not have the variant field value of `0b10`.
      */
-    UUID.prototype.getVersion = function () {
+    getVersion() {
         return this.getVariant() === "VAR_10" ? this.bytes[6] >>> 4 : undefined;
-    };
+    }
     /** Creates an object from `this`. */
-    UUID.prototype.clone = function () {
+    clone() {
         return new UUID(this.bytes.slice(0));
-    };
+    }
     /** Returns true if `this` is equivalent to `other`. */
-    UUID.prototype.equals = function (other) {
+    equals(other) {
         return this.compareTo(other) === 0;
-    };
+    }
     /**
      * Returns a negative integer, zero, or positive integer if `this` is less
      * than, equal to, or greater than `other`, respectively.
      */
-    UUID.prototype.compareTo = function (other) {
-        for (var i = 0; i < 16; i++) {
-            var diff = this.bytes[i] - other.bytes[i];
+    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;
-    };
-    return UUID;
-}());
+    }
+}
 /**
  * Encapsulates the monotonic counter state.
  *
@@ -910,16 +749,16 @@ var UUID = /** @class */ (function () {
  * that is useful to absolutely guarantee the monotonically increasing order of
  * generated UUIDs. See their respective documentation for details.
  */
-var V7Generator = /** @class */ (function () {
+class V7Generator {
     /**
      * Creates a generator object with the default random number generator, or
      * with the specified one if passed as an argument. The specified random
      * number generator should be cryptographically strong and securely seeded.
      */
-    function V7Generator(randomNumberGenerator) {
+    constructor(randomNumberGenerator) {
         this.timestamp = 0;
         this.counter = 0;
-        this.random = randomNumberGenerator !== null && randomNumberGenerator !== void 0 ? randomNumberGenerator : getDefaultRandom();
+        this.random = randomNumberGenerator ?? getDefaultRandom();
     }
     /**
      * Generates a new UUIDv7 object from the current timestamp, or resets the
@@ -935,9 +774,9 @@ var V7Generator = /** @class */ (function () {
      * See {@link generateOrAbort} for the other mode of generation and
      * {@link generateOrResetCore} for the low-level primitive.
      */
-    V7Generator.prototype.generate = function () {
+    generate() {
         return this.generateOrResetCore(Date.now(), 10000);
-    };
+    }
     /**
      * Generates a new UUIDv7 object from the current timestamp, or returns
      * `undefined` upon significant timestamp rollback.
@@ -951,9 +790,9 @@ var V7Generator = /** @class */ (function () {
      * See {@link generate} for the other mode of generation and
      * {@link generateOrAbortCore} for the low-level primitive.
      */
-    V7Generator.prototype.generateOrAbort = function () {
+    generateOrAbort() {
         return this.generateOrAbortCore(Date.now(), 10000);
-    };
+    }
     /**
      * Generates a new UUIDv7 object from the `unixTsMs` passed, or resets the
      * generator upon significant timestamp rollback.
@@ -965,15 +804,15 @@ var V7Generator = /** @class */ (function () {
      * considered significant. A suggested value is `10_000` (milliseconds).
      * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
      */
-    V7Generator.prototype.generateOrResetCore = function (unixTsMs, rollbackAllowance) {
-        var value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+    generateOrResetCore(unixTsMs, rollbackAllowance) {
+        let value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
         if (value === undefined) {
             // reset state and resume
             this.timestamp = 0;
             value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
         }
         return value;
-    };
+    }
     /**
      * Generates a new UUIDv7 object from the `unixTsMs` passed, or returns
      * `undefined` upon significant timestamp rollback.
@@ -985,8 +824,8 @@ var V7Generator = /** @class */ (function () {
      * considered significant. A suggested value is `10_000` (milliseconds).
      * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
      */
-    V7Generator.prototype.generateOrAbortCore = function (unixTsMs, rollbackAllowance) {
-        var MAX_COUNTER = 4398046511103;
+    generateOrAbortCore(unixTsMs, rollbackAllowance) {
+        const MAX_COUNTER = 4398046511103;
         if (!Number.isInteger(unixTsMs) ||
             unixTsMs < 1 ||
             unixTsMs > 281474976710655) {
@@ -1012,839 +851,861 @@ var V7Generator = /** @class */ (function () {
             // abort if clock went backwards to unbearable extent
             return undefined;
         }
-        return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / Math.pow(2, 30)), this.counter & (Math.pow(2, 30) - 1), this.random.nextUint32());
-    };
+        return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & (2 ** 30 - 1), this.random.nextUint32());
+    }
     /** Initializes the counter at a 42-bit random integer. */
-    V7Generator.prototype.resetCounter = function () {
+    resetCounter() {
         this.counter =
             this.random.nextUint32() * 0x400 + (this.random.nextUint32() & 0x3ff);
-    };
+    }
     /**
      * Generates a new UUIDv4 object utilizing the random number generator inside.
      *
      * @internal
      */
-    V7Generator.prototype.generateV4 = function () {
-        var bytes = new Uint8Array(Uint32Array.of(this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32()).buffer);
+    generateV4() {
+        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 V7Generator;
-}());
-/** Returns the default random number generator available in the environment. */
-var getDefaultRandom = function () {
-    // detect Web Crypto API
-    if (typeof crypto !== "undefined" &&
-        typeof crypto.getRandomValues !== "undefined") {
-        return new BufferedCryptoRandom();
-    }
-    else {
-        // fall back on Math.random() unless the flag is set to true
-        if (typeof UUIDV7_DENY_WEAK_RNG !== "undefined" && UUIDV7_DENY_WEAK_RNG) {
-            throw new Error("no cryptographically strong RNG available");
-        }
-        return {
-            nextUint32: function () { return Math.trunc(Math.random() * 65536) * 65536 +
-                Math.trunc(Math.random() * 65536); },
-        };
     }
-};
-/**
- * Wraps `crypto.getRandomValues()` to enable buffering; this uses a small
- * buffer by default to avoid both unbearable throughput decline in some
- * environments and the waste of time and space for unused values.
- */
-var BufferedCryptoRandom = /** @class */ (function () {
-    function BufferedCryptoRandom() {
-        this.buffer = new Uint32Array(8);
-        this.cursor = 0xffff;
-    }
-    BufferedCryptoRandom.prototype.nextUint32 = function () {
-        if (this.cursor >= this.buffer.length) {
-            crypto.getRandomValues(this.buffer);
-            this.cursor = 0;
-        }
-        return this.buffer[this.cursor++];
+}
+/** A global flag to force use of cryptographically strong RNG. */
+// declare const UUIDV7_DENY_WEAK_RNG: boolean;
+/** Returns the default random number generator available in the environment. */
+const getDefaultRandom = () => {
+    // fix: crypto isn't available in react-native, always use Math.random
+    //   // detect Web Crypto API
+    //   if (
+    //     typeof crypto !== "undefined" &&
+    //     typeof crypto.getRandomValues !== "undefined"
+    //   ) {
+    //     return new BufferedCryptoRandom();
+    //   } else {
+    //     // fall back on Math.random() unless the flag is set to true
+    //     if (typeof UUIDV7_DENY_WEAK_RNG !== "undefined" && UUIDV7_DENY_WEAK_RNG) {
+    //       throw new Error("no cryptographically strong RNG available");
+    //     }
+    //     return {
+    //       nextUint32: (): number =>
+    //         Math.trunc(Math.random() * 0x1_0000) * 0x1_0000 +
+    //         Math.trunc(Math.random() * 0x1_0000),
+    //     };
+    //   }
+    return {
+        nextUint32: () => Math.trunc(Math.random() * 65536) * 65536 +
+            Math.trunc(Math.random() * 65536),
     };
-    return BufferedCryptoRandom;
-}());
-var defaultGenerator;
+};
+// /**
+//  * Wraps `crypto.getRandomValues()` to enable buffering; this uses a small
+//  * buffer by default to avoid both unbearable throughput decline in some
+//  * environments and the waste of time and space for unused values.
+//  */
+// class BufferedCryptoRandom {
+//   private readonly buffer = new Uint32Array(8);
+//   private cursor = 0xffff;
+//   nextUint32(): number {
+//     if (this.cursor >= this.buffer.length) {
+//       crypto.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").
  */
-var uuidv7 = function () { return uuidv7obj().toString(); };
+const uuidv7 = () => uuidv7obj().toString();
 /** Generates a UUIDv7 object. */
-var uuidv7obj = function () { return (defaultGenerator || (defaultGenerator = new V7Generator())).generate(); };
-
-var PostHogFetchHttpError = /** @class */ (function (_super) {
-    __extends(PostHogFetchHttpError, _super);
-    function PostHogFetchHttpError(response) {
-        var _this = _super.call(this, 'HTTP error while fetching PostHog: ' + response.status) || this;
-        _this.response = response;
-        _this.name = 'PostHogFetchHttpError';
-        return _this;
-    }
-    return PostHogFetchHttpError;
-}(Error));
-var PostHogFetchNetworkError = /** @class */ (function (_super) {
-    __extends(PostHogFetchNetworkError, _super);
-    function PostHogFetchNetworkError(error) {
-        var _this = 
+const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
+
+class PostHogFetchHttpError extends Error {
+    constructor(response) {
+        super('HTTP error while fetching PostHog: ' + response.status);
+        this.response = response;
+        this.name = 'PostHogFetchHttpError';
+    }
+}
+class PostHogFetchNetworkError extends Error {
+    constructor(error) {
         // TRICKY: "cause" is a newer property but is just ignored otherwise. Cast to any to ignore the type issue.
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
         // @ts-ignore
-        _super.call(this, 'Network error while fetching PostHog', error instanceof Error ? { cause: error } : {}) || this;
-        _this.error = error;
-        _this.name = 'PostHogFetchNetworkError';
-        return _this;
+        super('Network error while fetching PostHog', error instanceof Error ? { cause: error } : {});
+        this.error = error;
+        this.name = 'PostHogFetchNetworkError';
     }
-    return PostHogFetchNetworkError;
-}(Error));
+}
 function isPostHogFetchError(err) {
-    return typeof err === 'object' && (err.name === 'PostHogFetchHttpError' || err.name === 'PostHogFetchNetworkError');
+    return typeof err === 'object' && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
 }
-var PostHogCoreStateless = /** @class */ (function () {
-    function PostHogCoreStateless(apiKey, options) {
-        var _a, _b, _c, _d, _e;
-        this.debugMode = false;
+class PostHogCoreStateless {
+    constructor(apiKey, options) {
         this.disableGeoip = true;
+        this.disabled = false;
+        this.defaultOptIn = true;
         this.pendingPromises = {};
         // internal
         this._events = new SimpleEventEmitter();
+        this._isInitialized = false;
         assert(apiKey, "You must pass your PostHog project's api key.");
         this.apiKey = apiKey;
-        this.host = removeTrailingSlash((options === null || options === void 0 ? void 0 : options.host) || 'https://app.posthog.com');
-        this.flushAt = (options === null || options === void 0 ? void 0 : options.flushAt) ? Math.max(options === null || options === void 0 ? void 0 : options.flushAt, 1) : 20;
-        this.flushInterval = (_a = options === null || options === void 0 ? void 0 : options.flushInterval) !== null && _a !== void 0 ? _a : 10000;
-        this.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'form';
+        this.host = removeTrailingSlash(options?.host || 'https://app.posthog.com');
+        this.flushAt = options?.flushAt ? Math.max(options?.flushAt, 1) : 20;
+        this.flushInterval = options?.flushInterval ?? 10000;
+        this.captureMode = options?.captureMode || 'form';
         // If enable is explicitly set to false we override the optout
-        this._optoutOverride = (options === null || options === void 0 ? void 0 : options.enable) === false;
+        this.defaultOptIn = options?.defaultOptIn ?? true;
         this._retryOptions = {
-            retryCount: (_b = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _b !== void 0 ? _b : 3,
-            retryDelay: (_c = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _c !== void 0 ? _c : 3000,
+            retryCount: options?.fetchRetryCount ?? 3,
+            retryDelay: options?.fetchRetryDelay ?? 3000,
             retryCheck: isPostHogFetchError,
         };
-        this.requestTimeout = (_d = options === null || options === void 0 ? void 0 : options.requestTimeout) !== null && _d !== void 0 ? _d : 10000; // 10 seconds
-        this.disableGeoip = (_e = options === null || options === void 0 ? void 0 : options.disableGeoip) !== null && _e !== void 0 ? _e : true;
+        this.requestTimeout = options?.requestTimeout ?? 10000; // 10 seconds
+        this.featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 3000; // 3 seconds
+        this.disableGeoip = options?.disableGeoip ?? true;
+        this.disabled = options?.disabled ?? false;
+        // Init promise allows the derived class to block calls until it is ready
+        this._initPromise = Promise.resolve();
+        this._isInitialized = true;
+    }
+    wrap(fn) {
+        if (this.disabled) {
+            if (this.isDebug) {
+                console.warn('[PostHog] The client is disabled');
+            }
+            return;
+        }
+        if (this._isInitialized) {
+            // NOTE: We could also check for the "opt in" status here...
+            return fn();
+        }
+        this._initPromise.then(() => fn());
     }
-    PostHogCoreStateless.prototype.getCommonEventProperties = function () {
+    getCommonEventProperties() {
         return {
             $lib: this.getLibraryId(),
             $lib_version: this.getLibraryVersion(),
         };
-    };
-    Object.defineProperty(PostHogCoreStateless.prototype, "optedOut", {
-        get: function () {
-            var _a, _b;
-            return (_b = (_a = this.getPersistedProperty(PostHogPersistedProperty.OptedOut)) !== null && _a !== void 0 ? _a : this._optoutOverride) !== null && _b !== void 0 ? _b : false;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PostHogCoreStateless.prototype.optIn = function () {
-        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, false);
-    };
-    PostHogCoreStateless.prototype.optOut = function () {
-        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, true);
-    };
-    PostHogCoreStateless.prototype.on = function (event, cb) {
+    }
+    get optedOut() {
+        return this.getPersistedProperty(PostHogPersistedProperty.OptedOut) ?? !this.defaultOptIn;
+    }
+    async optIn() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.OptedOut, false);
+        });
+    }
+    async optOut() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.OptedOut, true);
+        });
+    }
+    on(event, cb) {
         return this._events.on(event, cb);
-    };
-    PostHogCoreStateless.prototype.debug = function (enabled) {
-        var _a;
-        if (enabled === void 0) { enabled = true; }
-        (_a = this.removeDebugCallback) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.debugMode = enabled;
+    }
+    debug(enabled = true) {
+        this.removeDebugCallback?.();
         if (enabled) {
-            this.removeDebugCallback = this.on('*', function (event, payload) { return console.log('PostHog Debug', event, payload); });
+            const removeDebugCallback = this.on('*', (event, payload) => console.log('PostHog Debug', event, payload));
+            this.removeDebugCallback = () => {
+                removeDebugCallback();
+                this.removeDebugCallback = undefined;
+            };
         }
-    };
-    PostHogCoreStateless.prototype.buildPayload = function (payload) {
+    }
+    get isDebug() {
+        return !!this.removeDebugCallback;
+    }
+    buildPayload(payload) {
         return {
             distinct_id: payload.distinct_id,
             event: payload.event,
-            properties: __assign(__assign({}, (payload.properties || {})), this.getCommonEventProperties()),
+            properties: {
+                ...(payload.properties || {}),
+                ...this.getCommonEventProperties(), // Common PH props
+            },
         };
-    };
-    PostHogCoreStateless.prototype.addPendingPromise = function (promise) {
-        var _this = this;
-        var promiseUUID = uuidv7();
+    }
+    addPendingPromise(promise) {
+        const promiseUUID = uuidv7();
         this.pendingPromises[promiseUUID] = promise;
-        promise.finally(function () {
-            delete _this.pendingPromises[promiseUUID];
+        promise.finally(() => {
+            delete this.pendingPromises[promiseUUID];
         });
-    };
+    }
     /***
      *** TRACKING
      ***/
-    PostHogCoreStateless.prototype.identifyStateless = function (distinctId, properties, options) {
-        // The properties passed to identifyStateless are event properties.
-        // To add person properties, pass in all person properties to the `$set` key.
-        var payload = __assign({}, this.buildPayload({
-            distinct_id: distinctId,
-            event: '$identify',
-            properties: properties,
-        }));
-        this.enqueue('identify', payload, options);
-        return this;
-    };
-    PostHogCoreStateless.prototype.captureStateless = function (distinctId, event, properties, options) {
-        var payload = this.buildPayload({ distinct_id: distinctId, event: event, properties: properties });
-        this.enqueue('capture', payload, options);
-        return this;
-    };
-    PostHogCoreStateless.prototype.aliasStateless = function (alias, distinctId, properties, options) {
-        var payload = this.buildPayload({
-            event: '$create_alias',
-            distinct_id: distinctId,
-            properties: __assign(__assign({}, (properties || {})), { distinct_id: distinctId, alias: alias }),
+    identifyStateless(distinctId, properties, options) {
+        this.wrap(() => {
+            // The properties passed to identifyStateless are event properties.
+            // To add person properties, pass in all person properties to the `$set` key.
+            const payload = {
+                ...this.buildPayload({
+                    distinct_id: distinctId,
+                    event: '$identify',
+                    properties,
+                }),
+            };
+            this.enqueue('identify', payload, options);
         });
-        this.enqueue('alias', payload, options);
-        return this;
-    };
+    }
+    captureStateless(distinctId, event, properties, options) {
+        this.wrap(() => {
+            const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
+            this.enqueue('capture', payload, options);
+        });
+    }
+    aliasStateless(alias, distinctId, properties, options) {
+        this.wrap(() => {
+            const payload = this.buildPayload({
+                event: '$create_alias',
+                distinct_id: distinctId,
+                properties: {
+                    ...(properties || {}),
+                    distinct_id: distinctId,
+                    alias,
+                },
+            });
+            this.enqueue('alias', payload, options);
+        });
+    }
     /***
      *** GROUPS
      ***/
-    PostHogCoreStateless.prototype.groupIdentifyStateless = function (groupType, groupKey, groupProperties, options, distinctId, eventProperties) {
-        var payload = this.buildPayload({
-            distinct_id: distinctId || "$".concat(groupType, "_").concat(groupKey),
-            event: '$groupidentify',
-            properties: __assign({ $group_type: groupType, $group_key: groupKey, $group_set: groupProperties || {} }, (eventProperties || {})),
+    groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties) {
+        this.wrap(() => {
+            const payload = this.buildPayload({
+                distinct_id: distinctId || `$${groupType}_${groupKey}`,
+                event: '$groupidentify',
+                properties: {
+                    $group_type: groupType,
+                    $group_key: groupKey,
+                    $group_set: groupProperties || {},
+                    ...(eventProperties || {}),
+                },
+            });
+            this.enqueue('capture', payload, options);
         });
-        this.enqueue('capture', payload, options);
-        return this;
-    };
+    }
     /***
      *** FEATURE FLAGS
      ***/
-    PostHogCoreStateless.prototype.getDecide = function (distinctId, groups, personProperties, groupProperties, extraPayload) {
-        if (groups === void 0) { groups = {}; }
-        if (personProperties === void 0) { personProperties = {}; }
-        if (groupProperties === void 0) { groupProperties = {}; }
-        if (extraPayload === void 0) { extraPayload = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var url, fetchOptions;
-            var _this = this;
-            return __generator(this, function (_a) {
-                url = "".concat(this.host, "/decide/?v=3");
-                fetchOptions = {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(__assign({ token: this.apiKey, distinct_id: distinctId, groups: groups, person_properties: personProperties, group_properties: groupProperties }, extraPayload)),
-                };
-                return [2 /*return*/, this.fetchWithRetry(url, fetchOptions)
-                        .then(function (response) { return response.json(); })
-                        .catch(function (error) {
-                        _this._events.emit('error', error);
-                        return undefined;
-                    })];
-            });
-        });
-    };
-    PostHogCoreStateless.prototype.getFeatureFlagStateless = function (key, distinctId, groups, personProperties, groupProperties, disableGeoip) {
-        if (groups === void 0) { groups = {}; }
-        if (personProperties === void 0) { personProperties = {}; }
-        if (groupProperties === void 0) { groupProperties = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var featureFlags, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getFeatureFlagsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)];
-                    case 1:
-                        featureFlags = _a.sent();
-                        if (!featureFlags) {
-                            // If we haven't loaded flags yet, or errored out, we respond with undefined
-                            return [2 /*return*/, undefined];
-                        }
-                        response = featureFlags[key];
-                        // `/decide` v3 returns all flags
-                        if (response === undefined) {
-                            // For cases where the flag is unknown, return false
-                            response = false;
-                        }
-                        // If we have flags we either return the value (true or string) or false
-                        return [2 /*return*/, response];
-                }
-            });
-        });
-    };
-    PostHogCoreStateless.prototype.getFeatureFlagPayloadStateless = function (key, distinctId, groups, personProperties, groupProperties, disableGeoip) {
-        if (groups === void 0) { groups = {}; }
-        if (personProperties === void 0) { personProperties = {}; }
-        if (groupProperties === void 0) { groupProperties = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var payloads, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)];
-                    case 1:
-                        payloads = _a.sent();
-                        if (!payloads) {
-                            return [2 /*return*/, undefined];
-                        }
-                        response = payloads[key];
-                        // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
-                        if (response === undefined) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, this._parsePayload(response)];
-                }
-            });
-        });
-    };
-    PostHogCoreStateless.prototype.getFeatureFlagPayloadsStateless = function (distinctId, groups, personProperties, groupProperties, disableGeoip) {
-        if (groups === void 0) { groups = {}; }
-        if (personProperties === void 0) { personProperties = {}; }
-        if (groupProperties === void 0) { groupProperties = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var payloads;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)];
-                    case 1:
-                        payloads = (_a.sent()).payloads;
-                        if (payloads) {
-                            return [2 /*return*/, Object.fromEntries(Object.entries(payloads).map(function (_a) {
-                                    var k = _a[0], v = _a[1];
-                                    return [k, _this._parsePayload(v)];
-                                }))];
-                        }
-                        return [2 /*return*/, payloads];
-                }
-            });
+    async getDecide(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
+        await this._initPromise;
+        const url = `${this.host}/decide/?v=3`;
+        const fetchOptions = {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                token: this.apiKey,
+                distinct_id: distinctId,
+                groups,
+                person_properties: personProperties,
+                group_properties: groupProperties,
+                ...extraPayload,
+            }),
+        };
+        // Don't retry /decide API calls
+        return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
+            .then((response) => response.json())
+            .catch((error) => {
+            this._events.emit('error', error);
+            return undefined;
         });
-    };
-    PostHogCoreStateless.prototype._parsePayload = function (response) {
+    }
+    async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const featureFlags = await this.getFeatureFlagsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
+        if (!featureFlags) {
+            // If we haven't loaded flags yet, or errored out, we respond with undefined
+            return undefined;
+        }
+        let response = featureFlags[key];
+        // `/decide` v3 returns all flags
+        if (response === undefined) {
+            // For cases where the flag is unknown, return false
+            response = false;
+        }
+        // If we have flags we either return the value (true or string) or false
+        return response;
+    }
+    async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
+        if (!payloads) {
+            return undefined;
+        }
+        const response = payloads[key];
+        // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
+        if (response === undefined) {
+            return null;
+        }
+        return this._parsePayload(response);
+    }
+    async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)).payloads;
+        if (payloads) {
+            return Object.fromEntries(Object.entries(payloads).map(([k, v]) => [k, this._parsePayload(v)]));
+        }
+        return payloads;
+    }
+    _parsePayload(response) {
         try {
             return JSON.parse(response);
         }
-        catch (_a) {
+        catch {
             return response;
         }
-    };
-    PostHogCoreStateless.prototype.getFeatureFlagsStateless = function (distinctId, groups, personProperties, groupProperties, disableGeoip) {
-        if (groups === void 0) { groups = {}; }
-        if (personProperties === void 0) { personProperties = {}; }
-        if (groupProperties === void 0) { groupProperties = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)];
-                    case 1: return [2 /*return*/, (_a.sent()).flags];
-                }
-            });
-        });
-    };
-    PostHogCoreStateless.prototype.getFeatureFlagsAndPayloadsStateless = function (distinctId, groups, personProperties, groupProperties, disableGeoip) {
-        if (groups === void 0) { groups = {}; }
-        if (personProperties === void 0) { personProperties = {}; }
-        if (groupProperties === void 0) { groupProperties = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var extraPayload, decideResponse, flags, payloads;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        extraPayload = {};
-                        if (disableGeoip !== null && disableGeoip !== void 0 ? disableGeoip : this.disableGeoip) {
-                            extraPayload['geoip_disable'] = true;
-                        }
-                        return [4 /*yield*/, this.getDecide(distinctId, groups, personProperties, groupProperties, extraPayload)];
-                    case 1:
-                        decideResponse = _a.sent();
-                        flags = decideResponse === null || decideResponse === void 0 ? void 0 : decideResponse.featureFlags;
-                        payloads = decideResponse === null || decideResponse === void 0 ? void 0 : decideResponse.featureFlagPayloads;
-                        return [2 /*return*/, {
-                                flags: flags,
-                                payloads: payloads,
-                            }];
-                }
-            });
-        });
-    };
+    }
+    async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        return (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)).flags;
+    }
+    async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const extraPayload = {};
+        if (disableGeoip ?? this.disableGeoip) {
+            extraPayload['geoip_disable'] = true;
+        }
+        const decideResponse = await this.getDecide(distinctId, groups, personProperties, groupProperties, extraPayload);
+        const flags = decideResponse?.featureFlags;
+        const payloads = decideResponse?.featureFlagPayloads;
+        return {
+            flags,
+            payloads,
+        };
+    }
     /***
      *** QUEUEING AND FLUSHING
      ***/
-    PostHogCoreStateless.prototype.enqueue = function (type, _message, options) {
-        var _this = this;
-        var _a;
-        if (this.optedOut) {
-            this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
-            return;
-        }
-        var message = __assign(__assign({}, _message), { type: type, library: this.getLibraryId(), library_version: this.getLibraryVersion(), timestamp: (options === null || options === void 0 ? void 0 : options.timestamp) ? options === null || options === void 0 ? void 0 : options.timestamp : currentISOTime(), uuid: (options === null || options === void 0 ? void 0 : options.uuid) ? options.uuid : uuidv7() });
-        var addGeoipDisableProperty = (_a = options === null || options === void 0 ? void 0 : options.disableGeoip) !== null && _a !== void 0 ? _a : this.disableGeoip;
-        if (addGeoipDisableProperty) {
-            if (!message.properties) {
-                message.properties = {};
+    enqueue(type, _message, options) {
+        this.wrap(() => {
+            if (this.optedOut) {
+                this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
+                return;
             }
-            message['properties']['$geoip_disable'] = true;
-        }
-        if (message.distinctId) {
-            message.distinct_id = message.distinctId;
-            delete message.distinctId;
-        }
-        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-        queue.push({ message: message });
-        this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
-        this._events.emit(type, message);
-        // Flush queued events if we meet the flushAt length
-        if (queue.length >= this.flushAt) {
-            this.flush();
-        }
-        if (this.flushInterval && !this._flushTimer) {
-            this._flushTimer = safeSetTimeout(function () { return _this.flush(); }, this.flushInterval);
-        }
-    };
-    PostHogCoreStateless.prototype.flushAsync = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            _this.flush(function (err, data) {
+            const message = {
+                ..._message,
+                type: type,
+                library: this.getLibraryId(),
+                library_version: this.getLibraryVersion(),
+                timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
+                uuid: options?.uuid ? options.uuid : uuidv7(),
+            };
+            const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
+            if (addGeoipDisableProperty) {
+                if (!message.properties) {
+                    message.properties = {};
+                }
+                message['properties']['$geoip_disable'] = true;
+            }
+            if (message.distinctId) {
+                message.distinct_id = message.distinctId;
+                delete message.distinctId;
+            }
+            const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+            queue.push({ message });
+            this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
+            this._events.emit(type, message);
+            // Flush queued events if we meet the flushAt length
+            if (queue.length >= this.flushAt) {
+                this.flush();
+            }
+            if (this.flushInterval && !this._flushTimer) {
+                this._flushTimer = safeSetTimeout(() => this.flush(), this.flushInterval);
+            }
+        });
+    }
+    async flushAsync() {
+        await this._initPromise;
+        return new Promise((resolve, reject) => {
+            this.flush((err, data) => {
                 return err ? reject(err) : resolve(data);
             });
         });
-    };
-    PostHogCoreStateless.prototype.flush = function (callback) {
-        var _this = this;
-        if (this._flushTimer) {
-            clearTimeout(this._flushTimer);
-            this._flushTimer = null;
-        }
-        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-        if (!queue.length) {
-            return callback === null || callback === void 0 ? void 0 : callback();
-        }
-        var items = queue.splice(0, this.flushAt);
-        this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
-        var messages = items.map(function (item) { return item.message; });
-        var data = {
-            api_key: this.apiKey,
-            batch: messages,
-            sent_at: currentISOTime(),
-        };
-        var done = function (err) {
-            if (err) {
-                _this._events.emit('error', err);
+    }
+    flush(callback) {
+        this.wrap(() => {
+            if (this._flushTimer) {
+                clearTimeout(this._flushTimer);
+                this._flushTimer = null;
             }
-            callback === null || callback === void 0 ? void 0 : callback(err, messages);
-            _this._events.emit('flush', messages);
-        };
-        // Don't set the user agent if we're not on a browser. The latest spec allows
-        // the User-Agent header (see https://fetch.spec.whatwg.org/#terminology-headers
-        // and https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader),
-        // but browsers such as Chrome and Safari have not caught up.
-        this.getCustomUserAgent();
-        var payload = JSON.stringify(data);
-        var url = this.captureMode === 'form'
-            ? "".concat(this.host, "/e/?ip=1&_=").concat(currentTimestamp(), "&v=").concat(this.getLibraryVersion())
-            : "".concat(this.host, "/batch/");
-        var fetchOptions = this.captureMode === 'form'
-            ? {
-                method: 'POST',
-                mode: 'no-cors',
-                credentials: 'omit',
-                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-                body: "data=".concat(encodeURIComponent(LZString.compressToBase64(payload)), "&compression=lz64"),
+            const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+            if (!queue.length) {
+                return callback?.();
             }
-            : {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: payload,
+            const items = queue.splice(0, this.flushAt);
+            this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
+            const messages = items.map((item) => item.message);
+            const data = {
+                api_key: this.apiKey,
+                batch: messages,
+                sent_at: currentISOTime(),
             };
-        var requestPromise = this.fetchWithRetry(url, fetchOptions);
-        this.addPendingPromise(requestPromise
-            .then(function () { return done(); })
-            .catch(function (err) {
-            done(err);
-        }));
-    };
-    PostHogCoreStateless.prototype.fetchWithRetry = function (url, options, retryOptions) {
-        var _a;
-        var _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        (_a = (_b = AbortSignal).timeout) !== null && _a !== void 0 ? _a : (_b.timeout = function timeout(ms) {
-                            var ctrl = new AbortController();
-                            setTimeout(function () { return ctrl.abort(); }, ms);
-                            return ctrl.signal;
-                        });
-                        return [4 /*yield*/, retriable(function () { return __awaiter(_this, void 0, void 0, function () {
-                                var res, e_1;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            res = null;
-                                            _a.label = 1;
-                                        case 1:
-                                            _a.trys.push([1, 3, , 4]);
-                                            return [4 /*yield*/, this.fetch(url, __assign({ signal: AbortSignal.timeout(this.requestTimeout) }, options))];
-                                        case 2:
-                                            res = _a.sent();
-                                            return [3 /*break*/, 4];
-                                        case 3:
-                                            e_1 = _a.sent();
-                                            // fetch will only throw on network errors or on timeouts
-                                            throw new PostHogFetchNetworkError(e_1);
-                                        case 4:
-                                            if (res.status < 200 || res.status >= 400) {
-                                                throw new PostHogFetchHttpError(res);
-                                            }
-                                            return [2 /*return*/, res];
-                                    }
-                                });
-                            }); }, __assign(__assign({}, this._retryOptions), retryOptions))];
-                    case 1: return [2 /*return*/, _c.sent()];
+            const done = (err) => {
+                if (err) {
+                    this._events.emit('error', err);
                 }
-            });
-        });
-    };
-    PostHogCoreStateless.prototype.shutdownAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var e_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        clearTimeout(this._flushTimer);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 5, , 6]);
-                        return [4 /*yield*/, this.flushAsync()];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, Promise.all(Object.values(this.pendingPromises).map(function (x) {
-                                return x.catch(function () {
-                                    // ignore errors as we are shutting down and can't deal with them anyways.
-                                });
-                            }))
-                            // flush again to make sure we send all events, some of which might've been added
-                            // while we were waiting for the pending promises to resolve
-                            // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
-                        ];
-                    case 3:
-                        _a.sent();
-                        // flush again to make sure we send all events, some of which might've been added
-                        // while we were waiting for the pending promises to resolve
-                        // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
-                        return [4 /*yield*/, this.flushAsync()];
-                    case 4:
-                        // flush again to make sure we send all events, some of which might've been added
-                        // while we were waiting for the pending promises to resolve
-                        // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
-                        _a.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        e_2 = _a.sent();
-                        if (!isPostHogFetchError(e_2)) {
-                            throw e_2;
-                        }
-                        console.error('Error while shutting down PostHog', e_2);
-                        return [3 /*break*/, 6];
-                    case 6: return [2 /*return*/];
+                callback?.(err, messages);
+                this._events.emit('flush', messages);
+            };
+            // Don't set the user agent if we're not on a browser. The latest spec allows
+            // the User-Agent header (see https://fetch.spec.whatwg.org/#terminology-headers
+            // and https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader),
+            // but browsers such as Chrome and Safari have not caught up.
+            this.getCustomUserAgent();
+            const payload = JSON.stringify(data);
+            const url = this.captureMode === 'form'
+                ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+                : `${this.host}/batch/`;
+            const fetchOptions = this.captureMode === 'form'
+                ? {
+                    method: 'POST',
+                    mode: 'no-cors',
+                    credentials: 'omit',
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
                 }
-            });
+                : {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: payload,
+                };
+            const requestPromise = this.fetchWithRetry(url, fetchOptions);
+            this.addPendingPromise(requestPromise
+                .then(() => done())
+                .catch((err) => {
+                done(err);
+            }));
         });
-    };
-    PostHogCoreStateless.prototype.shutdown = function () {
-        void this.shutdownAsync();
-    };
-    return PostHogCoreStateless;
-}());
-var PostHogCore = /** @class */ (function (_super) {
-    __extends(PostHogCore, _super);
-    function PostHogCore(apiKey, options) {
-        var _this = this;
-        var _a, _b, _c;
+    }
+    async fetchWithRetry(url, options, retryOptions, requestTimeout) {
+        var _a;
+        (_a = AbortSignal).timeout ?? (_a.timeout = function timeout(ms) {
+            const ctrl = new AbortController();
+            setTimeout(() => ctrl.abort(), ms);
+            return ctrl.signal;
+        });
+        return await retriable(async () => {
+            let res = null;
+            try {
+                res = await this.fetch(url, {
+                    signal: AbortSignal.timeout(requestTimeout ?? this.requestTimeout),
+                    ...options,
+                });
+            }
+            catch (e) {
+                // fetch will only throw on network errors or on timeouts
+                throw new PostHogFetchNetworkError(e);
+            }
+            // If we're in no-cors mode, we can't access the response status
+            // We only throw on HTTP errors if we're not in no-cors mode
+            // https://developer.mozilla.org/en-US/docs/Web/API/Request/mode#no-cors
+            const isNoCors = options.mode === 'no-cors';
+            if (!isNoCors && (res.status < 200 || res.status >= 400)) {
+                throw new PostHogFetchHttpError(res);
+            }
+            return res;
+        }, { ...this._retryOptions, ...retryOptions });
+    }
+    async shutdownAsync(shutdownTimeoutMs) {
+        await this._initPromise;
+        clearTimeout(this._flushTimer);
+        try {
+            await Promise.all(Object.values(this.pendingPromises).map((x) => x.catch(() => {
+                // ignore errors as we are shutting down and can't deal with them anyways.
+            })));
+            const timeout = shutdownTimeoutMs ?? 30000;
+            const startTimeWithDelay = Date.now() + timeout;
+            while (true) {
+                const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+                if (queue.length === 0) {
+                    break;
+                }
+                // flush again to make sure we send all events, some of which might've been added
+                // while we were waiting for the pending promises to resolve
+                // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
+                await this.flushAsync();
+                // If we've been waiting for more than the shutdownTimeoutMs, stop it
+                const now = Date.now();
+                if (startTimeWithDelay < now) {
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            if (!isPostHogFetchError(e)) {
+                throw e;
+            }
+            console.error('Error while shutting down PostHog', e);
+        }
+    }
+    shutdown(shutdownTimeoutMs) {
+        void this.shutdownAsync(shutdownTimeoutMs);
+    }
+}
+class PostHogCore extends PostHogCoreStateless {
+    constructor(apiKey, options) {
         // Default for stateful mode is to not disable geoip. Only override if explicitly set
-        var disableGeoipOption = (_a = options === null || options === void 0 ? void 0 : options.disableGeoip) !== null && _a !== void 0 ? _a : false;
-        _this = _super.call(this, apiKey, __assign(__assign({}, options), { disableGeoip: disableGeoipOption })) || this;
-        _this.flagCallReported = {};
-        _this.sessionProps = {};
-        _this.sendFeatureFlagEvent = (_b = options === null || options === void 0 ? void 0 : options.sendFeatureFlagEvent) !== null && _b !== void 0 ? _b : true;
-        _this._sessionExpirationTimeSeconds = (_c = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _c !== void 0 ? _c : 1800; // 30 minutes
-        return _this;
-    }
-    PostHogCore.prototype.setupBootstrap = function (options) {
-        var _a, _b, _c, _d;
-        if ((_a = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _a === void 0 ? void 0 : _a.distinctId) {
-            if ((_b = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _b === void 0 ? void 0 : _b.isIdentifiedId) {
+        const disableGeoipOption = options?.disableGeoip ?? false;
+        // Default for stateful mode is to timeout at 10s. Only override if explicitly set
+        const featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 10000; // 10 seconds
+        super(apiKey, { ...options, disableGeoip: disableGeoipOption, featureFlagsRequestTimeoutMs });
+        this.flagCallReported = {};
+        this.sessionProps = {};
+        this.sendFeatureFlagEvent = options?.sendFeatureFlagEvent ?? true;
+        this._sessionExpirationTimeSeconds = options?.sessionExpirationTimeSeconds ?? 1800; // 30 minutes
+    }
+    setupBootstrap(options) {
+        if (options?.bootstrap?.distinctId) {
+            if (options?.bootstrap?.isIdentifiedId) {
                 this.setPersistedProperty(PostHogPersistedProperty.DistinctId, options.bootstrap.distinctId);
             }
             else {
                 this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, options.bootstrap.distinctId);
             }
         }
-        if ((_c = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _c === void 0 ? void 0 : _c.featureFlags) {
-            var activeFlags = Object.keys(((_d = options.bootstrap) === null || _d === void 0 ? void 0 : _d.featureFlags) || {})
-                .filter(function (flag) { var _a, _b; return !!((_b = (_a = options.bootstrap) === null || _a === void 0 ? void 0 : _a.featureFlags) === null || _b === void 0 ? void 0 : _b[flag]); })
-                .reduce(function (res, key) {
-                var _a, _b;
-                return ((res[key] = ((_b = (_a = options.bootstrap) === null || _a === void 0 ? void 0 : _a.featureFlags) === null || _b === void 0 ? void 0 : _b[key]) || false), res);
-            }, {});
+        if (options?.bootstrap?.featureFlags) {
+            const activeFlags = Object.keys(options.bootstrap?.featureFlags || {})
+                .filter((flag) => !!options.bootstrap?.featureFlags?.[flag])
+                .reduce((res, key) => ((res[key] = options.bootstrap?.featureFlags?.[key] || false), res), {});
             this.setKnownFeatureFlags(activeFlags);
-            (options === null || options === void 0 ? void 0 : options.bootstrap.featureFlagPayloads) && this.setKnownFeatureFlagPayloads(options === null || options === void 0 ? void 0 : options.bootstrap.featureFlagPayloads);
+            options?.bootstrap.featureFlagPayloads && this.setKnownFeatureFlagPayloads(options?.bootstrap.featureFlagPayloads);
         }
-    };
-    Object.defineProperty(PostHogCore.prototype, "props", {
-        // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
-        get: function () {
-            if (!this._props) {
-                this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
-            }
-            return this._props || {};
-        },
-        set: function (val) {
-            this._props = val;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PostHogCore.prototype.clearProps = function () {
+    }
+    // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
+    get props() {
+        if (!this._props) {
+            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
+        }
+        return this._props || {};
+    }
+    set props(val) {
+        this._props = val;
+    }
+    clearProps() {
         this.props = undefined;
         this.sessionProps = {};
-    };
-    PostHogCore.prototype.on = function (event, cb) {
+    }
+    on(event, cb) {
         return this._events.on(event, cb);
-    };
-    PostHogCore.prototype.reset = function (propertiesToKeep) {
-        var allPropertiesToKeep = __spreadArray([PostHogPersistedProperty.Queue], (propertiesToKeep || []), true);
-        // clean up props
-        this.clearProps();
-        for (var _i = 0, _a = Object.keys(PostHogPersistedProperty); _i < _a.length; _i++) {
-            var key = _a[_i];
-            if (!allPropertiesToKeep.includes(PostHogPersistedProperty[key])) {
-                this.setPersistedProperty(PostHogPersistedProperty[key], null);
+    }
+    reset(propertiesToKeep) {
+        this.wrap(() => {
+            const allPropertiesToKeep = [PostHogPersistedProperty.Queue, ...(propertiesToKeep || [])];
+            // clean up props
+            this.clearProps();
+            for (const key of Object.keys(PostHogPersistedProperty)) {
+                if (!allPropertiesToKeep.includes(PostHogPersistedProperty[key])) {
+                    this.setPersistedProperty(PostHogPersistedProperty[key], null);
+                }
             }
-        }
-    };
-    PostHogCore.prototype.getCommonEventProperties = function () {
-        var featureFlags = this.getFeatureFlags();
-        var featureVariantProperties = {};
+        });
+    }
+    getCommonEventProperties() {
+        const featureFlags = this.getFeatureFlags();
+        const featureVariantProperties = {};
         if (featureFlags) {
-            for (var _i = 0, _a = Object.entries(featureFlags); _i < _a.length; _i++) {
-                var _b = _a[_i], feature = _b[0], variant = _b[1];
-                featureVariantProperties["$feature/".concat(feature)] = variant;
+            for (const [feature, variant] of Object.entries(featureFlags)) {
+                featureVariantProperties[`$feature/${feature}`] = variant;
             }
         }
-        return __assign(__assign({ $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined }, featureVariantProperties), _super.prototype.getCommonEventProperties.call(this));
-    };
-    PostHogCore.prototype.enrichProperties = function (properties) {
-        return __assign(__assign(__assign(__assign(__assign({}, this.props), this.sessionProps), (properties || {})), this.getCommonEventProperties()), { $session_id: this.getSessionId() });
-    };
-    PostHogCore.prototype.getSessionId = function () {
-        var sessionId = this.getPersistedProperty(PostHogPersistedProperty.SessionId);
-        var sessionTimestamp = this.getPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp) || 0;
+        return {
+            $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined,
+            ...featureVariantProperties,
+            ...super.getCommonEventProperties(),
+        };
+    }
+    enrichProperties(properties) {
+        return {
+            ...this.props,
+            ...this.sessionProps,
+            ...(properties || {}),
+            ...this.getCommonEventProperties(),
+            $session_id: this.getSessionId(),
+        };
+    }
+    /**
+     * * @returns {string} The stored session ID for the current session. This may be an empty string if the client is not yet fully initialized.
+     */
+    getSessionId() {
+        if (!this._isInitialized) {
+            return '';
+        }
+        let sessionId = this.getPersistedProperty(PostHogPersistedProperty.SessionId);
+        const sessionTimestamp = this.getPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp) || 0;
         if (!sessionId || Date.now() - sessionTimestamp > this._sessionExpirationTimeSeconds * 1000) {
             sessionId = uuidv7();
             this.setPersistedProperty(PostHogPersistedProperty.SessionId, sessionId);
         }
         this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, Date.now());
         return sessionId;
-    };
-    PostHogCore.prototype.resetSessionId = function () {
-        this.setPersistedProperty(PostHogPersistedProperty.SessionId, null);
-    };
-    PostHogCore.prototype.getAnonymousId = function () {
-        var anonId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
+    }
+    resetSessionId() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.SessionId, null);
+        });
+    }
+    /**
+     * * @returns {string} The stored anonymous ID. This may be an empty string if the client is not yet fully initialized.
+     */
+    getAnonymousId() {
+        if (!this._isInitialized) {
+            return '';
+        }
+        let anonId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
         if (!anonId) {
             anonId = uuidv7();
             this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, anonId);
         }
         return anonId;
-    };
-    PostHogCore.prototype.getDistinctId = function () {
+    }
+    /**
+     * * @returns {string} The stored distinct ID. This may be an empty string if the client is not yet fully initialized.
+     */
+    getDistinctId() {
+        if (!this._isInitialized) {
+            return '';
+        }
         return this.getPersistedProperty(PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
-    };
-    PostHogCore.prototype.unregister = function (property) {
-        delete this.props[property];
-        this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-    };
-    PostHogCore.prototype.register = function (properties) {
-        this.props = __assign(__assign({}, this.props), properties);
-        this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-    };
-    PostHogCore.prototype.registerForSession = function (properties) {
-        this.sessionProps = __assign(__assign({}, this.sessionProps), properties);
-    };
-    PostHogCore.prototype.unregisterForSession = function (property) {
+    }
+    async unregister(property) {
+        this.wrap(() => {
+            delete this.props[property];
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    async register(properties) {
+        this.wrap(() => {
+            this.props = {
+                ...this.props,
+                ...properties,
+            };
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    registerForSession(properties) {
+        this.sessionProps = {
+            ...this.sessionProps,
+            ...properties,
+        };
+    }
+    unregisterForSession(property) {
         delete this.sessionProps[property];
-    };
+    }
     /***
      *** TRACKING
      ***/
-    PostHogCore.prototype.identify = function (distinctId, properties, options) {
-        var previousDistinctId = this.getDistinctId();
-        distinctId = distinctId || previousDistinctId;
-        if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
-            this.groups(properties.$groups);
-        }
-        var allProperties = this.enrichProperties(__assign(__assign({}, properties), { $anon_distinct_id: this.getAnonymousId(), $set: properties }));
-        if (distinctId !== previousDistinctId) {
-            // We keep the AnonymousId to be used by decide calls and identify to link the previousId
-            this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
-            this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
-            this.reloadFeatureFlags();
-        }
-        _super.prototype.identifyStateless.call(this, distinctId, allProperties, options);
-        return this;
-    };
-    PostHogCore.prototype.capture = function (event, properties, options) {
-        var distinctId = this.getDistinctId();
-        if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
-            this.groups(properties.$groups);
-        }
-        var allProperties = this.enrichProperties(properties);
-        _super.prototype.captureStateless.call(this, distinctId, event, allProperties, options);
-        return this;
-    };
-    PostHogCore.prototype.alias = function (alias) {
-        var distinctId = this.getDistinctId();
-        var allProperties = this.enrichProperties({});
-        _super.prototype.aliasStateless.call(this, alias, distinctId, allProperties);
-        return this;
-    };
-    PostHogCore.prototype.autocapture = function (eventType, elements, properties, options) {
-        if (properties === void 0) { properties = {}; }
-        var distinctId = this.getDistinctId();
-        var payload = {
-            distinct_id: distinctId,
-            event: '$autocapture',
-            properties: __assign(__assign({}, this.enrichProperties(properties)), { $event_type: eventType, $elements: elements }),
-        };
-        this.enqueue('autocapture', payload, options);
-        return this;
-    };
+    identify(distinctId, properties, options) {
+        this.wrap(() => {
+            const previousDistinctId = this.getDistinctId();
+            distinctId = distinctId || previousDistinctId;
+            if (properties?.$groups) {
+                this.groups(properties.$groups);
+            }
+            const allProperties = this.enrichProperties({
+                ...properties,
+                $anon_distinct_id: this.getAnonymousId(),
+                $set: properties,
+            });
+            if (distinctId !== previousDistinctId) {
+                // We keep the AnonymousId to be used by decide calls and identify to link the previousId
+                this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
+                this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
+                this.reloadFeatureFlags();
+            }
+            super.identifyStateless(distinctId, allProperties, options);
+        });
+    }
+    capture(event, properties, options) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            if (properties?.$groups) {
+                this.groups(properties.$groups);
+            }
+            const allProperties = this.enrichProperties(properties);
+            super.captureStateless(distinctId, event, allProperties, options);
+        });
+    }
+    alias(alias) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            const allProperties = this.enrichProperties({});
+            super.aliasStateless(alias, distinctId, allProperties);
+        });
+    }
+    autocapture(eventType, elements, properties = {}, options) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            const payload = {
+                distinct_id: distinctId,
+                event: '$autocapture',
+                properties: {
+                    ...this.enrichProperties(properties),
+                    $event_type: eventType,
+                    $elements: elements,
+                },
+            };
+            this.enqueue('autocapture', payload, options);
+        });
+    }
     /***
      *** GROUPS
      ***/
-    PostHogCore.prototype.groups = function (groups) {
-        // Get persisted groups
-        var existingGroups = this.props.$groups || {};
-        this.register({
-            $groups: __assign(__assign({}, existingGroups), groups),
+    groups(groups) {
+        this.wrap(() => {
+            // Get persisted groups
+            const existingGroups = this.props.$groups || {};
+            this.register({
+                $groups: {
+                    ...existingGroups,
+                    ...groups,
+                },
+            });
+            if (Object.keys(groups).find((type) => existingGroups[type] !== groups[type])) {
+                this.reloadFeatureFlags();
+            }
         });
-        if (Object.keys(groups).find(function (type) { return existingGroups[type] !== groups[type]; })) {
-            this.reloadFeatureFlags();
-        }
-        return this;
-    };
-    PostHogCore.prototype.group = function (groupType, groupKey, groupProperties, options) {
-        var _a;
-        this.groups((_a = {},
-            _a[groupType] = groupKey,
-            _a));
-        if (groupProperties) {
-            this.groupIdentify(groupType, groupKey, groupProperties, options);
-        }
-        return this;
-    };
-    PostHogCore.prototype.groupIdentify = function (groupType, groupKey, groupProperties, options) {
-        var distinctId = this.getDistinctId();
-        var eventProperties = this.enrichProperties({});
-        _super.prototype.groupIdentifyStateless.call(this, groupType, groupKey, groupProperties, options, distinctId, eventProperties);
-        return this;
-    };
+    }
+    group(groupType, groupKey, groupProperties, options) {
+        this.wrap(() => {
+            this.groups({
+                [groupType]: groupKey,
+            });
+            if (groupProperties) {
+                this.groupIdentify(groupType, groupKey, groupProperties, options);
+            }
+        });
+    }
+    groupIdentify(groupType, groupKey, groupProperties, options) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            const eventProperties = this.enrichProperties({});
+            super.groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties);
+        });
+    }
     /***
      * PROPERTIES
      ***/
-    PostHogCore.prototype.setPersonPropertiesForFlags = function (properties) {
-        // Get persisted person properties
-        var existingProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
-        this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, __assign(__assign({}, existingProperties), properties));
-        return this;
-    };
-    PostHogCore.prototype.resetPersonPropertiesForFlags = function () {
-        this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, {});
-    };
+    setPersonPropertiesForFlags(properties) {
+        this.wrap(() => {
+            // Get persisted person properties
+            const existingProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, {
+                ...existingProperties,
+                ...properties,
+            });
+        });
+    }
+    resetPersonPropertiesForFlags() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, {});
+        });
+    }
     /** @deprecated - Renamed to setPersonPropertiesForFlags */
-    PostHogCore.prototype.personProperties = function (properties) {
+    personProperties(properties) {
         return this.setPersonPropertiesForFlags(properties);
-    };
-    PostHogCore.prototype.setGroupPropertiesForFlags = function (properties) {
-        // Get persisted group properties
-        var existingProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
-        if (Object.keys(existingProperties).length !== 0) {
-            Object.keys(existingProperties).forEach(function (groupType) {
-                existingProperties[groupType] = __assign(__assign({}, existingProperties[groupType]), properties[groupType]);
-                delete properties[groupType];
+    }
+    setGroupPropertiesForFlags(properties) {
+        this.wrap(() => {
+            // Get persisted group properties
+            const existingProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) ||
+                {};
+            if (Object.keys(existingProperties).length !== 0) {
+                Object.keys(existingProperties).forEach((groupType) => {
+                    existingProperties[groupType] = {
+                        ...existingProperties[groupType],
+                        ...properties[groupType],
+                    };
+                    delete properties[groupType];
+                });
+            }
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, {
+                ...existingProperties,
+                ...properties,
             });
-        }
-        this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, __assign(__assign({}, existingProperties), properties));
-        return this;
-    };
-    PostHogCore.prototype.resetGroupPropertiesForFlags = function () {
-        this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, {});
-    };
+        });
+    }
+    resetGroupPropertiesForFlags() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, {});
+        });
+    }
     /** @deprecated - Renamed to setGroupPropertiesForFlags */
-    PostHogCore.prototype.groupProperties = function (properties) {
-        return this.setGroupPropertiesForFlags(properties);
-    };
+    groupProperties(properties) {
+        this.wrap(() => {
+            this.setGroupPropertiesForFlags(properties);
+        });
+    }
     /***
      *** FEATURE FLAGS
      ***/
-    PostHogCore.prototype.decideAsync = function (sendAnonDistinctId) {
-        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
+    async decideAsync(sendAnonDistinctId = true) {
+        await this._initPromise;
         if (this._decideResponsePromise) {
             return this._decideResponsePromise;
         }
         return this._decideAsync(sendAnonDistinctId);
-    };
-    PostHogCore.prototype._decideAsync = function (sendAnonDistinctId) {
-        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var distinctId, groups, personProperties, groupProperties, extraProperties;
-            var _this = this;
-            return __generator(this, function (_a) {
-                distinctId = this.getDistinctId();
-                groups = this.props.$groups || {};
-                personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
-                groupProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
-                extraProperties = {
-                    $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
-                };
-                this._decideResponsePromise = _super.prototype.getDecide.call(this, distinctId, groups, personProperties, groupProperties, extraProperties)
-                    .then(function (res) {
-                    if (res === null || res === void 0 ? void 0 : res.featureFlags) {
-                        var newFeatureFlags = res.featureFlags;
-                        var newFeatureFlagPayloads = res.featureFlagPayloads;
-                        if (res.errorsWhileComputingFlags) {
-                            // if not all flags were computed, we upsert flags instead of replacing them
-                            var currentFlags = _this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
-                            var currentFlagPayloads = _this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
-                            newFeatureFlags = __assign(__assign({}, currentFlags), res.featureFlags);
-                            newFeatureFlagPayloads = __assign(__assign({}, currentFlagPayloads), res.featureFlagPayloads);
-                        }
-                        _this.setKnownFeatureFlags(newFeatureFlags);
-                        _this.setKnownFeatureFlagPayloads(newFeatureFlagPayloads);
+    }
+    async _decideAsync(sendAnonDistinctId = true) {
+        this._decideResponsePromise = this._initPromise
+            .then(() => {
+            const distinctId = this.getDistinctId();
+            const groups = this.props.$groups || {};
+            const personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+            const groupProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) ||
+                {};
+            const extraProperties = {
+                $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
+            };
+            return super.getDecide(distinctId, groups, personProperties, groupProperties, extraProperties).then((res) => {
+                if (res?.featureFlags) {
+                    let newFeatureFlags = res.featureFlags;
+                    let newFeatureFlagPayloads = res.featureFlagPayloads;
+                    if (res.errorsWhileComputingFlags) {
+                        // if not all flags were computed, we upsert flags instead of replacing them
+                        const currentFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+                        const currentFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+                        newFeatureFlags = { ...currentFlags, ...res.featureFlags };
+                        newFeatureFlagPayloads = { ...currentFlagPayloads, ...res.featureFlagPayloads };
                     }
-                    return res;
-                })
-                    .finally(function () {
-                    _this._decideResponsePromise = undefined;
-                });
-                return [2 /*return*/, this._decideResponsePromise];
+                    this.setKnownFeatureFlags(newFeatureFlags);
+                    this.setKnownFeatureFlagPayloads(newFeatureFlagPayloads);
+                }
+                return res;
             });
+        })
+            .finally(() => {
+            this._decideResponsePromise = undefined;
         });
-    };
-    PostHogCore.prototype.setKnownFeatureFlags = function (featureFlags) {
-        this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, featureFlags);
-        this._events.emit('featureflags', featureFlags);
-    };
-    PostHogCore.prototype.setKnownFeatureFlagPayloads = function (featureFlagPayloads) {
-        this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads, featureFlagPayloads);
-    };
-    PostHogCore.prototype.getFeatureFlag = function (key) {
-        var featureFlags = this.getFeatureFlags();
+        return this._decideResponsePromise;
+    }
+    setKnownFeatureFlags(featureFlags) {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, featureFlags);
+            this._events.emit('featureflags', featureFlags);
+        });
+    }
+    setKnownFeatureFlagPayloads(featureFlagPayloads) {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads, featureFlagPayloads);
+        });
+    }
+    getFeatureFlag(key) {
+        const featureFlags = this.getFeatureFlags();
         if (!featureFlags) {
             // If we haven't loaded flags yet, or errored out, we respond with undefined
             return undefined;
         }
-        var response = featureFlags[key];
+        let response = featureFlags[key];
         // `/decide` v3 returns all flags
         if (response === undefined) {
             // For cases where the flag is unknown, return false
@@ -1859,38 +1720,36 @@ var PostHogCore = /** @class */ (function (_super) {
         }
         // If we have flags we either return the value (true or string) or false
         return response;
-    };
-    PostHogCore.prototype.getFeatureFlagPayload = function (key) {
-        var payloads = this.getFeatureFlagPayloads();
+    }
+    getFeatureFlagPayload(key) {
+        const payloads = this.getFeatureFlagPayloads();
         if (!payloads) {
             return undefined;
         }
-        var response = payloads[key];
+        const response = payloads[key];
         // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
         if (response === undefined) {
             return null;
         }
         return this._parsePayload(response);
-    };
-    PostHogCore.prototype.getFeatureFlagPayloads = function () {
-        var _this = this;
-        var payloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+    }
+    getFeatureFlagPayloads() {
+        const payloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
         if (payloads) {
-            return Object.fromEntries(Object.entries(payloads).map(function (_a) {
-                var k = _a[0], v = _a[1];
-                return [k, _this._parsePayload(v)];
-            }));
+            return Object.fromEntries(Object.entries(payloads).map(([k, v]) => [k, this._parsePayload(v)]));
         }
         return payloads;
-    };
-    PostHogCore.prototype.getFeatureFlags = function () {
-        var flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
-        var overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
+    }
+    getFeatureFlags() {
+        // NOTE: We don't check for _initPromise here as the function is designed to be
+        // callable before the state being loaded anyways
+        let flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+        const overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
         if (!overriddenFlags) {
             return flags;
         }
         flags = flags || {};
-        for (var key in overriddenFlags) {
+        for (const key in overriddenFlags) {
             if (!overriddenFlags[key]) {
                 delete flags[key];
             }
@@ -1899,90 +1758,72 @@ var PostHogCore = /** @class */ (function (_super) {
             }
         }
         return flags;
-    };
-    PostHogCore.prototype.getFeatureFlagsAndPayloads = function () {
-        var flags = this.getFeatureFlags();
-        var payloads = this.getFeatureFlagPayloads();
+    }
+    getFeatureFlagsAndPayloads() {
+        const flags = this.getFeatureFlags();
+        const payloads = this.getFeatureFlagPayloads();
         return {
-            flags: flags,
-            payloads: payloads,
+            flags,
+            payloads,
         };
-    };
-    PostHogCore.prototype.isFeatureEnabled = function (key) {
-        var response = this.getFeatureFlag(key);
+    }
+    isFeatureEnabled(key) {
+        const response = this.getFeatureFlag(key);
         if (response === undefined) {
             return undefined;
         }
         return !!response;
-    };
+    }
     // Used when we want to trigger the reload but we don't care about the result
-    PostHogCore.prototype.reloadFeatureFlags = function (cb) {
+    reloadFeatureFlags(cb) {
         this.decideAsync()
-            .then(function (res) {
-            cb === null || cb === void 0 ? void 0 : cb(undefined, res === null || res === void 0 ? void 0 : res.featureFlags);
+            .then((res) => {
+            cb?.(undefined, res?.featureFlags);
         })
-            .catch(function (e) {
-            cb === null || cb === void 0 ? void 0 : cb(e, undefined);
+            .catch((e) => {
+            cb?.(e, undefined);
             if (!cb) {
                 console.log('[PostHog] Error reloading feature flags', e);
             }
         });
-    };
-    PostHogCore.prototype.reloadFeatureFlagsAsync = function (sendAnonDistinctId) {
-        var _a;
-        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.decideAsync(sendAnonDistinctId)];
-                    case 1: return [2 /*return*/, (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.featureFlags];
-                }
-            });
+    }
+    async reloadFeatureFlagsAsync(sendAnonDistinctId = true) {
+        return (await this.decideAsync(sendAnonDistinctId))?.featureFlags;
+    }
+    onFeatureFlags(cb) {
+        return this.on('featureflags', async () => {
+            const flags = this.getFeatureFlags();
+            if (flags) {
+                cb(flags);
+            }
         });
-    };
-    PostHogCore.prototype.onFeatureFlags = function (cb) {
-        var _this = this;
-        return this.on('featureflags', function () { return __awaiter(_this, void 0, void 0, function () {
-            var flags;
-            return __generator(this, function (_a) {
-                flags = this.getFeatureFlags();
-                if (flags) {
-                    cb(flags);
-                }
-                return [2 /*return*/];
-            });
-        }); });
-    };
-    PostHogCore.prototype.onFeatureFlag = function (key, cb) {
-        var _this = this;
-        return this.on('featureflags', function () { return __awaiter(_this, void 0, void 0, function () {
-            var flagResponse;
-            return __generator(this, function (_a) {
-                flagResponse = this.getFeatureFlag(key);
-                if (flagResponse !== undefined) {
-                    cb(flagResponse);
-                }
-                return [2 /*return*/];
-            });
-        }); });
-    };
-    PostHogCore.prototype.overrideFeatureFlag = function (flags) {
-        if (flags === null) {
-            return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, null);
-        }
-        return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
-    };
-    return PostHogCore;
-}(PostHogCoreStateless));
+    }
+    onFeatureFlag(key, cb) {
+        return this.on('featureflags', async () => {
+            const flagResponse = this.getFeatureFlag(key);
+            if (flagResponse !== undefined) {
+                cb(flagResponse);
+            }
+        });
+    }
+    async overrideFeatureFlag(flags) {
+        this.wrap(() => {
+            if (flags === null) {
+                return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, null);
+            }
+            return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
+        });
+    }
+}
 
-var version = "2.6.1";
+var version = "3.0.0-beta.1";
 
 function getContext(window) {
-  var context = {};
+  let context = {};
 
   if (window.navigator) {
-    var userAgent = window.navigator.userAgent;
-    context = __assign(__assign({}, context), {
+    const userAgent = window.navigator.userAgent;
+    context = { ...context,
       $os: os(window),
       $browser: browser(userAgent, window.navigator.vendor, !!window.opera),
       $referrer: window.document.referrer,
@@ -1995,15 +1836,16 @@ function getContext(window) {
       $screen_height: window.screen.height,
       $screen_width: window.screen.width,
       $screen_dpr: window.devicePixelRatio
-    });
+    };
   }
 
-  context = __assign(__assign({}, context), {
+  context = { ...context,
     $lib: 'js',
     $lib_version: version,
     $insert_id: Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10),
-    $time: currentTimestamp() / 1000
-  });
+    $time: currentTimestamp() / 1000 // epoch time in seconds
+
+  };
   return context; // TODO: strip empty props?
 }
 
@@ -2061,7 +1903,7 @@ function browser(userAgent, vendor, opera) {
 }
 
 function browserVersion(userAgent, vendor, opera) {
-  var regexList = {
+  const regexList = {
     'Internet Explorer Mobile': /rv:(\d+(\.\d+)?)/,
     'Microsoft Edge': /Edge?\/(\d+(\.\d+)?)/,
     Chrome: /Chrome\/(\d+(\.\d+)?)/,
@@ -2079,14 +1921,14 @@ function browserVersion(userAgent, vendor, opera) {
     'Internet Explorer': /(rv:|MSIE )(\d+(\.\d+)?)/,
     Mozilla: /rv:(\d+(\.\d+)?)/
   };
-  var browserString = browser(userAgent, vendor, opera);
-  var regex = regexList[browserString] || undefined;
+  const browserString = browser(userAgent, vendor, opera);
+  const regex = regexList[browserString] || undefined;
 
   if (regex === undefined) {
     return null;
   }
 
-  var matches = userAgent.match(regex);
+  const matches = userAgent.match(regex);
 
   if (!matches) {
     return null;
@@ -2096,7 +1938,7 @@ function browserVersion(userAgent, vendor, opera) {
 }
 
 function os(window) {
-  var a = window.navigator.userAgent;
+  const a = window.navigator.userAgent;
 
   if (/Windows/i.test(a)) {
     if (/Phone/.test(a) || /WPDesktop/.test(a)) {
@@ -2140,7 +1982,7 @@ function device(userAgent) {
 }
 
 function referringDomain(referrer) {
-  var split = referrer.split('/');
+  const split = referrer.split('/');
 
   if (split.length >= 3) {
     return split[2];
@@ -2150,14 +1992,14 @@ function referringDomain(referrer) {
 }
 
 // Methods partially borrowed from quirksmode.org/js/cookies.html
-var cookieStore = {
-  getItem: function (key) {
+const cookieStore = {
+  getItem(key) {
     try {
-      var nameEQ = key + '=';
-      var ca = document.cookie.split(';');
+      const nameEQ = key + '=';
+      const ca = document.cookie.split(';');
 
-      for (var i = 0; i < ca.length; i++) {
-        var c = ca[i];
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
 
         while (c.charAt(0) == ' ') {
           c = c.substring(1, c.length);
@@ -2171,33 +2013,37 @@ var cookieStore = {
 
     return null;
   },
-  setItem: function (key, value) {
+
+  setItem(key, value) {
     try {
-      var cdomain = '',
-          expires = '',
-          secure = '';
-      var new_cookie_val = key + '=' + encodeURIComponent(value) + expires + '; path=/' + cdomain + secure;
+      const cdomain = '',
+            expires = '',
+            secure = '';
+      const new_cookie_val = key + '=' + encodeURIComponent(value) + expires + '; path=/' + cdomain + secure;
       document.cookie = new_cookie_val;
     } catch (err) {
       return;
     }
   },
-  removeItem: function (name) {
+
+  removeItem(name) {
     try {
       cookieStore.setItem(name, '');
     } catch (err) {
       return;
     }
   },
-  clear: function () {
+
+  clear() {
     document.cookie = '';
   },
-  getAllKeys: function () {
-    var ca = document.cookie.split(';');
-    var keys = [];
 
-    for (var i = 0; i < ca.length; i++) {
-      var c = ca[i];
+  getAllKeys() {
+    const ca = document.cookie.split(';');
+    const keys = [];
+
+    for (let i = 0; i < ca.length; i++) {
+      let c = ca[i];
 
       while (c.charAt(0) == ' ') {
         c = c.substring(1, c.length);
@@ -2208,45 +2054,47 @@ var cookieStore = {
 
     return keys;
   }
+
 };
 
-var createStorageLike = function (store) {
+const createStorageLike = store => {
   return {
-    getItem: function (key) {
+    getItem(key) {
       return store.getItem(key);
     },
-    setItem: function (key, value) {
+
+    setItem(key, value) {
       store.setItem(key, value);
     },
-    removeItem: function (key) {
+
+    removeItem(key) {
       store.removeItem(key);
     },
-    clear: function () {
+
+    clear() {
       store.clear();
     },
-    getAllKeys: function () {
-      var keys = [];
 
-      for (var key in localStorage) {
+    getAllKeys() {
+      const keys = [];
+
+      for (const key in localStorage) {
         keys.push(key);
       }
 
       return keys;
     }
+
   };
 };
 
-var checkStoreIsSupported = function (storage, key) {
-  if (key === void 0) {
-    key = '__mplssupport__';
-  }
-
+const checkStoreIsSupported = (storage, key = '__mplssupport__') => {
   if (!window) {
     return false;
   }
 
   try {
-    var val = 'xyz';
+    const val = 'xyz';
     storage.setItem(key, val);
 
     if (storage.getItem(key) !== val) {
@@ -2260,49 +2108,54 @@ var checkStoreIsSupported = function (storage, key) {
   }
 };
 
-var localStore = undefined;
-var sessionStore = undefined;
+let localStore = undefined;
+let sessionStore = undefined;
 
-var createMemoryStorage = function () {
-  var _cache = {};
-  var store = {
-    getItem: function (key) {
+const createMemoryStorage = () => {
+  const _cache = {};
+  const store = {
+    getItem(key) {
       return _cache[key];
     },
-    setItem: function (key, value) {
+
+    setItem(key, value) {
       _cache[key] = value !== null ? value : undefined;
     },
-    removeItem: function (key) {
+
+    removeItem(key) {
       delete _cache[key];
     },
-    clear: function () {
-      for (var key in _cache) {
+
+    clear() {
+      for (const key in _cache) {
         delete _cache[key];
       }
     },
-    getAllKeys: function () {
-      var keys = [];
 
-      for (var key in _cache) {
+    getAllKeys() {
+      const keys = [];
+
+      for (const key in _cache) {
         keys.push(key);
       }
 
       return keys;
     }
+
   };
   return store;
 };
 
-var getStorage = function (type, window) {
+const getStorage = (type, window) => {
   if (window) {
     if (!localStorage) {
-      var _localStore = createStorageLike(window.localStorage);
+      const _localStore = createStorageLike(window.localStorage);
 
       localStore = checkStoreIsSupported(_localStore) ? _localStore : undefined;
     }
 
     if (!sessionStore) {
-      var _sessionStore = createStorageLike(window.sessionStorage);
+      const _sessionStore = createStorageLike(window.sessionStorage);
 
       sessionStore = checkStoreIsSupported(_sessionStore) ? _sessionStore : undefined;
     }
@@ -2326,36 +2179,28 @@ var getStorage = function (type, window) {
   }
 };
 
-var PostHog =
-/** @class */
-function (_super) {
-  __extends(PostHog, _super);
-
-  function PostHog(apiKey, options) {
-    var _this = _super.call(this, apiKey, options) || this; // posthog-js stores options in one object on
-
+class PostHog extends PostHogCore {
+  constructor(apiKey, options) {
+    super(apiKey, options); // posthog-js stores options in one object on
 
-    _this._storageKey = (options === null || options === void 0 ? void 0 : options.persistence_name) ? "ph_".concat(options.persistence_name) : "ph_".concat(apiKey, "_posthog");
-    _this._storage = getStorage((options === null || options === void 0 ? void 0 : options.persistence) || 'localStorage', window);
+    this._storageKey = options?.persistence_name ? `ph_${options.persistence_name}` : `ph_${apiKey}_posthog`;
+    this._storage = getStorage(options?.persistence || 'localStorage', window);
+    this.setupBootstrap(options);
 
-    _this.setupBootstrap(options);
-
-    if ((options === null || options === void 0 ? void 0 : options.preloadFeatureFlags) !== false) {
-      _this.reloadFeatureFlags();
+    if (options?.preloadFeatureFlags !== false) {
+      this.reloadFeatureFlags();
     }
-
-    return _this;
   }
 
-  PostHog.prototype.getPersistedProperty = function (key) {
+  getPersistedProperty(key) {
     if (!this._storageCache) {
       this._storageCache = JSON.parse(this._storage.getItem(this._storageKey) || '{}') || {};
     }
 
     return this._storageCache[key];
-  };
+  }
 
-  PostHog.prototype.setPersistedProperty = function (key, value) {
+  setPersistedProperty(key, value) {
     if (!this._storageCache) {
       this._storageCache = JSON.parse(this._storage.getItem(this._storageKey) || '{}') || {};
     }
@@ -2367,30 +2212,31 @@ function (_super) {
     }
 
     this._storage.setItem(this._storageKey, JSON.stringify(this._storageCache));
-  };
+  }
 
-  PostHog.prototype.fetch = function (url, options) {
+  fetch(url, options) {
     return window.fetch(url, options);
-  };
+  }
 
-  PostHog.prototype.getLibraryId = function () {
+  getLibraryId() {
     return 'posthog-js-lite';
-  };
+  }
 
-  PostHog.prototype.getLibraryVersion = function () {
+  getLibraryVersion() {
     return version;
-  };
+  }
 
-  PostHog.prototype.getCustomUserAgent = function () {
+  getCustomUserAgent() {
     return;
-  };
+  }
 
-  PostHog.prototype.getCommonEventProperties = function () {
-    return __assign(__assign({}, _super.prototype.getCommonEventProperties.call(this)), getContext(window));
-  };
+  getCommonEventProperties() {
+    return { ...super.getCommonEventProperties(),
+      ...getContext(window)
+    };
+  }
 
-  return PostHog;
-}(PostHogCore);
+}
 
 exports.PostHog = PostHog;
 exports["default"] = PostHog;