@posthog/browser-common 0.9.2 → 0.9.3

package/dist/feature-flags.js

@@ -0,0 +1,1222 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__, {
+    FeatureFlagError: ()=>FeatureFlagError,
+    PostHogFeatureFlags: ()=>PostHogFeatureFlags,
+    QuotaLimitedResource: ()=>QuotaLimitedResource,
+    filterActiveFeatureFlags: ()=>filterActiveFeatureFlags,
+    parseFlagsResponse: ()=>parseFlagsResponse
+});
+const general_utils_js_namespaceObject = require("./utils/general-utils.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const core_namespaceObject = require("@posthog/core");
+const logger_js_namespaceObject = require("./utils/logger.js");
+const timezone_js_namespaceObject = require("./utils/timezone.js");
+const promise_utils_js_namespaceObject = require("./utils/promise-utils.js");
+const request_reachability_js_namespaceObject = require("./utils/request-reachability.js");
+const logger = (0, logger_js_namespaceObject.createLogger)('[FeatureFlags]');
+const forceDebugLogger = (0, logger_js_namespaceObject.createLogger)('[FeatureFlags]', {
+    debugEnabled: true
+});
+const FLAG_TIMEOUT_MSG = '" failed. Feature flags didn\'t load in time.';
+const MAX_CONSECUTIVE_FLAGS_STATUS_ZERO_FAILURES = 3;
+const RETRYABLE_FLAGS_HTTP_STATUSES = [
+    502,
+    504
+];
+const FLAGS_RETRY_DELAY_MS = 500;
+const isFlagsTimeout = (response)=>0 === response.statusCode && response.error instanceof Error && 'AbortError' === response.error.name;
+const isRetryableFlagsResponse = (response)=>RETRYABLE_FLAGS_HTTP_STATUSES.includes(response.statusCode) || isFlagsTimeout(response);
+const MAX_IDLE_REFRESH_INTERVAL_MS = 3600000;
+const USER_INTERACTION_EVENTS = [
+    'click',
+    'keydown',
+    'wheel',
+    'touchstart',
+    'pointerdown'
+];
+const FeatureFlagError = {
+    ERRORS_WHILE_COMPUTING: 'errors_while_computing_flags',
+    FLAG_MISSING: 'flag_missing',
+    QUOTA_LIMITED: 'quota_limited',
+    TIMEOUT: 'timeout',
+    CONNECTION_ERROR: 'connection_error',
+    UNKNOWN_ERROR: 'unknown_error',
+    apiError: (status)=>`api_error_${status}`
+};
+const arrayToFlagsRecord = (flags)=>{
+    const flagsObj = {};
+    for(let i = 0; i < flags.length; i++)flagsObj[flags[i]] = true;
+    return flagsObj;
+};
+const filterActiveFeatureFlags = (featureFlags)=>{
+    const activeFeatureFlags = {};
+    for (const [key, value] of (0, general_utils_js_namespaceObject.entries)(featureFlags || {}))if (value) activeFeatureFlags[key] = value;
+    return activeFeatureFlags;
+};
+const parseFlagsResponse = (response, currentFlags = {}, currentFlagPayloads = {}, currentFlagDetails = {}, options, responseLogger = logger)=>{
+    const normalizedResponse = normalizeFlagsResponse(response, responseLogger);
+    const flagDetails = normalizedResponse.flags;
+    const featureFlags = normalizedResponse.featureFlags;
+    const flagPayloads = normalizedResponse.featureFlagPayloads;
+    if (!featureFlags) return;
+    const requestId = response['requestId'];
+    const evaluatedAt = response['evaluatedAt'];
+    if ((0, core_namespaceObject.isArray)(featureFlags)) {
+        responseLogger.warn('v1 of the feature flags endpoint is deprecated. Please use the latest version.');
+        const $enabled_feature_flags = {};
+        if (featureFlags) for(let i = 0; i < featureFlags.length; i++)$enabled_feature_flags[featureFlags[i]] = true;
+        return {
+            [external_constants_js_namespaceObject.PERSISTENCE_ACTIVE_FEATURE_FLAGS]: featureFlags,
+            [external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS]: $enabled_feature_flags,
+            [external_constants_js_namespaceObject.PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS]: false
+        };
+    }
+    let newFeatureFlags = featureFlags;
+    let newFeatureFlagPayloads = flagPayloads;
+    let newFeatureFlagDetails = flagDetails;
+    if (options?.partialResponse) {
+        const evaluatedFlagKeys = Object.keys(newFeatureFlags);
+        const evaluatedPayloads = newFeatureFlagPayloads || {};
+        newFeatureFlags = {
+            ...currentFlags,
+            ...newFeatureFlags
+        };
+        newFeatureFlagPayloads = {
+            ...currentFlagPayloads,
+            ...evaluatedPayloads
+        };
+        evaluatedFlagKeys.forEach((key)=>{
+            if (!(key in evaluatedPayloads)) delete newFeatureFlagPayloads?.[key];
+        });
+        newFeatureFlagDetails = {
+            ...currentFlagDetails,
+            ...newFeatureFlagDetails
+        };
+    } else if (response.errorsWhileComputingFlags) if (flagDetails) {
+        const successfulKeys = new Set(Object.keys(flagDetails).filter((key)=>!flagDetails[key]?.failed));
+        newFeatureFlags = {
+            ...currentFlags,
+            ...Object.fromEntries(Object.entries(newFeatureFlags).filter(([key])=>successfulKeys.has(key)))
+        };
+        const successfulPayloads = Object.fromEntries(Object.entries(newFeatureFlagPayloads || {}).filter(([key])=>successfulKeys.has(key)));
+        newFeatureFlagPayloads = {
+            ...currentFlagPayloads,
+            ...successfulPayloads
+        };
+        successfulKeys.forEach((key)=>{
+            if (!(key in successfulPayloads)) delete newFeatureFlagPayloads?.[key];
+        });
+        newFeatureFlagDetails = {
+            ...currentFlagDetails,
+            ...Object.fromEntries(Object.entries(newFeatureFlagDetails || {}).filter(([key])=>successfulKeys.has(key)))
+        };
+    } else {
+        newFeatureFlags = {
+            ...currentFlags,
+            ...newFeatureFlags
+        };
+        newFeatureFlagPayloads = {
+            ...currentFlagPayloads,
+            ...newFeatureFlagPayloads
+        };
+        newFeatureFlagDetails = {
+            ...currentFlagDetails,
+            ...newFeatureFlagDetails
+        };
+    }
+    return {
+        [external_constants_js_namespaceObject.PERSISTENCE_ACTIVE_FEATURE_FLAGS]: Object.keys(filterActiveFeatureFlags(newFeatureFlags)),
+        [external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS]: newFeatureFlags || {},
+        [external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_PAYLOADS]: newFeatureFlagPayloads || {},
+        [external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_DETAILS]: newFeatureFlagDetails || {},
+        [external_constants_js_namespaceObject.PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS]: true === response.minimalFlagCalledEvents,
+        ...requestId ? {
+            [external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_REQUEST_ID]: requestId
+        } : {},
+        ...evaluatedAt ? {
+            [external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_EVALUATED_AT]: evaluatedAt
+        } : {}
+    };
+};
+const normalizeFlagsResponse = (response, responseLogger)=>{
+    const flagDetails = response['flags'];
+    if (flagDetails) {
+        const featureFlags = Object.fromEntries(Object.keys(flagDetails).map((flag)=>[
+                flag,
+                flagDetails[flag].variant ?? flagDetails[flag].enabled
+            ]));
+        const featureFlagPayloads = Object.fromEntries(Object.keys(flagDetails).filter((flag)=>flagDetails[flag].enabled).filter((flag)=>!(0, core_namespaceObject.isUndefined)(flagDetails[flag].metadata?.payload)).map((flag)=>[
+                flag,
+                flagDetails[flag].metadata?.payload
+            ]));
+        return {
+            ...response,
+            featureFlags,
+            featureFlagPayloads
+        };
+    }
+    if (response['featureFlags']) responseLogger.warn('Using an older version of the feature flags endpoint. Please upgrade your PostHog server to the latest version');
+    return response;
+};
+const QuotaLimitedResource = {
+    FeatureFlags: 'feature_flags',
+    Recordings: 'recordings'
+};
+class PostHogFeatureFlags {
+    constructor(configSource){
+        this.name = 'featureFlags';
+        this._override_warning = false;
+        this.featureFlagEventHandlers = [];
+        this._logger = logger;
+        this._baseEventProperties = {};
+        this._eventPropertiesWithFlagValues = {};
+        this._reloadingHandlers = [];
+        this._pendingReloads = new Set();
+        this._activeReloads = new Set();
+        this._hasLoadedFlags = false;
+        this._requestInFlight = false;
+        this._requestGeneration = 0;
+        this._reloadingDisabled = false;
+        this._additionalReloadRequested = false;
+        this._flagsLoadedFromRemote = false;
+        this._staleCacheRefreshTriggered = false;
+        this._consecutiveStatusZeroFailures = 0;
+        this._hadUserInteraction = false;
+        this._onOnline = ()=>{
+            const wasTripped = this._hasStatusZeroCircuitBreakerTripped();
+            this._consecutiveStatusZeroFailures = 0;
+            if (wasTripped) this.reloadFeatureFlags();
+        };
+        this._refreshIfDue = ()=>{
+            const refreshIntervalMs = this._refreshIntervalMs;
+            const dueIntervalMs = this._dueRefreshIntervalMs ?? refreshIntervalMs;
+            if ((0, core_namespaceObject.isUndefined)(refreshIntervalMs) || (0, core_namespaceObject.isUndefined)(dueIntervalMs) || this._config.remoteRequestsDisabled || !this._document || 'hidden' === this._document.visibilityState || Date.now() - (this._lastRefreshAt ?? 0) < dueIntervalMs) return;
+            this._dueRefreshIntervalMs = this._hadUserInteraction || !this._config.idleRefreshBackoff ? refreshIntervalMs : Math.min(2 * dueIntervalMs, MAX_IDLE_REFRESH_INTERVAL_MS);
+            this._hadUserInteraction = false;
+            this.reloadFeatureFlags();
+            this._scheduleNextRefresh();
+        };
+        this._onUserInteraction = ()=>{
+            if (this._hadUserInteraction && this._dueRefreshIntervalMs === this._refreshIntervalMs) return;
+            this._resumeConfiguredInterval();
+        };
+        this._onVisibilityChange = ()=>{
+            if (this._document?.visibilityState === 'visible') this._resumeConfiguredInterval();
+        };
+        this._configSource = configSource;
+    }
+    get _crossTabPersistence() {}
+    _onConfigUpdated() {
+        if (this._client) this._syncAutomaticRefresh();
+    }
+    setup(client) {
+        try {
+            this._window = "u" < typeof window ? void 0 : window;
+            this._document = "u" < typeof document ? void 0 : document;
+        } catch  {
+            this._window = void 0;
+            this._document = void 0;
+        }
+        this._initializingClient = client;
+        this._logger = client.logger.createLogger('[FeatureFlags]');
+        return (0, promise_utils_js_namespaceObject.continueWith)(client.kv.initialize(), ()=>{
+            if (this._initializingClient !== client) return;
+            this._initializingClient = void 0;
+            this._client = client;
+            this._finishSetup(client);
+        });
+    }
+    _finishSetup(client) {
+        if (this._client !== client) return;
+        if (this._window) (0, general_utils_js_namespaceObject.addEventListener)(this._window, 'online', this._onOnline);
+        this._syncAutomaticRefresh();
+        this._dynamicProperties = client.registerDynamicEventProperties(()=>this._isCacheStale() ? this._baseEventProperties : this._eventPropertiesWithFlagValues);
+        this._crossTabPersistenceUnsubscribe = this._crossTabPersistence?.onCrossTabFeatureFlagChange(()=>{
+            this._clearBootstrapState();
+            this._rebuildEventProperties();
+            this._fireFeatureFlagsCallbacks();
+        });
+        this._rebuildEventProperties();
+        return this.initialize();
+    }
+    _resumeConfiguredInterval() {
+        this._hadUserInteraction = true;
+        this._dueRefreshIntervalMs = this._refreshIntervalMs;
+        this._refreshIfDue();
+    }
+    _syncAutomaticRefresh() {
+        const configuredIntervalMs = this._config.refreshIntervalMs;
+        const refreshIntervalMs = !this._config.remoteRequestsDisabled && this._document && !(0, core_namespaceObject.isUndefined)(configuredIntervalMs) && configuredIntervalMs > 0 ? configuredIntervalMs : void 0;
+        if (!this._config.idleRefreshBackoff) this._dueRefreshIntervalMs = refreshIntervalMs;
+        if (refreshIntervalMs === this._refreshIntervalMs) return;
+        this._stopAutomaticRefresh();
+        if ((0, core_namespaceObject.isUndefined)(refreshIntervalMs)) return;
+        this._refreshIntervalMs = refreshIntervalMs;
+        this._dueRefreshIntervalMs = refreshIntervalMs;
+        this._scheduleNextRefresh();
+        if (this._document?.addEventListener) {
+            (0, general_utils_js_namespaceObject.addEventListener)(this._document, external_constants_js_namespaceObject.DOM_EVENT_VISIBILITYCHANGE, this._onVisibilityChange);
+            (0, general_utils_js_namespaceObject.eachArray)(USER_INTERACTION_EVENTS, (eventName)=>{
+                (0, general_utils_js_namespaceObject.addEventListener)(this._document, eventName, this._onUserInteraction, {
+                    capture: true
+                });
+            });
+        }
+    }
+    _scheduleNextRefresh() {
+        if ((0, core_namespaceObject.isUndefined)(this._refreshIntervalMs)) return;
+        if (!(0, core_namespaceObject.isUndefined)(this._refreshInterval)) clearInterval(this._refreshInterval);
+        this._lastRefreshAt = Date.now();
+        this._refreshInterval = setInterval(this._refreshIfDue, this._refreshIntervalMs);
+    }
+    _stopAutomaticRefresh() {
+        if (!(0, core_namespaceObject.isUndefined)(this._refreshInterval)) {
+            clearInterval(this._refreshInterval);
+            this._refreshInterval = void 0;
+            this._document?.removeEventListener?.(external_constants_js_namespaceObject.DOM_EVENT_VISIBILITYCHANGE, this._onVisibilityChange);
+            (0, general_utils_js_namespaceObject.eachArray)(USER_INTERACTION_EVENTS, (eventName)=>{
+                this._document?.removeEventListener?.(eventName, this._onUserInteraction, {
+                    capture: true
+                });
+            });
+        }
+        this._refreshIntervalMs = void 0;
+        this._dueRefreshIntervalMs = void 0;
+        this._hadUserInteraction = false;
+        this._lastRefreshAt = void 0;
+    }
+    destroy() {
+        this._dispose();
+    }
+    dispose() {
+        this._dispose();
+    }
+    _dispose() {
+        this._stopAutomaticRefresh();
+        this._requestGeneration++;
+        this._additionalReloadRequested = false;
+        this._initializingClient = void 0;
+        this._settleReloads(this._pendingReloads, 'cancelled');
+        this._settleReloads(this._activeReloads, 'cancelled');
+        if (!this._client) return;
+        this._clearDebouncer();
+        this._dynamicProperties?.dispose();
+        this._dynamicProperties = void 0;
+        this._crossTabPersistenceUnsubscribe?.();
+        this._crossTabPersistenceUnsubscribe = void 0;
+        this._reloadingHandlers = [];
+        this._window?.removeEventListener('online', this._onOnline);
+        this._client = void 0;
+    }
+    get _config() {
+        return this._configSource.get();
+    }
+    _prop(key) {
+        if (this._bootstrapState && key in this._bootstrapState) return this._bootstrapState[key];
+        return this._client?.kv.get(key);
+    }
+    _clearBootstrapState() {
+        if (!this._bootstrapState) return false;
+        this._bootstrapState = void 0;
+        return true;
+    }
+    _fallBackToPersistedFlags() {
+        if ((0, core_namespaceObject.isUndefined)(this._client?.kv.get(external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS))) return false;
+        return this._clearBootstrapState();
+    }
+    _set(properties) {
+        this._persist(()=>this._client?.kv.set(properties));
+    }
+    _markCrossTabFeatureFlagSnapshot(statePatch, response, partialResponse) {
+        if (!this._crossTabPersistence || !statePatch[external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS]) return;
+        const previousFlags = this._prop(external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS) || {};
+        const nextFlags = statePatch[external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS] || {};
+        const responseFlags = response.flags || response.featureFlags;
+        const successfulResponseFlagKeys = response.flags ? Object.entries(response.flags).filter(([, detail])=>!detail?.failed).map(([key])=>key) : [];
+        const isIncompleteResponse = !!response.errorsWhileComputingFlags && !!response.flags;
+        const ownedFlagKeys = isIncompleteResponse ? successfulResponseFlagKeys : partialResponse && !(0, core_namespaceObject.isArray)(responseFlags) ? Object.keys(responseFlags || {}) : Array.from(new Set([
+            ...Object.keys(previousFlags),
+            ...Object.keys(nextFlags)
+        ]));
+        const previousPayloads = this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_PAYLOADS) || {};
+        const nextPayloads = statePatch[external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_PAYLOADS] || {};
+        const ownedPayloadKeys = isIncompleteResponse || partialResponse ? ownedFlagKeys : Array.from(new Set([
+            ...Object.keys(previousPayloads),
+            ...Object.keys(nextPayloads)
+        ]));
+        const ownsCompleteSnapshot = !isIncompleteResponse && !partialResponse;
+        const flagOwnership = ownsCompleteSnapshot ? true : ownedFlagKeys;
+        const payloadOwnership = ownsCompleteSnapshot ? true : ownedPayloadKeys;
+        const changes = {
+            [external_constants_js_namespaceObject.PERSISTENCE_ACTIVE_FEATURE_FLAGS]: flagOwnership,
+            [external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS]: flagOwnership,
+            [external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_PAYLOADS]: payloadOwnership
+        };
+        if (statePatch[external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_DETAILS]) changes[external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_DETAILS] = flagOwnership;
+        for (const key of [
+            external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_REQUEST_ID,
+            external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_EVALUATED_AT,
+            external_constants_js_namespaceObject.PERSISTENCE_MINIMAL_FLAG_CALLED_EVENTS
+        ])if (!(0, core_namespaceObject.isUndefined)(statePatch[key])) changes[key] = true;
+        this._crossTabPersistence.markCrossTabFeatureFlagChanges(changes);
+    }
+    _remove(keys) {
+        this._persist(()=>this._client?.kv.remove(keys));
+    }
+    _persist(operation) {
+        try {
+            operation();
+        } catch (error) {
+            this._logger.error('Failed to update feature flag persistence', error);
+        }
+    }
+    _rebuildEventProperties() {
+        const common = {};
+        for (const key of [
+            external_constants_js_namespaceObject.PERSISTENCE_ACTIVE_FEATURE_FLAGS,
+            external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_PAYLOADS,
+            external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_REQUEST_ID,
+            external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS
+        ]){
+            const value = this._prop(key);
+            if (!(0, core_namespaceObject.isUndefined)(value)) common[key] = value;
+        }
+        this._baseEventProperties = common;
+        const withFlagValues = {
+            ...common
+        };
+        const flags = this._prop(external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS);
+        if (flags) for (const [key, value] of Object.entries(flags))withFlagValues[`$feature/${key}`] = value;
+        this._eventPropertiesWithFlagValues = withFlagValues;
+    }
+    _isCacheStale() {
+        const ttl = this._config.cacheTtlMs;
+        if (!ttl || ttl <= 0) return false;
+        const evaluatedAt = this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_EVALUATED_AT);
+        return 'number' != typeof evaluatedAt || Date.now() - evaluatedAt > ttl;
+    }
+    _checkAndTriggerStaleRefresh() {
+        if (!this._isCacheStale()) return false;
+        if (!this._staleCacheRefreshTriggered && !this._requestInFlight) {
+            this._staleCacheRefreshTriggered = true;
+            this._logger.warn('Feature flag cache is stale, triggering refresh...');
+            this.reloadFeatureFlags();
+        }
+        return true;
+    }
+    _getValidEvaluationEnvironments() {
+        const envs = this._config.evaluationContexts;
+        if (!envs?.length) return [];
+        return envs.filter((env)=>{
+            const isValid = env && 'string' == typeof env && env.trim().length > 0;
+            if (!isValid) this._logger.error('Invalid evaluation context found:', env, 'Expected non-empty string');
+            return isValid;
+        });
+    }
+    _getValidFlagKeys() {
+        const flagKeys = this._config.flagKeys;
+        if ((0, core_namespaceObject.isUndefined)(flagKeys)) return;
+        return flagKeys.filter((flagKey)=>{
+            const isValid = flagKey && 'string' == typeof flagKey && flagKey.trim().length > 0;
+            if (!isValid) this._logger.error('Invalid flag key found:', flagKey, 'Expected non-empty string');
+            return isValid;
+        });
+    }
+    initialize() {
+        const config = this._config;
+        const bootstrapFlags = config.bootstrap?.featureFlags ?? {};
+        const hasBootstrappedFlags = Object.keys(bootstrapFlags).length;
+        if (hasBootstrappedFlags) {
+            const bootstrapPayloads = config.bootstrap?.featureFlagPayloads ?? {};
+            const featureFlags = Object.keys(bootstrapFlags).filter((flag)=>!(0, core_namespaceObject.isUndefined)(bootstrapFlags[flag])).reduce((res, key)=>{
+                res[key] = bootstrapFlags[key];
+                return res;
+            }, {});
+            const featureFlagPayloads = Object.keys(bootstrapPayloads).filter((key)=>featureFlags[key]).reduce((res, key)=>{
+                res[key] = bootstrapPayloads[key];
+                return res;
+            }, {});
+            return this._receivedFeatureFlags({
+                featureFlags,
+                featureFlagPayloads
+            }, void 0, {
+                persist: false
+            });
+        }
+    }
+    updateFlags(flags, payloads, options) {
+        const existingFlags = options?.merge ? this._prop(external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS) ?? {} : {};
+        const existingPayloads = options?.merge ? this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_PAYLOADS) ?? {} : {};
+        const finalFlags = {
+            ...existingFlags,
+            ...flags
+        };
+        const finalPayloads = {
+            ...existingPayloads,
+            ...payloads
+        };
+        const flagDetails = {};
+        for (const [key, value] of Object.entries(finalFlags))flagDetails[key] = {
+            key,
+            enabled: (0, core_namespaceObject.getEnabledFromValue)(value),
+            variant: (0, core_namespaceObject.getVariantFromValue)(value),
+            reason: void 0,
+            metadata: (0, core_namespaceObject.isUndefined)(finalPayloads?.[key]) ? void 0 : {
+                id: 0,
+                version: void 0,
+                description: void 0,
+                payload: finalPayloads[key]
+            }
+        };
+        this._receivedFeatureFlags({
+            flags: flagDetails
+        });
+    }
+    get hasLoadedFlags() {
+        return this._hasLoadedFlags;
+    }
+    getFlags() {
+        return Object.keys(this.getFlagVariants());
+    }
+    getFlagsWithDetails() {
+        const flagDetails = this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_DETAILS);
+        const overridenFlags = this._prop(external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS);
+        const overriddenPayloads = this._prop(external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS);
+        if (!overriddenPayloads && !overridenFlags) return flagDetails || {};
+        const finalDetails = (0, general_utils_js_namespaceObject.extend)({}, flagDetails || {});
+        const overriddenKeys = [
+            ...new Set([
+                ...Object.keys(overriddenPayloads || {}),
+                ...Object.keys(overridenFlags || {})
+            ])
+        ];
+        for (const key of overriddenKeys){
+            const originalDetail = finalDetails[key];
+            const overrideFlagValue = overridenFlags?.[key];
+            const finalEnabled = (0, core_namespaceObject.isUndefined)(overrideFlagValue) ? originalDetail?.enabled ?? false : !!overrideFlagValue;
+            const overrideVariant = (0, core_namespaceObject.isUndefined)(overrideFlagValue) ? originalDetail?.variant : 'string' == typeof overrideFlagValue ? overrideFlagValue : void 0;
+            const overridePayload = overriddenPayloads?.[key];
+            const overridenDetail = {
+                ...originalDetail,
+                enabled: finalEnabled,
+                variant: finalEnabled ? overrideVariant ?? originalDetail?.variant : void 0
+            };
+            if (finalEnabled !== originalDetail?.enabled) overridenDetail.original_enabled = originalDetail?.enabled;
+            if (overrideVariant !== originalDetail?.variant) overridenDetail.original_variant = originalDetail?.variant;
+            if (overridePayload) overridenDetail.metadata = {
+                ...originalDetail?.metadata,
+                payload: overridePayload,
+                original_payload: originalDetail?.metadata?.payload
+            };
+            finalDetails[key] = overridenDetail;
+        }
+        if (!this._override_warning) {
+            this._logger.warn(' Overriding feature flag details!', {
+                flagDetails,
+                overriddenPayloads,
+                finalDetails
+            });
+            this._override_warning = true;
+        }
+        return finalDetails;
+    }
+    getAllFeatureFlags() {
+        const flagVariants = this.getFlagVariants();
+        const payloads = this.getFlagPayloads();
+        return Object.keys(flagVariants).map((key)=>{
+            const flagValue = flagVariants[key];
+            return {
+                key,
+                enabled: (0, core_namespaceObject.getEnabledFromValue)(flagValue),
+                variant: (0, core_namespaceObject.getVariantFromValue)(flagValue),
+                payload: (0, core_namespaceObject.parsePayload)(payloads[key])
+            };
+        });
+    }
+    getFlagVariants() {
+        const enabledFlags = this._prop(external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS);
+        const overriddenFlags = this._prop(external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS);
+        if (!overriddenFlags) return enabledFlags || {};
+        const finalFlags = (0, general_utils_js_namespaceObject.extend)({}, enabledFlags || {});
+        const overriddenKeys = Object.keys(overriddenFlags);
+        for(let i = 0; i < overriddenKeys.length; i++)finalFlags[overriddenKeys[i]] = overriddenFlags[overriddenKeys[i]];
+        if (!this._override_warning) {
+            this._logger.warn(' Overriding feature flags!', {
+                enabledFlags,
+                overriddenFlags,
+                finalFlags
+            });
+            this._override_warning = true;
+        }
+        return finalFlags;
+    }
+    getFlagPayloads() {
+        const flagPayloads = this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_PAYLOADS);
+        const overriddenPayloads = this._prop(external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS);
+        if (!overriddenPayloads) return flagPayloads || {};
+        const finalPayloads = (0, general_utils_js_namespaceObject.extend)({}, flagPayloads || {});
+        const overriddenKeys = Object.keys(overriddenPayloads);
+        for(let i = 0; i < overriddenKeys.length; i++)finalPayloads[overriddenKeys[i]] = overriddenPayloads[overriddenKeys[i]];
+        if (!this._override_warning) {
+            this._logger.warn(' Overriding feature flag payloads!', {
+                flagPayloads,
+                overriddenPayloads,
+                finalPayloads
+            });
+            this._override_warning = true;
+        }
+        return finalPayloads;
+    }
+    reloadFeatureFlags() {
+        if (this._reloadingDisabled || this._config.featureFlagsDisabled) return;
+        if (this._hasStatusZeroCircuitBreakerTripped()) return;
+        if (this._requestInFlight) this._additionalReloadRequested = true;
+        if (this._reloadDebouncer) return;
+        this._reloadingHandlers.slice().forEach((handler)=>{
+            try {
+                handler();
+            } catch (error) {
+                this._logger.error('Error while running feature flags reloading callback', error);
+            }
+        });
+        this._reloadDebouncer = setTimeout(()=>{
+            this._callFlagsEndpoint();
+        }, 5);
+    }
+    reloadFeatureFlagsAsync() {
+        if (!this._client || this._reloadingDisabled || this._config.featureFlagsDisabled || this._config.remoteRequestsDisabled || this._hasStatusZeroCircuitBreakerTripped()) return Promise.resolve({
+            status: 'skipped'
+        });
+        return new Promise((resolve)=>{
+            this._pendingReloads.add(resolve);
+            this.reloadFeatureFlags();
+        });
+    }
+    _settleReloads(completions, status) {
+        completions.forEach((complete)=>complete({
+                status
+            }));
+        completions.clear();
+    }
+    _clearDebouncer() {
+        clearTimeout(this._reloadDebouncer);
+        this._reloadDebouncer = void 0;
+    }
+    onReloading(handler) {
+        this._reloadingHandlers.push(handler);
+        return ()=>{
+            this._reloadingHandlers = this._reloadingHandlers.filter((entry)=>entry !== handler);
+        };
+    }
+    ensureFlagsLoaded() {
+        if (this._hasLoadedFlags || this._requestInFlight || this._reloadDebouncer) return;
+        this.reloadFeatureFlags();
+    }
+    setAnonymousDistinctId(anon_distinct_id) {
+        this.$anon_distinct_id = anon_distinct_id;
+    }
+    setReloadingPaused(isPaused) {
+        this._reloadingDisabled = isPaused;
+    }
+    resetFlagCallReported() {
+        this._remove(external_constants_js_namespaceObject.FLAG_CALL_REPORTED);
+    }
+    _callFlagsEndpoint(options) {
+        this._clearDebouncer();
+        const client = this._client;
+        if (!client || this._config.remoteRequestsDisabled || this._hasStatusZeroCircuitBreakerTripped()) return void this._settleReloads(this._pendingReloads, 'skipped');
+        if (this._requestInFlight) {
+            this._additionalReloadRequested = true;
+            return;
+        }
+        const data = {
+            token: client.projectToken,
+            distinct_id: client.distinctId,
+            groups: client.groups,
+            $anon_distinct_id: this.$anon_distinct_id,
+            person_properties: {
+                ...client.initialPersonProperties,
+                ...this._prop(external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY) || {},
+                $lib: client.library.name,
+                $lib_version: client.library.version
+            },
+            group_properties: this._prop(external_constants_js_namespaceObject.STORED_GROUP_PROPERTIES_KEY),
+            timezone: (0, timezone_js_namespaceObject.getTimezone)()
+        };
+        if (!(0, core_namespaceObject.isUndefined)(client.deviceId)) data.$device_id = client.deviceId;
+        if (options?.disableFlags || this._config.featureFlagsDisabled) data.disable_flags = true;
+        const evaluationContexts = this._getValidEvaluationEnvironments();
+        if (evaluationContexts.length) data.evaluation_contexts = evaluationContexts;
+        const flagKeys = this._getValidFlagKeys();
+        if (!(0, core_namespaceObject.isUndefined)(flagKeys)) data.flag_keys = flagKeys;
+        const isPartialFlagsResponse = this._config.onlyEvaluateSurveyFeatureFlags;
+        const path = `/flags/?v=2${isPartialFlagsResponse ? '&only_evaluate_survey_feature_flags=true' : ''}`;
+        const requestGeneration = this._requestGeneration;
+        const completions = this._pendingReloads;
+        this._pendingReloads = new Set();
+        this._activeReloads = completions;
+        this._requestInFlight = true;
+        const requestAdditionalReload = ()=>{
+            if (this._additionalReloadRequested) {
+                this._additionalReloadRequested = false;
+                this._callFlagsEndpoint();
+            }
+        };
+        const handleResponse = (response)=>{
+            const json = response.json ?? {};
+            const errorsLoading = 200 !== response.statusCode;
+            this._requestInFlight = false;
+            if (requestGeneration !== this._requestGeneration) return void requestAdditionalReload();
+            this._trackStatusZeroReachability(response.statusCode);
+            if (!errorsLoading && !this._additionalReloadRequested) this.$anon_distinct_id = void 0;
+            if (data.disable_flags && !this._additionalReloadRequested) return void this._settleReloads(completions, 'skipped');
+            this._flagsLoadedFromRemote = !errorsLoading;
+            const flagErrors = [];
+            if (response.error) flagErrors.push(response.error instanceof Error && 'AbortError' === response.error.name ? FeatureFlagError.TIMEOUT : response.error instanceof Error ? FeatureFlagError.CONNECTION_ERROR : FeatureFlagError.UNKNOWN_ERROR);
+            else if (200 !== response.statusCode) flagErrors.push(FeatureFlagError.apiError(response.statusCode));
+            if (json.errorsWhileComputingFlags) flagErrors.push(FeatureFlagError.ERRORS_WHILE_COMPUTING);
+            const isQuotaLimited = !!json.quotaLimited?.includes(QuotaLimitedResource.FeatureFlags);
+            if (isQuotaLimited) flagErrors.push(FeatureFlagError.QUOTA_LIMITED);
+            this._set({
+                [external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_ERRORS]: flagErrors
+            });
+            if (isQuotaLimited) this._logger.warn('You have hit your feature flags quota limit, and will not be able to load feature flags until the quota is reset.  Please visit https://posthog.com/docs/billing/limits-alerts to learn more.');
+            else if (!data.disable_flags) this._receivedFeatureFlags(json, errorsLoading, {
+                partialResponse: isPartialFlagsResponse
+            });
+            this._settleReloads(completions, data.disable_flags ? 'skipped' : !flagErrors.length && (json.flags || json.featureFlags) ? 'loaded' : 'error');
+            requestAdditionalReload();
+        };
+        const handleError = (error)=>{
+            this._requestInFlight = false;
+            if (requestGeneration !== this._requestGeneration) return void requestAdditionalReload();
+            this._set({
+                [external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_ERRORS]: [
+                    FeatureFlagError.CONNECTION_ERROR
+                ]
+            });
+            this._logger.error('Feature flag request failed', error);
+            if (this._fallBackToPersistedFlags()) this._fireFeatureFlagsCallbacks(true);
+            this._settleReloads(completions, 'error');
+            requestAdditionalReload();
+        };
+        let attemptsLeft = this._config.requestMaxRetries ?? 1;
+        const shouldRetry = ()=>attemptsLeft > 0 && requestGeneration === this._requestGeneration;
+        const attempt = ()=>{
+            if (requestGeneration !== this._requestGeneration || !this._client || this._config.remoteRequestsDisabled) {
+                this._requestInFlight = false;
+                this._settleReloads(completions, 'skipped');
+                requestAdditionalReload();
+                return;
+            }
+            const retryLater = ()=>{
+                attemptsLeft--;
+                setTimeout(attempt, FLAGS_RETRY_DELAY_MS);
+            };
+            try {
+                client.sendRequest(path, {
+                    target: 'flags',
+                    method: 'POST',
+                    body: data,
+                    compression: this._config.compression,
+                    sentAt: 'body',
+                    timeoutMs: this._config.requestTimeoutMs
+                }).then((response)=>{
+                    if (isRetryableFlagsResponse(response) && shouldRetry()) return void retryLater();
+                    handleResponse(response);
+                }).catch(handleError);
+            } catch (error) {
+                handleError(error);
+            }
+        };
+        attempt();
+    }
+    _hasStatusZeroCircuitBreakerTripped() {
+        return (0, request_reachability_js_namespaceObject.isStatusZeroFailureCircuitBreakerTripped)(this._consecutiveStatusZeroFailures, MAX_CONSECUTIVE_FLAGS_STATUS_ZERO_FAILURES);
+    }
+    _trackStatusZeroReachability(statusCode) {
+        this._consecutiveStatusZeroFailures = (0, request_reachability_js_namespaceObject.updateStatusZeroFailureCount)(statusCode, this._consecutiveStatusZeroFailures, MAX_CONSECUTIVE_FLAGS_STATUS_ZERO_FAILURES, ()=>this._logger.warn('Feature flag requests are failing before receiving an HTTP response; this can happen due to network issues, CORS, browser blocking, or ad blockers. Stopped refreshing feature flags; will try again when connectivity changes.'));
+    }
+    getFeatureFlag(key, options = {}) {
+        if (options.fresh && !this._flagsLoadedFromRemote) return;
+        if (!this._hasLoadedFlags && !(this.getFlags() && this.getFlags().length > 0)) return void this._logger.warn('getFeatureFlag for key "' + key + FLAG_TIMEOUT_MSG);
+        if (this._checkAndTriggerStaleRefresh()) return;
+        const result = this.getFeatureFlagResult(key, options);
+        return result?.variant ?? result?.enabled;
+    }
+    getFeatureFlagDetails(key) {
+        const details = this.getFlagsWithDetails();
+        return details[key];
+    }
+    getFeatureFlagPayload(key) {
+        const result = this.getFeatureFlagResult(key, {
+            send_event: false
+        });
+        return result?.payload;
+    }
+    getFeatureFlagResult(key, options = {}) {
+        if (options.fresh && !this._flagsLoadedFromRemote) return;
+        if (!this._hasLoadedFlags && !(this.getFlags() && this.getFlags().length > 0)) return void this._logger.warn('getFeatureFlagResult for key "' + key + FLAG_TIMEOUT_MSG);
+        if (this._checkAndTriggerStaleRefresh()) return;
+        const flagVariants = this.getFlagVariants();
+        const flagExists = key in flagVariants;
+        const flagValue = flagVariants[key];
+        const payloads = this.getFlagPayloads();
+        const payload = payloads[key];
+        const flagReportValue = String(flagValue);
+        const requestId = this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_REQUEST_ID) || void 0;
+        const evaluatedAt = this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_EVALUATED_AT) || void 0;
+        let flagCallReported = this._prop(external_constants_js_namespaceObject.FLAG_CALL_REPORTED) || {};
+        let sessionIdToPersist;
+        if (this._config.deduplicateCallsPerSession) {
+            const currentSessionId = this._client?.session.sessionId;
+            const storedSessionId = this._prop(external_constants_js_namespaceObject.FLAG_CALL_REPORTED_SESSION_ID);
+            if (currentSessionId && currentSessionId !== storedSessionId) {
+                flagCallReported = {};
+                sessionIdToPersist = currentSessionId;
+            }
+        }
+        if (!options.send_event && 'send_event' in options) {
+            if (sessionIdToPersist) this._set({
+                [external_constants_js_namespaceObject.FLAG_CALL_REPORTED]: flagCallReported,
+                [external_constants_js_namespaceObject.FLAG_CALL_REPORTED_SESSION_ID]: sessionIdToPersist
+            });
+        } else if (key in flagCallReported && flagCallReported[key].includes(flagReportValue)) {
+            if (sessionIdToPersist) this._set({
+                [external_constants_js_namespaceObject.FLAG_CALL_REPORTED]: flagCallReported,
+                [external_constants_js_namespaceObject.FLAG_CALL_REPORTED_SESSION_ID]: sessionIdToPersist
+            });
+        } else {
+            if ((0, core_namespaceObject.isArray)(flagCallReported[key])) flagCallReported[key].push(flagReportValue);
+            else flagCallReported[key] = [
+                flagReportValue
+            ];
+            this._set({
+                [external_constants_js_namespaceObject.FLAG_CALL_REPORTED]: flagCallReported,
+                ...sessionIdToPersist ? {
+                    [external_constants_js_namespaceObject.FLAG_CALL_REPORTED_SESSION_ID]: sessionIdToPersist
+                } : {}
+            });
+            const flagDetails = this.getFeatureFlagDetails(key);
+            const errors = [
+                ...this._prop(external_constants_js_namespaceObject.PERSISTENCE_FEATURE_FLAG_ERRORS) ?? []
+            ];
+            if ((0, core_namespaceObject.isUndefined)(flagValue)) errors.push(FeatureFlagError.FLAG_MISSING);
+            const properties = {
+                $feature_flag: key,
+                $feature_flag_response: flagValue,
+                $feature_flag_payload: payload ?? null,
+                $feature_flag_request_id: requestId,
+                $feature_flag_evaluated_at: evaluatedAt,
+                $feature_flag_bootstrapped_response: this._config.bootstrap?.featureFlags?.[key] ?? null,
+                $feature_flag_bootstrapped_payload: this._config.bootstrap?.featureFlagPayloads?.[key] ?? null,
+                $used_bootstrap_value: !this._flagsLoadedFromRemote
+            };
+            if (!(0, core_namespaceObject.isUndefined)(flagDetails?.metadata?.has_experiment)) properties.$feature_flag_has_experiment = flagDetails.metadata.has_experiment;
+            if (!(0, core_namespaceObject.isUndefined)(flagDetails?.metadata?.version)) properties.$feature_flag_version = flagDetails.metadata.version;
+            const reason = flagDetails?.reason?.description ?? flagDetails?.reason?.code;
+            if (reason) properties.$feature_flag_reason = reason;
+            if (flagDetails?.metadata?.id) properties.$feature_flag_id = flagDetails.metadata.id;
+            if (!(0, core_namespaceObject.isUndefined)(flagDetails?.original_variant) || !(0, core_namespaceObject.isUndefined)(flagDetails?.original_enabled)) properties.$feature_flag_original_response = (0, core_namespaceObject.isUndefined)(flagDetails.original_variant) ? flagDetails.original_enabled : flagDetails.original_variant;
+            if (flagDetails?.metadata?.original_payload) properties.$feature_flag_original_payload = flagDetails?.metadata?.original_payload;
+            if (errors.length) properties.$feature_flag_error = errors.join(',');
+            this._captureFeatureFlagCalled(properties);
+        }
+        if (!flagExists) return;
+        return {
+            key,
+            enabled: !!flagValue,
+            variant: 'string' == typeof flagValue ? flagValue : void 0,
+            payload: (0, core_namespaceObject.parsePayload)(payload)
+        };
+    }
+    _captureFeatureFlagCalled(properties) {
+        try {
+            this._client?.capture('$feature_flag_called', properties);
+        } catch (error) {
+            this._logger.error('Failed to capture feature flag call', error);
+        }
+    }
+    getRemoteConfigPayload(key, callback) {
+        this._getRemoteConfigPayload(key, callback);
+    }
+    async _getRemoteConfigPayload(key, callback) {
+        const client = this._client;
+        if (!client) return;
+        const data = {
+            distinct_id: client.distinctId,
+            token: client.projectToken,
+            person_properties: {
+                $lib: client.library.name,
+                $lib_version: client.library.version
+            }
+        };
+        const evaluationContexts = this._getValidEvaluationEnvironments();
+        if (evaluationContexts.length) data.evaluation_contexts = evaluationContexts;
+        const flagKeys = this._getValidFlagKeys();
+        if (!(0, core_namespaceObject.isUndefined)(flagKeys)) data.flag_keys = flagKeys;
+        let payload;
+        try {
+            const response = await client.sendRequest('/flags/?v=2', {
+                target: 'flags',
+                method: 'POST',
+                body: data,
+                compression: this._config.compression,
+                sentAt: 'body',
+                timeoutMs: this._config.requestTimeoutMs
+            });
+            const payloads = response.json?.featureFlagPayloads;
+            payload = payloads?.[key] || void 0;
+        } catch (error) {
+            this._logger.error('Remote config feature flag request failed', error);
+            return;
+        }
+        try {
+            callback(payload);
+        } catch (error) {
+            this._logger.error('Remote config feature flag callback failed', error);
+        }
+    }
+    isFeatureEnabled(key, options = {}) {
+        if (options.fresh && !this._flagsLoadedFromRemote) return options.defaultValue;
+        if (!this._hasLoadedFlags && !(this.getFlags() && this.getFlags().length > 0)) {
+            this._logger.warn('isFeatureEnabled for key "' + key + FLAG_TIMEOUT_MSG);
+            return options.defaultValue;
+        }
+        const flagValue = this.getFeatureFlag(key, options);
+        return (0, core_namespaceObject.isUndefined)(flagValue) ? options.defaultValue : !!flagValue;
+    }
+    addFeatureFlagsHandler(handler) {
+        this.featureFlagEventHandlers.push(handler);
+    }
+    removeFeatureFlagsHandler(handler) {
+        this.featureFlagEventHandlers = this.featureFlagEventHandlers.filter((h)=>h !== handler);
+    }
+    receivedFeatureFlags(response, errorsLoading, options) {
+        this._receivedFeatureFlags(response, errorsLoading, options);
+    }
+    _receivedFeatureFlags(response, errorsLoading, options) {
+        if (!this._client) return;
+        this._hasLoadedFlags = true;
+        const currentFlags = this.getFlagVariants();
+        const currentFlagPayloads = this.getFlagPayloads();
+        const currentFlagDetails = this.getFlagsWithDetails();
+        const statePatch = parseFlagsResponse(response, currentFlags, currentFlagPayloads, currentFlagDetails, options, this._logger);
+        if (statePatch) if (options?.persist === false) {
+            const hasPersistedFlags = !(0, core_namespaceObject.isUndefined)(this._client.kv.get(external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS));
+            this._bootstrapState = statePatch;
+            if (!hasPersistedFlags) this._set(statePatch);
+        } else {
+            this._clearBootstrapState();
+            this._markCrossTabFeatureFlagSnapshot(statePatch, response, !!options?.partialResponse);
+            this._set(statePatch);
+        }
+        else if (errorsLoading) this._fallBackToPersistedFlags();
+        if (!errorsLoading) this._staleCacheRefreshTriggered = false;
+        this._fireFeatureFlagsCallbacks(errorsLoading);
+    }
+    override(flags, suppressWarning = false) {
+        this._logger.warn('override is deprecated. Please use overrideFeatureFlags instead.');
+        this.overrideFeatureFlags({
+            flags: flags,
+            suppressWarning: suppressWarning
+        });
+    }
+    overrideFeatureFlags(overrideOptions) {
+        this._overrideFeatureFlags(overrideOptions);
+    }
+    _overrideFeatureFlags(overrideOptions) {
+        if (!this._client) return void this._logger.warn('posthog.featureFlags.overrideFeatureFlags called before feature flags were ready');
+        if (false === overrideOptions) {
+            this._remove([
+                external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS,
+                external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS
+            ]);
+            this._fireFeatureFlagsCallbacks();
+            forceDebugLogger.info('All overrides cleared');
+            return;
+        }
+        if ((0, core_namespaceObject.isArray)(overrideOptions)) {
+            this._set({
+                [external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS]: arrayToFlagsRecord(overrideOptions)
+            });
+            this._fireFeatureFlagsCallbacks();
+            forceDebugLogger.info('Flag overrides set', {
+                flags: overrideOptions
+            });
+            return;
+        }
+        if (overrideOptions && 'object' == typeof overrideOptions && ('flags' in overrideOptions || 'payloads' in overrideOptions)) {
+            const options = overrideOptions;
+            this._override_warning = Boolean(options.suppressWarning ?? false);
+            const statePatch = {};
+            const flags = options.flags;
+            const payloads = options.payloads;
+            if (flags) statePatch[external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS] = (0, core_namespaceObject.isArray)(flags) ? arrayToFlagsRecord(flags) : flags;
+            if (payloads) statePatch[external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS] = payloads;
+            if (Object.keys(statePatch).length) this._set(statePatch);
+            if (false === flags && false === payloads) this._remove([
+                external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS,
+                external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS
+            ]);
+            else if (false === flags) this._remove(external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS);
+            else if (false === payloads) this._remove(external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAG_PAYLOADS);
+            this._fireFeatureFlagsCallbacks();
+            if (false === flags) forceDebugLogger.info('Flag overrides cleared');
+            else if (flags) forceDebugLogger.info('Flag overrides set', {
+                flags
+            });
+            if (false === payloads) forceDebugLogger.info('Payload overrides cleared');
+            else if (payloads) forceDebugLogger.info('Payload overrides set', {
+                payloads
+            });
+            return;
+        }
+        if (overrideOptions && 'object' == typeof overrideOptions) {
+            this._set({
+                [external_constants_js_namespaceObject.PERSISTENCE_OVERRIDE_FEATURE_FLAGS]: overrideOptions
+            });
+            this._fireFeatureFlagsCallbacks();
+            forceDebugLogger.info('Flag overrides set', {
+                flags: overrideOptions
+            });
+            return;
+        }
+        this._logger.warn('Invalid overrideOptions provided to overrideFeatureFlags', {
+            overrideOptions
+        });
+    }
+    onFeatureFlags(callback) {
+        this.addFeatureFlagsHandler(callback);
+        if (this._hasLoadedFlags) {
+            const { flags, flagVariants } = this._prepareFeatureFlagsForCallbacks();
+            try {
+                callback(flags, flagVariants);
+            } catch (error) {
+                this._logger.error('Error while running feature flags callback', error);
+            }
+        }
+        return ()=>this.removeFeatureFlagsHandler(callback);
+    }
+    updateEarlyAccessFeatureEnrollment(key, isEnrolled, stage) {
+        const existing_early_access_features = this._prop(external_constants_js_namespaceObject.PERSISTENCE_EARLY_ACCESS_FEATURES) || [];
+        const feature = existing_early_access_features.find((f)=>f.flagKey === key);
+        const enrollmentPersonProp = {
+            [`$feature_enrollment/${key}`]: isEnrolled
+        };
+        const properties = {
+            $feature_flag: key,
+            $feature_enrollment: isEnrolled,
+            $set: enrollmentPersonProp
+        };
+        if (feature) properties['$early_access_feature_name'] = feature.name;
+        if (stage) properties['$feature_enrollment_stage'] = stage;
+        const newFlags = {
+            ...this.getFlagVariants(),
+            [key]: isEnrolled
+        };
+        this._crossTabPersistence?.markCrossTabFeatureFlagChanges({
+            [external_constants_js_namespaceObject.PERSISTENCE_ACTIVE_FEATURE_FLAGS]: [
+                key
+            ],
+            [external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS]: [
+                key
+            ],
+            [external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY]: Object.keys(enrollmentPersonProp)
+        });
+        this._set({
+            [external_constants_js_namespaceObject.PERSISTENCE_ACTIVE_FEATURE_FLAGS]: Object.keys(filterActiveFeatureFlags(newFlags)),
+            [external_constants_js_namespaceObject.ENABLED_FEATURE_FLAGS]: newFlags,
+            [external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY]: {
+                ...this._prop(external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY) || {},
+                ...enrollmentPersonProp
+            }
+        });
+        this._fireFeatureFlagsCallbacks();
+        try {
+            this._client?.capture('$feature_enrollment_update', properties);
+        } catch (error) {
+            this._logger.error('Failed to capture early access feature enrollment', error);
+        }
+    }
+    getEarlyAccessFeatures(callback, force_reload = false, stages) {
+        const existing_early_access_features = this._prop(external_constants_js_namespaceObject.PERSISTENCE_EARLY_ACCESS_FEATURES);
+        if (existing_early_access_features && !force_reload) return void callback(existing_early_access_features);
+        this._getEarlyAccessFeatures(callback, stages);
+    }
+    async _getEarlyAccessFeatures(callback, stages) {
+        const client = this._client;
+        if (!client) return;
+        const stageParams = stages ? `&${stages.map((s)=>`stage=${s}`).join('&')}` : '';
+        let earlyAccessFeatures;
+        try {
+            const response = await client.sendRequest(`/api/early_access_features/?token=${client.projectToken}${stageParams}`, {
+                target: 'api',
+                method: 'GET',
+                sentAt: 'query'
+            });
+            if (!response.json) return;
+            earlyAccessFeatures = response.json.earlyAccessFeatures;
+            this._set({
+                [external_constants_js_namespaceObject.PERSISTENCE_EARLY_ACCESS_FEATURES]: earlyAccessFeatures
+            });
+        } catch (error) {
+            this._logger.error('Early access feature request failed', error);
+            return;
+        }
+        try {
+            callback(earlyAccessFeatures);
+        } catch (error) {
+            this._logger.error('Early access feature callback failed', error);
+        }
+    }
+    _prepareFeatureFlagsForCallbacks() {
+        const flags = this.getFlags();
+        const flagVariants = this.getFlagVariants();
+        const truthyFlags = flags.filter((flag)=>flagVariants[flag]);
+        const truthyFlagVariants = Object.keys(flagVariants).filter((variantKey)=>flagVariants[variantKey]).reduce((res, key)=>{
+            res[key] = flagVariants[key];
+            return res;
+        }, {});
+        return {
+            flags: truthyFlags,
+            flagVariants: truthyFlagVariants
+        };
+    }
+    _fireFeatureFlagsCallbacks(errorsLoading) {
+        this._rebuildEventProperties();
+        const { flags, flagVariants } = this._prepareFeatureFlagsForCallbacks();
+        this.featureFlagEventHandlers.forEach((handler)=>{
+            try {
+                handler(flags, flagVariants, {
+                    errorsLoading
+                });
+            } catch (error) {
+                this._logger.error('Error while running feature flags callback', error);
+            }
+        });
+    }
+    setPersonPropertiesForFlags(properties, reloadFeatureFlags = true) {
+        this._setPersonPropertiesForFlags(properties, reloadFeatureFlags);
+    }
+    _setPersonPropertiesForFlags(properties, reloadFeatureFlags = true) {
+        const existingProperties = this._prop(external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY) || {};
+        const propsToSet = properties?.['$set'] || (properties?.['$set_once'] ? {} : properties);
+        const propsToSetOnce = properties?.['$set_once'];
+        const setOnceProps = {};
+        if (propsToSetOnce) {
+            for(const key in propsToSetOnce)if (Object.prototype.hasOwnProperty.call(propsToSetOnce, key)) {
+                if (!(key in existingProperties)) setOnceProps[key] = propsToSetOnce[key];
+            }
+        }
+        this._set({
+            [external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY]: {
+                ...existingProperties,
+                ...setOnceProps,
+                ...propsToSet
+            }
+        });
+        if (reloadFeatureFlags) this.reloadFeatureFlags();
+    }
+    unsetPersonPropertiesForFlags(propertyNames, reloadFeatureFlags = true) {
+        const existingProperties = this._prop(external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY) || {};
+        const nextProperties = {
+            ...existingProperties
+        };
+        propertyNames.forEach((name)=>{
+            delete nextProperties[name];
+        });
+        this._set({
+            [external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY]: nextProperties
+        });
+        if (reloadFeatureFlags) this.reloadFeatureFlags();
+    }
+    resetPersonPropertiesForFlags(reloadFeatureFlags = true) {
+        this._remove(external_constants_js_namespaceObject.STORED_PERSON_PROPERTIES_KEY);
+        if (reloadFeatureFlags) this.reloadFeatureFlags();
+    }
+    setGroupPropertiesForFlags(properties, reloadFeatureFlags = true) {
+        const existingProperties = this._prop(external_constants_js_namespaceObject.STORED_GROUP_PROPERTIES_KEY) || {};
+        const nextProperties = {
+            ...existingProperties
+        };
+        for (const groupType of Object.keys(properties))nextProperties[groupType] = {
+            ...existingProperties[groupType],
+            ...properties[groupType]
+        };
+        this._set({
+            [external_constants_js_namespaceObject.STORED_GROUP_PROPERTIES_KEY]: nextProperties
+        });
+        if (reloadFeatureFlags) this.reloadFeatureFlags();
+    }
+    resetGroupPropertiesForFlags(group_type) {
+        if (group_type) {
+            const existingProperties = this._prop(external_constants_js_namespaceObject.STORED_GROUP_PROPERTIES_KEY) || {};
+            this._set({
+                [external_constants_js_namespaceObject.STORED_GROUP_PROPERTIES_KEY]: {
+                    ...existingProperties,
+                    [group_type]: {}
+                }
+            });
+        } else this._remove(external_constants_js_namespaceObject.STORED_GROUP_PROPERTIES_KEY);
+    }
+    reset() {
+        this._requestGeneration++;
+        this._settleReloads(this._pendingReloads, 'cancelled');
+        this._settleReloads(this._activeReloads, 'cancelled');
+        this._additionalReloadRequested = false;
+        this._baseEventProperties = {};
+        this._eventPropertiesWithFlagValues = {};
+        this._bootstrapState = void 0;
+        this._hasLoadedFlags = false;
+        this._reloadingDisabled = false;
+        this._flagsLoadedFromRemote = false;
+        this.$anon_distinct_id = void 0;
+        this._clearDebouncer();
+        this._override_warning = false;
+        this._consecutiveStatusZeroFailures = 0;
+    }
+}
+exports.FeatureFlagError = __webpack_exports__.FeatureFlagError;
+exports.PostHogFeatureFlags = __webpack_exports__.PostHogFeatureFlags;
+exports.QuotaLimitedResource = __webpack_exports__.QuotaLimitedResource;
+exports.filterActiveFeatureFlags = __webpack_exports__.filterActiveFeatureFlags;
+exports.parseFlagsResponse = __webpack_exports__.parseFlagsResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FeatureFlagError",
+    "PostHogFeatureFlags",
+    "QuotaLimitedResource",
+    "filterActiveFeatureFlags",
+    "parseFlagsResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});