posthog-node 5.6.0 → 5.8.0

package/{lib → dist}/node/index.cjs

@@ -1,51 +1,32 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var path = require('path');
 var node_fs = require('node:fs');
 var node_readline = require('node:readline');
+var core = require('@posthog/core');
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-/**
- * @file Adapted from [posthog-js](https://github.com/PostHog/posthog-js/blob/8157df935a4d0e71d2fefef7127aa85ee51c82d1/src/extensions/sentry-integration.ts) with modifications for the Node SDK.
+/**
+ * @file Adapted from [posthog-js](https://github.com/PostHog/posthog-js/blob/8157df935a4d0e71d2fefef7127aa85ee51c82d1/src/extensions/sentry-integration.ts) with modifications for the Node SDK.
  */
-/**
- * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog.
- *
- * ### Usage
- *
- *     Sentry.init({
- *          dsn: 'https://example',
- *          integrations: [
- *              new PostHogSentryIntegration(posthog)
- *          ]
- *     })
- *
- *     Sentry.setTag(PostHogSentryIntegration.POSTHOG_ID_TAG, 'some distinct id');
- *
- * @param {Object} [posthog] The posthog object
- * @param {string} [organization] Optional: The Sentry organization, used to send a direct link from PostHog to Sentry
- * @param {Number} [projectId] Optional: The Sentry project id, used to send a direct link from PostHog to Sentry
- * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
- * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
+/**
+ * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog.
+ *
+ * ### Usage
+ *
+ *     Sentry.init({
+ *          dsn: 'https://example',
+ *          integrations: [
+ *              new PostHogSentryIntegration(posthog)
+ *          ]
+ *     })
+ *
+ *     Sentry.setTag(PostHogSentryIntegration.POSTHOG_ID_TAG, 'some distinct id');
+ *
+ * @param {Object} [posthog] The posthog object
+ * @param {string} [organization] Optional: The Sentry organization, used to send a direct link from PostHog to Sentry
+ * @param {Number} [projectId] Optional: The Sentry project id, used to send a direct link from PostHog to Sentry
+ * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
+ * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
  */
 const NAME = 'posthog-node';
 function createEventProcessor(_posthog, {
@@ -139,411 +120,175 @@ class PostHogSentryIntegration {
 }
 PostHogSentryIntegration.POSTHOG_ID_TAG = 'posthog_distinct_id';
 
-// 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
- *
- * @license Apache-2.0
- * @copyright 2021-2023 LiosK
- * @packageDocumentation
- */
-const DIGITS = "0123456789abcdef";
-/** Represents a UUID as a 16-byte byte array. */
-class UUID {
-    /** @param bytes - The 16-byte byte array representation. */
-    constructor(bytes) {
-        this.bytes = bytes;
-    }
-    /**
-     * Creates an object from the internal representation, a 16-byte byte array
-     * containing the binary UUID representation in the big-endian byte order.
-     *
-     * This method does NOT shallow-copy the argument, and thus the created object
-     * holds the reference to the underlying buffer.
-     *
-     * @throws TypeError if the length of the argument is not 16.
-     */
-    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.
-     *
-     * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
-     * @param randA - A 12-bit `rand_a` field value.
-     * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
-     * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
-     * @throws RangeError if any field value is out of the specified range.
-     */
-    static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
-        if (!Number.isInteger(unixTsMs) ||
-            !Number.isInteger(randA) ||
-            !Number.isInteger(randBHi) ||
-            !Number.isInteger(randBLo) ||
-            unixTsMs < 0 ||
-            randA < 0 ||
-            randBHi < 0 ||
-            randBLo < 0 ||
-            unixTsMs > 281474976710655 ||
-            randA > 0xfff ||
-            randBHi > 1073741823 ||
-            randBLo > 4294967295) {
-            throw new RangeError("invalid field value");
-        }
-        const bytes = new Uint8Array(16);
-        bytes[0] = unixTsMs / 2 ** 40;
-        bytes[1] = unixTsMs / 2 ** 32;
-        bytes[2] = unixTsMs / 2 ** 24;
-        bytes[3] = unixTsMs / 2 ** 16;
-        bytes[4] = unixTsMs / 2 ** 8;
-        bytes[5] = unixTsMs;
-        bytes[6] = 0x70 | (randA >>> 8);
-        bytes[7] = randA;
-        bytes[8] = 0x80 | (randBHi >>> 24);
-        bytes[9] = randBHi >>> 16;
-        bytes[10] = randBHi >>> 8;
-        bytes[11] = randBHi;
-        bytes[12] = randBLo >>> 24;
-        bytes[13] = randBLo >>> 16;
-        bytes[14] = randBLo >>> 8;
-        bytes[15] = randBLo;
-        return new UUID(bytes);
-    }
-    /**
-     * Builds a byte array from a string representation.
-     *
-     * This method accepts the following formats:
-     *
-     * - 32-digit hexadecimal format without hyphens: `0189dcd553117d408db09496a2eef37b`
-     * - 8-4-4-4-12 hyphenated format: `0189dcd5-5311-7d40-8db0-9496a2eef37b`
-     * - Hyphenated format with surrounding braces: `{0189dcd5-5311-7d40-8db0-9496a2eef37b}`
-     * - RFC 4122 URN format: `urn:uuid:0189dcd5-5311-7d40-8db0-9496a2eef37b`
-     *
-     * Leading and trailing whitespaces represents an error.
-     *
-     * @throws SyntaxError if the argument could not parse as a valid UUID string.
-     */
-    static parse(uuid) {
-        let hex = undefined;
-        switch (uuid.length) {
-            case 32:
-                hex = /^[0-9a-f]{32}$/i.exec(uuid)?.[0];
-                break;
-            case 36:
-                hex =
-                    /^([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 =
-                    /^\{([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 =
-                    /^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) {
-            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;
-                inner[i + 3] = n;
-            }
-            return new UUID(inner);
-        }
-        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`).
-     */
-    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) {
-                text += "-";
-            }
-        }
-        return text;
-    }
-    /**
-     * @returns The 32-digit hexadecimal representation without hyphens
-     * (`0189dcd553117d408db09496a2eef37b`).
-     */
-    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. */
-    toJSON() {
-        return this.toString();
-    }
-    /**
-     * Reports the variant field value of the UUID or, if appropriate, "NIL" or
-     * "MAX".
-     *
-     * For convenience, this method reports "NIL" or "MAX" if `this` represents
-     * the Nil or Max UUID, although the Nil and Max UUIDs are technically
-     * subsumed under the variants `0b0` and `0b111`, respectively.
-     */
-    getVariant() {
-        const n = this.bytes[8] >>> 4;
-        if (n < 0) {
-            throw new Error("unreachable");
-        }
-        else if (n <= 0b0111) {
-            return this.bytes.every((e) => e === 0) ? "NIL" : "VAR_0";
-        }
-        else if (n <= 0b1011) {
-            return "VAR_10";
-        }
-        else if (n <= 0b1101) {
-            return "VAR_110";
-        }
-        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`.
-     */
-    getVersion() {
-        return this.getVariant() === "VAR_10" ? this.bytes[6] >>> 4 : undefined;
-    }
-    /** Creates an object from `this`. */
-    clone() {
-        return new UUID(this.bytes.slice(0));
-    }
-    /** Returns true if `this` is equivalent to `other`. */
-    equals(other) {
-        return this.compareTo(other) === 0;
-    }
-    /**
-     * Returns a negative integer, zero, or positive integer if `this` is less
-     * than, equal to, or greater than `other`, respectively.
-     */
-    compareTo(other) {
-        for (let i = 0; i < 16; i++) {
-            const diff = this.bytes[i] - other.bytes[i];
-            if (diff !== 0) {
-                return Math.sign(diff);
-            }
-        }
-        return 0;
-    }
-}
-/**
- * Encapsulates the monotonic counter state.
- *
- * This class provides APIs to utilize a separate counter state from that of the
- * global generator used by {@link uuidv7} and {@link uuidv7obj}. In addition to
- * the default {@link generate} method, this class has {@link generateOrAbort}
- * that is useful to absolutely guarantee the monotonically increasing order of
- * generated UUIDs. See their respective documentation for details.
- */
-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.
-     */
-    constructor(randomNumberGenerator) {
-        this.timestamp = 0;
-        this.counter = 0;
-        this.random = randomNumberGenerator ?? getDefaultRandom();
-    }
-    /**
-     * Generates a new UUIDv7 object from the current timestamp, or resets the
-     * generator upon significant timestamp rollback.
-     *
-     * This method returns a monotonically increasing UUID by reusing the previous
-     * timestamp even if the up-to-date timestamp is smaller than the immediately
-     * preceding UUID's. However, when such a clock rollback is considered
-     * significant (i.e., by more than ten seconds), this method resets the
-     * generator and returns a new UUID based on the given timestamp, breaking the
-     * increasing order of UUIDs.
-     *
-     * See {@link generateOrAbort} for the other mode of generation and
-     * {@link generateOrResetCore} for the low-level primitive.
-     */
-    generate() {
-        return this.generateOrResetCore(Date.now(), 10000);
-    }
-    /**
-     * Generates a new UUIDv7 object from the current timestamp, or returns
-     * `undefined` upon significant timestamp rollback.
-     *
-     * This method returns a monotonically increasing UUID by reusing the previous
-     * timestamp even if the up-to-date timestamp is smaller than the immediately
-     * preceding UUID's. However, when such a clock rollback is considered
-     * significant (i.e., by more than ten seconds), this method aborts and
-     * returns `undefined` immediately.
-     *
-     * See {@link generate} for the other mode of generation and
-     * {@link generateOrAbortCore} for the low-level primitive.
-     */
-    generateOrAbort() {
-        return this.generateOrAbortCore(Date.now(), 10000);
-    }
-    /**
-     * Generates a new UUIDv7 object from the `unixTsMs` passed, or resets the
-     * generator upon significant timestamp rollback.
-     *
-     * This method is equivalent to {@link generate} except that it takes a custom
-     * timestamp and clock rollback allowance.
-     *
-     * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
-     * considered significant. A suggested value is `10_000` (milliseconds).
-     * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
-     */
-    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.
-     *
-     * This method is equivalent to {@link generateOrAbort} except that it takes a
-     * custom timestamp and clock rollback allowance.
-     *
-     * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
-     * considered significant. A suggested value is `10_000` (milliseconds).
-     * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
-     */
-    generateOrAbortCore(unixTsMs, rollbackAllowance) {
-        const MAX_COUNTER = 4398046511103;
-        if (!Number.isInteger(unixTsMs) ||
-            unixTsMs < 1 ||
-            unixTsMs > 281474976710655) {
-            throw new RangeError("`unixTsMs` must be a 48-bit positive integer");
-        }
-        else if (rollbackAllowance < 0 || rollbackAllowance > 281474976710655) {
-            throw new RangeError("`rollbackAllowance` out of reasonable range");
-        }
-        if (unixTsMs > this.timestamp) {
-            this.timestamp = unixTsMs;
-            this.resetCounter();
-        }
-        else if (unixTsMs + rollbackAllowance >= this.timestamp) {
-            // go on with previous timestamp if new one is not much smaller
-            this.counter++;
-            if (this.counter > MAX_COUNTER) {
-                // increment timestamp at counter overflow
-                this.timestamp++;
-                this.resetCounter();
-            }
-        }
-        else {
-            // abort if clock went backwards to unbearable extent
-            return undefined;
-        }
-        return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & (2 ** 30 - 1), this.random.nextUint32());
-    }
-    /** Initializes the counter at a 42-bit random integer. */
-    resetCounter() {
-        this.counter =
-            this.random.nextUint32() * 0x400 + (this.random.nextUint32() & 0x3ff);
-    }
-    /**
-     * Generates a new UUIDv4 object utilizing the random number generator inside.
-     *
-     * @internal
-     */
-    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);
-    }
-}
-/** 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),
-    };
-};
-// /**
-//  * 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").
- */
-const uuidv7 = () => uuidv7obj().toString();
-/** Generates a UUIDv7 object. */
-const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
+/*! For license information please see uuidv7.mjs.LICENSE.txt */
+/**
+ * uuidv7: An experimental implementation of the proposed UUID Version 7
+ *
+ * @license Apache-2.0
+ * @copyright 2021-2023 LiosK
+ * @packageDocumentation
+ */ const DIGITS = "0123456789abcdef";
+class UUID {
+    static ofInner(bytes) {
+        if (16 === bytes.length) return new UUID(bytes);
+        throw new TypeError("not 128-bit length");
+    }
+    static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
+        if (!Number.isInteger(unixTsMs) || !Number.isInteger(randA) || !Number.isInteger(randBHi) || !Number.isInteger(randBLo) || unixTsMs < 0 || randA < 0 || randBHi < 0 || randBLo < 0 || unixTsMs > 0xffffffffffff || randA > 0xfff || randBHi > 0x3fffffff || randBLo > 0xffffffff) throw new RangeError("invalid field value");
+        const bytes = new Uint8Array(16);
+        bytes[0] = unixTsMs / 2 ** 40;
+        bytes[1] = unixTsMs / 2 ** 32;
+        bytes[2] = unixTsMs / 2 ** 24;
+        bytes[3] = unixTsMs / 2 ** 16;
+        bytes[4] = unixTsMs / 256;
+        bytes[5] = unixTsMs;
+        bytes[6] = 0x70 | randA >>> 8;
+        bytes[7] = randA;
+        bytes[8] = 0x80 | randBHi >>> 24;
+        bytes[9] = randBHi >>> 16;
+        bytes[10] = randBHi >>> 8;
+        bytes[11] = randBHi;
+        bytes[12] = randBLo >>> 24;
+        bytes[13] = randBLo >>> 16;
+        bytes[14] = randBLo >>> 8;
+        bytes[15] = randBLo;
+        return new UUID(bytes);
+    }
+    static parse(uuid) {
+        let hex;
+        switch(uuid.length){
+            case 32:
+                var _exec;
+                hex = null == (_exec = /^[0-9a-f]{32}$/i.exec(uuid)) ? void 0 : _exec[0];
+                break;
+            case 36:
+                var _exec1;
+                hex = null == (_exec1 = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(uuid)) ? void 0 : _exec1.slice(1, 6).join("");
+                break;
+            case 38:
+                var _exec2;
+                hex = null == (_exec2 = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i.exec(uuid)) ? void 0 : _exec2.slice(1, 6).join("");
+                break;
+            case 45:
+                var _exec3;
+                hex = null == (_exec3 = /^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)) ? void 0 : _exec3.slice(1, 6).join("");
+                break;
+        }
+        if (hex) {
+            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;
+                inner[i + 3] = n;
+            }
+            return new UUID(inner);
+        }
+        throw new SyntaxError("could not parse UUID string");
+    }
+    toString() {
+        let text = "";
+        for(let i = 0; i < this.bytes.length; i++){
+            text += DIGITS.charAt(this.bytes[i] >>> 4);
+            text += DIGITS.charAt(0xf & this.bytes[i]);
+            if (3 === i || 5 === i || 7 === i || 9 === i) text += "-";
+        }
+        return text;
+    }
+    toHex() {
+        let text = "";
+        for(let i = 0; i < this.bytes.length; i++){
+            text += DIGITS.charAt(this.bytes[i] >>> 4);
+            text += DIGITS.charAt(0xf & this.bytes[i]);
+        }
+        return text;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    getVariant() {
+        const n = this.bytes[8] >>> 4;
+        if (n < 0) throw new Error("unreachable");
+        if (n <= 7) return this.bytes.every((e)=>0 === e) ? "NIL" : "VAR_0";
+        if (n <= 11) return "VAR_10";
+        if (n <= 13) return "VAR_110";
+        if (n <= 15) return this.bytes.every((e)=>0xff === e) ? "MAX" : "VAR_RESERVED";
+        else throw new Error("unreachable");
+    }
+    getVersion() {
+        return "VAR_10" === this.getVariant() ? this.bytes[6] >>> 4 : void 0;
+    }
+    clone() {
+        return new UUID(this.bytes.slice(0));
+    }
+    equals(other) {
+        return 0 === this.compareTo(other);
+    }
+    compareTo(other) {
+        for(let i = 0; i < 16; i++){
+            const diff = this.bytes[i] - other.bytes[i];
+            if (0 !== diff) return Math.sign(diff);
+        }
+        return 0;
+    }
+    constructor(bytes){
+        this.bytes = bytes;
+    }
+}
+class V7Generator {
+    generate() {
+        return this.generateOrResetCore(Date.now(), 10000);
+    }
+    generateOrAbort() {
+        return this.generateOrAbortCore(Date.now(), 10000);
+    }
+    generateOrResetCore(unixTsMs, rollbackAllowance) {
+        let value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+        if (void 0 === value) {
+            this.timestamp = 0;
+            value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+        }
+        return value;
+    }
+    generateOrAbortCore(unixTsMs, rollbackAllowance) {
+        const MAX_COUNTER = 0x3ffffffffff;
+        if (!Number.isInteger(unixTsMs) || unixTsMs < 1 || unixTsMs > 0xffffffffffff) throw new RangeError("`unixTsMs` must be a 48-bit positive integer");
+        if (rollbackAllowance < 0 || rollbackAllowance > 0xffffffffffff) throw new RangeError("`rollbackAllowance` out of reasonable range");
+        if (unixTsMs > this.timestamp) {
+            this.timestamp = unixTsMs;
+            this.resetCounter();
+        } else {
+            if (!(unixTsMs + rollbackAllowance >= this.timestamp)) return;
+            this.counter++;
+            if (this.counter > MAX_COUNTER) {
+                this.timestamp++;
+                this.resetCounter();
+            }
+        }
+        return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & 2 ** 30 - 1, this.random.nextUint32());
+    }
+    resetCounter() {
+        this.counter = 0x400 * this.random.nextUint32() + (0x3ff & this.random.nextUint32());
+    }
+    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);
+    }
+    constructor(randomNumberGenerator){
+        this.timestamp = 0;
+        this.counter = 0;
+        this.random = null != randomNumberGenerator ? randomNumberGenerator : getDefaultRandom();
+    }
+}
+const getDefaultRandom = ()=>({
+        nextUint32: ()=>0x10000 * Math.trunc(0x10000 * Math.random()) + Math.trunc(0x10000 * Math.random())
+    });
+let defaultGenerator;
+const uuidv7 = ()=>uuidv7obj().toString();
+const uuidv7obj = ()=>(defaultGenerator || (defaultGenerator = new V7Generator())).generate();
 
 // Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
 // Licensed under the MIT License
@@ -668,6 +413,7 @@ function isBuiltin(candidate, className) {
 }
 
 // Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
 async function propertiesFromUnknownInput(stackParser, frameModifiers, input, hint) {
   const providedMechanism = hint && hint.mechanism;
   const mechanism = providedMechanism || {
@@ -756,10 +502,10 @@ function getObjectClassName(obj) {
     // ignore errors here
   }
 }
-/**
- * Given any captured exception, extract its keys and create a sorted
- * and truncated list that will be used inside the event message.
- * eg. `Non-error exception captured with keys: foo, bar, baz`
+/**
+ * Given any captured exception, extract its keys and create a sorted
+ * and truncated list that will be used inside the event message.
+ * eg. `Non-error exception captured with keys: foo, bar, baz`
  */
 function extractExceptionKeysForMessage(exception, maxLength = 40) {
   const keys = Object.keys(convertToPlainObject(exception));
@@ -789,13 +535,13 @@ function truncate(str, max = 0) {
   }
   return str.length <= max ? str : `${str.slice(0, max)}...`;
 }
-/**
- * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
- * non-enumerable properties attached.
- *
- * @param value Initial source that we have to transform in order for it to be usable by the serializer
- * @returns An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor
- *  an Error.
+/**
+ * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
+ * non-enumerable properties attached.
+ *
+ * @param value Initial source that we have to transform in order for it to be usable by the serializer
+ * @returns An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor
+ *  an Error.
  */
 function convertToPlainObject(value) {
   if (isError(value)) {
@@ -843,8 +589,8 @@ function serializeEventTarget(target) {
     return '<unknown>';
   }
 }
-/**
- * Extracts stack frames from the error and builds an Exception
+/**
+ * Extracts stack frames from the error and builds an Exception
  */
 async function exceptionFromError(stackParser, frameModifiers, error) {
   const exception = {
@@ -863,8 +609,8 @@ async function exceptionFromError(stackParser, frameModifiers, error) {
   }
   return exception;
 }
-/**
- * Extracts stack frames from the error.stack string
+/**
+ * Extracts stack frames from the error.stack string
  */
 function parseStackFrames(stackParser, error) {
   return applyChunkIds(stackParser(error.stack || '', 1), stackParser);
@@ -879,6 +625,71 @@ function applyChunkIds(frames, parser) {
   return frames;
 }
 
+const ObjProto = Object.prototype;
+const type_utils_toString = ObjProto.toString;
+const isNumber = (x)=>'[object Number]' == type_utils_toString.call(x);
+
+function clampToRange(value, min, max, logger, fallbackValue) {
+    if (min > max) {
+        logger.warn('min cannot be greater than max.');
+        min = max;
+    }
+    if (isNumber(value)) if (value > max) {
+        logger.warn(' cannot be  greater than max: ' + max + '. Using max value instead.');
+        return max;
+    } else {
+        if (!(value < min)) return value;
+        logger.warn(' cannot be less than min: ' + min + '. Using min value instead.');
+        return min;
+    }
+    logger.warn(' must be a number. using max or fallback. max: ' + max + ', fallback: ' + fallbackValue);
+    return clampToRange(max, min, max, logger);
+}
+
+class BucketedRateLimiter {
+    constructor(_options){
+        this._options = _options;
+        this._buckets = {};
+        this._refillBuckets = ()=>{
+            Object.keys(this._buckets).forEach((key)=>{
+                const newTokens = this._getBucket(key) + this._refillRate;
+                if (newTokens >= this._bucketSize) delete this._buckets[key];
+                else this._setBucket(key, newTokens);
+            });
+        };
+        this._getBucket = (key)=>this._buckets[String(key)];
+        this._setBucket = (key, value)=>{
+            this._buckets[String(key)] = value;
+        };
+        this.consumeRateLimit = (key)=>{
+            var _this__getBucket;
+            let tokens = null != (_this__getBucket = this._getBucket(key)) ? _this__getBucket : this._bucketSize;
+            tokens = Math.max(tokens - 1, 0);
+            if (0 === tokens) return true;
+            this._setBucket(key, tokens);
+            const hasReachedZero = 0 === tokens;
+            if (hasReachedZero) {
+                var _this__onBucketRateLimited, _this;
+                null == (_this__onBucketRateLimited = (_this = this)._onBucketRateLimited) || _this__onBucketRateLimited.call(_this, key);
+            }
+            return hasReachedZero;
+        };
+        this._onBucketRateLimited = this._options._onBucketRateLimited;
+        this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger);
+        this._refillRate = clampToRange(this._options.refillRate, 0, this._bucketSize, this._options._logger);
+        this._refillInterval = clampToRange(this._options.refillInterval, 0, 86400000, this._options._logger);
+        setInterval(()=>{
+            this._refillBuckets();
+        }, this._refillInterval);
+    }
+}
+
+function safeSetTimeout(fn, timeout) {
+    const t = setTimeout(fn, timeout);
+    (null == t ? void 0 : t.unref) && (null == t || t.unref());
+    return t;
+}
+
 const SHUTDOWN_TIMEOUT = 2000;
 class ErrorTracking {
   static async buildEventMessage(error, hint, distinctId, additionalProperties) {
@@ -900,9 +711,20 @@ class ErrorTracking {
       }
     };
   }
-  constructor(client, options) {
+  constructor(client, options, _logger) {
     this.client = client;
     this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
+    this._logger = _logger;
+    // by default captures ten exceptions before rate limiting by exception type
+    // refills at a rate of one token / 10 second period
+    // e.g. will capture 1 exception rate limited exception every 10 seconds until burst ends
+    this._rateLimiter = new BucketedRateLimiter({
+      refillRate: 1,
+      bucketSize: 10,
+      refillInterval: 10000,
+      // ten seconds in milliseconds
+      _logger: this._logger
+    });
     this.startAutocaptureIfEnabled();
   }
   startAutocaptureIfEnabled() {
@@ -912,7 +734,16 @@ class ErrorTracking {
     }
   }
   onException(exception, hint) {
-    void ErrorTracking.buildEventMessage(exception, hint).then(msg => {
+    return ErrorTracking.buildEventMessage(exception, hint).then(msg => {
+      const exceptionProperties = msg.properties;
+      const exceptionType = exceptionProperties?.$exception_list[0].type ?? 'Exception';
+      const isRateLimited = this._rateLimiter.consumeRateLimit(exceptionType);
+      if (isRateLimited) {
+        this._logger.info('Skipping exception capture because of client rate limiting.', {
+          exception: exceptionType
+        });
+        return;
+      }
       this.client.capture(msg);
     });
   }
@@ -942,6 +773,7 @@ function setupExpressErrorHandler(_posthog, app) {
 }
 
 // Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
 /** Creates a function that gets the module name from a filename */
 function createGetModuleFromFilename(basePath = process.argv[1] ? path.dirname(process.argv[1]) : process.cwd(), isWindows = path.sep === '\\') {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
@@ -1021,6 +853,7 @@ class ReduceableCache {
 }
 
 // Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
 const LRU_FILE_CONTENTS_CACHE = new ReduceableCache(25);
 const LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache(20);
 const DEFAULT_LINES_OF_CONTEXT = 7;
@@ -1083,8 +916,8 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-/**
- * Extracts lines from a file and stores them in a cache.
+/**
+ * Extracts lines from a file and stores them in a cache.
  */
 function getContextLinesFromFile(path, ranges, output) {
   return new Promise(resolve => {
@@ -1168,8 +1001,8 @@ function addSourceContextToFrames(frames, cache) {
     }
   }
 }
-/**
- * Resolves context lines before and after the given line number and appends them to the frame;
+/**
+ * Resolves context lines before and after the given line number and appends them to the frame;
  */
 function addContextToFrame(lineno, frame, contents) {
   // When there is no line number in the frame, attaching context is nonsensical and will even break grouping.
@@ -1207,28 +1040,28 @@ function addContextToFrame(lineno, frame, contents) {
     frame.post_context.push(line);
   }
 }
-/**
- * Clears the context lines from a frame, used to reset a frame to its original state
- * if we fail to resolve all context lines for it.
+/**
+ * Clears the context lines from a frame, used to reset a frame to its original state
+ * if we fail to resolve all context lines for it.
  */
 function clearLineContext(frame) {
   delete frame.pre_context;
   delete frame.context_line;
   delete frame.post_context;
 }
-/**
- * Determines if context lines should be skipped for a file.
- * - .min.(mjs|cjs|js) files are and not useful since they dont point to the original source
- * - node: prefixed modules are part of the runtime and cannot be resolved to a file
- * - data: skip json, wasm and inline js https://nodejs.org/api/esm.html#data-imports
+/**
+ * Determines if context lines should be skipped for a file.
+ * - .min.(mjs|cjs|js) files are and not useful since they dont point to the original source
+ * - node: prefixed modules are part of the runtime and cannot be resolved to a file
+ * - data: skip json, wasm and inline js https://nodejs.org/api/esm.html#data-imports
  */
 function shouldSkipContextLinesForFile(path) {
   // Test the most common prefix and extension first. These are the ones we
   // are most likely to see in user applications and are the ones we can break out of first.
   return path.startsWith('node:') || path.endsWith('.min.js') || path.endsWith('.min.cjs') || path.endsWith('.min.mjs') || path.startsWith('data:');
 }
-/**
- * Determines if we should skip contextlines based off the max lineno and colno values.
+/**
+ * Determines if we should skip contextlines based off the max lineno and colno values.
  */
 function shouldSkipContextLinesForFrame(frame) {
   if (frame.lineno !== undefined && frame.lineno > MAX_CONTEXTLINES_LINENO) {
@@ -1239,8 +1072,8 @@ function shouldSkipContextLinesForFrame(frame) {
   }
   return false;
 }
-/**
- * Checks if we have all the contents that we need in the cache.
+/**
+ * Checks if we have all the contents that we need in the cache.
  */
 function rangeExistsInContentCache(file, range) {
   const contents = LRU_FILE_CONTENTS_CACHE.get(file);
@@ -1254,9 +1087,9 @@ function rangeExistsInContentCache(file, range) {
   }
   return true;
 }
-/**
- * Creates contiguous ranges of lines to read from a file. In the case where context lines overlap,
- * the ranges are merged to create a single range.
+/**
+ * Creates contiguous ranges of lines to read from a file. In the case where context lines overlap,
+ * the ranges are merged to create a single range.
  */
 function makeLineReaderRanges(lines) {
   if (!lines.length) {
@@ -1301,8 +1134,8 @@ function makeRangeStart(line) {
 function makeRangeEnd(line) {
   return line + DEFAULT_LINES_OF_CONTEXT;
 }
-/**
- * Get or init map value
+/**
+ * Get or init map value
  */
 function emplace(map, key, contents) {
   const value = map.get(key);
@@ -1342,1092 +1175,18 @@ function snipLine(line, colno) {
   return newLine;
 }
 
-var version = "5.6.0";
+var version = "5.8.0";
 
-var PostHogPersistedProperty;
-(function (PostHogPersistedProperty) {
-    PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
-    PostHogPersistedProperty["DistinctId"] = "distinct_id";
-    PostHogPersistedProperty["Props"] = "props";
-    PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
-    PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
-    PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
-    PostHogPersistedProperty["BootstrapFeatureFlagDetails"] = "bootstrap_feature_flag_details";
-    PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
-    PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
-    PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
-    PostHogPersistedProperty["Queue"] = "queue";
-    PostHogPersistedProperty["OptedOut"] = "opted_out";
-    PostHogPersistedProperty["SessionId"] = "session_id";
-    PostHogPersistedProperty["SessionStartTimestamp"] = "session_start_timestamp";
-    PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
-    PostHogPersistedProperty["PersonProperties"] = "person_properties";
-    PostHogPersistedProperty["GroupProperties"] = "group_properties";
-    PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
-    PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
-    PostHogPersistedProperty["SessionReplay"] = "session_replay";
-    PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
-    PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
-    PostHogPersistedProperty["Surveys"] = "surveys";
-    PostHogPersistedProperty["RemoteConfig"] = "remote_config";
-    PostHogPersistedProperty["FlagsEndpointWasHit"] = "flags_endpoint_was_hit";
-})(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
-// Any key prefixed with `attr__` can be added
-var Compression;
-(function (Compression) {
-    Compression["GZipJS"] = "gzip-js";
-    Compression["Base64"] = "base64";
-})(Compression || (Compression = {}));
-var SurveyPosition;
-(function (SurveyPosition) {
-    SurveyPosition["TopLeft"] = "top_left";
-    SurveyPosition["TopCenter"] = "top_center";
-    SurveyPosition["TopRight"] = "top_right";
-    SurveyPosition["MiddleLeft"] = "middle_left";
-    SurveyPosition["MiddleCenter"] = "middle_center";
-    SurveyPosition["MiddleRight"] = "middle_right";
-    SurveyPosition["Left"] = "left";
-    SurveyPosition["Right"] = "right";
-    SurveyPosition["Center"] = "center";
-})(SurveyPosition || (SurveyPosition = {}));
-var SurveyWidgetType;
-(function (SurveyWidgetType) {
-    SurveyWidgetType["Button"] = "button";
-    SurveyWidgetType["Tab"] = "tab";
-    SurveyWidgetType["Selector"] = "selector";
-})(SurveyWidgetType || (SurveyWidgetType = {}));
-var SurveyType;
-(function (SurveyType) {
-    SurveyType["Popover"] = "popover";
-    SurveyType["API"] = "api";
-    SurveyType["Widget"] = "widget";
-})(SurveyType || (SurveyType = {}));
-var SurveyQuestionDescriptionContentType;
-(function (SurveyQuestionDescriptionContentType) {
-    SurveyQuestionDescriptionContentType["Html"] = "html";
-    SurveyQuestionDescriptionContentType["Text"] = "text";
-})(SurveyQuestionDescriptionContentType || (SurveyQuestionDescriptionContentType = {}));
-var SurveyRatingDisplay;
-(function (SurveyRatingDisplay) {
-    SurveyRatingDisplay["Number"] = "number";
-    SurveyRatingDisplay["Emoji"] = "emoji";
-})(SurveyRatingDisplay || (SurveyRatingDisplay = {}));
-var SurveyQuestionType;
-(function (SurveyQuestionType) {
-    SurveyQuestionType["Open"] = "open";
-    SurveyQuestionType["MultipleChoice"] = "multiple_choice";
-    SurveyQuestionType["SingleChoice"] = "single_choice";
-    SurveyQuestionType["Rating"] = "rating";
-    SurveyQuestionType["Link"] = "link";
-})(SurveyQuestionType || (SurveyQuestionType = {}));
-var SurveyQuestionBranchingType;
-(function (SurveyQuestionBranchingType) {
-    SurveyQuestionBranchingType["NextQuestion"] = "next_question";
-    SurveyQuestionBranchingType["End"] = "end";
-    SurveyQuestionBranchingType["ResponseBased"] = "response_based";
-    SurveyQuestionBranchingType["SpecificQuestion"] = "specific_question";
-})(SurveyQuestionBranchingType || (SurveyQuestionBranchingType = {}));
-var SurveyMatchType;
-(function (SurveyMatchType) {
-    SurveyMatchType["Regex"] = "regex";
-    SurveyMatchType["NotRegex"] = "not_regex";
-    SurveyMatchType["Exact"] = "exact";
-    SurveyMatchType["IsNot"] = "is_not";
-    SurveyMatchType["Icontains"] = "icontains";
-    SurveyMatchType["NotIcontains"] = "not_icontains";
-})(SurveyMatchType || (SurveyMatchType = {}));
-/** Sync with plugin-server/src/types.ts */
-var ActionStepStringMatching;
-(function (ActionStepStringMatching) {
-    ActionStepStringMatching["Contains"] = "contains";
-    ActionStepStringMatching["Exact"] = "exact";
-    ActionStepStringMatching["Regex"] = "regex";
-})(ActionStepStringMatching || (ActionStepStringMatching = {}));
-
-const normalizeFlagsResponse = (flagsResponse) => {
-    if ('flags' in flagsResponse) {
-        // Convert v2 format to v1 format
-        const featureFlags = getFlagValuesFromFlags(flagsResponse.flags);
-        const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags);
-        return {
-            ...flagsResponse,
-            featureFlags,
-            featureFlagPayloads,
-        };
-    }
-    else {
-        // Convert v1 format to v2 format
-        const featureFlags = flagsResponse.featureFlags ?? {};
-        const featureFlagPayloads = Object.fromEntries(Object.entries(flagsResponse.featureFlagPayloads || {}).map(([k, v]) => [k, parsePayload(v)]));
-        const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value]) => [
-            key,
-            getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key]),
-        ]));
-        return {
-            ...flagsResponse,
-            featureFlags,
-            featureFlagPayloads,
-            flags,
-        };
-    }
-};
-function getFlagDetailFromFlagAndPayload(key, value, payload) {
-    return {
-        key: key,
-        enabled: typeof value === 'string' ? true : value,
-        variant: typeof value === 'string' ? value : undefined,
-        reason: undefined,
-        metadata: {
-            id: undefined,
-            version: undefined,
-            payload: payload ? JSON.stringify(payload) : undefined,
-            description: undefined,
-        },
-    };
-}
-/**
- * Get the flag values from the flags v4 response.
- * @param flags - The flags
- * @returns The flag values
- */
-const getFlagValuesFromFlags = (flags) => {
-    return Object.fromEntries(Object.entries(flags ?? {})
-        .map(([key, detail]) => [key, getFeatureFlagValue(detail)])
-        .filter(([, value]) => value !== undefined));
-};
-/**
- * Get the payloads from the flags v4 response.
- * @param flags - The flags
- * @returns The payloads
- */
-const getPayloadsFromFlags = (flags) => {
-    const safeFlags = flags ?? {};
-    return Object.fromEntries(Object.keys(safeFlags)
-        .filter((flag) => {
-        const details = safeFlags[flag];
-        return details.enabled && details.metadata && details.metadata.payload !== undefined;
-    })
-        .map((flag) => {
-        const payload = safeFlags[flag].metadata?.payload;
-        return [flag, payload ? parsePayload(payload) : undefined];
-    }));
-};
-const getFeatureFlagValue = (detail) => {
-    return detail === undefined ? undefined : detail.variant ?? detail.enabled;
-};
-const parsePayload = (response) => {
-    if (typeof response !== 'string') {
-        return response;
-    }
-    try {
-        return JSON.parse(response);
-    }
-    catch {
-        return response;
-    }
-};
-
-const STRING_FORMAT = 'utf8';
-function assert(truthyValue, message) {
-    if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
-        throw new Error(message);
-    }
-}
-function isEmpty(truthyValue) {
-    if (truthyValue.trim().length === 0) {
-        return true;
-    }
-    return false;
-}
-function removeTrailingSlash(url) {
-    return url?.replace(/\/+$/, '');
-}
-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 currentISOTime() {
-    return new Date().toISOString();
-}
-function safeSetTimeout(fn, timeout) {
-    // NOTE: we use this so rarely that it is totally fine to do `safeSetTimeout(fn, 0)``
-    // rather than setImmediate.
-    const t = setTimeout(fn, timeout);
-    // We unref if available to prevent Node.js hanging on exit
-    t?.unref && t?.unref();
-    return t;
-}
-function allSettled(promises) {
-    return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason }))));
-}
-
-/**
- * Older browsers and some runtimes don't support this yet
- * This API (as of 2025-05-07) is not available on React Native.
- */
-function isGzipSupported() {
-    return 'CompressionStream' in globalThis;
-}
-/**
- * Gzip a string using Compression Streams API if it's available
- */
-async function gzipCompress(input, isDebug = true) {
-    try {
-        // Turn the string into a stream using a Blob, and then compress it
-        const dataStream = new Blob([input], {
-            type: 'text/plain',
-        }).stream();
-        const compressedStream = dataStream.pipeThrough(new CompressionStream('gzip'));
-        // Using a Response to easily extract the readablestream value. Decoding into a string for fetch
-        return await new Response(compressedStream).blob();
-    }
-    catch (error) {
-        if (isDebug) {
-            console.error('Failed to gzip compress data', error);
-        }
-        return null;
-    }
-}
-
-class SimpleEventEmitter {
-    constructor() {
-        this.events = {};
-        this.events = {};
-    }
-    on(event, listener) {
-        if (!this.events[event]) {
-            this.events[event] = [];
-        }
-        this.events[event].push(listener);
-        return () => {
-            this.events[event] = this.events[event].filter((x) => x !== listener);
-        };
-    }
-    emit(event, payload) {
-        for (const listener of this.events[event] || []) {
-            listener(payload);
-        }
-        for (const listener of this.events['*'] || []) {
-            listener(event, payload);
-        }
-    }
-}
-
-class PostHogFetchHttpError extends Error {
-    constructor(response, reqByteLength) {
-        super('HTTP error while fetching PostHog: status=' + response.status + ', reqByteLength=' + reqByteLength);
-        this.response = response;
-        this.reqByteLength = reqByteLength;
-        this.name = 'PostHogFetchHttpError';
-    }
-    get status() {
-        return this.response.status;
-    }
-    get text() {
-        return this.response.text();
-    }
-    get json() {
-        return this.response.json();
-    }
-}
-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('Network error while fetching PostHog', error instanceof Error ? { cause: error } : {});
-        this.error = error;
-        this.name = 'PostHogFetchNetworkError';
-    }
-}
-async function logFlushError(err) {
-    if (err instanceof PostHogFetchHttpError) {
-        let text = '';
-        try {
-            text = await err.text;
-        }
-        catch { }
-        console.error(`Error while flushing PostHog: message=${err.message}, response body=${text}`, err);
-    }
-    else {
-        console.error('Error while flushing PostHog', err);
-    }
-    return Promise.resolve();
-}
-function isPostHogFetchError(err) {
-    return typeof err === 'object' && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
-}
-function isPostHogFetchContentTooLargeError(err) {
-    return typeof err === 'object' && err instanceof PostHogFetchHttpError && err.status === 413;
-}
-var QuotaLimitedFeature;
-(function (QuotaLimitedFeature) {
-    QuotaLimitedFeature["FeatureFlags"] = "feature_flags";
-    QuotaLimitedFeature["Recordings"] = "recordings";
-})(QuotaLimitedFeature || (QuotaLimitedFeature = {}));
-class PostHogCoreStateless {
-    constructor(apiKey, options) {
-        this.flushPromise = null;
-        this.shutdownPromise = null;
-        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?.host || 'https://us.i.posthog.com');
-        this.flushAt = options?.flushAt ? Math.max(options?.flushAt, 1) : 20;
-        this.maxBatchSize = Math.max(this.flushAt, options?.maxBatchSize ?? 100);
-        this.maxQueueSize = Math.max(this.flushAt, options?.maxQueueSize ?? 1000);
-        this.flushInterval = options?.flushInterval ?? 10000;
-        this.preloadFeatureFlags = options?.preloadFeatureFlags ?? true;
-        // If enable is explicitly set to false we override the optout
-        this.defaultOptIn = options?.defaultOptIn ?? true;
-        this.disableSurveys = options?.disableSurveys ?? false;
-        this._retryOptions = {
-            retryCount: options?.fetchRetryCount ?? 3,
-            retryDelay: options?.fetchRetryDelay ?? 3000,
-            retryCheck: isPostHogFetchError,
-        };
-        this.requestTimeout = options?.requestTimeout ?? 10000; // 10 seconds
-        this.featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 3000; // 3 seconds
-        this.remoteConfigRequestTimeoutMs = options?.remoteConfigRequestTimeoutMs ?? 3000; // 3 seconds
-        this.disableGeoip = options?.disableGeoip ?? true;
-        this.disabled = options?.disabled ?? false;
-        this.historicalMigration = options?.historicalMigration ?? false;
-        // Init promise allows the derived class to block calls until it is ready
-        this._initPromise = Promise.resolve();
-        this._isInitialized = true;
-        this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
-    }
-    logMsgIfDebug(fn) {
-        if (this.isDebug) {
-            fn();
-        }
-    }
-    wrap(fn) {
-        if (this.disabled) {
-            this.logMsgIfDebug(() => 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());
-    }
-    getCommonEventProperties() {
-        return {
-            $lib: this.getLibraryId(),
-            $lib_version: this.getLibraryVersion(),
-        };
-    }
-    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);
-    }
-    debug(enabled = true) {
-        this.removeDebugCallback?.();
-        if (enabled) {
-            const removeDebugCallback = this.on('*', (event, payload) => console.log('PostHog Debug', event, payload));
-            this.removeDebugCallback = () => {
-                removeDebugCallback();
-                this.removeDebugCallback = undefined;
-            };
-        }
-    }
-    get isDebug() {
-        return !!this.removeDebugCallback;
-    }
-    get isDisabled() {
-        return this.disabled;
-    }
-    buildPayload(payload) {
-        return {
-            distinct_id: payload.distinct_id,
-            event: payload.event,
-            properties: {
-                ...(payload.properties || {}),
-                ...this.getCommonEventProperties(), // Common PH props
-            },
-        };
-    }
-    addPendingPromise(promise) {
-        const promiseUUID = uuidv7();
-        this.pendingPromises[promiseUUID] = promise;
-        promise
-            .catch(() => { })
-            .finally(() => {
-            delete this.pendingPromises[promiseUUID];
-        });
-        return promise;
-    }
-    /***
-     *** TRACKING
-     ***/
-    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` and `$set_once` keys.
-            const payload = {
-                ...this.buildPayload({
-                    distinct_id: distinctId,
-                    event: '$identify',
-                    properties,
-                }),
-            };
-            this.enqueue('identify', payload, options);
-        });
-    }
-    async identifyStatelessImmediate(distinctId, properties, options) {
-        const payload = {
-            ...this.buildPayload({
-                distinct_id: distinctId,
-                event: '$identify',
-                properties,
-            }),
-        };
-        await this.sendImmediate('identify', payload, options);
-    }
-    captureStateless(distinctId, event, properties, options) {
-        this.wrap(() => {
-            const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
-            this.enqueue('capture', payload, options);
-        });
-    }
-    async captureStatelessImmediate(distinctId, event, properties, options) {
-        const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
-        await this.sendImmediate('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);
-        });
-    }
-    async aliasStatelessImmediate(alias, distinctId, properties, options) {
-        const payload = this.buildPayload({
-            event: '$create_alias',
-            distinct_id: distinctId,
-            properties: {
-                ...(properties || {}),
-                distinct_id: distinctId,
-                alias,
-            },
-        });
-        await this.sendImmediate('alias', payload, options);
-    }
-    /***
-     *** GROUPS
-     ***/
-    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);
-        });
-    }
-    async getRemoteConfig() {
-        await this._initPromise;
-        let host = this.host;
-        if (host === 'https://us.i.posthog.com') {
-            host = 'https://us-assets.i.posthog.com';
-        }
-        else if (host === 'https://eu.i.posthog.com') {
-            host = 'https://eu-assets.i.posthog.com';
-        }
-        const url = `${host}/array/${this.apiKey}/config`;
-        const fetchOptions = {
-            method: 'GET',
-            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
-        };
-        // Don't retry remote config API calls
-        return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.remoteConfigRequestTimeoutMs)
-            .then((response) => response.json())
-            .catch((error) => {
-            this.logMsgIfDebug(() => console.error('Remote config could not be loaded', error));
-            this._events.emit('error', error);
-            return undefined;
-        });
-    }
-    /***
-     *** FEATURE FLAGS
-     ***/
-    async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
-        await this._initPromise;
-        const url = `${this.host}/flags/?v=2&config=true`;
-        const fetchOptions = {
-            method: 'POST',
-            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                token: this.apiKey,
-                distinct_id: distinctId,
-                groups,
-                person_properties: personProperties,
-                group_properties: groupProperties,
-                ...extraPayload,
-            }),
-        };
-        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Flags URL', url));
-        // Don't retry /flags API calls
-        return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
-            .then((response) => response.json())
-            .then((response) => normalizeFlagsResponse(response))
-            .catch((error) => {
-            this._events.emit('error', error);
-            return undefined;
-        });
-    }
-    async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
-        await this._initPromise;
-        const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
-        if (flagDetailResponse === undefined) {
-            // If we haven't loaded flags yet, or errored out, we respond with undefined
-            return {
-                response: undefined,
-                requestId: undefined,
-            };
-        }
-        let response = getFeatureFlagValue(flagDetailResponse.response);
-        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,
-            requestId: flagDetailResponse.requestId,
-        };
-    }
-    async getFeatureFlagDetailStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
-        await this._initPromise;
-        const flagsResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
-        if (flagsResponse === undefined) {
-            return undefined;
-        }
-        const featureFlags = flagsResponse.flags;
-        const flagDetail = featureFlags[key];
-        return {
-            response: flagDetail,
-            requestId: flagsResponse.requestId,
-        };
-    }
-    async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
-        await this._initPromise;
-        const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
-        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 response;
-    }
-    async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-        await this._initPromise;
-        const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate)).payloads;
-        return payloads;
-    }
-    async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-        await this._initPromise;
-        return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
-    }
-    async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-        await this._initPromise;
-        const featureFlagDetails = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
-        if (!featureFlagDetails) {
-            return {
-                flags: undefined,
-                payloads: undefined,
-                requestId: undefined,
-            };
-        }
-        return {
-            flags: featureFlagDetails.featureFlags,
-            payloads: featureFlagDetails.featureFlagPayloads,
-            requestId: featureFlagDetails.requestId,
-        };
-    }
-    async getFeatureFlagDetailsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-        await this._initPromise;
-        const extraPayload = {};
-        if (disableGeoip ?? this.disableGeoip) {
-            extraPayload['geoip_disable'] = true;
-        }
-        if (flagKeysToEvaluate) {
-            extraPayload['flag_keys_to_evaluate'] = flagKeysToEvaluate;
-        }
-        const flagsResponse = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
-        if (flagsResponse === undefined) {
-            // We probably errored out, so return undefined
-            return undefined;
-        }
-        // if there's an error on the flagsResponse, log a console error, but don't throw an error
-        if (flagsResponse.errorsWhileComputingFlags) {
-            console.error('[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices');
-        }
-        // Add check for quota limitation on feature flags
-        if (flagsResponse.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
-            console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
-            return {
-                flags: {},
-                featureFlags: {},
-                featureFlagPayloads: {},
-                requestId: flagsResponse?.requestId,
-            };
-        }
-        return flagsResponse;
-    }
-    /***
-     *** SURVEYS
-     ***/
-    async getSurveysStateless() {
-        await this._initPromise;
-        if (this.disableSurveys === true) {
-            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Loading surveys is disabled.'));
-            return [];
-        }
-        const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
-        const fetchOptions = {
-            method: 'GET',
-            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
-        };
-        const response = await this.fetchWithRetry(url, fetchOptions)
-            .then((response) => {
-            if (response.status !== 200 || !response.json) {
-                const msg = `Surveys API could not be loaded: ${response.status}`;
-                const error = new Error(msg);
-                this.logMsgIfDebug(() => console.error(error));
-                this._events.emit('error', new Error(msg));
-                return undefined;
-            }
-            return response.json();
-        })
-            .catch((error) => {
-            this.logMsgIfDebug(() => console.error('Surveys API could not be loaded', error));
-            this._events.emit('error', error);
-            return undefined;
-        });
-        const newSurveys = response?.surveys;
-        if (newSurveys) {
-            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from API: ', JSON.stringify(newSurveys)));
-        }
-        return newSurveys ?? [];
-    }
-    get props() {
-        if (!this._props) {
-            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
-        }
-        return this._props || {};
-    }
-    set props(val) {
-        this._props = val;
-    }
-    async register(properties) {
-        this.wrap(() => {
-            this.props = {
-                ...this.props,
-                ...properties,
-            };
-            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-        });
-    }
-    async unregister(property) {
-        this.wrap(() => {
-            delete this.props[property];
-            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-        });
-    }
-    /***
-     *** QUEUEING AND FLUSHING
-     ***/
-    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;
-            }
-            const message = this.prepareMessage(type, _message, options);
-            const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-            if (queue.length >= this.maxQueueSize) {
-                queue.shift();
-                this.logMsgIfDebug(() => console.info('Queue is full, the oldest event is dropped.'));
-            }
-            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.flushBackground();
-            }
-            if (this.flushInterval && !this._flushTimer) {
-                this._flushTimer = safeSetTimeout(() => this.flushBackground(), this.flushInterval);
-            }
-        });
-    }
-    async sendImmediate(type, _message, options) {
-        if (this.disabled) {
-            this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'));
-            return;
-        }
-        if (!this._isInitialized) {
-            await this._initPromise;
-        }
-        if (this.optedOut) {
-            this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
-            return;
-        }
-        const data = {
-            api_key: this.apiKey,
-            batch: [this.prepareMessage(type, _message, options)],
-            sent_at: currentISOTime(),
-        };
-        if (this.historicalMigration) {
-            data.historical_migration = true;
-        }
-        const payload = JSON.stringify(data);
-        const url = `${this.host}/batch/`;
-        const gzippedPayload = !this.disableCompression ? await gzipCompress(payload, this.isDebug) : null;
-        const fetchOptions = {
-            method: 'POST',
-            headers: {
-                ...this.getCustomHeaders(),
-                'Content-Type': 'application/json',
-                ...(gzippedPayload !== null && { 'Content-Encoding': 'gzip' }),
-            },
-            body: gzippedPayload || payload,
-        };
-        try {
-            await this.fetchWithRetry(url, fetchOptions);
-        }
-        catch (err) {
-            this._events.emit('error', err);
-        }
-    }
-    prepareMessage(type, _message, options) {
-        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;
-        }
-        return message;
-    }
-    clearFlushTimer() {
-        if (this._flushTimer) {
-            clearTimeout(this._flushTimer);
-            this._flushTimer = undefined;
-        }
-    }
-    /**
-     * Helper for flushing the queue in the background
-     * Avoids unnecessary promise errors
-     */
-    flushBackground() {
-        void this.flush().catch(async (err) => {
-            await logFlushError(err);
-        });
-    }
-    /**
-     * Flushes the queue
-     *
-     * This function will return a promise that will resolve when the flush is complete,
-     * or reject if there was an error (for example if the server or network is down).
-     *
-     * If there is already a flush in progress, this function will wait for that flush to complete.
-     *
-     * It's recommended to do error handling in the callback of the promise.
-     *
-     * @example
-     * posthog.flush().then(() => {
-     *   console.log('Flush complete')
-     * }).catch((err) => {
-     *   console.error('Flush failed', err)
-     * })
-     *
-     *
-     * @throws PostHogFetchHttpError
-     * @throws PostHogFetchNetworkError
-     * @throws Error
-     */
-    async flush() {
-        // Wait for the current flush operation to finish (regardless of success or failure), then try to flush again.
-        // Use allSettled instead of finally to be defensive around flush throwing errors immediately rather than rejecting.
-        // Use a custom allSettled implementation to avoid issues with patching Promise on RN
-        const nextFlushPromise = allSettled([this.flushPromise]).then(() => {
-            return this._flush();
-        });
-        this.flushPromise = nextFlushPromise;
-        void this.addPendingPromise(nextFlushPromise);
-        allSettled([nextFlushPromise]).then(() => {
-            // If there are no others waiting to flush, clear the promise.
-            // We don't strictly need to do this, but it could make debugging easier
-            if (this.flushPromise === nextFlushPromise) {
-                this.flushPromise = null;
-            }
-        });
-        return nextFlushPromise;
-    }
-    getCustomHeaders() {
-        // 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.
-        const customUserAgent = this.getCustomUserAgent();
-        const headers = {};
-        if (customUserAgent && customUserAgent !== '') {
-            headers['User-Agent'] = customUserAgent;
-        }
-        return headers;
-    }
-    async _flush() {
-        this.clearFlushTimer();
-        await this._initPromise;
-        let queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-        if (!queue.length) {
-            return;
-        }
-        const sentMessages = [];
-        const originalQueueLength = queue.length;
-        while (queue.length > 0 && sentMessages.length < originalQueueLength) {
-            const batchItems = queue.slice(0, this.maxBatchSize);
-            const batchMessages = batchItems.map((item) => item.message);
-            const persistQueueChange = () => {
-                const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-                const newQueue = refreshedQueue.slice(batchItems.length);
-                this.setPersistedProperty(PostHogPersistedProperty.Queue, newQueue);
-                queue = newQueue;
-            };
-            const data = {
-                api_key: this.apiKey,
-                batch: batchMessages,
-                sent_at: currentISOTime(),
-            };
-            if (this.historicalMigration) {
-                data.historical_migration = true;
-            }
-            const payload = JSON.stringify(data);
-            const url = `${this.host}/batch/`;
-            const gzippedPayload = !this.disableCompression ? await gzipCompress(payload, this.isDebug) : null;
-            const fetchOptions = {
-                method: 'POST',
-                headers: {
-                    ...this.getCustomHeaders(),
-                    'Content-Type': 'application/json',
-                    ...(gzippedPayload !== null && { 'Content-Encoding': 'gzip' }),
-                },
-                body: gzippedPayload || payload,
-            };
-            const retryOptions = {
-                retryCheck: (err) => {
-                    // don't automatically retry on 413 errors, we want to reduce the batch size first
-                    if (isPostHogFetchContentTooLargeError(err)) {
-                        return false;
-                    }
-                    // otherwise, retry on network errors
-                    return isPostHogFetchError(err);
-                },
-            };
-            try {
-                await this.fetchWithRetry(url, fetchOptions, retryOptions);
-            }
-            catch (err) {
-                if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
-                    // if we get a 413 error, we want to reduce the batch size and try again
-                    this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2));
-                    this.logMsgIfDebug(() => console.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`));
-                    // do not persist the queue change, we want to retry the same batch
-                    continue;
-                }
-                // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
-                // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
-                if (!(err instanceof PostHogFetchNetworkError)) {
-                    persistQueueChange();
-                }
-                this._events.emit('error', err);
-                throw err;
-            }
-            persistQueueChange();
-            sentMessages.push(...batchMessages);
-        }
-        this._events.emit('flush', sentMessages);
-    }
-    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;
-        });
-        const body = options.body ? options.body : '';
-        let reqByteLength = -1;
-        try {
-            if (body instanceof Blob) {
-                reqByteLength = body.size;
-            }
-            else {
-                reqByteLength = Buffer.byteLength(body, STRING_FORMAT);
-            }
-        }
-        catch {
-            if (body instanceof Blob) {
-                reqByteLength = body.size;
-            }
-            else {
-                const encoded = new TextEncoder().encode(body);
-                reqByteLength = encoded.length;
-            }
-        }
-        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, reqByteLength);
-            }
-            return res;
-        }, { ...this._retryOptions, ...retryOptions });
-    }
-    async _shutdown(shutdownTimeoutMs = 30000) {
-        // A little tricky - we want to have a max shutdown time and enforce it, even if that means we have some
-        // dangling promises. We'll keep track of the timeout and resolve/reject based on that.
-        await this._initPromise;
-        let hasTimedOut = false;
-        this.clearFlushTimer();
-        const doShutdown = async () => {
-            try {
-                await Promise.all(Object.values(this.pendingPromises));
-                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.flush();
-                    if (hasTimedOut) {
-                        break;
-                    }
-                }
-            }
-            catch (e) {
-                if (!isPostHogFetchError(e)) {
-                    throw e;
-                }
-                await logFlushError(e);
-            }
-        };
-        return Promise.race([
-            new Promise((_, reject) => {
-                safeSetTimeout(() => {
-                    this.logMsgIfDebug(() => console.error('Timed out while shutting down PostHog'));
-                    hasTimedOut = true;
-                    reject('Timeout while shutting down PostHog. Some events may not have been sent.');
-                }, shutdownTimeoutMs);
-            }),
-            doShutdown(),
-        ]);
-    }
-    /**
-     *  Call shutdown() once before the node process exits, so ensure that all events have been sent and all promises
-     *  have resolved. Do not use this function if you intend to keep using this PostHog instance after calling it.
-     * @param shutdownTimeoutMs
-     */
-    async shutdown(shutdownTimeoutMs = 30000) {
-        if (this.shutdownPromise) {
-            this.logMsgIfDebug(() => console.warn('shutdown() called while already shutting down. shutdown() is meant to be called once before process exit - use flush() for per-request cleanup'));
-        }
-        else {
-            this.shutdownPromise = this._shutdown(shutdownTimeoutMs).finally(() => {
-                this.shutdownPromise = null;
-            });
-        }
-        return this.shutdownPromise;
-    }
-}
-
-/**
- * A lazy value that is only computed when needed. Inspired by C#'s Lazy<T> class.
+/**
+ * A lazy value that is only computed when needed. Inspired by C#'s Lazy<T> class.
  */
 class Lazy {
   constructor(factory) {
     this.factory = factory;
   }
-  /**
-   * Gets the value, initializing it if necessary.
-   * Multiple concurrent calls will share the same initialization promise.
+  /**
+   * Gets the value, initializing it if necessary.
+   * Multiple concurrent calls will share the same initialization promise.
    */
   async getValue() {
     if (this.value !== undefined) {
@@ -2447,15 +1206,15 @@ class Lazy {
     }
     return this.initializationPromise;
   }
-  /**
-   * Returns true if the value has been initialized.
+  /**
+   * Returns true if the value has been initialized.
    */
   isInitialized() {
     return this.value !== undefined;
   }
-  /**
-   * Returns a promise that resolves when the value is initialized.
-   * If already initialized, resolves immediately.
+  /**
+   * Returns a promise that resolves when the value is initialized.
+   * If already initialized, resolves immediately.
    */
   async waitForInitialization() {
     if (this.isInitialized()) {
@@ -2468,7 +1227,7 @@ class Lazy {
 /// <reference lib="dom" />
 const nodeCrypto = new Lazy(async () => {
   try {
-    return await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('crypto')); });
+    return await import('crypto');
   } catch {
     return undefined;
   }
@@ -2584,7 +1343,8 @@ class FeatureFlagsPoller {
     featureFlag = this.featureFlagsByKey[key];
     if (featureFlag !== undefined) {
       try {
-        response = await this.computeFlagLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
+        const result = await this.computeFlagAndPayloadLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
+        response = result.value;
         this.logMsgIfDebug(() => console.debug(`Successfully computed flag locally: ${key} -> ${response}`));
       } catch (e) {
         if (e instanceof InconclusiveMatchError) {
@@ -2596,27 +1356,6 @@ class FeatureFlagsPoller {
     }
     return response;
   }
-  async computeFeatureFlagPayloadLocally(key, matchValue) {
-    await this.loadFeatureFlags();
-    let response = undefined;
-    if (!this.loadedSuccessfullyOnce) {
-      return undefined;
-    }
-    if (typeof matchValue == 'boolean') {
-      response = this.featureFlagsByKey?.[key]?.filters?.payloads?.[matchValue.toString()];
-    } else if (typeof matchValue == 'string') {
-      response = this.featureFlagsByKey?.[key]?.filters?.payloads?.[matchValue];
-    }
-    // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
-    if (response === undefined || response === null) {
-      return null;
-    }
-    try {
-      return JSON.parse(response);
-    } catch {
-      return response;
-    }
-  }
   async getAllFlagsAndPayloads(distinctId, groups = {}, personProperties = {}, groupProperties = {}, flagKeysToExplicitlyEvaluate) {
     await this.loadFeatureFlags();
     const response = {};
@@ -2625,9 +1364,11 @@ class FeatureFlagsPoller {
     const flagsToEvaluate = flagKeysToExplicitlyEvaluate ? flagKeysToExplicitlyEvaluate.map(key => this.featureFlagsByKey[key]).filter(Boolean) : this.featureFlags;
     await Promise.all(flagsToEvaluate.map(async flag => {
       try {
-        const matchValue = await this.computeFlagLocally(flag, distinctId, groups, personProperties, groupProperties);
+        const {
+          value: matchValue,
+          payload: matchPayload
+        } = await this.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties);
         response[flag.key] = matchValue;
-        const matchPayload = await this.computeFeatureFlagPayloadLocally(flag.key, matchValue);
         if (matchPayload) {
           payloads[flag.key] = matchPayload;
         }
@@ -2646,7 +1387,30 @@ class FeatureFlagsPoller {
       fallbackToFlags
     };
   }
-  async computeFlagLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
+  async computeFlagAndPayloadLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}, matchValue) {
+    // Always ensure flags are loaded for payload computation
+    await this.loadFeatureFlags();
+    if (!this.loadedSuccessfullyOnce) {
+      return {
+        value: false,
+        payload: null
+      };
+    }
+    let flagValue;
+    // If matchValue is provided, use it directly; otherwise evaluate the flag
+    if (matchValue !== undefined) {
+      flagValue = matchValue;
+    } else {
+      flagValue = await this.computeFlagValueLocally(flag, distinctId, groups, personProperties, groupProperties);
+    }
+    // Always compute payload based on the final flagValue (whether provided or computed)
+    const payload = this.getFeatureFlagPayload(flag.key, flagValue);
+    return {
+      value: flagValue,
+      payload
+    };
+  }
+  async computeFlagValueLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
     if (flag.ensure_experience_continuity) {
       throw new InconclusiveMatchError('Flag has experience continuity enabled');
     }
@@ -2671,7 +1435,98 @@ class FeatureFlagsPoller {
       return await this.matchFeatureFlagProperties(flag, distinctId, personProperties);
     }
   }
-  async matchFeatureFlagProperties(flag, distinctId, properties) {
+  getFeatureFlagPayload(key, flagValue) {
+    let payload = null;
+    if (flagValue !== false && flagValue !== null && flagValue !== undefined) {
+      if (typeof flagValue == 'boolean') {
+        payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue.toString()] || null;
+      } else if (typeof flagValue == 'string') {
+        payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue] || null;
+      }
+      if (payload !== null && payload !== undefined) {
+        // If payload is already an object, return it directly
+        if (typeof payload === 'object') {
+          return payload;
+        }
+        // If payload is a string, try to parse it as JSON
+        if (typeof payload === 'string') {
+          try {
+            return JSON.parse(payload);
+          } catch {
+            // If parsing fails, return the string as is
+            return payload;
+          }
+        }
+        // For other types, return as is
+        return payload;
+      }
+    }
+    return null;
+  }
+  async evaluateFlagDependency(property, distinctId, properties, evaluationCache) {
+    const targetFlagKey = property.key;
+    if (!this.featureFlagsByKey) {
+      throw new InconclusiveMatchError('Feature flags not available for dependency evaluation');
+    }
+    // Check if dependency_chain is present - it should always be provided for flag dependencies
+    if (!('dependency_chain' in property)) {
+      throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' is missing required 'dependency_chain' field`);
+    }
+    const dependencyChain = property.dependency_chain;
+    // Check for missing or invalid dependency chain (This should never happen, but being defensive)
+    if (!Array.isArray(dependencyChain)) {
+      throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' has an invalid 'dependency_chain' (expected array, got ${typeof dependencyChain})`);
+    }
+    // Handle circular dependency (empty chain means circular)  (This should never happen, but being defensive)
+    if (dependencyChain.length === 0) {
+      throw new InconclusiveMatchError(`Circular dependency detected for flag '${targetFlagKey}' (empty dependency chain)`);
+    }
+    // Evaluate all dependencies in the chain order
+    for (const depFlagKey of dependencyChain) {
+      if (!(depFlagKey in evaluationCache)) {
+        // Need to evaluate this dependency first
+        const depFlag = this.featureFlagsByKey[depFlagKey];
+        if (!depFlag) {
+          // Missing flag dependency - cannot evaluate locally
+          throw new InconclusiveMatchError(`Missing flag dependency '${depFlagKey}' for flag '${targetFlagKey}'`);
+        } else if (!depFlag.active) {
+          // Inactive flag evaluates to false
+          evaluationCache[depFlagKey] = false;
+        } else {
+          // Recursively evaluate the dependency
+          try {
+            const depResult = await this.matchFeatureFlagProperties(depFlag, distinctId, properties, evaluationCache);
+            evaluationCache[depFlagKey] = depResult;
+          } catch (error) {
+            // If we can't evaluate a dependency, store throw InconclusiveMatchError(`Missing flag dependency '${depFlagKey}' for flag '${targetFlagKey}'`)
+            throw new InconclusiveMatchError(`Error evaluating flag dependency '${depFlagKey}' for flag '${targetFlagKey}': ${error}`);
+          }
+        }
+      }
+      // Check if dependency evaluation was inconclusive
+      const cachedResult = evaluationCache[depFlagKey];
+      if (cachedResult === null || cachedResult === undefined) {
+        throw new InconclusiveMatchError(`Dependency '${depFlagKey}' could not be evaluated`);
+      }
+    }
+    // The target flag is specified in property.key (This should match the last element in the dependency chain)
+    const targetFlagValue = evaluationCache[targetFlagKey];
+    return this.flagEvaluatesToExpectedValue(property.value, targetFlagValue);
+  }
+  flagEvaluatesToExpectedValue(expectedValue, flagValue) {
+    // If the expected value is a boolean, then return true if the flag evaluated to true (or any string variant)
+    // If the expected value is false, then only return true if the flag evaluated to false.
+    if (typeof expectedValue === 'boolean') {
+      return expectedValue === flagValue || typeof flagValue === 'string' && flagValue !== '' && expectedValue === true;
+    }
+    // If the expected value is a string, then return true if and only if the flag evaluated to the expected value.
+    if (typeof expectedValue === 'string') {
+      return flagValue === expectedValue;
+    }
+    // The `flag_evaluates_to` operator is not supported for numbers and arrays.
+    return false;
+  }
+  async matchFeatureFlagProperties(flag, distinctId, properties, evaluationCache = {}) {
     const flagFilters = flag.filters || {};
     const flagConditions = flagFilters.groups || [];
     let isInconclusive = false;
@@ -2693,7 +1548,7 @@ class FeatureFlagsPoller {
     });
     for (const condition of sortedFlagConditions) {
       try {
-        if (await this.isConditionMatch(flag, distinctId, condition, properties)) {
+        if (await this.isConditionMatch(flag, distinctId, condition, properties, evaluationCache)) {
           const variantOverride = condition.variant;
           const flagVariants = flagFilters.multivariate?.variants || [];
           if (variantOverride && flagVariants.some(variant => variant.key === variantOverride)) {
@@ -2719,7 +1574,7 @@ class FeatureFlagsPoller {
     // We can only return False when all conditions are False
     return false;
   }
-  async isConditionMatch(flag, distinctId, condition, properties) {
+  async isConditionMatch(flag, distinctId, condition, properties, evaluationCache = {}) {
     const rolloutPercentage = condition.rollout_percentage;
     const warnFunction = msg => {
       this.logMsgIfDebug(() => console.warn(msg));
@@ -2731,8 +1586,7 @@ class FeatureFlagsPoller {
         if (propertyType === 'cohort') {
           matches = matchCohort(prop, properties, this.cohorts, this.debugMode);
         } else if (propertyType === 'flag') {
-          this.logMsgIfDebug(() => console.warn(`[FEATURE FLAGS] Flag dependency filters are not supported in local evaluation. ` + `Skipping condition for flag '${flag.key}' with dependency on flag '${prop.key || 'unknown'}'`));
-          continue;
+          matches = await this.evaluateFlagDependency(prop, distinctId, properties, evaluationCache);
         } else {
           matches = matchProperty(prop, properties, warnFunction);
         }
@@ -2781,18 +1635,18 @@ class FeatureFlagsPoller {
       await this._loadFeatureFlags();
     }
   }
-  /**
-   * Returns true if the feature flags poller has loaded successfully at least once and has more than 0 feature flags.
-   * This is useful to check if local evaluation is ready before calling getFeatureFlag.
+  /**
+   * Returns true if the feature flags poller has loaded successfully at least once and has more than 0 feature flags.
+   * This is useful to check if local evaluation is ready before calling getFeatureFlag.
    */
   isLocalEvaluationReady() {
     return (this.loadedSuccessfullyOnce ?? false) && (this.featureFlags?.length ?? 0) > 0;
   }
-  /**
-   * If a client is misconfigured with an invalid or improper API key, the polling interval is doubled each time
-   * until a successful request is made, up to a maximum of 60 seconds.
-   *
-   * @returns The polling interval to use for the next request.
+  /**
+   * If a client is misconfigured with an invalid or improper API key, the polling interval is doubled each time
+   * until a successful request is made, up to a maximum of 60 seconds.
+   *
+   * @returns The polling interval to use for the next request.
    */
   getPollingInterval() {
     if (!this.shouldBeginExponentialBackoff) {
@@ -2997,6 +1851,10 @@ function matchProperty(property, propertyValues, warnFunction) {
     case 'is_date_after':
     case 'is_date_before':
       {
+        // Boolean values should never be used with date operations
+        if (typeof value === 'boolean') {
+          throw new InconclusiveMatchError(`Date operations cannot be performed on boolean values`);
+        }
         let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
         if (parsedDate == null) {
           parsedDate = convertToDateTime(value);
@@ -3180,17 +2038,49 @@ class PostHogMemoryStorage {
   }
 }
 
+const _createLogger = (prefix, logMsgIfDebug) => {
+  const logger = {
+    _log: (level, ...args) => {
+      logMsgIfDebug(() => {
+        const consoleLog = console[level];
+        consoleLog(prefix, ...args);
+      });
+    },
+    info: (...args) => {
+      logger._log('log', ...args);
+    },
+    warn: (...args) => {
+      logger._log('warn', ...args);
+    },
+    error: (...args) => {
+      logger._log('error', ...args);
+    },
+    critical: (...args) => {
+      // Critical errors are always logged to the console
+      // eslint-disable-next-line no-console
+      console.error(prefix, ...args);
+    },
+    uninitializedWarning: methodName => {
+      logger.error(`You must initialize PostHog before calling ${methodName}`);
+    },
+    createLogger: additionalPrefix => _createLogger(`${prefix} ${additionalPrefix}`, logMsgIfDebug)
+  };
+  return logger;
+};
+const createLogger = logMsgIfDebug => _createLogger('[PostHog.js]', logMsgIfDebug);
+
 // Standard local evaluation rate limit is 600 per minute (10 per second),
 // so the fastest a poller should ever be set is 100ms.
 const MINIMUM_POLLING_INTERVAL = 100;
 const THIRTY_SECONDS = 30 * 1000;
 const MAX_CACHE_SIZE = 50 * 1000;
 // The actual exported Nodejs API.
-class PostHogBackendClient extends PostHogCoreStateless {
+class PostHogBackendClient extends core.PostHogCoreStateless {
   constructor(apiKey, options = {}) {
     super(apiKey, options);
     this._memoryStorage = new PostHogMemoryStorage();
     this.options = options;
+    this.logger = createLogger(this.logMsgIfDebug.bind(this));
     this.options.featureFlagsPollingInterval = typeof options.featureFlagsPollingInterval === 'number' ? Math.max(options.featureFlagsPollingInterval, MINIMUM_POLLING_INTERVAL) : THIRTY_SECONDS;
     if (options.personalApiKey) {
       if (options.personalApiKey.includes('phc_')) {
@@ -3204,6 +2094,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
           personalApiKey: options.personalApiKey,
           projectApiKey: apiKey,
           timeout: options.requestTimeout ?? 10000,
+          // 10 seconds
           host: this.host,
           fetch: options.fetch,
           onError: err => {
@@ -3216,7 +2107,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
         });
       }
     }
-    this.errorTracking = new ErrorTracking(this, options);
+    this.errorTracking = new ErrorTracking(this, options, this.logger);
     this.distinctIdHasSentFlagCalls = {};
     this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
   }
@@ -3259,11 +2150,25 @@ class PostHogBackendClient extends PostHogCoreStateless {
       disableGeoip,
       uuid
     } = props;
+    // Run before_send if configured
+    const eventMessage = this._runBeforeSend({
+      distinctId,
+      event,
+      properties,
+      groups,
+      sendFeatureFlags,
+      timestamp,
+      disableGeoip,
+      uuid
+    });
+    if (!eventMessage) {
+      return;
+    }
     const _capture = props => {
-      super.captureStateless(distinctId, event, props, {
-        timestamp,
-        disableGeoip,
-        uuid
+      super.captureStateless(eventMessage.distinctId, eventMessage.event, props, {
+        timestamp: eventMessage.timestamp,
+        disableGeoip: eventMessage.disableGeoip,
+        uuid: eventMessage.uuid
       });
     };
     // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
@@ -3298,8 +2203,8 @@ class PostHogBackendClient extends PostHogCoreStateless {
       // No matter what - capture the event
       _capture({
         ...additionalProperties,
-        ...properties,
-        $groups: groups
+        ...(eventMessage.properties || {}),
+        $groups: eventMessage.groups || groups
       });
     });
     this.addPendingPromise(capturePromise);
@@ -3318,11 +2223,25 @@ class PostHogBackendClient extends PostHogCoreStateless {
       disableGeoip,
       uuid
     } = props;
+    // Run before_send if configured
+    const eventMessage = this._runBeforeSend({
+      distinctId,
+      event,
+      properties,
+      groups,
+      sendFeatureFlags,
+      timestamp,
+      disableGeoip,
+      uuid
+    });
+    if (!eventMessage) {
+      return;
+    }
     const _capture = props => {
-      return super.captureStatelessImmediate(distinctId, event, props, {
-        timestamp,
-        disableGeoip,
-        uuid
+      return super.captureStatelessImmediate(eventMessage.distinctId, eventMessage.event, props, {
+        timestamp: eventMessage.timestamp,
+        disableGeoip: eventMessage.disableGeoip,
+        uuid: eventMessage.uuid
       });
     };
     const capturePromise = Promise.resolve().then(async () => {
@@ -3356,8 +2275,8 @@ class PostHogBackendClient extends PostHogCoreStateless {
       // No matter what - capture the event
       _capture({
         ...additionalProperties,
-        ...properties,
-        $groups: groups
+        ...(eventMessage.properties || {}),
+        $groups: eventMessage.groups || groups
       });
     });
     await capturePromise;
@@ -3460,7 +2379,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
         return undefined;
       }
       flagDetail = remoteResponse.response;
-      response = getFeatureFlagValue(flagDetail);
+      response = core.getFeatureFlagValue(flagDetail);
       requestId = remoteResponse?.requestId;
     }
     const featureFlagReportedKey = `${key}_${response}`;
@@ -3509,19 +2428,17 @@ class PostHogBackendClient extends PostHogCoreStateless {
     let response = undefined;
     const localEvaluationEnabled = this.featureFlagsPoller !== undefined;
     if (localEvaluationEnabled) {
-      // Try to get match value locally if not provided
-      if (!matchValue) {
-        matchValue = await this.getFeatureFlag(key, distinctId, {
-          ...options,
-          onlyEvaluateLocally: true,
-          sendFeatureFlagEvents: false
-        });
-      }
-      if (matchValue) {
-        response = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
+      // Ensure flags are loaded before checking for the specific flag
+      await this.featureFlagsPoller?.loadFeatureFlags();
+      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
+      if (flag) {
+        const result = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
+        if (result) {
+          matchValue = result.value;
+          response = result.payload;
+        }
       }
     }
-    //}
     // set defaults
     if (onlyEvaluateLocally == undefined) {
       onlyEvaluateLocally = false;
@@ -3529,10 +2446,6 @@ class PostHogBackendClient extends PostHogCoreStateless {
     if (sendFeatureFlagEvents == undefined) {
       sendFeatureFlagEvents = true;
     }
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      onlyEvaluateLocally = false;
-    }
     const payloadWasLocallyEvaluated = response !== undefined;
     if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) {
       response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
@@ -3627,9 +2540,9 @@ class PostHogBackendClient extends PostHogCoreStateless {
       disableGeoip
     }, distinctId);
   }
-  /**
-   * Reloads the feature flag definitions from the server for local evaluation.
-   * This is useful to call if you want to ensure that the feature flags are up to date before calling getFeatureFlag.
+  /**
+   * Reloads the feature flag definitions from the server for local evaluation.
+   * This is useful to call if you want to ensure that the feature flags are up to date before calling getFeatureFlag.
    */
   async reloadFeatureFlags() {
     await this.featureFlagsPoller?.loadFeatureFlags(true);
@@ -3642,7 +2555,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
     if (!this.options.personalApiKey) {
       return undefined;
     }
-    const url = `${this.host}/api/projects/@current/feature_flags/${flagKey}/remote_config/`;
+    const url = `${this.host}/api/projects/@current/feature_flags/${flagKey}/remote_config?token=${encodeURIComponent(this.apiKey)}`;
     const options = {
       method: 'GET',
       headers: {
@@ -3776,6 +2689,26 @@ class PostHogBackendClient extends PostHogCoreStateless {
     }, distinctId, additionalProperties);
     return await this.captureImmediate(evtMsg);
   }
+  _runBeforeSend(eventMessage) {
+    const beforeSend = this.options.before_send;
+    if (!beforeSend) {
+      return eventMessage;
+    }
+    const fns = Array.isArray(beforeSend) ? beforeSend : [beforeSend];
+    let result = eventMessage;
+    for (const fn of fns) {
+      result = fn(result);
+      if (!result) {
+        this.logMsgIfDebug(() => console.info(`Event '${eventMessage.event}' was rejected in beforeSend function`));
+        return null;
+      }
+      if (!result.properties || Object.keys(result.properties).length === 0) {
+        const message = `Event '${result.event}' has no properties after beforeSend function, this is likely an error.`;
+        this.logMsgIfDebug(() => console.warn(message));
+      }
+    }
+    return result;
+  }
 }
 
 // Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
@@ -3875,8 +2808,8 @@ function node(getModule) {
     return undefined;
   };
 }
-/**
- * Does this filename look like it's part of the app code?
+/**
+ * Does this filename look like it's part of the app code?
  */
 function filenameIsInApp(filename, isNative = false) {
   const isInternal = isNative || filename &&