@posthog/core 1.1.0 → 1.2.1

package/dist/posthog-core-stateless.js

@@ -0,0 +1,675 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    maybeAdd: ()=>maybeAdd,
+    logFlushError: ()=>logFlushError,
+    PostHogCoreStateless: ()=>PostHogCoreStateless,
+    QuotaLimitedFeature: ()=>posthog_core_stateless_QuotaLimitedFeature
+});
+const external_eventemitter_js_namespaceObject = require("./eventemitter.js");
+const external_featureFlagUtils_js_namespaceObject = require("./featureFlagUtils.js");
+const external_gzip_js_namespaceObject = require("./gzip.js");
+const external_types_js_namespaceObject = require("./types.js");
+const index_js_namespaceObject = require("./utils/index.js");
+const uuidv7_js_namespaceObject = require("./vendor/uuidv7.js");
+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 index_js_namespaceObject.PromiseQueue();
+        this._events = new external_eventemitter_js_namespaceObject.SimpleEventEmitter();
+        this._isInitialized = false;
+        (0, index_js_namespaceObject.assert)(apiKey, "You must pass your PostHog project's api key.");
+        this.apiKey = apiKey;
+        this.host = (0, index_js_namespaceObject.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._initPromise = Promise.resolve();
+        this._isInitialized = true;
+        this.disableCompression = !(0, external_gzip_js_namespaceObject.isGzipSupported)() || (options?.disableCompression ?? false);
+    }
+    logMsgIfDebug(fn) {
+        if (this.isDebug) fn();
+    }
+    wrap(fn) {
+        if (this.disabled) return void this.logMsgIfDebug(()=>console.warn('[PostHog] 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(external_types_js_namespaceObject.PostHogPersistedProperty.OptedOut) ?? !this.defaultOptIn;
+    }
+    async optIn() {
+        this.wrap(()=>{
+            this.setPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.OptedOut, false);
+        });
+    }
+    async optOut() {
+        this.wrap(()=>{
+            this.setPersistedProperty(external_types_js_namespaceObject.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 = 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.logMsgIfDebug(()=>console.error('Remote config could not be loaded', error));
+            this._events.emit('error', error);
+        });
+    }
+    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));
+        return this.fetchWithRetry(url, fetchOptions, {
+            retryCount: 0
+        }, this.featureFlagsRequestTimeoutMs).then((response)=>response.json()).then((response)=>(0, external_featureFlagUtils_js_namespaceObject.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 = (0, external_featureFlagUtils_js_namespaceObject.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.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 (200 !== response.status || !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;
+            }
+            return response.json();
+        }).catch((error)=>{
+            this.logMsgIfDebug(()=>console.error('Surveys API could not be loaded', error));
+            this._events.emit('error', error);
+        });
+        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(external_types_js_namespaceObject.PostHogPersistedProperty.Props);
+        return this._props || {};
+    }
+    set props(val) {
+        this._props = val;
+    }
+    async register(properties) {
+        this.wrap(()=>{
+            this.props = {
+                ...this.props,
+                ...properties
+            };
+            this.setPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    async unregister(property) {
+        this.wrap(()=>{
+            delete this.props[property];
+            this.setPersistedProperty(external_types_js_namespaceObject.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(external_types_js_namespaceObject.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(external_types_js_namespaceObject.PostHogPersistedProperty.Queue, queue);
+            this._events.emit(type, message);
+            if (queue.length >= this.flushAt) this.flushBackground();
+            if (this.flushInterval && !this._flushTimer) this._flushTimer = (0, index_js_namespaceObject.safeSetTimeout)(()=>this.flushBackground(), this.flushInterval);
+        });
+    }
+    async sendImmediate(type, _message, options) {
+        if (this.disabled) return void this.logMsgIfDebug(()=>console.warn('[PostHog] 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: (0, index_js_namespaceObject.currentISOTime)()
+        };
+        if (this.historicalMigration) data.historical_migration = true;
+        const payload = JSON.stringify(data);
+        const url = `${this.host}/batch/`;
+        const gzippedPayload = this.disableCompression ? null : await (0, external_gzip_js_namespaceObject.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 : (0, index_js_namespaceObject.currentISOTime)(),
+            uuid: options?.uuid ? options.uuid : (0, uuidv7_js_namespaceObject.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 = (0, index_js_namespaceObject.allSettled)([
+            this.flushPromise
+        ]).then(()=>this._flush());
+        this.flushPromise = nextFlushPromise;
+        this.addPendingPromise(nextFlushPromise);
+        (0, index_js_namespaceObject.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(external_types_js_namespaceObject.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(external_types_js_namespaceObject.PostHogPersistedProperty.Queue) || [];
+                const newQueue = refreshedQueue.slice(batchItems.length);
+                this.setPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.Queue, newQueue);
+                queue = newQueue;
+            };
+            const data = {
+                api_key: this.apiKey,
+                batch: batchMessages,
+                sent_at: (0, index_js_namespaceObject.currentISOTime)()
+            };
+            if (this.historicalMigration) data.historical_migration = true;
+            const payload = JSON.stringify(data);
+            const url = `${this.host}/batch/`;
+            const gzippedPayload = this.disableCompression ? null : await (0, external_gzip_js_namespaceObject.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.logMsgIfDebug(()=>console.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, index_js_namespaceObject.STRING_FORMAT);
+        } catch  {
+            if (body instanceof Blob) reqByteLength = body.size;
+            else {
+                const encoded = new TextEncoder().encode(body);
+                reqByteLength = encoded.length;
+            }
+        }
+        return await (0, index_js_namespaceObject.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(external_types_js_namespaceObject.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)=>{
+                (0, index_js_namespaceObject.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()
+        ]);
+    }
+    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;
+    }
+}
+exports.PostHogCoreStateless = __webpack_exports__.PostHogCoreStateless;
+exports.QuotaLimitedFeature = __webpack_exports__.QuotaLimitedFeature;
+exports.logFlushError = __webpack_exports__.logFlushError;
+exports.maybeAdd = __webpack_exports__.maybeAdd;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "PostHogCoreStateless",
+    "QuotaLimitedFeature",
+    "logFlushError",
+    "maybeAdd"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});