@leanbase.com/js 0.1.0

package/dist/leanbase.iife.js

@@ -0,0 +1,1789 @@
+var leanbase = (function () {
+    'use strict';
+
+    const normalizeFlagsResponse = (flagsResponse)=>{
+        if ('flags' in flagsResponse) {
+            const featureFlags = getFlagValuesFromFlags(flagsResponse.flags);
+            const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags);
+            return {
+                ...flagsResponse,
+                featureFlags,
+                featureFlagPayloads
+            };
+        }
+        {
+            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: 'string' == typeof value ? true : value,
+            variant: 'string' == typeof value ? value : void 0,
+            reason: void 0,
+            metadata: {
+                id: void 0,
+                version: void 0,
+                payload: payload ? JSON.stringify(payload) : void 0,
+                description: void 0
+            }
+        };
+    }
+    const getFlagValuesFromFlags = (flags)=>Object.fromEntries(Object.entries(flags ?? {}).map(([key, detail])=>[
+                key,
+                getFeatureFlagValue(detail)
+            ]).filter(([, value])=>void 0 !== value));
+    const getPayloadsFromFlags = (flags)=>{
+        const safeFlags = flags ?? {};
+        return Object.fromEntries(Object.keys(safeFlags).filter((flag)=>{
+            const details = safeFlags[flag];
+            return details.enabled && details.metadata && void 0 !== details.metadata.payload;
+        }).map((flag)=>{
+            const payload = safeFlags[flag].metadata?.payload;
+            return [
+                flag,
+                payload ? parsePayload(payload) : void 0
+            ];
+        }));
+    };
+    const getFeatureFlagValue = (detail)=>void 0 === detail ? void 0 : detail.variant ?? detail.enabled;
+    const parsePayload = (response)=>{
+        if ('string' != typeof response) return response;
+        try {
+            return JSON.parse(response);
+        } catch  {
+            return response;
+        }
+    };
+    const createFlagsResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads)=>{
+        const allKeys = [
+            ...new Set([
+                ...Object.keys(featureFlags ?? {}),
+                ...Object.keys(featureFlagPayloads ?? {})
+            ])
+        ];
+        const enabledFlags = allKeys.filter((flag)=>!!featureFlags[flag] || !!featureFlagPayloads[flag]).reduce((res, key)=>(res[key] = featureFlags[key] ?? true, res), {});
+        const flagDetails = {
+            featureFlags: enabledFlags,
+            featureFlagPayloads: featureFlagPayloads ?? {}
+        };
+        return normalizeFlagsResponse(flagDetails);
+    };
+    const updateFlagValue = (flag, value)=>({
+            ...flag,
+            enabled: getEnabledFromValue(value),
+            variant: getVariantFromValue(value)
+        });
+    function getEnabledFromValue(value) {
+        return 'string' == typeof value ? true : value;
+    }
+    function getVariantFromValue(value) {
+        return 'string' == typeof value ? value : void 0;
+    }
+
+    /*! 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 {
+        constructor(bytes){
+            this.bytes = bytes;
+        }
+        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:
+                    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);
+            }
+            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;
+        }
+    }
+    class V7Generator {
+        constructor(randomNumberGenerator){
+            this.timestamp = 0;
+            this.counter = 0;
+            this.random = randomNumberGenerator ?? getDefaultRandom();
+        }
+        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);
+        }
+    }
+    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();
+
+    var types_PostHogPersistedProperty = /*#__PURE__*/ 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";
+        return PostHogPersistedProperty;
+    }({});
+    var types_Compression = /*#__PURE__*/ function(Compression) {
+        Compression["GZipJS"] = "gzip-js";
+        Compression["Base64"] = "base64";
+        return Compression;
+    }({});
+
+    const nativeIsArray = Array.isArray;
+    const ObjProto = Object.prototype;
+    const type_utils_toString = ObjProto.toString;
+    const isArray = nativeIsArray || function(obj) {
+        return '[object Array]' === type_utils_toString.call(obj);
+    };
+    const isFunction = (x)=>'function' == typeof x;
+    const isNull = (x)=>null === x;
+    const isPlainError = (x)=>x instanceof Error;
+
+    class PromiseQueue {
+        add(promise) {
+            const promiseUUID = uuidv7();
+            this.promiseByIds[promiseUUID] = promise;
+            promise.catch(()=>{}).finally(()=>{
+                delete this.promiseByIds[promiseUUID];
+            });
+            return promise;
+        }
+        async join() {
+            let promises = Object.values(this.promiseByIds);
+            let length = promises.length;
+            while(length > 0){
+                await Promise.all(promises);
+                promises = Object.values(this.promiseByIds);
+                length = promises.length;
+            }
+        }
+        get length() {
+            return Object.keys(this.promiseByIds).length;
+        }
+        constructor(){
+            this.promiseByIds = {};
+        }
+    }
+
+    const STRING_FORMAT = 'utf8';
+    function assert(truthyValue, message) {
+        if (!truthyValue || 'string' != typeof truthyValue || isEmpty(truthyValue)) throw new Error(message);
+    }
+    function isEmpty(truthyValue) {
+        if (0 === truthyValue.trim().length) 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) 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) {
+        const t = setTimeout(fn, timeout);
+        t?.unref && t?.unref();
+        return t;
+    }
+    function getFetch() {
+        return 'undefined' != typeof fetch ? fetch : void 0 !== globalThis.fetch ? globalThis.fetch : void 0;
+    }
+    function allSettled(promises) {
+        return Promise.all(promises.map((p)=>(p ?? Promise.resolve()).then((value)=>({
+                    status: 'fulfilled',
+                    value
+                }), (reason)=>({
+                    status: 'rejected',
+                    reason
+                }))));
+    }
+
+    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);
+        }
+    }
+
+    function isGzipSupported() {
+        return 'CompressionStream' in globalThis;
+    }
+    async function gzipCompress(input, isDebug = true) {
+        try {
+            const dataStream = new Blob([
+                input
+            ], {
+                type: 'text/plain'
+            }).stream();
+            const compressedStream = dataStream.pipeThrough(new CompressionStream('gzip'));
+            return await new Response(compressedStream).blob();
+        } catch (error) {
+            if (isDebug) console.error('Failed to gzip compress data', error);
+            return null;
+        }
+    }
+
+    function createConsole(consoleLike = console) {
+        const lockedMethods = {
+            log: consoleLike.log.bind(consoleLike),
+            warn: consoleLike.warn.bind(consoleLike),
+            error: consoleLike.error.bind(consoleLike),
+            debug: consoleLike.debug.bind(consoleLike)
+        };
+        return lockedMethods;
+    }
+    const _createLogger = (prefix, maybeCall, consoleLike)=>{
+        function _log(level, ...args) {
+            maybeCall(()=>{
+                const consoleMethod = consoleLike[level];
+                consoleMethod(prefix, ...args);
+            });
+        }
+        const logger = {
+            info: (...args)=>{
+                _log('log', ...args);
+            },
+            warn: (...args)=>{
+                _log('warn', ...args);
+            },
+            error: (...args)=>{
+                _log('error', ...args);
+            },
+            critical: (...args)=>{
+                consoleLike['error'](prefix, ...args);
+            },
+            createLogger: (additionalPrefix)=>_createLogger(`${prefix} ${additionalPrefix}`, maybeCall, consoleLike)
+        };
+        return logger;
+    };
+    function createLogger(prefix, maybeCall) {
+        return _createLogger(prefix, maybeCall, createConsole());
+    }
+
+    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){
+            super('Network error while fetching PostHog', error instanceof Error ? {
+                cause: error
+            } : {}), this.error = error, this.name = 'PostHogFetchNetworkError';
+        }
+    }
+    const maybeAdd = (key, value)=>void 0 !== value ? {
+            [key]: value
+        } : {};
+    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 'object' == typeof err && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
+    }
+    function isPostHogFetchContentTooLargeError(err) {
+        return 'object' == typeof err && err instanceof PostHogFetchHttpError && 413 === err.status;
+    }
+    var posthog_core_stateless_QuotaLimitedFeature = /*#__PURE__*/ function(QuotaLimitedFeature) {
+        QuotaLimitedFeature["FeatureFlags"] = "feature_flags";
+        QuotaLimitedFeature["Recordings"] = "recordings";
+        return QuotaLimitedFeature;
+    }({});
+    class PostHogCoreStateless {
+        constructor(apiKey, options = {}){
+            this.flushPromise = null;
+            this.shutdownPromise = null;
+            this.promiseQueue = new PromiseQueue();
+            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;
+            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;
+            this.featureFlagsRequestTimeoutMs = options.featureFlagsRequestTimeoutMs ?? 3000;
+            this.remoteConfigRequestTimeoutMs = options.remoteConfigRequestTimeoutMs ?? 3000;
+            this.disableGeoip = options.disableGeoip ?? true;
+            this.disabled = options.disabled ?? false;
+            this.historicalMigration = options?.historicalMigration ?? false;
+            this.evaluationEnvironments = options?.evaluationEnvironments;
+            this._initPromise = Promise.resolve();
+            this._isInitialized = true;
+            this._logger = createLogger('[PostHog]', this.logMsgIfDebug.bind(this));
+            this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
+        }
+        logMsgIfDebug(fn) {
+            if (this.isDebug) fn();
+        }
+        wrap(fn) {
+            if (this.disabled) return void this._logger.warn('The client is disabled');
+            if (this._isInitialized) return fn();
+            this._initPromise.then(()=>fn());
+        }
+        getCommonEventProperties() {
+            return {
+                $lib: this.getLibraryId(),
+                $lib_version: this.getLibraryVersion()
+            };
+        }
+        get optedOut() {
+            return this.getPersistedProperty(types_PostHogPersistedProperty.OptedOut) ?? !this.defaultOptIn;
+        }
+        async optIn() {
+            this.wrap(()=>{
+                this.setPersistedProperty(types_PostHogPersistedProperty.OptedOut, false);
+            });
+        }
+        async optOut() {
+            this.wrap(()=>{
+                this.setPersistedProperty(types_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)=>this._logger.info(event, payload));
+                this.removeDebugCallback = ()=>{
+                    removeDebugCallback();
+                    this.removeDebugCallback = void 0;
+                };
+            }
+        }
+        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()
+                }
+            };
+        }
+        addPendingPromise(promise) {
+            return this.promiseQueue.add(promise);
+        }
+        identifyStateless(distinctId, properties, options) {
+            this.wrap(()=>{
+                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);
+        }
+        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 ('https://us.i.posthog.com' === host) host = 'https://us-assets.i.posthog.com';
+            else if ('https://eu.i.posthog.com' === host) 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'
+                }
+            };
+            return this.fetchWithRetry(url, fetchOptions, {
+                retryCount: 0
+            }, this.remoteConfigRequestTimeoutMs).then((response)=>response.json()).catch((error)=>{
+                this._logger.error('Remote config could not be loaded', error);
+                this._events.emit('error', error);
+            });
+        }
+        async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}, fetchConfig = true) {
+            await this._initPromise;
+            const configParam = fetchConfig ? '&config=true' : '';
+            const url = `${this.host}/flags/?v=2${configParam}`;
+            const requestData = {
+                token: this.apiKey,
+                distinct_id: distinctId,
+                groups,
+                person_properties: personProperties,
+                group_properties: groupProperties,
+                ...extraPayload
+            };
+            if (this.evaluationEnvironments && this.evaluationEnvironments.length > 0) requestData.evaluation_environments = this.evaluationEnvironments;
+            const fetchOptions = {
+                method: 'POST',
+                headers: {
+                    ...this.getCustomHeaders(),
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(requestData)
+            };
+            this._logger.info('Flags URL', url);
+            return this.fetchWithRetry(url, fetchOptions, {
+                retryCount: 0
+            }, this.featureFlagsRequestTimeoutMs).then((response)=>response.json()).then((response)=>normalizeFlagsResponse(response)).catch((error)=>{
+                this._events.emit('error', error);
+            });
+        }
+        async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+            await this._initPromise;
+            const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+            if (void 0 === flagDetailResponse) return {
+                response: void 0,
+                requestId: void 0
+            };
+            let response = getFeatureFlagValue(flagDetailResponse.response);
+            if (void 0 === response) response = 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 (void 0 === flagsResponse) return;
+            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;
+            const response = payloads[key];
+            if (void 0 === response) 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: void 0,
+                payloads: void 0,
+                requestId: void 0
+            };
+            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 (void 0 === flagsResponse) return;
+            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');
+            if (flagsResponse.quotaLimited?.includes("feature_flags")) {
+                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;
+        }
+        async getSurveysStateless() {
+            await this._initPromise;
+            if (true === this.disableSurveys) {
+                this._logger.info('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 (200 !== response.status || !response.json) {
+                    const msg = `Surveys API could not be loaded: ${response.status}`;
+                    const error = new Error(msg);
+                    this._logger.error(error);
+                    this._events.emit('error', new Error(msg));
+                    return;
+                }
+                return response.json();
+            }).catch((error)=>{
+                this._logger.error('Surveys API could not be loaded', error);
+                this._events.emit('error', error);
+            });
+            const newSurveys = response?.surveys;
+            if (newSurveys) this._logger.info('Surveys fetched from API: ', JSON.stringify(newSurveys));
+            return newSurveys ?? [];
+        }
+        get props() {
+            if (!this._props) this._props = this.getPersistedProperty(types_PostHogPersistedProperty.Props);
+            return this._props || {};
+        }
+        set props(val) {
+            this._props = val;
+        }
+        async register(properties) {
+            this.wrap(()=>{
+                this.props = {
+                    ...this.props,
+                    ...properties
+                };
+                this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
+            });
+        }
+        async unregister(property) {
+            this.wrap(()=>{
+                delete this.props[property];
+                this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
+            });
+        }
+        enqueue(type, _message, options) {
+            this.wrap(()=>{
+                if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
+                const message = this.prepareMessage(type, _message, options);
+                const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+                if (queue.length >= this.maxQueueSize) {
+                    queue.shift();
+                    this._logger.info('Queue is full, the oldest event is dropped.');
+                }
+                queue.push({
+                    message
+                });
+                this.setPersistedProperty(types_PostHogPersistedProperty.Queue, queue);
+                this._events.emit(type, message);
+                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) return void this._logger.warn('The client is disabled');
+            if (!this._isInitialized) await this._initPromise;
+            if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
+            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 ? null : await gzipCompress(payload, this.isDebug);
+            const fetchOptions = {
+                method: 'POST',
+                headers: {
+                    ...this.getCustomHeaders(),
+                    'Content-Type': 'application/json',
+                    ...null !== gzippedPayload && {
+                        '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 = void 0;
+            }
+        }
+        flushBackground() {
+            this.flush().catch(async (err)=>{
+                await logFlushError(err);
+            });
+        }
+        async flush() {
+            const nextFlushPromise = allSettled([
+                this.flushPromise
+            ]).then(()=>this._flush());
+            this.flushPromise = nextFlushPromise;
+            this.addPendingPromise(nextFlushPromise);
+            allSettled([
+                nextFlushPromise
+            ]).then(()=>{
+                if (this.flushPromise === nextFlushPromise) this.flushPromise = null;
+            });
+            return nextFlushPromise;
+        }
+        getCustomHeaders() {
+            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(types_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(types_PostHogPersistedProperty.Queue) || [];
+                    const newQueue = refreshedQueue.slice(batchItems.length);
+                    this.setPersistedProperty(types_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 ? null : await gzipCompress(payload, this.isDebug);
+                const fetchOptions = {
+                    method: 'POST',
+                    headers: {
+                        ...this.getCustomHeaders(),
+                        'Content-Type': 'application/json',
+                        ...null !== gzippedPayload && {
+                            'Content-Encoding': 'gzip'
+                        }
+                    },
+                    body: gzippedPayload || payload
+                };
+                const retryOptions = {
+                    retryCheck: (err)=>{
+                        if (isPostHogFetchContentTooLargeError(err)) return false;
+                        return isPostHogFetchError(err);
+                    }
+                };
+                try {
+                    await this.fetchWithRetry(url, fetchOptions, retryOptions);
+                } catch (err) {
+                    if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
+                        this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2));
+                        this._logger.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`);
+                        continue;
+                    }
+                    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) {
+            AbortSignal.timeout ??= function(ms) {
+                const ctrl = new AbortController();
+                setTimeout(()=>ctrl.abort(), ms);
+                return ctrl.signal;
+            };
+            const body = options.body ? options.body : '';
+            let reqByteLength = -1;
+            try {
+                reqByteLength = body instanceof Blob ? body.size : 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) {
+                    throw new PostHogFetchNetworkError(e);
+                }
+                const isNoCors = 'no-cors' === options.mode;
+                if (!isNoCors && (res.status < 200 || res.status >= 400)) throw new PostHogFetchHttpError(res, reqByteLength);
+                return res;
+            }, {
+                ...this._retryOptions,
+                ...retryOptions
+            });
+        }
+        async _shutdown(shutdownTimeoutMs = 30000) {
+            await this._initPromise;
+            let hasTimedOut = false;
+            this.clearFlushTimer();
+            const doShutdown = async ()=>{
+                try {
+                    await this.promiseQueue.join();
+                    while(true){
+                        const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+                        if (0 === queue.length) break;
+                        await this.flush();
+                        if (hasTimedOut) break;
+                    }
+                } catch (e) {
+                    if (!isPostHogFetchError(e)) throw e;
+                    await logFlushError(e);
+                }
+            };
+            return Promise.race([
+                new Promise((_, reject)=>{
+                    safeSetTimeout(()=>{
+                        this._logger.error('Timed out while shutting down PostHog');
+                        hasTimedOut = true;
+                        reject('Timeout while shutting down PostHog. Some events may not have been sent.');
+                    }, shutdownTimeoutMs);
+                }),
+                doShutdown()
+            ]);
+        }
+        async shutdown(shutdownTimeoutMs = 30000) {
+            if (this.shutdownPromise) this._logger.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;
+        }
+    }
+
+    class PostHogCore extends PostHogCoreStateless {
+        constructor(apiKey, options){
+            const disableGeoipOption = options?.disableGeoip ?? false;
+            const featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 10000;
+            super(apiKey, {
+                ...options,
+                disableGeoip: disableGeoipOption,
+                featureFlagsRequestTimeoutMs
+            }), this.flagCallReported = {}, this._sessionMaxLengthSeconds = 86400, this.sessionProps = {};
+            this.sendFeatureFlagEvent = options?.sendFeatureFlagEvent ?? true;
+            this._sessionExpirationTimeSeconds = options?.sessionExpirationTimeSeconds ?? 1800;
+        }
+        setupBootstrap(options) {
+            const bootstrap = options?.bootstrap;
+            if (!bootstrap) return;
+            if (bootstrap.distinctId) if (bootstrap.isIdentifiedId) {
+                const distinctId = this.getPersistedProperty(types_PostHogPersistedProperty.DistinctId);
+                if (!distinctId) this.setPersistedProperty(types_PostHogPersistedProperty.DistinctId, bootstrap.distinctId);
+            } else {
+                const anonymousId = this.getPersistedProperty(types_PostHogPersistedProperty.AnonymousId);
+                if (!anonymousId) this.setPersistedProperty(types_PostHogPersistedProperty.AnonymousId, bootstrap.distinctId);
+            }
+            const bootstrapFeatureFlags = bootstrap.featureFlags;
+            const bootstrapFeatureFlagPayloads = bootstrap.featureFlagPayloads ?? {};
+            if (bootstrapFeatureFlags && Object.keys(bootstrapFeatureFlags).length) {
+                const normalizedBootstrapFeatureFlagDetails = createFlagsResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
+                if (Object.keys(normalizedBootstrapFeatureFlagDetails.flags).length > 0) {
+                    this.setBootstrappedFeatureFlagDetails(normalizedBootstrapFeatureFlagDetails);
+                    const currentFeatureFlagDetails = this.getKnownFeatureFlagDetails() || {
+                        flags: {}};
+                    const newFeatureFlagDetails = {
+                        flags: {
+                            ...normalizedBootstrapFeatureFlagDetails.flags,
+                            ...currentFeatureFlagDetails.flags
+                        },
+                        requestId: normalizedBootstrapFeatureFlagDetails.requestId
+                    };
+                    this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
+                }
+            }
+        }
+        clearProps() {
+            this.props = void 0;
+            this.sessionProps = {};
+            this.flagCallReported = {};
+        }
+        on(event, cb) {
+            return this._events.on(event, cb);
+        }
+        reset(propertiesToKeep) {
+            this.wrap(()=>{
+                const allPropertiesToKeep = [
+                    types_PostHogPersistedProperty.Queue,
+                    ...propertiesToKeep || []
+                ];
+                this.clearProps();
+                for (const key of Object.keys(types_PostHogPersistedProperty))if (!allPropertiesToKeep.includes(types_PostHogPersistedProperty[key])) this.setPersistedProperty(types_PostHogPersistedProperty[key], null);
+                this.reloadFeatureFlags();
+            });
+        }
+        getCommonEventProperties() {
+            const featureFlags = this.getFeatureFlags();
+            const featureVariantProperties = {};
+            if (featureFlags) for (const [feature, variant] of Object.entries(featureFlags))featureVariantProperties[`$feature/${feature}`] = variant;
+            return {
+                ...maybeAdd('$active_feature_flags', featureFlags ? Object.keys(featureFlags) : void 0),
+                ...featureVariantProperties,
+                ...super.getCommonEventProperties()
+            };
+        }
+        enrichProperties(properties) {
+            return {
+                ...this.props,
+                ...this.sessionProps,
+                ...properties || {},
+                ...this.getCommonEventProperties(),
+                $session_id: this.getSessionId()
+            };
+        }
+        getSessionId() {
+            if (!this._isInitialized) return '';
+            let sessionId = this.getPersistedProperty(types_PostHogPersistedProperty.SessionId);
+            const sessionLastTimestamp = this.getPersistedProperty(types_PostHogPersistedProperty.SessionLastTimestamp) || 0;
+            const sessionStartTimestamp = this.getPersistedProperty(types_PostHogPersistedProperty.SessionStartTimestamp) || 0;
+            const now = Date.now();
+            const sessionLastDif = now - sessionLastTimestamp;
+            const sessionStartDif = now - sessionStartTimestamp;
+            if (!sessionId || sessionLastDif > 1000 * this._sessionExpirationTimeSeconds || sessionStartDif > 1000 * this._sessionMaxLengthSeconds) {
+                sessionId = uuidv7();
+                this.setPersistedProperty(types_PostHogPersistedProperty.SessionId, sessionId);
+                this.setPersistedProperty(types_PostHogPersistedProperty.SessionStartTimestamp, now);
+            }
+            this.setPersistedProperty(types_PostHogPersistedProperty.SessionLastTimestamp, now);
+            return sessionId;
+        }
+        resetSessionId() {
+            this.wrap(()=>{
+                this.setPersistedProperty(types_PostHogPersistedProperty.SessionId, null);
+                this.setPersistedProperty(types_PostHogPersistedProperty.SessionLastTimestamp, null);
+                this.setPersistedProperty(types_PostHogPersistedProperty.SessionStartTimestamp, null);
+            });
+        }
+        getAnonymousId() {
+            if (!this._isInitialized) return '';
+            let anonId = this.getPersistedProperty(types_PostHogPersistedProperty.AnonymousId);
+            if (!anonId) {
+                anonId = uuidv7();
+                this.setPersistedProperty(types_PostHogPersistedProperty.AnonymousId, anonId);
+            }
+            return anonId;
+        }
+        getDistinctId() {
+            if (!this._isInitialized) return '';
+            return this.getPersistedProperty(types_PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
+        }
+        registerForSession(properties) {
+            this.sessionProps = {
+                ...this.sessionProps,
+                ...properties
+            };
+        }
+        unregisterForSession(property) {
+            delete this.sessionProps[property];
+        }
+        identify(distinctId, properties, options) {
+            this.wrap(()=>{
+                const previousDistinctId = this.getDistinctId();
+                distinctId = distinctId || previousDistinctId;
+                if (properties?.$groups) this.groups(properties.$groups);
+                const userPropsOnce = properties?.$set_once;
+                delete properties?.$set_once;
+                const userProps = properties?.$set || properties;
+                const allProperties = this.enrichProperties({
+                    $anon_distinct_id: this.getAnonymousId(),
+                    ...maybeAdd('$set', userProps),
+                    ...maybeAdd('$set_once', userPropsOnce)
+                });
+                if (distinctId !== previousDistinctId) {
+                    this.setPersistedProperty(types_PostHogPersistedProperty.AnonymousId, previousDistinctId);
+                    this.setPersistedProperty(types_PostHogPersistedProperty.DistinctId, distinctId);
+                    this.reloadFeatureFlags();
+                }
+                super.identifyStateless(distinctId, allProperties, options);
+            });
+        }
+        capture(event, properties, options) {
+            this.wrap(()=>{
+                const distinctId = this.getDistinctId();
+                if (properties?.$groups) this.groups(properties.$groups);
+                const allProperties = this.enrichProperties(properties);
+                super.captureStateless(distinctId, event, allProperties, options);
+            });
+        }
+        alias(alias) {
+            this.wrap(()=>{
+                const distinctId = this.getDistinctId();
+                const allProperties = this.enrichProperties({});
+                super.aliasStateless(alias, distinctId, allProperties);
+            });
+        }
+        autocapture(eventType, elements, properties = {}, options) {
+            this.wrap(()=>{
+                const distinctId = this.getDistinctId();
+                const payload = {
+                    distinct_id: distinctId,
+                    event: '$autocapture',
+                    properties: {
+                        ...this.enrichProperties(properties),
+                        $event_type: eventType,
+                        $elements: elements
+                    }
+                };
+                this.enqueue('autocapture', payload, options);
+            });
+        }
+        groups(groups) {
+            this.wrap(()=>{
+                const existingGroups = this.props.$groups || {};
+                this.register({
+                    $groups: {
+                        ...existingGroups,
+                        ...groups
+                    }
+                });
+                if (Object.keys(groups).find((type)=>existingGroups[type] !== groups[type])) this.reloadFeatureFlags();
+            });
+        }
+        group(groupType, groupKey, groupProperties, options) {
+            this.wrap(()=>{
+                this.groups({
+                    [groupType]: groupKey
+                });
+                if (groupProperties) this.groupIdentify(groupType, groupKey, groupProperties, options);
+            });
+        }
+        groupIdentify(groupType, groupKey, groupProperties, options) {
+            this.wrap(()=>{
+                const distinctId = this.getDistinctId();
+                const eventProperties = this.enrichProperties({});
+                super.groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties);
+            });
+        }
+        setPersonPropertiesForFlags(properties) {
+            this.wrap(()=>{
+                const existingProperties = this.getPersistedProperty(types_PostHogPersistedProperty.PersonProperties) || {};
+                this.setPersistedProperty(types_PostHogPersistedProperty.PersonProperties, {
+                    ...existingProperties,
+                    ...properties
+                });
+            });
+        }
+        resetPersonPropertiesForFlags() {
+            this.wrap(()=>{
+                this.setPersistedProperty(types_PostHogPersistedProperty.PersonProperties, null);
+            });
+        }
+        setGroupPropertiesForFlags(properties) {
+            this.wrap(()=>{
+                const existingProperties = this.getPersistedProperty(types_PostHogPersistedProperty.GroupProperties) || {};
+                if (0 !== Object.keys(existingProperties).length) Object.keys(existingProperties).forEach((groupType)=>{
+                    existingProperties[groupType] = {
+                        ...existingProperties[groupType],
+                        ...properties[groupType]
+                    };
+                    delete properties[groupType];
+                });
+                this.setPersistedProperty(types_PostHogPersistedProperty.GroupProperties, {
+                    ...existingProperties,
+                    ...properties
+                });
+            });
+        }
+        resetGroupPropertiesForFlags() {
+            this.wrap(()=>{
+                this.setPersistedProperty(types_PostHogPersistedProperty.GroupProperties, null);
+            });
+        }
+        async remoteConfigAsync() {
+            await this._initPromise;
+            if (this._remoteConfigResponsePromise) return this._remoteConfigResponsePromise;
+            return this._remoteConfigAsync();
+        }
+        async flagsAsync(sendAnonDistinctId = true, fetchConfig = true) {
+            await this._initPromise;
+            if (this._flagsResponsePromise) return this._flagsResponsePromise;
+            return this._flagsAsync(sendAnonDistinctId, fetchConfig);
+        }
+        cacheSessionReplay(source, response) {
+            const sessionReplay = response?.sessionRecording;
+            if (sessionReplay) {
+                this.setPersistedProperty(types_PostHogPersistedProperty.SessionReplay, sessionReplay);
+                this._logger.info(`Session replay config from ${source}: `, JSON.stringify(sessionReplay));
+            } else if ('boolean' == typeof sessionReplay && false === sessionReplay) {
+                this._logger.info(`Session replay config from ${source} disabled.`);
+                this.setPersistedProperty(types_PostHogPersistedProperty.SessionReplay, null);
+            }
+        }
+        async _remoteConfigAsync() {
+            this._remoteConfigResponsePromise = this._initPromise.then(()=>{
+                let remoteConfig = this.getPersistedProperty(types_PostHogPersistedProperty.RemoteConfig);
+                this._logger.info('Cached remote config: ', JSON.stringify(remoteConfig));
+                return super.getRemoteConfig().then((response)=>{
+                    if (response) {
+                        const remoteConfigWithoutSurveys = {
+                            ...response
+                        };
+                        delete remoteConfigWithoutSurveys.surveys;
+                        this._logger.info('Fetched remote config: ', JSON.stringify(remoteConfigWithoutSurveys));
+                        if (false === this.disableSurveys) {
+                            const surveys = response.surveys;
+                            let hasSurveys = true;
+                            if (Array.isArray(surveys)) this._logger.info('Surveys fetched from remote config: ', JSON.stringify(surveys));
+                            else {
+                                this._logger.info('There are no surveys.');
+                                hasSurveys = false;
+                            }
+                            if (hasSurveys) this.setPersistedProperty(types_PostHogPersistedProperty.Surveys, surveys);
+                            else this.setPersistedProperty(types_PostHogPersistedProperty.Surveys, null);
+                        } else this.setPersistedProperty(types_PostHogPersistedProperty.Surveys, null);
+                        this.setPersistedProperty(types_PostHogPersistedProperty.RemoteConfig, remoteConfigWithoutSurveys);
+                        this.cacheSessionReplay('remote config', response);
+                        if (false === response.hasFeatureFlags) {
+                            this.setKnownFeatureFlagDetails({
+                                flags: {}
+                            });
+                            this._logger.warn('Remote config has no feature flags, will not load feature flags.');
+                        } else if (false !== this.preloadFeatureFlags) this.reloadFeatureFlags();
+                        if (!response.supportedCompression?.includes(types_Compression.GZipJS)) this.disableCompression = true;
+                        remoteConfig = response;
+                    }
+                    return remoteConfig;
+                });
+            }).finally(()=>{
+                this._remoteConfigResponsePromise = void 0;
+            });
+            return this._remoteConfigResponsePromise;
+        }
+        async _flagsAsync(sendAnonDistinctId = true, fetchConfig = true) {
+            this._flagsResponsePromise = this._initPromise.then(async ()=>{
+                const distinctId = this.getDistinctId();
+                const groups = this.props.$groups || {};
+                const personProperties = this.getPersistedProperty(types_PostHogPersistedProperty.PersonProperties) || {};
+                const groupProperties = this.getPersistedProperty(types_PostHogPersistedProperty.GroupProperties) || {};
+                const extraProperties = {
+                    $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : void 0
+                };
+                const res = await super.getFlags(distinctId, groups, personProperties, groupProperties, extraProperties, fetchConfig);
+                if (res?.quotaLimited?.includes(posthog_core_stateless_QuotaLimitedFeature.FeatureFlags)) {
+                    this.setKnownFeatureFlagDetails(null);
+                    console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
+                    return res;
+                }
+                if (res?.featureFlags) {
+                    if (this.sendFeatureFlagEvent) this.flagCallReported = {};
+                    let newFeatureFlagDetails = res;
+                    if (res.errorsWhileComputingFlags) {
+                        const currentFlagDetails = this.getKnownFeatureFlagDetails();
+                        this._logger.info('Cached feature flags: ', JSON.stringify(currentFlagDetails));
+                        newFeatureFlagDetails = {
+                            ...res,
+                            flags: {
+                                ...currentFlagDetails?.flags,
+                                ...res.flags
+                            }
+                        };
+                    }
+                    this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
+                    this.setPersistedProperty(types_PostHogPersistedProperty.FlagsEndpointWasHit, true);
+                    this.cacheSessionReplay('flags', res);
+                }
+                return res;
+            }).finally(()=>{
+                this._flagsResponsePromise = void 0;
+            });
+            return this._flagsResponsePromise;
+        }
+        setKnownFeatureFlagDetails(flagsResponse) {
+            this.wrap(()=>{
+                this.setPersistedProperty(types_PostHogPersistedProperty.FeatureFlagDetails, flagsResponse);
+                this._events.emit('featureflags', getFlagValuesFromFlags(flagsResponse?.flags ?? {}));
+            });
+        }
+        getKnownFeatureFlagDetails() {
+            const storedDetails = this.getPersistedProperty(types_PostHogPersistedProperty.FeatureFlagDetails);
+            if (!storedDetails) {
+                const featureFlags = this.getPersistedProperty(types_PostHogPersistedProperty.FeatureFlags);
+                const featureFlagPayloads = this.getPersistedProperty(types_PostHogPersistedProperty.FeatureFlagPayloads);
+                if (void 0 === featureFlags && void 0 === featureFlagPayloads) return;
+                return createFlagsResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
+            }
+            return normalizeFlagsResponse(storedDetails);
+        }
+        getKnownFeatureFlags() {
+            const featureFlagDetails = this.getKnownFeatureFlagDetails();
+            if (!featureFlagDetails) return;
+            return getFlagValuesFromFlags(featureFlagDetails.flags);
+        }
+        getKnownFeatureFlagPayloads() {
+            const featureFlagDetails = this.getKnownFeatureFlagDetails();
+            if (!featureFlagDetails) return;
+            return getPayloadsFromFlags(featureFlagDetails.flags);
+        }
+        getBootstrappedFeatureFlagDetails() {
+            const details = this.getPersistedProperty(types_PostHogPersistedProperty.BootstrapFeatureFlagDetails);
+            if (!details) return;
+            return details;
+        }
+        setBootstrappedFeatureFlagDetails(details) {
+            this.setPersistedProperty(types_PostHogPersistedProperty.BootstrapFeatureFlagDetails, details);
+        }
+        getBootstrappedFeatureFlags() {
+            const details = this.getBootstrappedFeatureFlagDetails();
+            if (!details) return;
+            return getFlagValuesFromFlags(details.flags);
+        }
+        getBootstrappedFeatureFlagPayloads() {
+            const details = this.getBootstrappedFeatureFlagDetails();
+            if (!details) return;
+            return getPayloadsFromFlags(details.flags);
+        }
+        getFeatureFlag(key) {
+            const details = this.getFeatureFlagDetails();
+            if (!details) return;
+            const featureFlag = details.flags[key];
+            let response = getFeatureFlagValue(featureFlag);
+            if (void 0 === response) response = false;
+            if (this.sendFeatureFlagEvent && !this.flagCallReported[key]) {
+                const bootstrappedResponse = this.getBootstrappedFeatureFlags()?.[key];
+                const bootstrappedPayload = this.getBootstrappedFeatureFlagPayloads()?.[key];
+                this.flagCallReported[key] = true;
+                this.capture('$feature_flag_called', {
+                    $feature_flag: key,
+                    $feature_flag_response: response,
+                    ...maybeAdd('$feature_flag_id', featureFlag?.metadata?.id),
+                    ...maybeAdd('$feature_flag_version', featureFlag?.metadata?.version),
+                    ...maybeAdd('$feature_flag_reason', featureFlag?.reason?.description ?? featureFlag?.reason?.code),
+                    ...maybeAdd('$feature_flag_bootstrapped_response', bootstrappedResponse),
+                    ...maybeAdd('$feature_flag_bootstrapped_payload', bootstrappedPayload),
+                    $used_bootstrap_value: !this.getPersistedProperty(types_PostHogPersistedProperty.FlagsEndpointWasHit),
+                    ...maybeAdd('$feature_flag_request_id', details.requestId)
+                });
+            }
+            return response;
+        }
+        getFeatureFlagPayload(key) {
+            const payloads = this.getFeatureFlagPayloads();
+            if (!payloads) return;
+            const response = payloads[key];
+            if (void 0 === response) return null;
+            return response;
+        }
+        getFeatureFlagPayloads() {
+            return this.getFeatureFlagDetails()?.featureFlagPayloads;
+        }
+        getFeatureFlags() {
+            return this.getFeatureFlagDetails()?.featureFlags;
+        }
+        getFeatureFlagDetails() {
+            let details = this.getKnownFeatureFlagDetails();
+            const overriddenFlags = this.getPersistedProperty(types_PostHogPersistedProperty.OverrideFeatureFlags);
+            if (!overriddenFlags) return details;
+            details = details ?? {
+                featureFlags: {},
+                featureFlagPayloads: {},
+                flags: {}
+            };
+            const flags = details.flags ?? {};
+            for(const key in overriddenFlags)if (overriddenFlags[key]) flags[key] = updateFlagValue(flags[key], overriddenFlags[key]);
+            else delete flags[key];
+            const result = {
+                ...details,
+                flags
+            };
+            return normalizeFlagsResponse(result);
+        }
+        getFeatureFlagsAndPayloads() {
+            const flags = this.getFeatureFlags();
+            const payloads = this.getFeatureFlagPayloads();
+            return {
+                flags,
+                payloads
+            };
+        }
+        isFeatureEnabled(key) {
+            const response = this.getFeatureFlag(key);
+            if (void 0 === response) return;
+            return !!response;
+        }
+        reloadFeatureFlags(options) {
+            this.flagsAsync(true).then((res)=>{
+                options?.cb?.(void 0, res?.featureFlags);
+            }).catch((e)=>{
+                options?.cb?.(e, void 0);
+                if (!options?.cb) this._logger.info('Error reloading feature flags', e);
+            });
+        }
+        async reloadRemoteConfigAsync() {
+            return await this.remoteConfigAsync();
+        }
+        async reloadFeatureFlagsAsync(sendAnonDistinctId) {
+            return (await this.flagsAsync(sendAnonDistinctId ?? true))?.featureFlags;
+        }
+        onFeatureFlags(cb) {
+            return this.on('featureflags', async ()=>{
+                const flags = this.getFeatureFlags();
+                if (flags) cb(flags);
+            });
+        }
+        onFeatureFlag(key, cb) {
+            return this.on('featureflags', async ()=>{
+                const flagResponse = this.getFeatureFlag(key);
+                if (void 0 !== flagResponse) cb(flagResponse);
+            });
+        }
+        async overrideFeatureFlag(flags) {
+            this.wrap(()=>{
+                if (null === flags) return this.setPersistedProperty(types_PostHogPersistedProperty.OverrideFeatureFlags, null);
+                return this.setPersistedProperty(types_PostHogPersistedProperty.OverrideFeatureFlags, flags);
+            });
+        }
+        captureException(error, additionalProperties) {
+            const properties = {
+                $exception_level: 'error',
+                $exception_list: [
+                    {
+                        type: isPlainError(error) ? error.name : 'Error',
+                        value: isPlainError(error) ? error.message : error,
+                        mechanism: {
+                            handled: true,
+                            synthetic: false
+                        }
+                    }
+                ],
+                ...additionalProperties
+            };
+            this.capture('$exception', properties);
+        }
+        captureTraceFeedback(traceId, userFeedback) {
+            this.capture('$ai_feedback', {
+                $ai_feedback_text: userFeedback,
+                $ai_trace_id: String(traceId)
+            });
+        }
+        captureTraceMetric(traceId, metricName, metricValue) {
+            this.capture('$ai_metric', {
+                $ai_metric_name: metricName,
+                $ai_metric_value: String(metricValue),
+                $ai_trace_id: String(traceId)
+            });
+        }
+    }
+
+    const version = '0.1.0';
+
+    // Simple logger with [Leanbase] prefix
+    const PREFIX = '[Leanbase]';
+    const logger = {
+      info: (...args) => {
+        if (typeof console !== 'undefined') {
+          // eslint-disable-next-line no-console
+          console.log(PREFIX, ...args);
+        }
+      },
+      warn: (...args) => {
+        if (typeof console !== 'undefined') {
+          // eslint-disable-next-line no-console
+          console.warn(PREFIX, ...args);
+        }
+      },
+      error: (...args) => {
+        if (typeof console !== 'undefined') {
+          // eslint-disable-next-line no-console
+          console.error(PREFIX, ...args);
+        }
+      }
+    };
+
+    class Leanbase extends PostHogCore {
+      constructor(apiKey, options) {
+        // Leanbase defaults
+        const leanbaseOptions = {
+          host: 'https://i.leanbase.co',
+          ...options
+        };
+        super(apiKey, leanbaseOptions);
+        this._storage = new Map();
+        this._storageKey = `leanbase_${apiKey}`;
+        // Load from localStorage if available
+        if (typeof window !== 'undefined' && window.localStorage) {
+          try {
+            const stored = window.localStorage.getItem(this._storageKey);
+            if (stored) {
+              const parsed = JSON.parse(stored);
+              Object.entries(parsed).forEach(([key, value]) => {
+                this._storage.set(key, value);
+              });
+            }
+          } catch (err) {
+            logger.warn('Failed to load persisted data', err);
+          }
+        }
+        logger.info('Leanbase initialized', {
+          apiKey,
+          host: leanbaseOptions.host
+        });
+        // Preload feature flags if not explicitly disabled
+        if (options?.preloadFeatureFlags !== false) {
+          this.reloadFeatureFlags();
+        }
+      }
+      // PostHogCore abstract methods
+      fetch(url, options) {
+        const fetchFn = getFetch();
+        if (!fetchFn) {
+          return Promise.reject(new Error('Fetch API is not available in this environment.'));
+        }
+        return fetchFn(url, options);
+      }
+      getLibraryId() {
+        return 'leanbase';
+      }
+      getLibraryVersion() {
+        return version;
+      }
+      getCustomUserAgent() {
+        return;
+      }
+      getPersistedProperty(key) {
+        return this._storage.get(key);
+      }
+      setPersistedProperty(key, value) {
+        if (isNull(value)) {
+          this._storage.delete(key);
+        } else {
+          this._storage.set(key, value);
+        }
+        // Persist to localStorage if available
+        if (typeof window !== 'undefined' && window.localStorage) {
+          try {
+            const obj = {};
+            this._storage.forEach((v, k) => {
+              obj[k] = v;
+            });
+            window.localStorage.setItem(this._storageKey, JSON.stringify(obj));
+          } catch (err) {
+            logger.warn('Failed to persist data', err);
+          }
+        }
+      }
+      // Public API: leanbase.capture()
+      capture(event, properties, options) {
+        super.capture(event, properties, options);
+      }
+      // Public API: leanbase.identify()
+      identify(distinctId, properties, options) {
+        super.identify(distinctId, properties, options);
+      }
+      // Cleanup
+      destroy() {
+        // Future: cleanup autocapture and session recording
+        this._storage.clear();
+      }
+    }
+
+    const api = {
+      _instance: null,
+      _queue: [],
+      init(apiKey, options) {
+        this._instance = new Leanbase(apiKey, options);
+        // Flush queued calls
+        const q = this._queue;
+        this._queue = [];
+        for (const {
+          fn,
+          args
+        } of q) {
+          // @ts-expect-error dynamic dispatch to API methods
+          this[fn](...args);
+        }
+      },
+      capture(...args) {
+        if (this._instance) {
+          this._instance.capture(...args);
+        } else {
+          this._queue.push({
+            fn: 'capture',
+            args
+          });
+        }
+      },
+      identify(...args) {
+        if (this._instance) {
+          this._instance.identify(...args);
+        } else {
+          this._queue.push({
+            fn: 'identify',
+            args
+          });
+        }
+      },
+      group(...args) {
+        if (this._instance && isFunction(this._instance.group)) {
+          this._instance.group(...args);
+        } else {
+          this._queue.push({
+            fn: 'group',
+            args
+          });
+        }
+      },
+      alias(...args) {
+        if (this._instance && isFunction(this._instance.alias)) {
+          this._instance.alias(...args);
+        } else {
+          this._queue.push({
+            fn: 'alias',
+            args
+          });
+        }
+      },
+      reset() {
+        this._instance?.reset();
+        this._instance = null;
+      },
+      getInstance() {
+        return this._instance;
+      }
+    };
+    (function attachToGlobal(g) {
+      // Prefer not to overwrite if a stub already exists (e.g., user queued calls before script loaded)
+      const existing = g.leanbase;
+      if (existing && typeof existing === 'object') {
+        // If there is a pre-existing queue-compatible stub, try to drain it into our API
+        if (isArray(existing._queue)) {
+          api._queue = existing._queue;
+        }
+      }
+      g.leanbase = api;
+      // Also expose PascalCase alias for familiarity
+      g.Leanbase = g.leanbase;
+    })(globalThis);
+
+    return api;
+
+})();
+//# sourceMappingURL=leanbase.iife.js.map