posthog-react-native 3.13.2 → 3.15.0

package/lib/index.esm.js

@@ -0,0 +1,4659 @@
+import { Platform, AppState, Dimensions, Linking, View, StyleSheet, TouchableOpacity, Text, TextInput, Pressable, ScrollView, Modal, KeyboardAvoidingView, TouchableWithoutFeedback, Keyboard } from 'react-native';
+import React, { useCallback, useEffect, useState, useMemo } from 'react';
+import { Svg, Path } from 'react-native-svg';
+
+var PostHogPersistedProperty;
+(function (PostHogPersistedProperty) {
+    PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
+    PostHogPersistedProperty["DistinctId"] = "distinct_id";
+    PostHogPersistedProperty["Props"] = "props";
+    PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
+    PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
+    PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
+    PostHogPersistedProperty["BootstrapFeatureFlagDetails"] = "bootstrap_feature_flag_details";
+    PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
+    PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
+    PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
+    PostHogPersistedProperty["Queue"] = "queue";
+    PostHogPersistedProperty["OptedOut"] = "opted_out";
+    PostHogPersistedProperty["SessionId"] = "session_id";
+    PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
+    PostHogPersistedProperty["PersonProperties"] = "person_properties";
+    PostHogPersistedProperty["GroupProperties"] = "group_properties";
+    PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
+    PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
+    PostHogPersistedProperty["SessionReplay"] = "session_replay";
+    PostHogPersistedProperty["DecideEndpointWasHit"] = "decide_endpoint_was_hit";
+    PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
+    PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
+    PostHogPersistedProperty["Surveys"] = "surveys";
+    PostHogPersistedProperty["RemoteConfig"] = "remote_config";
+})(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
+var SurveyPosition;
+(function (SurveyPosition) {
+    SurveyPosition["Left"] = "left";
+    SurveyPosition["Right"] = "right";
+    SurveyPosition["Center"] = "center";
+})(SurveyPosition || (SurveyPosition = {}));
+var SurveyWidgetType;
+(function (SurveyWidgetType) {
+    SurveyWidgetType["Button"] = "button";
+    SurveyWidgetType["Tab"] = "tab";
+    SurveyWidgetType["Selector"] = "selector";
+})(SurveyWidgetType || (SurveyWidgetType = {}));
+var SurveyType;
+(function (SurveyType) {
+    SurveyType["Popover"] = "popover";
+    SurveyType["API"] = "api";
+    SurveyType["Widget"] = "widget";
+})(SurveyType || (SurveyType = {}));
+var SurveyQuestionDescriptionContentType;
+(function (SurveyQuestionDescriptionContentType) {
+    SurveyQuestionDescriptionContentType["Html"] = "html";
+    SurveyQuestionDescriptionContentType["Text"] = "text";
+})(SurveyQuestionDescriptionContentType || (SurveyQuestionDescriptionContentType = {}));
+var SurveyRatingDisplay;
+(function (SurveyRatingDisplay) {
+    SurveyRatingDisplay["Number"] = "number";
+    SurveyRatingDisplay["Emoji"] = "emoji";
+})(SurveyRatingDisplay || (SurveyRatingDisplay = {}));
+var SurveyQuestionType;
+(function (SurveyQuestionType) {
+    SurveyQuestionType["Open"] = "open";
+    SurveyQuestionType["MultipleChoice"] = "multiple_choice";
+    SurveyQuestionType["SingleChoice"] = "single_choice";
+    SurveyQuestionType["Rating"] = "rating";
+    SurveyQuestionType["Link"] = "link";
+})(SurveyQuestionType || (SurveyQuestionType = {}));
+var SurveyQuestionBranchingType;
+(function (SurveyQuestionBranchingType) {
+    SurveyQuestionBranchingType["NextQuestion"] = "next_question";
+    SurveyQuestionBranchingType["End"] = "end";
+    SurveyQuestionBranchingType["ResponseBased"] = "response_based";
+    SurveyQuestionBranchingType["SpecificQuestion"] = "specific_question";
+})(SurveyQuestionBranchingType || (SurveyQuestionBranchingType = {}));
+var SurveyMatchType;
+(function (SurveyMatchType) {
+    SurveyMatchType["Regex"] = "regex";
+    SurveyMatchType["NotRegex"] = "not_regex";
+    SurveyMatchType["Exact"] = "exact";
+    SurveyMatchType["IsNot"] = "is_not";
+    SurveyMatchType["Icontains"] = "icontains";
+    SurveyMatchType["NotIcontains"] = "not_icontains";
+})(SurveyMatchType || (SurveyMatchType = {}));
+/** Sync with plugin-server/src/types.ts */
+var ActionStepStringMatching;
+(function (ActionStepStringMatching) {
+    ActionStepStringMatching["Contains"] = "contains";
+    ActionStepStringMatching["Exact"] = "exact";
+    ActionStepStringMatching["Regex"] = "regex";
+})(ActionStepStringMatching || (ActionStepStringMatching = {}));
+
+const normalizeDecideResponse = (decideResponse) => {
+    var _a;
+    if ('flags' in decideResponse) {
+        // Convert v4 format to v3 format
+        const featureFlags = getFlagValuesFromFlags(decideResponse.flags);
+        const featureFlagPayloads = getPayloadsFromFlags(decideResponse.flags);
+        return {
+            ...decideResponse,
+            featureFlags,
+            featureFlagPayloads,
+        };
+    }
+    else {
+        // Convert v3 format to v4 format
+        const featureFlags = (_a = decideResponse.featureFlags) !== null && _a !== void 0 ? _a : {};
+        const featureFlagPayloads = Object.fromEntries(Object.entries(decideResponse.featureFlagPayloads || {}).map(([k, v]) => [k, parsePayload(v)]));
+        const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value]) => [
+            key,
+            getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key]),
+        ]));
+        return {
+            ...decideResponse,
+            featureFlags,
+            featureFlagPayloads,
+            flags,
+        };
+    }
+};
+function getFlagDetailFromFlagAndPayload(key, value, payload) {
+    return {
+        key: key,
+        enabled: typeof value === 'string' ? true : value,
+        variant: typeof value === 'string' ? value : undefined,
+        reason: undefined,
+        metadata: {
+            id: undefined,
+            version: undefined,
+            payload: payload ? JSON.stringify(payload) : undefined,
+            description: undefined,
+        },
+    };
+}
+/**
+ * Get the flag values from the flags v4 response.
+ * @param flags - The flags
+ * @returns The flag values
+ */
+const getFlagValuesFromFlags = (flags) => {
+    return Object.fromEntries(Object.entries(flags !== null && flags !== void 0 ? flags : {})
+        .map(([key, detail]) => [key, getFeatureFlagValue(detail)])
+        .filter(([, value]) => value !== undefined));
+};
+/**
+ * Get the payloads from the flags v4 response.
+ * @param flags - The flags
+ * @returns The payloads
+ */
+const getPayloadsFromFlags = (flags) => {
+    const safeFlags = flags !== null && flags !== void 0 ? flags : {};
+    return Object.fromEntries(Object.keys(safeFlags)
+        .filter((flag) => {
+        const details = safeFlags[flag];
+        return details.enabled && details.metadata && details.metadata.payload !== undefined;
+    })
+        .map((flag) => {
+        var _a;
+        const payload = (_a = safeFlags[flag].metadata) === null || _a === void 0 ? void 0 : _a.payload;
+        return [flag, payload ? parsePayload(payload) : undefined];
+    }));
+};
+const getFeatureFlagValue = (detail) => {
+    var _a;
+    return detail === undefined ? undefined : (_a = detail.variant) !== null && _a !== void 0 ? _a : detail.enabled;
+};
+const parsePayload = (response) => {
+    if (typeof response !== 'string') {
+        return response;
+    }
+    try {
+        return JSON.parse(response);
+    }
+    catch (_a) {
+        return response;
+    }
+};
+/**
+ * Get the normalized flag details from the flags and payloads.
+ * This is used to convert things like boostrap and stored feature flags and payloads to the v4 format.
+ * This helps us ensure backwards compatibility.
+ * If a key exists in the featureFlagPayloads that is not in the featureFlags, we treat it as a true feature flag.
+ *
+ * @param featureFlags - The feature flags
+ * @param featureFlagPayloads - The feature flag payloads
+ * @returns The normalized flag details
+ */
+const createDecideResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads) => {
+    // If a feature flag payload key is not in the feature flags, we treat it as true feature flag.
+    const allKeys = [...new Set([...Object.keys(featureFlags !== null && featureFlags !== void 0 ? featureFlags : {}), ...Object.keys(featureFlagPayloads !== null && featureFlagPayloads !== void 0 ? featureFlagPayloads : {})])];
+    const enabledFlags = allKeys
+        .filter((flag) => !!featureFlags[flag] || !!featureFlagPayloads[flag])
+        .reduce((res, key) => { var _a; return ((res[key] = (_a = featureFlags[key]) !== null && _a !== void 0 ? _a : true), res); }, {});
+    const flagDetails = {
+        featureFlags: enabledFlags,
+        featureFlagPayloads: featureFlagPayloads !== null && featureFlagPayloads !== void 0 ? featureFlagPayloads : {},
+    };
+    return normalizeDecideResponse(flagDetails);
+};
+const updateFlagValue = (flag, value) => {
+    return {
+        ...flag,
+        enabled: getEnabledFromValue(value),
+        variant: getVariantFromValue(value),
+    };
+};
+function getEnabledFromValue(value) {
+    return typeof value === 'string' ? true : value;
+}
+function getVariantFromValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+
+// Rollout constants
+const NEW_FLAGS_ROLLOUT_PERCENTAGE = 1;
+// The fnv1a hashes of the tokens that are explicitly excluded from the rollout
+// see https://github.com/PostHog/posthog-js-lite/blob/main/posthog-core/src/utils.ts#L84
+// are hashed API tokens from our top 10 for each category supported by this SDK.
+const NEW_FLAGS_EXCLUDED_HASHES = new Set([
+    // Node
+    '61be3dd8',
+    '96f6df5f',
+    '8cfdba9b',
+    'bf027177',
+    'e59430a8',
+    '7fa5500b',
+    '569798e9',
+    '04809ff7',
+    '0ebc61a5',
+    '32de7f98',
+    '3beeb69a',
+    '12d34ad9',
+    '733853ec',
+    '0645bb64',
+    '5dcbee21',
+    'b1f95fa3',
+    '2189e408',
+    '82b460c2',
+    '3a8cc979',
+    '29ef8843',
+    '2cdbf767',
+    '38084b54',
+    // React Native
+    '50f9f8de',
+    '41d0df91',
+    '5c236689',
+    'c11aedd3',
+    'ada46672',
+    'f4331ee1',
+    '42fed62a',
+    'c957462c',
+    'd62f705a',
+    // Web (lots of teams per org, hence lots of API tokens)
+    'e0162666',
+    '01b3e5cf',
+    '441cef7f',
+    'bb9cafee',
+    '8f348eb0',
+    'b2553f3a',
+    '97469d7d',
+    '39f21a76',
+    '03706dcc',
+    '27d50569',
+    '307584a7',
+    '6433e92e',
+    '150c7fbb',
+    '49f57f22',
+    '3772f65b',
+    '01eb8256',
+    '3c9e9234',
+    'f853c7f7',
+    'c0ac4b67',
+    'cd609d40',
+    '10ca9b1a',
+    '8a87f11b',
+    '8e8e5216',
+    '1f6b63b3',
+    'db7943dd',
+    '79b7164c',
+    '07f78e33',
+    '2d21b6fd',
+    '952db5ee',
+    'a7d3b43f',
+    '1924dd9c',
+    '84e1b8f6',
+    'dff631b6',
+    'c5aa8a79',
+    'fa133a95',
+    '498a4508',
+    '24748755',
+    '98f3d658',
+    '21bbda67',
+    '7dbfed69',
+    'be3ec24c',
+    'fc80b8e2',
+    '75cc0998',
+]);
+function assert(truthyValue, message) {
+    if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
+        throw new Error(message);
+    }
+}
+function isEmpty(truthyValue) {
+    if (truthyValue.trim().length === 0) {
+        return true;
+    }
+    return false;
+}
+function removeTrailingSlash(url) {
+    return url === null || url === void 0 ? void 0 : url.replace(/\/+$/, '');
+}
+async function retriable(fn, props) {
+    let lastError = null;
+    for (let i = 0; i < props.retryCount + 1; i++) {
+        if (i > 0) {
+            // don't wait when it's the last try
+            await new Promise((r) => setTimeout(r, props.retryDelay));
+        }
+        try {
+            const res = await fn();
+            return res;
+        }
+        catch (e) {
+            lastError = e;
+            if (!props.retryCheck(e)) {
+                throw e;
+            }
+        }
+    }
+    throw lastError;
+}
+function currentTimestamp() {
+    return new Date().getTime();
+}
+function currentISOTime() {
+    return new Date().toISOString();
+}
+function safeSetTimeout(fn, timeout) {
+    // NOTE: we use this so rarely that it is totally fine to do `safeSetTimeout(fn, 0)``
+    // rather than setImmediate.
+    const t = setTimeout(fn, timeout);
+    // We unref if available to prevent Node.js hanging on exit
+    (t === null || t === void 0 ? void 0 : t.unref) && (t === null || t === void 0 ? void 0 : t.unref());
+    return t;
+}
+// NOTE: We opt for this slightly imperfect check as the global "Promise" object can get mutated in certain environments
+const isPromise = (obj) => {
+    return obj && typeof obj.then === 'function';
+};
+const isError = (x) => {
+    return x instanceof Error;
+};
+// FNV-1a hash function
+// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+// I know, I know, I'm rolling my own hash function, but I didn't want to take on
+// a crypto dependency and this is just temporary anyway
+function fnv1a(str) {
+    let hash = 0x811c9dc5; // FNV offset basis
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    // Convert to hex string, padding to 8 chars
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function isTokenInRollout(token, percentage = 0, excludedHashes) {
+    const tokenHash = fnv1a(token);
+    // Check excluded hashes (we're explicitly including these tokens from the rollout)
+    if (excludedHashes === null || excludedHashes === void 0 ? void 0 : excludedHashes.has(tokenHash)) {
+        return false;
+    }
+    // Convert hash to int and divide by max value to get number between 0-1
+    const hashInt = parseInt(tokenHash, 16);
+    const hashFloat = hashInt / 0xffffffff;
+    return hashFloat < percentage;
+}
+
+// Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
+// This work is free. You can redistribute it and/or modify it
+// under the terms of the WTFPL, Version 2
+// For more information see LICENSE.txt or http://www.wtfpl.net/
+//
+// For more information, the home page:
+// http://pieroxy.net/blog/pages/lz-string/testing.html
+//
+// LZ-based compression algorithm, version 1.4.4
+// private property
+const f = String.fromCharCode;
+const keyStrBase64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+const baseReverseDic = {};
+function getBaseValue(alphabet, character) {
+    if (!baseReverseDic[alphabet]) {
+        baseReverseDic[alphabet] = {};
+        for (let i = 0; i < alphabet.length; i++) {
+            baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+        }
+    }
+    return baseReverseDic[alphabet][character];
+}
+const LZString = {
+    compressToBase64: function (input) {
+        if (input == null) {
+            return '';
+        }
+        const res = LZString._compress(input, 6, function (a) {
+            return keyStrBase64.charAt(a);
+        });
+        switch (res.length % 4 // To produce valid Base64
+        ) {
+            default: // When could this happen ?
+            case 0:
+                return res;
+            case 1:
+                return res + '===';
+            case 2:
+                return res + '==';
+            case 3:
+                return res + '=';
+        }
+    },
+    decompressFromBase64: function (input) {
+        if (input == null) {
+            return '';
+        }
+        if (input == '') {
+            return null;
+        }
+        return LZString._decompress(input.length, 32, function (index) {
+            return getBaseValue(keyStrBase64, input.charAt(index));
+        });
+    },
+    compress: function (uncompressed) {
+        return LZString._compress(uncompressed, 16, function (a) {
+            return f(a);
+        });
+    },
+    _compress: function (uncompressed, bitsPerChar, getCharFromInt) {
+        if (uncompressed == null) {
+            return '';
+        }
+        const context_dictionary = {}, context_dictionaryToCreate = {}, context_data = [];
+        let i, value, context_c = '', context_wc = '', context_w = '', context_enlargeIn = 2, // Compensate for the first entry which should not count
+        context_dictSize = 3, context_numBits = 2, context_data_val = 0, context_data_position = 0, ii;
+        for (ii = 0; ii < uncompressed.length; ii += 1) {
+            context_c = uncompressed.charAt(ii);
+            if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+                context_dictionary[context_c] = context_dictSize++;
+                context_dictionaryToCreate[context_c] = true;
+            }
+            context_wc = context_w + context_c;
+            if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
+                context_w = context_wc;
+            }
+            else {
+                if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+                    if (context_w.charCodeAt(0) < 256) {
+                        for (i = 0; i < context_numBits; i++) {
+                            context_data_val = context_data_val << 1;
+                            if (context_data_position == bitsPerChar - 1) {
+                                context_data_position = 0;
+                                context_data.push(getCharFromInt(context_data_val));
+                                context_data_val = 0;
+                            }
+                            else {
+                                context_data_position++;
+                            }
+                        }
+                        value = context_w.charCodeAt(0);
+                        for (i = 0; i < 8; i++) {
+                            context_data_val = (context_data_val << 1) | (value & 1);
+                            if (context_data_position == bitsPerChar - 1) {
+                                context_data_position = 0;
+                                context_data.push(getCharFromInt(context_data_val));
+                                context_data_val = 0;
+                            }
+                            else {
+                                context_data_position++;
+                            }
+                            value = value >> 1;
+                        }
+                    }
+                    else {
+                        value = 1;
+                        for (i = 0; i < context_numBits; i++) {
+                            context_data_val = (context_data_val << 1) | value;
+                            if (context_data_position == bitsPerChar - 1) {
+                                context_data_position = 0;
+                                context_data.push(getCharFromInt(context_data_val));
+                                context_data_val = 0;
+                            }
+                            else {
+                                context_data_position++;
+                            }
+                            value = 0;
+                        }
+                        value = context_w.charCodeAt(0);
+                        for (i = 0; i < 16; i++) {
+                            context_data_val = (context_data_val << 1) | (value & 1);
+                            if (context_data_position == bitsPerChar - 1) {
+                                context_data_position = 0;
+                                context_data.push(getCharFromInt(context_data_val));
+                                context_data_val = 0;
+                            }
+                            else {
+                                context_data_position++;
+                            }
+                            value = value >> 1;
+                        }
+                    }
+                    context_enlargeIn--;
+                    if (context_enlargeIn == 0) {
+                        context_enlargeIn = Math.pow(2, context_numBits);
+                        context_numBits++;
+                    }
+                    delete context_dictionaryToCreate[context_w];
+                }
+                else {
+                    value = context_dictionary[context_w];
+                    for (i = 0; i < context_numBits; i++) {
+                        context_data_val = (context_data_val << 1) | (value & 1);
+                        if (context_data_position == bitsPerChar - 1) {
+                            context_data_position = 0;
+                            context_data.push(getCharFromInt(context_data_val));
+                            context_data_val = 0;
+                        }
+                        else {
+                            context_data_position++;
+                        }
+                        value = value >> 1;
+                    }
+                }
+                context_enlargeIn--;
+                if (context_enlargeIn == 0) {
+                    context_enlargeIn = Math.pow(2, context_numBits);
+                    context_numBits++;
+                }
+                // Add wc to the dictionary.
+                context_dictionary[context_wc] = context_dictSize++;
+                context_w = String(context_c);
+            }
+        }
+        // Output the code for w.
+        if (context_w !== '') {
+            if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+                if (context_w.charCodeAt(0) < 256) {
+                    for (i = 0; i < context_numBits; i++) {
+                        context_data_val = context_data_val << 1;
+                        if (context_data_position == bitsPerChar - 1) {
+                            context_data_position = 0;
+                            context_data.push(getCharFromInt(context_data_val));
+                            context_data_val = 0;
+                        }
+                        else {
+                            context_data_position++;
+                        }
+                    }
+                    value = context_w.charCodeAt(0);
+                    for (i = 0; i < 8; i++) {
+                        context_data_val = (context_data_val << 1) | (value & 1);
+                        if (context_data_position == bitsPerChar - 1) {
+                            context_data_position = 0;
+                            context_data.push(getCharFromInt(context_data_val));
+                            context_data_val = 0;
+                        }
+                        else {
+                            context_data_position++;
+                        }
+                        value = value >> 1;
+                    }
+                }
+                else {
+                    value = 1;
+                    for (i = 0; i < context_numBits; i++) {
+                        context_data_val = (context_data_val << 1) | value;
+                        if (context_data_position == bitsPerChar - 1) {
+                            context_data_position = 0;
+                            context_data.push(getCharFromInt(context_data_val));
+                            context_data_val = 0;
+                        }
+                        else {
+                            context_data_position++;
+                        }
+                        value = 0;
+                    }
+                    value = context_w.charCodeAt(0);
+                    for (i = 0; i < 16; i++) {
+                        context_data_val = (context_data_val << 1) | (value & 1);
+                        if (context_data_position == bitsPerChar - 1) {
+                            context_data_position = 0;
+                            context_data.push(getCharFromInt(context_data_val));
+                            context_data_val = 0;
+                        }
+                        else {
+                            context_data_position++;
+                        }
+                        value = value >> 1;
+                    }
+                }
+                context_enlargeIn--;
+                if (context_enlargeIn == 0) {
+                    context_enlargeIn = Math.pow(2, context_numBits);
+                    context_numBits++;
+                }
+                delete context_dictionaryToCreate[context_w];
+            }
+            else {
+                value = context_dictionary[context_w];
+                for (i = 0; i < context_numBits; i++) {
+                    context_data_val = (context_data_val << 1) | (value & 1);
+                    if (context_data_position == bitsPerChar - 1) {
+                        context_data_position = 0;
+                        context_data.push(getCharFromInt(context_data_val));
+                        context_data_val = 0;
+                    }
+                    else {
+                        context_data_position++;
+                    }
+                    value = value >> 1;
+                }
+            }
+            context_enlargeIn--;
+            if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+            }
+        }
+        // Mark the end of the stream
+        value = 2;
+        for (i = 0; i < context_numBits; i++) {
+            context_data_val = (context_data_val << 1) | (value & 1);
+            if (context_data_position == bitsPerChar - 1) {
+                context_data_position = 0;
+                context_data.push(getCharFromInt(context_data_val));
+                context_data_val = 0;
+            }
+            else {
+                context_data_position++;
+            }
+            value = value >> 1;
+        }
+        // Flush the last char
+        while (true) {
+            context_data_val = context_data_val << 1;
+            if (context_data_position == bitsPerChar - 1) {
+                context_data.push(getCharFromInt(context_data_val));
+                break;
+            }
+            else {
+                context_data_position++;
+            }
+        }
+        return context_data.join('');
+    },
+    decompress: function (compressed) {
+        if (compressed == null) {
+            return '';
+        }
+        if (compressed == '') {
+            return null;
+        }
+        return LZString._decompress(compressed.length, 32768, function (index) {
+            return compressed.charCodeAt(index);
+        });
+    },
+    _decompress: function (length, resetValue, getNextValue) {
+        const dictionary = [], result = [], data = { val: getNextValue(0), position: resetValue, index: 1 };
+        let enlargeIn = 4, dictSize = 4, numBits = 3, entry = '', i, w, bits, resb, maxpower, power, c;
+        for (i = 0; i < 3; i += 1) {
+            dictionary[i] = i;
+        }
+        bits = 0;
+        maxpower = Math.pow(2, 2);
+        power = 1;
+        while (power != maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+                data.position = resetValue;
+                data.val = getNextValue(data.index++);
+            }
+            bits |= (resb > 0 ? 1 : 0) * power;
+            power <<= 1;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        switch ((bits)) {
+            case 0:
+                bits = 0;
+                maxpower = Math.pow(2, 8);
+                power = 1;
+                while (power != maxpower) {
+                    resb = data.val & data.position;
+                    data.position >>= 1;
+                    if (data.position == 0) {
+                        data.position = resetValue;
+                        data.val = getNextValue(data.index++);
+                    }
+                    bits |= (resb > 0 ? 1 : 0) * power;
+                    power <<= 1;
+                }
+                c = f(bits);
+                break;
+            case 1:
+                bits = 0;
+                maxpower = Math.pow(2, 16);
+                power = 1;
+                while (power != maxpower) {
+                    resb = data.val & data.position;
+                    data.position >>= 1;
+                    if (data.position == 0) {
+                        data.position = resetValue;
+                        data.val = getNextValue(data.index++);
+                    }
+                    bits |= (resb > 0 ? 1 : 0) * power;
+                    power <<= 1;
+                }
+                c = f(bits);
+                break;
+            case 2:
+                return '';
+        }
+        dictionary[3] = c;
+        w = c;
+        result.push(c);
+        while (true) {
+            if (data.index > length) {
+                return '';
+            }
+            bits = 0;
+            maxpower = Math.pow(2, numBits);
+            power = 1;
+            while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+            }
+            switch ((c = bits)) {
+                case 0:
+                    bits = 0;
+                    maxpower = Math.pow(2, 8);
+                    power = 1;
+                    while (power != maxpower) {
+                        resb = data.val & data.position;
+                        data.position >>= 1;
+                        if (data.position == 0) {
+                            data.position = resetValue;
+                            data.val = getNextValue(data.index++);
+                        }
+                        bits |= (resb > 0 ? 1 : 0) * power;
+                        power <<= 1;
+                    }
+                    dictionary[dictSize++] = f(bits);
+                    c = dictSize - 1;
+                    enlargeIn--;
+                    break;
+                case 1:
+                    bits = 0;
+                    maxpower = Math.pow(2, 16);
+                    power = 1;
+                    while (power != maxpower) {
+                        resb = data.val & data.position;
+                        data.position >>= 1;
+                        if (data.position == 0) {
+                            data.position = resetValue;
+                            data.val = getNextValue(data.index++);
+                        }
+                        bits |= (resb > 0 ? 1 : 0) * power;
+                        power <<= 1;
+                    }
+                    dictionary[dictSize++] = f(bits);
+                    c = dictSize - 1;
+                    enlargeIn--;
+                    break;
+                case 2:
+                    return result.join('');
+            }
+            if (enlargeIn == 0) {
+                enlargeIn = Math.pow(2, numBits);
+                numBits++;
+            }
+            if (dictionary[c]) {
+                entry = dictionary[c];
+            }
+            else {
+                if (c === dictSize) {
+                    entry = w + w.charAt(0);
+                }
+                else {
+                    return null;
+                }
+            }
+            result.push(entry);
+            // Add w+entry[0] to the dictionary.
+            dictionary[dictSize++] = w + entry.charAt(0);
+            enlargeIn--;
+            w = entry;
+            if (enlargeIn == 0) {
+                enlargeIn = Math.pow(2, numBits);
+                numBits++;
+            }
+        }
+    },
+};
+
+class SimpleEventEmitter {
+    constructor() {
+        this.events = {};
+        this.events = {};
+    }
+    on(event, listener) {
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        this.events[event].push(listener);
+        return () => {
+            this.events[event] = this.events[event].filter((x) => x !== listener);
+        };
+    }
+    emit(event, payload) {
+        for (const listener of this.events[event] || []) {
+            listener(payload);
+        }
+        for (const listener of this.events['*'] || []) {
+            listener(event, payload);
+        }
+    }
+}
+
+// vendor from: https://github.com/LiosK/uuidv7/blob/f30b7a7faff73afbce0b27a46c638310f96912ba/src/index.ts
+// https://github.com/LiosK/uuidv7#license
+/**
+ * uuidv7: An experimental implementation of the proposed UUID Version 7
+ *
+ * @license Apache-2.0
+ * @copyright 2021-2023 LiosK
+ * @packageDocumentation
+ */
+const DIGITS = "0123456789abcdef";
+/** Represents a UUID as a 16-byte byte array. */
+class UUID {
+    /** @param bytes - The 16-byte byte array representation. */
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    /**
+     * Creates an object from the internal representation, a 16-byte byte array
+     * containing the binary UUID representation in the big-endian byte order.
+     *
+     * This method does NOT shallow-copy the argument, and thus the created object
+     * holds the reference to the underlying buffer.
+     *
+     * @throws TypeError if the length of the argument is not 16.
+     */
+    static ofInner(bytes) {
+        if (bytes.length !== 16) {
+            throw new TypeError("not 128-bit length");
+        }
+        else {
+            return new UUID(bytes);
+        }
+    }
+    /**
+     * Builds a byte array from UUIDv7 field values.
+     *
+     * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
+     * @param randA - A 12-bit `rand_a` field value.
+     * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
+     * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
+     * @throws RangeError if any field value is out of the specified range.
+     */
+    static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
+        if (!Number.isInteger(unixTsMs) ||
+            !Number.isInteger(randA) ||
+            !Number.isInteger(randBHi) ||
+            !Number.isInteger(randBLo) ||
+            unixTsMs < 0 ||
+            randA < 0 ||
+            randBHi < 0 ||
+            randBLo < 0 ||
+            unixTsMs > 281474976710655 ||
+            randA > 0xfff ||
+            randBHi > 1073741823 ||
+            randBLo > 4294967295) {
+            throw new RangeError("invalid field value");
+        }
+        const bytes = new Uint8Array(16);
+        bytes[0] = unixTsMs / 2 ** 40;
+        bytes[1] = unixTsMs / 2 ** 32;
+        bytes[2] = unixTsMs / 2 ** 24;
+        bytes[3] = unixTsMs / 2 ** 16;
+        bytes[4] = unixTsMs / 2 ** 8;
+        bytes[5] = unixTsMs;
+        bytes[6] = 0x70 | (randA >>> 8);
+        bytes[7] = randA;
+        bytes[8] = 0x80 | (randBHi >>> 24);
+        bytes[9] = randBHi >>> 16;
+        bytes[10] = randBHi >>> 8;
+        bytes[11] = randBHi;
+        bytes[12] = randBLo >>> 24;
+        bytes[13] = randBLo >>> 16;
+        bytes[14] = randBLo >>> 8;
+        bytes[15] = randBLo;
+        return new UUID(bytes);
+    }
+    /**
+     * Builds a byte array from a string representation.
+     *
+     * This method accepts the following formats:
+     *
+     * - 32-digit hexadecimal format without hyphens: `0189dcd553117d408db09496a2eef37b`
+     * - 8-4-4-4-12 hyphenated format: `0189dcd5-5311-7d40-8db0-9496a2eef37b`
+     * - Hyphenated format with surrounding braces: `{0189dcd5-5311-7d40-8db0-9496a2eef37b}`
+     * - RFC 4122 URN format: `urn:uuid:0189dcd5-5311-7d40-8db0-9496a2eef37b`
+     *
+     * Leading and trailing whitespaces represents an error.
+     *
+     * @throws SyntaxError if the argument could not parse as a valid UUID string.
+     */
+    static parse(uuid) {
+        var _a, _b, _c, _d;
+        let hex = undefined;
+        switch (uuid.length) {
+            case 32:
+                hex = (_a = /^[0-9a-f]{32}$/i.exec(uuid)) === null || _a === void 0 ? void 0 : _a[0];
+                break;
+            case 36:
+                hex =
+                    (_b = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
+                        .exec(uuid)) === null || _b === void 0 ? void 0 : _b.slice(1, 6).join("");
+                break;
+            case 38:
+                hex =
+                    (_c = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i
+                        .exec(uuid)) === null || _c === void 0 ? void 0 : _c.slice(1, 6).join("");
+                break;
+            case 45:
+                hex =
+                    (_d = /^urn:uuid:([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
+                        .exec(uuid)) === null || _d === void 0 ? void 0 : _d.slice(1, 6).join("");
+                break;
+        }
+        if (hex) {
+            const inner = new Uint8Array(16);
+            for (let i = 0; i < 16; i += 4) {
+                const n = parseInt(hex.substring(2 * i, 2 * i + 8), 16);
+                inner[i + 0] = n >>> 24;
+                inner[i + 1] = n >>> 16;
+                inner[i + 2] = n >>> 8;
+                inner[i + 3] = n;
+            }
+            return new UUID(inner);
+        }
+        else {
+            throw new SyntaxError("could not parse UUID string");
+        }
+    }
+    /**
+     * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+     * (`0189dcd5-5311-7d40-8db0-9496a2eef37b`).
+     */
+    toString() {
+        let text = "";
+        for (let i = 0; i < this.bytes.length; i++) {
+            text += DIGITS.charAt(this.bytes[i] >>> 4);
+            text += DIGITS.charAt(this.bytes[i] & 0xf);
+            if (i === 3 || i === 5 || i === 7 || i === 9) {
+                text += "-";
+            }
+        }
+        return text;
+    }
+    /**
+     * @returns The 32-digit hexadecimal representation without hyphens
+     * (`0189dcd553117d408db09496a2eef37b`).
+     */
+    toHex() {
+        let text = "";
+        for (let i = 0; i < this.bytes.length; i++) {
+            text += DIGITS.charAt(this.bytes[i] >>> 4);
+            text += DIGITS.charAt(this.bytes[i] & 0xf);
+        }
+        return text;
+    }
+    /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
+    toJSON() {
+        return this.toString();
+    }
+    /**
+     * Reports the variant field value of the UUID or, if appropriate, "NIL" or
+     * "MAX".
+     *
+     * For convenience, this method reports "NIL" or "MAX" if `this` represents
+     * the Nil or Max UUID, although the Nil and Max UUIDs are technically
+     * subsumed under the variants `0b0` and `0b111`, respectively.
+     */
+    getVariant() {
+        const n = this.bytes[8] >>> 4;
+        if (n < 0) {
+            throw new Error("unreachable");
+        }
+        else if (n <= 0b0111) {
+            return this.bytes.every((e) => e === 0) ? "NIL" : "VAR_0";
+        }
+        else if (n <= 0b1011) {
+            return "VAR_10";
+        }
+        else if (n <= 0b1101) {
+            return "VAR_110";
+        }
+        else if (n <= 0b1111) {
+            return this.bytes.every((e) => e === 0xff) ? "MAX" : "VAR_RESERVED";
+        }
+        else {
+            throw new Error("unreachable");
+        }
+    }
+    /**
+     * Returns the version field value of the UUID or `undefined` if the UUID does
+     * not have the variant field value of `0b10`.
+     */
+    getVersion() {
+        return this.getVariant() === "VAR_10" ? this.bytes[6] >>> 4 : undefined;
+    }
+    /** Creates an object from `this`. */
+    clone() {
+        return new UUID(this.bytes.slice(0));
+    }
+    /** Returns true if `this` is equivalent to `other`. */
+    equals(other) {
+        return this.compareTo(other) === 0;
+    }
+    /**
+     * Returns a negative integer, zero, or positive integer if `this` is less
+     * than, equal to, or greater than `other`, respectively.
+     */
+    compareTo(other) {
+        for (let i = 0; i < 16; i++) {
+            const diff = this.bytes[i] - other.bytes[i];
+            if (diff !== 0) {
+                return Math.sign(diff);
+            }
+        }
+        return 0;
+    }
+}
+/**
+ * Encapsulates the monotonic counter state.
+ *
+ * This class provides APIs to utilize a separate counter state from that of the
+ * global generator used by {@link uuidv7} and {@link uuidv7obj}. In addition to
+ * the default {@link generate} method, this class has {@link generateOrAbort}
+ * that is useful to absolutely guarantee the monotonically increasing order of
+ * generated UUIDs. See their respective documentation for details.
+ */
+class V7Generator {
+    /**
+     * Creates a generator object with the default random number generator, or
+     * with the specified one if passed as an argument. The specified random
+     * number generator should be cryptographically strong and securely seeded.
+     */
+    constructor(randomNumberGenerator) {
+        this.timestamp = 0;
+        this.counter = 0;
+        this.random = randomNumberGenerator !== null && randomNumberGenerator !== void 0 ? randomNumberGenerator : getDefaultRandom();
+    }
+    /**
+     * Generates a new UUIDv7 object from the current timestamp, or resets the
+     * generator upon significant timestamp rollback.
+     *
+     * This method returns a monotonically increasing UUID by reusing the previous
+     * timestamp even if the up-to-date timestamp is smaller than the immediately
+     * preceding UUID's. However, when such a clock rollback is considered
+     * significant (i.e., by more than ten seconds), this method resets the
+     * generator and returns a new UUID based on the given timestamp, breaking the
+     * increasing order of UUIDs.
+     *
+     * See {@link generateOrAbort} for the other mode of generation and
+     * {@link generateOrResetCore} for the low-level primitive.
+     */
+    generate() {
+        return this.generateOrResetCore(Date.now(), 10000);
+    }
+    /**
+     * Generates a new UUIDv7 object from the current timestamp, or returns
+     * `undefined` upon significant timestamp rollback.
+     *
+     * This method returns a monotonically increasing UUID by reusing the previous
+     * timestamp even if the up-to-date timestamp is smaller than the immediately
+     * preceding UUID's. However, when such a clock rollback is considered
+     * significant (i.e., by more than ten seconds), this method aborts and
+     * returns `undefined` immediately.
+     *
+     * See {@link generate} for the other mode of generation and
+     * {@link generateOrAbortCore} for the low-level primitive.
+     */
+    generateOrAbort() {
+        return this.generateOrAbortCore(Date.now(), 10000);
+    }
+    /**
+     * Generates a new UUIDv7 object from the `unixTsMs` passed, or resets the
+     * generator upon significant timestamp rollback.
+     *
+     * This method is equivalent to {@link generate} except that it takes a custom
+     * timestamp and clock rollback allowance.
+     *
+     * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
+     * considered significant. A suggested value is `10_000` (milliseconds).
+     * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
+     */
+    generateOrResetCore(unixTsMs, rollbackAllowance) {
+        let value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+        if (value === undefined) {
+            // reset state and resume
+            this.timestamp = 0;
+            value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+        }
+        return value;
+    }
+    /**
+     * Generates a new UUIDv7 object from the `unixTsMs` passed, or returns
+     * `undefined` upon significant timestamp rollback.
+     *
+     * This method is equivalent to {@link generateOrAbort} except that it takes a
+     * custom timestamp and clock rollback allowance.
+     *
+     * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
+     * considered significant. A suggested value is `10_000` (milliseconds).
+     * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
+     */
+    generateOrAbortCore(unixTsMs, rollbackAllowance) {
+        const MAX_COUNTER = 4398046511103;
+        if (!Number.isInteger(unixTsMs) ||
+            unixTsMs < 1 ||
+            unixTsMs > 281474976710655) {
+            throw new RangeError("`unixTsMs` must be a 48-bit positive integer");
+        }
+        else if (rollbackAllowance < 0 || rollbackAllowance > 281474976710655) {
+            throw new RangeError("`rollbackAllowance` out of reasonable range");
+        }
+        if (unixTsMs > this.timestamp) {
+            this.timestamp = unixTsMs;
+            this.resetCounter();
+        }
+        else if (unixTsMs + rollbackAllowance >= this.timestamp) {
+            // go on with previous timestamp if new one is not much smaller
+            this.counter++;
+            if (this.counter > MAX_COUNTER) {
+                // increment timestamp at counter overflow
+                this.timestamp++;
+                this.resetCounter();
+            }
+        }
+        else {
+            // abort if clock went backwards to unbearable extent
+            return undefined;
+        }
+        return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & (2 ** 30 - 1), this.random.nextUint32());
+    }
+    /** Initializes the counter at a 42-bit random integer. */
+    resetCounter() {
+        this.counter =
+            this.random.nextUint32() * 0x400 + (this.random.nextUint32() & 0x3ff);
+    }
+    /**
+     * Generates a new UUIDv4 object utilizing the random number generator inside.
+     *
+     * @internal
+     */
+    generateV4() {
+        const bytes = new Uint8Array(Uint32Array.of(this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32()).buffer);
+        bytes[6] = 0x40 | (bytes[6] >>> 4);
+        bytes[8] = 0x80 | (bytes[8] >>> 2);
+        return UUID.ofInner(bytes);
+    }
+}
+/** A global flag to force use of cryptographically strong RNG. */
+// declare const UUIDV7_DENY_WEAK_RNG: boolean;
+/** Returns the default random number generator available in the environment. */
+const getDefaultRandom = () => {
+    // fix: crypto isn't available in react-native, always use Math.random
+    //   // detect Web Crypto API
+    //   if (
+    //     typeof crypto !== "undefined" &&
+    //     typeof crypto.getRandomValues !== "undefined"
+    //   ) {
+    //     return new BufferedCryptoRandom();
+    //   } else {
+    //     // fall back on Math.random() unless the flag is set to true
+    //     if (typeof UUIDV7_DENY_WEAK_RNG !== "undefined" && UUIDV7_DENY_WEAK_RNG) {
+    //       throw new Error("no cryptographically strong RNG available");
+    //     }
+    //     return {
+    //       nextUint32: (): number =>
+    //         Math.trunc(Math.random() * 0x1_0000) * 0x1_0000 +
+    //         Math.trunc(Math.random() * 0x1_0000),
+    //     };
+    //   }
+    return {
+        nextUint32: () => Math.trunc(Math.random() * 65536) * 65536 +
+            Math.trunc(Math.random() * 65536),
+    };
+};
+// /**
+//  * Wraps `crypto.getRandomValues()` to enable buffering; this uses a small
+//  * buffer by default to avoid both unbearable throughput decline in some
+//  * environments and the waste of time and space for unused values.
+//  */
+// class BufferedCryptoRandom {
+//   private readonly buffer = new Uint32Array(8);
+//   private cursor = 0xffff;
+//   nextUint32(): number {
+//     if (this.cursor >= this.buffer.length) {
+//       crypto.getRandomValues(this.buffer);
+//       this.cursor = 0;
+//     }
+//     return this.buffer[this.cursor++];
+//   }
+// }
+let defaultGenerator;
+/**
+ * Generates a UUIDv7 string.
+ *
+ * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+ * ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
+ */
+const uuidv7 = () => uuidv7obj().toString();
+/** Generates a UUIDv7 object. */
+const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
+
+class PostHogFetchHttpError extends Error {
+    constructor(response) {
+        super('HTTP error while fetching PostHog: ' + response.status);
+        this.response = response;
+        this.name = 'PostHogFetchHttpError';
+    }
+}
+class PostHogFetchNetworkError extends Error {
+    constructor(error) {
+        // TRICKY: "cause" is a newer property but is just ignored otherwise. Cast to any to ignore the type issue.
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore
+        super('Network error while fetching PostHog', error instanceof Error ? { cause: error } : {});
+        this.error = error;
+        this.name = 'PostHogFetchNetworkError';
+    }
+}
+function isPostHogFetchError(err) {
+    return typeof err === 'object' && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
+}
+var QuotaLimitedFeature;
+(function (QuotaLimitedFeature) {
+    QuotaLimitedFeature["FeatureFlags"] = "feature_flags";
+    QuotaLimitedFeature["Recordings"] = "recordings";
+})(QuotaLimitedFeature || (QuotaLimitedFeature = {}));
+class PostHogCoreStateless {
+    constructor(apiKey, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        this.flushPromise = null;
+        this.pendingPromises = {};
+        // internal
+        this._events = new SimpleEventEmitter();
+        this._isInitialized = false;
+        assert(apiKey, "You must pass your PostHog project's api key.");
+        this.apiKey = apiKey;
+        this.host = removeTrailingSlash((options === null || options === void 0 ? void 0 : options.host) || 'https://us.i.posthog.com');
+        this.flushAt = (options === null || options === void 0 ? void 0 : options.flushAt) ? Math.max(options === null || options === void 0 ? void 0 : options.flushAt, 1) : 20;
+        this.maxBatchSize = Math.max(this.flushAt, (_a = options === null || options === void 0 ? void 0 : options.maxBatchSize) !== null && _a !== void 0 ? _a : 100);
+        this.maxQueueSize = Math.max(this.flushAt, (_b = options === null || options === void 0 ? void 0 : options.maxQueueSize) !== null && _b !== void 0 ? _b : 1000);
+        this.flushInterval = (_c = options === null || options === void 0 ? void 0 : options.flushInterval) !== null && _c !== void 0 ? _c : 10000;
+        this.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'json';
+        this.preloadFeatureFlags = (_d = options === null || options === void 0 ? void 0 : options.preloadFeatureFlags) !== null && _d !== void 0 ? _d : true;
+        // If enable is explicitly set to false we override the optout
+        this.defaultOptIn = (_e = options === null || options === void 0 ? void 0 : options.defaultOptIn) !== null && _e !== void 0 ? _e : true;
+        this.disableSurveys = (_f = options === null || options === void 0 ? void 0 : options.disableSurveys) !== null && _f !== void 0 ? _f : false;
+        this._retryOptions = {
+            retryCount: (_g = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _g !== void 0 ? _g : 3,
+            retryDelay: (_h = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _h !== void 0 ? _h : 3000,
+            retryCheck: isPostHogFetchError,
+        };
+        this.requestTimeout = (_j = options === null || options === void 0 ? void 0 : options.requestTimeout) !== null && _j !== void 0 ? _j : 10000; // 10 seconds
+        this.featureFlagsRequestTimeoutMs = (_k = options === null || options === void 0 ? void 0 : options.featureFlagsRequestTimeoutMs) !== null && _k !== void 0 ? _k : 3000; // 3 seconds
+        this.remoteConfigRequestTimeoutMs = (_l = options === null || options === void 0 ? void 0 : options.remoteConfigRequestTimeoutMs) !== null && _l !== void 0 ? _l : 3000; // 3 seconds
+        this.disableGeoip = (_m = options === null || options === void 0 ? void 0 : options.disableGeoip) !== null && _m !== void 0 ? _m : true;
+        this.disabled = (_o = options === null || options === void 0 ? void 0 : options.disabled) !== null && _o !== void 0 ? _o : false;
+        this.historicalMigration = (_p = options === null || options === void 0 ? void 0 : options.historicalMigration) !== null && _p !== void 0 ? _p : false;
+        // Init promise allows the derived class to block calls until it is ready
+        this._initPromise = Promise.resolve();
+        this._isInitialized = true;
+    }
+    logMsgIfDebug(fn) {
+        if (this.isDebug) {
+            fn();
+        }
+    }
+    wrap(fn) {
+        if (this.disabled) {
+            this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'));
+            return;
+        }
+        if (this._isInitialized) {
+            // NOTE: We could also check for the "opt in" status here...
+            return fn();
+        }
+        this._initPromise.then(() => fn());
+    }
+    getCommonEventProperties() {
+        return {
+            $lib: this.getLibraryId(),
+            $lib_version: this.getLibraryVersion(),
+        };
+    }
+    get optedOut() {
+        var _a;
+        return (_a = this.getPersistedProperty(PostHogPersistedProperty.OptedOut)) !== null && _a !== void 0 ? _a : !this.defaultOptIn;
+    }
+    async optIn() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.OptedOut, false);
+        });
+    }
+    async optOut() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.OptedOut, true);
+        });
+    }
+    on(event, cb) {
+        return this._events.on(event, cb);
+    }
+    debug(enabled = true) {
+        var _a;
+        (_a = this.removeDebugCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (enabled) {
+            const removeDebugCallback = this.on('*', (event, payload) => console.log('PostHog Debug', event, payload));
+            this.removeDebugCallback = () => {
+                removeDebugCallback();
+                this.removeDebugCallback = undefined;
+            };
+        }
+    }
+    get isDebug() {
+        return !!this.removeDebugCallback;
+    }
+    get isDisabled() {
+        return this.disabled;
+    }
+    buildPayload(payload) {
+        return {
+            distinct_id: payload.distinct_id,
+            event: payload.event,
+            properties: {
+                ...(payload.properties || {}),
+                ...this.getCommonEventProperties(), // Common PH props
+            },
+        };
+    }
+    addPendingPromise(promise) {
+        const promiseUUID = uuidv7();
+        this.pendingPromises[promiseUUID] = promise;
+        promise
+            .catch(() => { })
+            .finally(() => {
+            delete this.pendingPromises[promiseUUID];
+        });
+        return promise;
+    }
+    /***
+     *** TRACKING
+     ***/
+    identifyStateless(distinctId, properties, options) {
+        this.wrap(() => {
+            // The properties passed to identifyStateless are event properties.
+            // To add person properties, pass in all person properties to the `$set` and `$set_once` keys.
+            const payload = {
+                ...this.buildPayload({
+                    distinct_id: distinctId,
+                    event: '$identify',
+                    properties,
+                }),
+            };
+            this.enqueue('identify', payload, options);
+        });
+    }
+    captureStateless(distinctId, event, properties, options) {
+        this.wrap(() => {
+            const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
+            this.enqueue('capture', payload, options);
+        });
+    }
+    aliasStateless(alias, distinctId, properties, options) {
+        this.wrap(() => {
+            const payload = this.buildPayload({
+                event: '$create_alias',
+                distinct_id: distinctId,
+                properties: {
+                    ...(properties || {}),
+                    distinct_id: distinctId,
+                    alias,
+                },
+            });
+            this.enqueue('alias', payload, options);
+        });
+    }
+    /***
+     *** GROUPS
+     ***/
+    groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties) {
+        this.wrap(() => {
+            const payload = this.buildPayload({
+                distinct_id: distinctId || `$${groupType}_${groupKey}`,
+                event: '$groupidentify',
+                properties: {
+                    $group_type: groupType,
+                    $group_key: groupKey,
+                    $group_set: groupProperties || {},
+                    ...(eventProperties || {}),
+                },
+            });
+            this.enqueue('capture', payload, options);
+        });
+    }
+    async getRemoteConfig() {
+        await this._initPromise;
+        let host = this.host;
+        if (host === 'https://us.i.posthog.com') {
+            host = 'https://us-assets.i.posthog.com';
+        }
+        else if (host === 'https://eu.i.posthog.com') {
+            host = 'https://eu-assets.i.posthog.com';
+        }
+        const url = `${host}/array/${this.apiKey}/config`;
+        const fetchOptions = {
+            method: 'GET',
+            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+        };
+        // Don't retry remote config API calls
+        return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.remoteConfigRequestTimeoutMs)
+            .then((response) => response.json())
+            .catch((error) => {
+            this.logMsgIfDebug(() => console.error('Remote config could not be loaded', error));
+            this._events.emit('error', error);
+            return undefined;
+        });
+    }
+    /***
+     *** FEATURE FLAGS
+     ***/
+    async getDecide(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
+        await this._initPromise;
+        // Check if the API token is in the new flags rollout
+        // This is a temporary measure to ensure that we can still use the old flags API
+        // while we migrate to the new flags API
+        const useFlags = isTokenInRollout(this.apiKey, NEW_FLAGS_ROLLOUT_PERCENTAGE, NEW_FLAGS_EXCLUDED_HASHES);
+        const url = useFlags ? `${this.host}/flags/?v=2` : `${this.host}/decide/?v=4`;
+        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,
+            }),
+        };
+        // Don't retry /decide API calls
+        return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
+            .then((response) => response.json())
+            .then((response) => normalizeDecideResponse(response))
+            .catch((error) => {
+            this._events.emit('error', error);
+            return undefined;
+        });
+    }
+    async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+        if (flagDetailResponse === undefined) {
+            // If we haven't loaded flags yet, or errored out, we respond with undefined
+            return {
+                response: undefined,
+                requestId: undefined,
+            };
+        }
+        let response = getFeatureFlagValue(flagDetailResponse.response);
+        if (response === undefined) {
+            // For cases where the flag is unknown, return false
+            response = false;
+        }
+        // If we have flags we either return the value (true or string) or false
+        return {
+            response,
+            requestId: flagDetailResponse.requestId,
+        };
+    }
+    async getFeatureFlagDetailStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const decideResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
+        if (decideResponse === undefined) {
+            return undefined;
+        }
+        const featureFlags = decideResponse.flags;
+        const flagDetail = featureFlags[key];
+        return {
+            response: flagDetail,
+            requestId: decideResponse.requestId,
+        };
+    }
+    async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
+        if (!payloads) {
+            return undefined;
+        }
+        const response = payloads[key];
+        // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
+        if (response === undefined) {
+            return null;
+        }
+        return response;
+    }
+    async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+        await this._initPromise;
+        const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate)).payloads;
+        return payloads;
+    }
+    async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+        await this._initPromise;
+        return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
+    }
+    async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+        await this._initPromise;
+        const featureFlagDetails = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
+        if (!featureFlagDetails) {
+            return {
+                flags: undefined,
+                payloads: undefined,
+                requestId: undefined,
+            };
+        }
+        return {
+            flags: featureFlagDetails.featureFlags,
+            payloads: featureFlagDetails.featureFlagPayloads,
+            requestId: featureFlagDetails.requestId,
+        };
+    }
+    async getFeatureFlagDetailsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+        var _a;
+        await this._initPromise;
+        const extraPayload = {};
+        if (disableGeoip !== null && disableGeoip !== void 0 ? disableGeoip : this.disableGeoip) {
+            extraPayload['geoip_disable'] = true;
+        }
+        if (flagKeysToEvaluate) {
+            extraPayload['flag_keys_to_evaluate'] = flagKeysToEvaluate;
+        }
+        const decideResponse = await this.getDecide(distinctId, groups, personProperties, groupProperties, extraPayload);
+        if (decideResponse === undefined) {
+            // We probably errored out, so return undefined
+            return undefined;
+        }
+        // if there's an error on the decideResponse, log a console error, but don't throw an error
+        if (decideResponse.errorsWhileComputingFlags) {
+            console.error('[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices');
+        }
+        // Add check for quota limitation on feature flags
+        if ((_a = decideResponse.quotaLimited) === null || _a === void 0 ? void 0 : _a.includes(QuotaLimitedFeature.FeatureFlags)) {
+            console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
+            return {
+                flags: {},
+                featureFlags: {},
+                featureFlagPayloads: {},
+                requestId: decideResponse === null || decideResponse === void 0 ? void 0 : decideResponse.requestId,
+            };
+        }
+        return decideResponse;
+    }
+    /***
+     *** SURVEYS
+     ***/
+    async getSurveysStateless() {
+        await this._initPromise;
+        if (this.disableSurveys === true) {
+            this.logMsgIfDebug(() => console.log('Loading surveys is disabled.'));
+            return [];
+        }
+        const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
+        const fetchOptions = {
+            method: 'GET',
+            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+        };
+        const response = await this.fetchWithRetry(url, fetchOptions)
+            .then((response) => {
+            if (response.status !== 200 || !response.json) {
+                const msg = `Surveys API could not be loaded: ${response.status}`;
+                const error = new Error(msg);
+                this.logMsgIfDebug(() => console.error(error));
+                this._events.emit('error', new Error(msg));
+                return undefined;
+            }
+            return response.json();
+        })
+            .catch((error) => {
+            this.logMsgIfDebug(() => console.error('Surveys API could not be loaded', error));
+            this._events.emit('error', error);
+            return undefined;
+        });
+        const newSurveys = response === null || response === void 0 ? void 0 : response.surveys;
+        if (newSurveys) {
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from API: ', JSON.stringify(newSurveys)));
+        }
+        return newSurveys !== null && newSurveys !== void 0 ? newSurveys : [];
+    }
+    /***
+     *** QUEUEING AND FLUSHING
+     ***/
+    enqueue(type, _message, options) {
+        this.wrap(() => {
+            var _a;
+            if (this.optedOut) {
+                this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
+                return;
+            }
+            const message = {
+                ..._message,
+                type: type,
+                library: this.getLibraryId(),
+                library_version: this.getLibraryVersion(),
+                timestamp: (options === null || options === void 0 ? void 0 : options.timestamp) ? options === null || options === void 0 ? void 0 : options.timestamp : currentISOTime(),
+                uuid: (options === null || options === void 0 ? void 0 : options.uuid) ? options.uuid : uuidv7(),
+            };
+            const addGeoipDisableProperty = (_a = options === null || options === void 0 ? void 0 : options.disableGeoip) !== null && _a !== void 0 ? _a : this.disableGeoip;
+            if (addGeoipDisableProperty) {
+                if (!message.properties) {
+                    message.properties = {};
+                }
+                message['properties']['$geoip_disable'] = true;
+            }
+            if (message.distinctId) {
+                message.distinct_id = message.distinctId;
+                delete message.distinctId;
+            }
+            const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+            if (queue.length >= this.maxQueueSize) {
+                queue.shift();
+                this.logMsgIfDebug(() => console.info('Queue is full, the oldest event is dropped.'));
+            }
+            queue.push({ message });
+            this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
+            this._events.emit(type, message);
+            // Flush queued events if we meet the flushAt length
+            if (queue.length >= this.flushAt) {
+                this.flushBackground();
+            }
+            if (this.flushInterval && !this._flushTimer) {
+                this._flushTimer = safeSetTimeout(() => this.flushBackground(), this.flushInterval);
+            }
+        });
+    }
+    clearFlushTimer() {
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = undefined;
+        }
+    }
+    /**
+     * Helper for flushing the queue in the background
+     * Avoids unnecessary promise errors
+     */
+    flushBackground() {
+        void this.flush().catch(() => { });
+    }
+    async flush() {
+        if (!this.flushPromise) {
+            this.flushPromise = this._flush().finally(() => {
+                this.flushPromise = null;
+            });
+            this.addPendingPromise(this.flushPromise);
+        }
+        return this.flushPromise;
+    }
+    getCustomHeaders() {
+        // Don't set the user agent if we're not on a browser. The latest spec allows
+        // the User-Agent header (see https://fetch.spec.whatwg.org/#terminology-headers
+        // and https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader),
+        // but browsers such as Chrome and Safari have not caught up.
+        const customUserAgent = this.getCustomUserAgent();
+        const headers = {};
+        if (customUserAgent && customUserAgent !== '') {
+            headers['User-Agent'] = customUserAgent;
+        }
+        return headers;
+    }
+    async _flush() {
+        this.clearFlushTimer();
+        await this._initPromise;
+        const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        if (!queue.length) {
+            return [];
+        }
+        const items = queue.slice(0, this.maxBatchSize);
+        const messages = items.map((item) => item.message);
+        const persistQueueChange = () => {
+            const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+            this.setPersistedProperty(PostHogPersistedProperty.Queue, refreshedQueue.slice(items.length));
+        };
+        const data = {
+            api_key: this.apiKey,
+            batch: messages,
+            sent_at: currentISOTime(),
+        };
+        if (this.historicalMigration) {
+            data.historical_migration = true;
+        }
+        const payload = JSON.stringify(data);
+        const url = this.captureMode === 'form'
+            ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+            : `${this.host}/batch/`;
+        const fetchOptions = this.captureMode === 'form'
+            ? {
+                method: 'POST',
+                mode: 'no-cors',
+                credentials: 'omit',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+            }
+            : {
+                method: 'POST',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+                body: payload,
+            };
+        try {
+            await this.fetchWithRetry(url, fetchOptions);
+        }
+        catch (err) {
+            // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
+            // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
+            if (!(err instanceof PostHogFetchNetworkError)) {
+                persistQueueChange();
+            }
+            this._events.emit('error', err);
+            throw err;
+        }
+        persistQueueChange();
+        this._events.emit('flush', messages);
+        return messages;
+    }
+    async fetchWithRetry(url, options, retryOptions, requestTimeout) {
+        var _a;
+        var _b;
+        (_a = (_b = AbortSignal).timeout) !== null && _a !== void 0 ? _a : (_b.timeout = function timeout(ms) {
+            const ctrl = new AbortController();
+            setTimeout(() => ctrl.abort(), ms);
+            return ctrl.signal;
+        });
+        return await retriable(async () => {
+            let res = null;
+            try {
+                res = await this.fetch(url, {
+                    signal: AbortSignal.timeout(requestTimeout !== null && requestTimeout !== void 0 ? requestTimeout : this.requestTimeout),
+                    ...options,
+                });
+            }
+            catch (e) {
+                // fetch will only throw on network errors or on timeouts
+                throw new PostHogFetchNetworkError(e);
+            }
+            // If we're in no-cors mode, we can't access the response status
+            // We only throw on HTTP errors if we're not in no-cors mode
+            // https://developer.mozilla.org/en-US/docs/Web/API/Request/mode#no-cors
+            const isNoCors = options.mode === 'no-cors';
+            if (!isNoCors && (res.status < 200 || res.status >= 400)) {
+                throw new PostHogFetchHttpError(res);
+            }
+            return res;
+        }, { ...this._retryOptions, ...retryOptions });
+    }
+    async shutdown(shutdownTimeoutMs = 30000) {
+        // A little tricky - we want to have a max shutdown time and enforce it, even if that means we have some
+        // dangling promises. We'll keep track of the timeout and resolve/reject based on that.
+        await this._initPromise;
+        let hasTimedOut = false;
+        this.clearFlushTimer();
+        const doShutdown = async () => {
+            try {
+                await Promise.all(Object.values(this.pendingPromises));
+                while (true) {
+                    const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+                    if (queue.length === 0) {
+                        break;
+                    }
+                    // flush again to make sure we send all events, some of which might've been added
+                    // while we were waiting for the pending promises to resolve
+                    // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
+                    await this.flush();
+                    if (hasTimedOut) {
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                if (!isPostHogFetchError(e)) {
+                    throw e;
+                }
+                this.logMsgIfDebug(() => console.error('Error while shutting down PostHog', e));
+            }
+        };
+        return Promise.race([
+            new Promise((_, reject) => {
+                safeSetTimeout(() => {
+                    this.logMsgIfDebug(() => console.error('Timed out while shutting down PostHog'));
+                    hasTimedOut = true;
+                    reject('Timeout while shutting down PostHog. Some events may not have been sent.');
+                }, shutdownTimeoutMs);
+            }),
+            doShutdown(),
+        ]);
+    }
+}
+class PostHogCore extends PostHogCoreStateless {
+    constructor(apiKey, options) {
+        var _a, _b, _c, _d;
+        // Default for stateful mode is to not disable geoip. Only override if explicitly set
+        const disableGeoipOption = (_a = options === null || options === void 0 ? void 0 : options.disableGeoip) !== null && _a !== void 0 ? _a : false;
+        // Default for stateful mode is to timeout at 10s. Only override if explicitly set
+        const featureFlagsRequestTimeoutMs = (_b = options === null || options === void 0 ? void 0 : options.featureFlagsRequestTimeoutMs) !== null && _b !== void 0 ? _b : 10000; // 10 seconds
+        super(apiKey, { ...options, disableGeoip: disableGeoipOption, featureFlagsRequestTimeoutMs });
+        this.flagCallReported = {};
+        this.sessionProps = {};
+        this.sendFeatureFlagEvent = (_c = options === null || options === void 0 ? void 0 : options.sendFeatureFlagEvent) !== null && _c !== void 0 ? _c : true;
+        this._sessionExpirationTimeSeconds = (_d = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _d !== void 0 ? _d : 1800; // 30 minutes
+    }
+    setupBootstrap(options) {
+        var _a;
+        const bootstrap = options === null || options === void 0 ? void 0 : options.bootstrap;
+        if (!bootstrap) {
+            return;
+        }
+        // bootstrap options are only set if no persisted values are found
+        // this is to prevent overwriting existing values
+        if (bootstrap.distinctId) {
+            if (bootstrap.isIdentifiedId) {
+                const distinctId = this.getPersistedProperty(PostHogPersistedProperty.DistinctId);
+                if (!distinctId) {
+                    this.setPersistedProperty(PostHogPersistedProperty.DistinctId, bootstrap.distinctId);
+                }
+            }
+            else {
+                const anonymousId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
+                if (!anonymousId) {
+                    this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, bootstrap.distinctId);
+                }
+            }
+        }
+        const bootstrapFeatureFlags = bootstrap.featureFlags;
+        const bootstrapFeatureFlagPayloads = (_a = bootstrap.featureFlagPayloads) !== null && _a !== void 0 ? _a : {};
+        if (bootstrapFeatureFlags && Object.keys(bootstrapFeatureFlags).length) {
+            const normalizedBootstrapFeatureFlagDetails = createDecideResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
+            if (Object.keys(normalizedBootstrapFeatureFlagDetails.flags).length > 0) {
+                this.setBootstrappedFeatureFlagDetails(normalizedBootstrapFeatureFlagDetails);
+                const currentFeatureFlagDetails = this.getKnownFeatureFlagDetails() || { flags: {}, requestId: undefined };
+                const newFeatureFlagDetails = {
+                    flags: {
+                        ...normalizedBootstrapFeatureFlagDetails.flags,
+                        ...currentFeatureFlagDetails.flags,
+                    },
+                    requestId: normalizedBootstrapFeatureFlagDetails.requestId,
+                };
+                this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
+            }
+        }
+    }
+    // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
+    get props() {
+        if (!this._props) {
+            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
+        }
+        return this._props || {};
+    }
+    set props(val) {
+        this._props = val;
+    }
+    clearProps() {
+        this.props = undefined;
+        this.sessionProps = {};
+        this.flagCallReported = {};
+    }
+    on(event, cb) {
+        return this._events.on(event, cb);
+    }
+    reset(propertiesToKeep) {
+        this.wrap(() => {
+            const allPropertiesToKeep = [PostHogPersistedProperty.Queue, ...(propertiesToKeep || [])];
+            // clean up props
+            this.clearProps();
+            for (const key of Object.keys(PostHogPersistedProperty)) {
+                if (!allPropertiesToKeep.includes(PostHogPersistedProperty[key])) {
+                    this.setPersistedProperty(PostHogPersistedProperty[key], null);
+                }
+            }
+            this.reloadFeatureFlags();
+        });
+    }
+    getCommonEventProperties() {
+        const featureFlags = this.getFeatureFlags();
+        const featureVariantProperties = {};
+        if (featureFlags) {
+            for (const [feature, variant] of Object.entries(featureFlags)) {
+                featureVariantProperties[`$feature/${feature}`] = variant;
+            }
+        }
+        return {
+            $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined,
+            ...featureVariantProperties,
+            ...super.getCommonEventProperties(),
+        };
+    }
+    enrichProperties(properties) {
+        return {
+            ...this.props,
+            ...this.sessionProps,
+            ...(properties || {}),
+            ...this.getCommonEventProperties(),
+            $session_id: this.getSessionId(),
+        };
+    }
+    /**
+     * * @returns {string} The stored session ID for the current session. This may be an empty string if the client is not yet fully initialized.
+     */
+    getSessionId() {
+        if (!this._isInitialized) {
+            return '';
+        }
+        let sessionId = this.getPersistedProperty(PostHogPersistedProperty.SessionId);
+        const sessionTimestamp = this.getPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp) || 0;
+        if (!sessionId || Date.now() - sessionTimestamp > this._sessionExpirationTimeSeconds * 1000) {
+            sessionId = uuidv7();
+            this.setPersistedProperty(PostHogPersistedProperty.SessionId, sessionId);
+        }
+        this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, Date.now());
+        return sessionId;
+    }
+    resetSessionId() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.SessionId, null);
+            this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, null);
+        });
+    }
+    /**
+     * * @returns {string} The stored anonymous ID. This may be an empty string if the client is not yet fully initialized.
+     */
+    getAnonymousId() {
+        if (!this._isInitialized) {
+            return '';
+        }
+        let anonId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
+        if (!anonId) {
+            anonId = uuidv7();
+            this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, anonId);
+        }
+        return anonId;
+    }
+    /**
+     * * @returns {string} The stored distinct ID. This may be an empty string if the client is not yet fully initialized.
+     */
+    getDistinctId() {
+        if (!this._isInitialized) {
+            return '';
+        }
+        return this.getPersistedProperty(PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
+    }
+    async unregister(property) {
+        this.wrap(() => {
+            delete this.props[property];
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    async register(properties) {
+        this.wrap(() => {
+            this.props = {
+                ...this.props,
+                ...properties,
+            };
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    registerForSession(properties) {
+        this.sessionProps = {
+            ...this.sessionProps,
+            ...properties,
+        };
+    }
+    unregisterForSession(property) {
+        delete this.sessionProps[property];
+    }
+    /***
+     *** TRACKING
+     ***/
+    identify(distinctId, properties, options) {
+        this.wrap(() => {
+            const previousDistinctId = this.getDistinctId();
+            distinctId = distinctId || previousDistinctId;
+            if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
+                this.groups(properties.$groups);
+            }
+            // promote $set and $set_once to top level
+            const userPropsOnce = properties === null || properties === void 0 ? void 0 : properties.$set_once;
+            properties === null || properties === void 0 ? true : delete properties.$set_once;
+            // if no $set is provided we assume all properties are $set
+            const userProps = (properties === null || properties === void 0 ? void 0 : properties.$set) || properties;
+            const allProperties = this.enrichProperties({
+                $anon_distinct_id: this.getAnonymousId(),
+                $set: userProps,
+                $set_once: userPropsOnce,
+            });
+            if (distinctId !== previousDistinctId) {
+                // We keep the AnonymousId to be used by decide calls and identify to link the previousId
+                this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
+                this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
+                this.reloadFeatureFlags();
+            }
+            super.identifyStateless(distinctId, allProperties, options);
+        });
+    }
+    capture(event, properties, options) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
+                this.groups(properties.$groups);
+            }
+            const allProperties = this.enrichProperties(properties);
+            super.captureStateless(distinctId, event, allProperties, options);
+        });
+    }
+    alias(alias) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            const allProperties = this.enrichProperties({});
+            super.aliasStateless(alias, distinctId, allProperties);
+        });
+    }
+    autocapture(eventType, elements, properties = {}, options) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            const payload = {
+                distinct_id: distinctId,
+                event: '$autocapture',
+                properties: {
+                    ...this.enrichProperties(properties),
+                    $event_type: eventType,
+                    $elements: elements,
+                },
+            };
+            this.enqueue('autocapture', payload, options);
+        });
+    }
+    /***
+     *** GROUPS
+     ***/
+    groups(groups) {
+        this.wrap(() => {
+            // Get persisted groups
+            const existingGroups = this.props.$groups || {};
+            this.register({
+                $groups: {
+                    ...existingGroups,
+                    ...groups,
+                },
+            });
+            if (Object.keys(groups).find((type) => existingGroups[type] !== groups[type])) {
+                this.reloadFeatureFlags();
+            }
+        });
+    }
+    group(groupType, groupKey, groupProperties, options) {
+        this.wrap(() => {
+            this.groups({
+                [groupType]: groupKey,
+            });
+            if (groupProperties) {
+                this.groupIdentify(groupType, groupKey, groupProperties, options);
+            }
+        });
+    }
+    groupIdentify(groupType, groupKey, groupProperties, options) {
+        this.wrap(() => {
+            const distinctId = this.getDistinctId();
+            const eventProperties = this.enrichProperties({});
+            super.groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties);
+        });
+    }
+    /***
+     * PROPERTIES
+     ***/
+    setPersonPropertiesForFlags(properties) {
+        this.wrap(() => {
+            // Get persisted person properties
+            const existingProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, {
+                ...existingProperties,
+                ...properties,
+            });
+        });
+    }
+    resetPersonPropertiesForFlags() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, null);
+        });
+    }
+    /** @deprecated - Renamed to setPersonPropertiesForFlags */
+    personProperties(properties) {
+        return this.setPersonPropertiesForFlags(properties);
+    }
+    setGroupPropertiesForFlags(properties) {
+        this.wrap(() => {
+            // Get persisted group properties
+            const existingProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) ||
+                {};
+            if (Object.keys(existingProperties).length !== 0) {
+                Object.keys(existingProperties).forEach((groupType) => {
+                    existingProperties[groupType] = {
+                        ...existingProperties[groupType],
+                        ...properties[groupType],
+                    };
+                    delete properties[groupType];
+                });
+            }
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, {
+                ...existingProperties,
+                ...properties,
+            });
+        });
+    }
+    resetGroupPropertiesForFlags() {
+        this.wrap(() => {
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, null);
+        });
+    }
+    /** @deprecated - Renamed to setGroupPropertiesForFlags */
+    groupProperties(properties) {
+        this.wrap(() => {
+            this.setGroupPropertiesForFlags(properties);
+        });
+    }
+    async remoteConfigAsync() {
+        await this._initPromise;
+        if (this._remoteConfigResponsePromise) {
+            return this._remoteConfigResponsePromise;
+        }
+        return this._remoteConfigAsync();
+    }
+    /***
+     *** FEATURE FLAGS
+     ***/
+    async decideAsync(sendAnonDistinctId = true) {
+        await this._initPromise;
+        if (this._decideResponsePromise) {
+            return this._decideResponsePromise;
+        }
+        return this._decideAsync(sendAnonDistinctId);
+    }
+    cacheSessionReplay(response) {
+        const sessionReplay = response === null || response === void 0 ? void 0 : response.sessionRecording;
+        if (sessionReplay) {
+            this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay);
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Session replay config: ', JSON.stringify(sessionReplay)));
+        }
+        else {
+            this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay config disabled.'));
+            this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, null);
+        }
+    }
+    async _remoteConfigAsync() {
+        this._remoteConfigResponsePromise = this._initPromise
+            .then(() => {
+            let remoteConfig = this.getPersistedProperty(PostHogPersistedProperty.RemoteConfig);
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached remote config: ', JSON.stringify(remoteConfig)));
+            return super.getRemoteConfig().then((response) => {
+                if (response) {
+                    const remoteConfigWithoutSurveys = { ...response };
+                    delete remoteConfigWithoutSurveys.surveys;
+                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Fetched remote config: ', JSON.stringify(remoteConfigWithoutSurveys)));
+                    const surveys = response.surveys;
+                    let hasSurveys = true;
+                    if (!Array.isArray(surveys)) {
+                        // If surveys is not an array, it means there are no surveys (its a boolean instead)
+                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'There are no surveys.'));
+                        hasSurveys = false;
+                    }
+                    else {
+                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from remote config: ', JSON.stringify(surveys)));
+                    }
+                    if (this.disableSurveys === false && hasSurveys) {
+                        this.setPersistedProperty(PostHogPersistedProperty.Surveys, surveys);
+                    }
+                    else {
+                        this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
+                    }
+                    // we cache the surveys in its own storage key
+                    this.setPersistedProperty(PostHogPersistedProperty.RemoteConfig, remoteConfigWithoutSurveys);
+                    this.cacheSessionReplay(response);
+                    // we only dont load flags if the remote config has no feature flags
+                    if (response.hasFeatureFlags === false) {
+                        // resetting flags to empty object
+                        this.setKnownFeatureFlagDetails({ flags: {} });
+                        this.logMsgIfDebug(() => console.warn('Remote config has no feature flags, will not load feature flags.'));
+                    }
+                    else if (this.preloadFeatureFlags !== false) {
+                        this.reloadFeatureFlags();
+                    }
+                    remoteConfig = response;
+                }
+                return remoteConfig;
+            });
+        })
+            .finally(() => {
+            this._remoteConfigResponsePromise = undefined;
+        });
+        return this._remoteConfigResponsePromise;
+    }
+    async _decideAsync(sendAnonDistinctId = true) {
+        this._decideResponsePromise = this._initPromise
+            .then(async () => {
+            var _a;
+            const distinctId = this.getDistinctId();
+            const groups = this.props.$groups || {};
+            const personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+            const groupProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) ||
+                {};
+            const extraProperties = {
+                $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
+            };
+            const res = await super.getDecide(distinctId, groups, personProperties, groupProperties, extraProperties);
+            // Add check for quota limitation on feature flags
+            if ((_a = res === null || res === void 0 ? void 0 : res.quotaLimited) === null || _a === void 0 ? void 0 : _a.includes(QuotaLimitedFeature.FeatureFlags)) {
+                // Unset all feature flags by setting to null
+                this.setKnownFeatureFlagDetails(null);
+                console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
+                return res;
+            }
+            if (res === null || res === void 0 ? void 0 : res.featureFlags) {
+                // clear flag call reported if we have new flags since they might have changed
+                if (this.sendFeatureFlagEvent) {
+                    this.flagCallReported = {};
+                }
+                let newFeatureFlagDetails = res;
+                if (res.errorsWhileComputingFlags) {
+                    // if not all flags were computed, we upsert flags instead of replacing them
+                    const currentFlagDetails = this.getKnownFeatureFlagDetails();
+                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached feature flags: ', JSON.stringify(currentFlagDetails)));
+                    newFeatureFlagDetails = {
+                        ...res,
+                        flags: { ...currentFlagDetails === null || currentFlagDetails === void 0 ? void 0 : currentFlagDetails.flags, ...res.flags },
+                    };
+                }
+                this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
+                // Mark that we hit the /decide endpoint so we can capture this in the $feature_flag_called event
+                this.setPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit, true);
+                this.cacheSessionReplay(res);
+            }
+            return res;
+        })
+            .finally(() => {
+            this._decideResponsePromise = undefined;
+        });
+        return this._decideResponsePromise;
+    }
+    // We only store the flags and request id in the feature flag details storage key
+    setKnownFeatureFlagDetails(decideResponse) {
+        this.wrap(() => {
+            var _a;
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, decideResponse);
+            this._events.emit('featureflags', getFlagValuesFromFlags((_a = decideResponse === null || decideResponse === void 0 ? void 0 : decideResponse.flags) !== null && _a !== void 0 ? _a : {}));
+        });
+    }
+    getKnownFeatureFlagDetails() {
+        const storedDetails = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails);
+        if (!storedDetails) {
+            // Rebuild from the stored feature flags and feature flag payloads
+            const featureFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+            const featureFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+            if (featureFlags === undefined && featureFlagPayloads === undefined) {
+                return undefined;
+            }
+            return createDecideResponseFromFlagsAndPayloads(featureFlags !== null && featureFlags !== void 0 ? featureFlags : {}, featureFlagPayloads !== null && featureFlagPayloads !== void 0 ? featureFlagPayloads : {});
+        }
+        return normalizeDecideResponse(storedDetails);
+    }
+    getKnownFeatureFlags() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) {
+            return undefined;
+        }
+        return getFlagValuesFromFlags(featureFlagDetails.flags);
+    }
+    getKnownFeatureFlagPayloads() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) {
+            return undefined;
+        }
+        return getPayloadsFromFlags(featureFlagDetails.flags);
+    }
+    getBootstrappedFeatureFlagDetails() {
+        const details = this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails);
+        if (!details) {
+            return undefined;
+        }
+        return details;
+    }
+    setBootstrappedFeatureFlagDetails(details) {
+        this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails, details);
+    }
+    getBootstrappedFeatureFlags() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) {
+            return undefined;
+        }
+        return getFlagValuesFromFlags(details.flags);
+    }
+    getBootstrappedFeatureFlagPayloads() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) {
+            return undefined;
+        }
+        return getPayloadsFromFlags(details.flags);
+    }
+    getFeatureFlag(key) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const details = this.getFeatureFlagDetails();
+        if (!details) {
+            // If we haven't loaded flags yet, or errored out, we respond with undefined
+            return undefined;
+        }
+        const featureFlag = details.flags[key];
+        let response = getFeatureFlagValue(featureFlag);
+        if (response === undefined) {
+            // For cases where the flag is unknown, return false
+            response = false;
+        }
+        if (this.sendFeatureFlagEvent && !this.flagCallReported[key]) {
+            const bootstrappedResponse = (_a = this.getBootstrappedFeatureFlags()) === null || _a === void 0 ? void 0 : _a[key];
+            const bootstrappedPayload = (_b = this.getBootstrappedFeatureFlagPayloads()) === null || _b === void 0 ? void 0 : _b[key];
+            this.flagCallReported[key] = true;
+            this.capture('$feature_flag_called', {
+                $feature_flag: key,
+                $feature_flag_response: response,
+                $feature_flag_id: (_c = featureFlag === null || featureFlag === void 0 ? void 0 : featureFlag.metadata) === null || _c === void 0 ? void 0 : _c.id,
+                $feature_flag_version: (_d = featureFlag === null || featureFlag === void 0 ? void 0 : featureFlag.metadata) === null || _d === void 0 ? void 0 : _d.version,
+                $feature_flag_reason: (_f = (_e = featureFlag === null || featureFlag === void 0 ? void 0 : featureFlag.reason) === null || _e === void 0 ? void 0 : _e.description) !== null && _f !== void 0 ? _f : (_g = featureFlag === null || featureFlag === void 0 ? void 0 : featureFlag.reason) === null || _g === void 0 ? void 0 : _g.code,
+                $feature_flag_bootstrapped_response: bootstrappedResponse,
+                $feature_flag_bootstrapped_payload: bootstrappedPayload,
+                // If we haven't yet received a response from the /decide endpoint, we must have used the bootstrapped value
+                $used_bootstrap_value: !this.getPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit),
+                $feature_flag_request_id: details.requestId,
+            });
+        }
+        // If we have flags we either return the value (true or string) or false
+        return response;
+    }
+    getFeatureFlagPayload(key) {
+        const payloads = this.getFeatureFlagPayloads();
+        if (!payloads) {
+            return undefined;
+        }
+        const response = payloads[key];
+        // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
+        if (response === undefined) {
+            return null;
+        }
+        return response;
+    }
+    getFeatureFlagPayloads() {
+        var _a;
+        return (_a = this.getFeatureFlagDetails()) === null || _a === void 0 ? void 0 : _a.featureFlagPayloads;
+    }
+    getFeatureFlags() {
+        var _a;
+        // NOTE: We don't check for _initPromise here as the function is designed to be
+        // callable before the state being loaded anyways
+        return (_a = this.getFeatureFlagDetails()) === null || _a === void 0 ? void 0 : _a.featureFlags;
+    }
+    getFeatureFlagDetails() {
+        var _a;
+        // NOTE: We don't check for _initPromise here as the function is designed to be
+        // callable before the state being loaded anyways
+        let details = this.getKnownFeatureFlagDetails();
+        const overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
+        if (!overriddenFlags) {
+            return details;
+        }
+        details = details !== null && details !== void 0 ? details : { featureFlags: {}, featureFlagPayloads: {}, flags: {} };
+        const flags = (_a = details.flags) !== null && _a !== void 0 ? _a : {};
+        for (const key in overriddenFlags) {
+            if (!overriddenFlags[key]) {
+                delete flags[key];
+            }
+            else {
+                flags[key] = updateFlagValue(flags[key], overriddenFlags[key]);
+            }
+        }
+        const result = {
+            ...details,
+            flags,
+        };
+        return normalizeDecideResponse(result);
+    }
+    getFeatureFlagsAndPayloads() {
+        const flags = this.getFeatureFlags();
+        const payloads = this.getFeatureFlagPayloads();
+        return {
+            flags,
+            payloads,
+        };
+    }
+    isFeatureEnabled(key) {
+        const response = this.getFeatureFlag(key);
+        if (response === undefined) {
+            return undefined;
+        }
+        return !!response;
+    }
+    // Used when we want to trigger the reload but we don't care about the result
+    reloadFeatureFlags(cb) {
+        this.decideAsync()
+            .then((res) => {
+            cb === null || cb === void 0 ? void 0 : cb(undefined, res === null || res === void 0 ? void 0 : res.featureFlags);
+        })
+            .catch((e) => {
+            cb === null || cb === void 0 ? void 0 : cb(e, undefined);
+            if (!cb) {
+                this.logMsgIfDebug(() => console.log('[PostHog] Error reloading feature flags', e));
+            }
+        });
+    }
+    async reloadRemoteConfigAsync() {
+        return await this.remoteConfigAsync();
+    }
+    async reloadFeatureFlagsAsync(sendAnonDistinctId = true) {
+        var _a;
+        return (_a = (await this.decideAsync(sendAnonDistinctId))) === null || _a === void 0 ? void 0 : _a.featureFlags;
+    }
+    onFeatureFlags(cb) {
+        return this.on('featureflags', async () => {
+            const flags = this.getFeatureFlags();
+            if (flags) {
+                cb(flags);
+            }
+        });
+    }
+    onFeatureFlag(key, cb) {
+        return this.on('featureflags', async () => {
+            const flagResponse = this.getFeatureFlag(key);
+            if (flagResponse !== undefined) {
+                cb(flagResponse);
+            }
+        });
+    }
+    async overrideFeatureFlag(flags) {
+        this.wrap(() => {
+            if (flags === null) {
+                return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, null);
+            }
+            return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
+        });
+    }
+    /***
+     *** ERROR TRACKING
+     ***/
+    captureException(error, additionalProperties) {
+        const properties = {
+            $exception_level: 'error',
+            $exception_list: [
+                {
+                    type: isError(error) ? error.name : 'Error',
+                    value: isError(error) ? error.message : error,
+                    mechanism: {
+                        handled: true,
+                        synthetic: false,
+                    },
+                },
+            ],
+            ...additionalProperties,
+        };
+        properties.$exception_personURL = new URL(`/project/${this.apiKey}/person/${this.getDistinctId()}`, this.host).toString();
+        this.capture('$exception', properties);
+    }
+    /**
+     * Capture written user feedback for a LLM trace. Numeric values are converted to strings.
+     * @param traceId The trace ID to capture feedback for.
+     * @param userFeedback The feedback to capture.
+     */
+    captureTraceFeedback(traceId, userFeedback) {
+        this.capture('$ai_feedback', {
+            $ai_feedback_text: userFeedback,
+            $ai_trace_id: String(traceId),
+        });
+    }
+    /**
+     * Capture a metric for a LLM trace. Numeric values are converted to strings.
+     * @param traceId The trace ID to capture the metric for.
+     * @param metricName The name of the metric to capture.
+     * @param metricValue The value of the metric to capture.
+     */
+    captureTraceMetric(traceId, metricName, metricValue) {
+        this.capture('$ai_metric', {
+            $ai_metric_name: metricName,
+            $ai_metric_value: String(metricValue),
+            $ai_trace_id: String(traceId),
+        });
+    }
+}
+
+let OptionalExpoApplication = undefined;
+try {
+  // macos not supported
+  OptionalExpoApplication = Platform.select({
+    macos: undefined,
+    default: require('expo-application')
+  });
+} catch (e) {}
+
+let OptionalExpoFileSystem = undefined;
+try {
+  // do not try to load expo-file-system on web and macos, otherwise it will throw an error
+  // Error: The method or property expo-file-system.writeAsStringAsync is not available on web
+  // See https://github.com/PostHog/posthog-js-lite/issues/140
+  // Once expo-file-system is supported on web/macos, we can remove this try/catch block
+  // For now, use the react-native-async-storage/async-storage package instead
+  OptionalExpoFileSystem = Platform.select({
+    macos: undefined,
+    web: undefined,
+    default: require('expo-file-system')
+  });
+} catch (e) {}
+
+const getLegacyValues = async () => {
+  // NOTE: The old react-native lib stored data in files on the filesystem.
+  // This function takes care of pulling the legacy IDs to ensure we are using them if already present
+  if (!OptionalExpoFileSystem || !OptionalExpoApplication) {
+    return;
+  }
+  // legacy didn't support macos, no need to check it
+  if (Platform.OS === 'ios') {
+    const posthogFileDirectory = `${OptionalExpoFileSystem.documentDirectory}../Library/Application%20Support/${OptionalExpoApplication.applicationId}/`;
+    const posthogDistinctIdFile = posthogFileDirectory + 'posthog.distinctId';
+    const posthogAnonymousIdFile = posthogFileDirectory + 'posthog.anonymousId';
+    const res = {
+      distinctId: undefined,
+      anonymousId: undefined
+    };
+    try {
+      res.distinctId = JSON.parse(await OptionalExpoFileSystem.readAsStringAsync(posthogDistinctIdFile))['posthog.distinctId'];
+    } catch (e) {}
+    try {
+      res.anonymousId = JSON.parse(await OptionalExpoFileSystem.readAsStringAsync(posthogAnonymousIdFile))['posthog.anonymousId'];
+    } catch (e) {}
+    return res;
+  }
+};
+
+const POSTHOG_STORAGE_KEY = '.posthog-rn.json';
+const POSTHOG_STORAGE_VERSION = 'v1';
+class PostHogRNStorage {
+  constructor(storage) {
+    var _a;
+    this.memoryCache = {};
+    this.storage = storage;
+    const preloadResult = this.storage.getItem(POSTHOG_STORAGE_KEY);
+    if (isPromise(preloadResult)) {
+      this.preloadPromise = preloadResult.then(res => {
+        this.populateMemoryCache(res);
+      });
+      (_a = this.preloadPromise) === null || _a === void 0 ? void 0 : _a.finally(() => {
+        this.preloadPromise = undefined;
+      });
+    } else {
+      this.populateMemoryCache(preloadResult);
+    }
+  }
+  persist() {
+    const payload = {
+      version: POSTHOG_STORAGE_VERSION,
+      content: this.memoryCache
+    };
+    void this.storage.setItem(POSTHOG_STORAGE_KEY, JSON.stringify(payload));
+  }
+  getItem(key) {
+    return this.memoryCache[key];
+  }
+  setItem(key, value) {
+    this.memoryCache[key] = value;
+    this.persist();
+  }
+  removeItem(key) {
+    delete this.memoryCache[key];
+    this.persist();
+  }
+  clear() {
+    for (const key in this.memoryCache) {
+      delete this.memoryCache[key];
+    }
+    this.persist();
+  }
+  getAllKeys() {
+    return Object.keys(this.memoryCache);
+  }
+  populateMemoryCache(res) {
+    try {
+      const data = res ? JSON.parse(res).content : {};
+      for (const key in data) {
+        this.memoryCache[key] = data[key];
+      }
+    } catch (e) {
+      console.warn("PostHog failed to load persisted data from storage. This is likely because the storage format is. We'll reset the storage.", e);
+    }
+  }
+}
+class PostHogRNSyncMemoryStorage extends PostHogRNStorage {
+  constructor() {
+    const cache = {};
+    const storage = {
+      getItem: key => cache[key],
+      setItem: (key, value) => {
+        cache[key] = value;
+      }
+    };
+    super(storage);
+  }
+}
+
+const version = "3.15.0";
+
+let OptionalAsyncStorage = undefined;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  OptionalAsyncStorage = require('@react-native-async-storage/async-storage').default;
+} catch (e) {}
+
+let OptionalExpoDevice = undefined;
+try {
+  // macos not supported
+  OptionalExpoDevice = Platform.select({
+    macos: undefined,
+    default: require('expo-device')
+  });
+} catch (e) {}
+
+let OptionalExpoLocalization = undefined;
+try {
+  // macos not supported
+  OptionalExpoLocalization = Platform.select({
+    macos: undefined,
+    default: require('expo-localization')
+  });
+} catch (e) {}
+
+let OptionalReactNativeDeviceInfo = undefined;
+try {
+  // macos not supported
+  OptionalReactNativeDeviceInfo = Platform.select({
+    macos: undefined,
+    default: require('react-native-device-info') // No Web support, returns unknown
+  });
+} catch (e) {}
+
+let OptionalReactNativeLocalize = undefined;
+// web support requires webpack
+// https://github.com/zoontek/react-native-localize#web-support
+try {
+  OptionalReactNativeLocalize = require('react-native-localize');
+} catch (e) {}
+
+const getDeviceType = () => {
+  let deviceType = 'Mobile';
+  if (Platform.OS === 'macos' || Platform.OS === 'windows') {
+    deviceType = 'Desktop';
+  } else if (Platform.OS === 'web') {
+    deviceType = 'Web';
+  }
+  return deviceType;
+};
+const currentDeviceType = getDeviceType();
+const getAppProperties = () => {
+  const properties = {
+    $device_type: currentDeviceType
+  };
+  if (OptionalExpoApplication) {
+    properties.$app_build = OptionalExpoApplication.nativeBuildVersion;
+    properties.$app_name = OptionalExpoApplication.applicationName;
+    properties.$app_namespace = OptionalExpoApplication.applicationId;
+    properties.$app_version = OptionalExpoApplication.nativeApplicationVersion;
+  } else if (OptionalReactNativeDeviceInfo) {
+    properties.$app_build = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getBuildNumber());
+    properties.$app_name = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getApplicationName());
+    properties.$app_namespace = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getBundleId());
+    properties.$app_version = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getVersion());
+  }
+  if (OptionalExpoDevice) {
+    properties.$device_manufacturer = OptionalExpoDevice.manufacturer;
+    // expo-device already maps the device model identifier to a human readable name
+    properties.$device_name = OptionalExpoDevice.modelName;
+    // https://github.com/expo/expo/issues/6990
+    // some devices return a value similar to:
+    // HUAWEI/SNE-LX1/HWSNE:8.1.0/HUAWEISNE-LX1/131(C432):user/release-keys
+    if (Platform.OS === 'android') {
+      properties.$os_name = 'Android';
+    } else {
+      properties.$os_name = OptionalExpoDevice.osName;
+    }
+    properties.$os_version = OptionalExpoDevice.osVersion;
+  } else if (OptionalReactNativeDeviceInfo) {
+    properties.$device_manufacturer = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getManufacturerSync());
+    // react-native-device-info already maps the device model identifier to a human readable name
+    properties.$device_name = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getModel());
+    properties.$os_name = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getSystemName());
+    properties.$os_version = returnPropertyIfNotUnknown(OptionalReactNativeDeviceInfo.getSystemVersion());
+  }
+  if (OptionalExpoLocalization) {
+    properties.$locale = OptionalExpoLocalization.locale;
+    properties.$timezone = OptionalExpoLocalization.timezone;
+  } else if (OptionalReactNativeLocalize) {
+    const localesFn = OptionalReactNativeLocalize.getLocales;
+    if (localesFn) {
+      const locales = localesFn();
+      if (locales && locales.length > 0) {
+        const languageTag = locales[0].languageTag;
+        if (languageTag) {
+          properties.$locale = languageTag;
+        }
+      }
+    }
+    const timezoneFn = OptionalReactNativeLocalize.getTimeZone;
+    if (timezoneFn) {
+      const timezone = timezoneFn();
+      if (timezone) {
+        properties.$timezone = timezone;
+      }
+    }
+  }
+  return properties;
+};
+// react-native-device-info returns 'unknown' if the property is not available (Web target)
+const returnPropertyIfNotUnknown = value => {
+  if (value !== 'unknown') {
+    return value;
+  }
+  return null;
+};
+const buildOptimisiticAsyncStorage = () => {
+  if (OptionalExpoFileSystem) {
+    const filesystem = OptionalExpoFileSystem;
+    return {
+      async getItem(key) {
+        const uri = (filesystem.documentDirectory || '') + key;
+        try {
+          const stringContent = await filesystem.readAsStringAsync(uri);
+          return stringContent;
+        } catch (e) {
+          return null;
+        }
+      },
+      async setItem(key, value) {
+        const uri = (filesystem.documentDirectory || '') + key;
+        await filesystem.writeAsStringAsync(uri, value);
+      }
+    };
+  }
+  if (OptionalAsyncStorage) {
+    return OptionalAsyncStorage;
+  }
+  throw new Error('PostHog: No storage available. Please install expo-filesystem or react-native-async-storage OR implement a custom storage provider.');
+};
+
+let OptionalReactNativeNavigationWix = undefined;
+try {
+  // macos/web not supported
+  OptionalReactNativeNavigationWix = Platform.select({
+    macos: undefined,
+    web: undefined,
+    default: require('react-native-navigation')
+  });
+} catch (e) {}
+
+/*
+ * Wix Navigation (react-native-navigation)
+ *
+ * Wix Navigation uses a very different paradigm for rendering screens, with a more imperative / config driven approach
+ * Instead of hooking into the natural React lifecycle, it provides a very different API which we can hook into and use instead.
+ */
+const withReactNativeNavigation = (posthog, options = {}) => {
+  if (!OptionalReactNativeNavigationWix) {
+    return false;
+  }
+  const Navigation = OptionalReactNativeNavigationWix.Navigation;
+  // Equivalent of `useNavigationTracker`
+  Navigation.events().registerComponentDidAppearListener(({
+    componentName,
+    passProps
+  }) => {
+    var _a, _b, _c, _d, _e;
+    if (!((_a = options.captureScreens) !== null && _a !== void 0 ? _a : true)) {
+      return;
+    }
+    const currentRouteName = ((_c = (_b = options === null || options === void 0 ? void 0 : options.navigation) === null || _b === void 0 ? void 0 : _b.routeToName) === null || _c === void 0 ? void 0 : _c.call(_b, componentName, passProps || {})) || componentName || 'Unknown';
+    if (currentRouteName) {
+      const properties = (_e = (_d = options === null || options === void 0 ? void 0 : options.navigation) === null || _d === void 0 ? void 0 : _d.routeToProperties) === null || _e === void 0 ? void 0 : _e.call(_d, currentRouteName, passProps || {});
+      posthog.screen(currentRouteName, properties);
+    }
+  });
+  return true;
+};
+
+let OptionalReactNativeSessionReplay = undefined;
+try {
+  OptionalReactNativeSessionReplay = Platform.select({
+    macos: undefined,
+    web: undefined,
+    default: require('posthog-react-native-session-replay') // Only Android and iOS
+  });
+} catch (e) {}
+
+class PostHog extends PostHogCore {
+  constructor(apiKey, options) {
+    var _a, _b, _c, _d;
+    super(apiKey, options);
+    this._appProperties = {};
+    this._isInitialized = false;
+    this._persistence = (_a = options === null || options === void 0 ? void 0 : options.persistence) !== null && _a !== void 0 ? _a : 'file';
+    this._disableSurveys = (_b = options === null || options === void 0 ? void 0 : options.disableSurveys) !== null && _b !== void 0 ? _b : false;
+    this._disableRemoteConfig = (_c = options === null || options === void 0 ? void 0 : options.disableRemoteConfig) !== null && _c !== void 0 ? _c : false;
+    // Either build the app properties from the existing ones
+    this._appProperties = typeof (options === null || options === void 0 ? void 0 : options.customAppProperties) === 'function' ? options.customAppProperties(getAppProperties()) : (options === null || options === void 0 ? void 0 : options.customAppProperties) || getAppProperties();
+    AppState.addEventListener('change', () => {
+      void this.flush();
+    });
+    let storagePromise;
+    if (this._persistence === 'file') {
+      this._storage = new PostHogRNStorage((_d = options === null || options === void 0 ? void 0 : options.customStorage) !== null && _d !== void 0 ? _d : buildOptimisiticAsyncStorage());
+      storagePromise = this._storage.preloadPromise;
+    } else {
+      this._storage = new PostHogRNSyncMemoryStorage();
+    }
+    if (storagePromise) {
+      storagePromise.then(() => {
+        // This code is for migrating from V1 to V2 and tries its best to keep the existing anon/distinctIds
+        // It only applies for async storage
+        if (!this._storage.getItem(PostHogPersistedProperty.AnonymousId)) {
+          void getLegacyValues().then(legacyValues => {
+            var _a, _b;
+            if (legacyValues === null || legacyValues === void 0 ? void 0 : legacyValues.distinctId) {
+              (_a = this._storage) === null || _a === void 0 ? void 0 : _a.setItem(PostHogPersistedProperty.DistinctId, legacyValues.distinctId);
+              (_b = this._storage) === null || _b === void 0 ? void 0 : _b.setItem(PostHogPersistedProperty.AnonymousId, legacyValues.anonymousId);
+            }
+          });
+        }
+      });
+    }
+    const initAfterStorage = () => {
+      // reset session id on app restart
+      const enablePersistSessionIdAcrossRestart = options === null || options === void 0 ? void 0 : options.enablePersistSessionIdAcrossRestart;
+      if (!enablePersistSessionIdAcrossRestart) {
+        this.setPersistedProperty(PostHogPersistedProperty.SessionId, null);
+        this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, null);
+      }
+      this.setupBootstrap(options);
+      this._isInitialized = true;
+      if (this._disableRemoteConfig === false) {
+        this.reloadRemoteConfigAsync();
+      } else {
+        this.logMsgIfDebug(() => console.info('PostHog Debug', `Remote config is disabled.`));
+        if ((options === null || options === void 0 ? void 0 : options.preloadFeatureFlags) !== false) {
+          this.logMsgIfDebug(() => console.info('PostHog Debug', `Feature flags will be preloaded from Decide API.`));
+          this.reloadFeatureFlags();
+        } else {
+          this.logMsgIfDebug(() => console.info('PostHog Debug', `preloadFeatureFlags is disabled.`));
+        }
+      }
+      // this value could have been inferred from the autocapture options (captureLifecycleEvents)
+      if (options === null || options === void 0 ? void 0 : options.captureNativeAppLifecycleEvents) {
+        void this.captureNativeAppLifecycleEvents();
+      }
+      void this.persistAppVersion();
+      void this.startSessionReplay(options);
+    };
+    // For async storage, we wait for the storage to be ready before we start the SDK
+    // For sync storage we can start the SDK immediately
+    if (storagePromise) {
+      this._initPromise = storagePromise.then(initAfterStorage);
+    } else {
+      this._initPromise = Promise.resolve();
+      initAfterStorage();
+    }
+  }
+  // NOTE: This is purely a helper method for testing purposes or those who wish to be certain the SDK is fully initialised
+  async ready() {
+    await this._initPromise;
+  }
+  getPersistedProperty(key) {
+    return this._storage.getItem(key);
+  }
+  setPersistedProperty(key, value) {
+    return value !== null ? this._storage.setItem(key, value) : this._storage.removeItem(key);
+  }
+  fetch(url, options) {
+    return fetch(url, options);
+  }
+  getLibraryId() {
+    return 'posthog-react-native';
+  }
+  getLibraryVersion() {
+    return version;
+  }
+  getCustomUserAgent() {
+    if (Platform.OS === 'web') {
+      return '';
+    }
+    return `${this.getLibraryId()}/${this.getLibraryVersion()}`;
+  }
+  getCommonEventProperties() {
+    return {
+      ...super.getCommonEventProperties(),
+      ...this._appProperties,
+      $screen_height: Dimensions.get('screen').height,
+      $screen_width: Dimensions.get('screen').width
+    };
+  }
+  // Custom methods
+  async screen(name, properties, options) {
+    await this._initPromise;
+    // Screen name is good to know for all other subsequent events
+    this.registerForSession({
+      $screen_name: name
+    });
+    return this.capture('$screen', {
+      ...properties,
+      $screen_name: name
+    }, options);
+  }
+  _isEnableSessionReplay() {
+    var _a;
+    return !this.isDisabled && ((_a = this._enableSessionReplay) !== null && _a !== void 0 ? _a : false);
+  }
+  _resetSessionId(reactNativeSessionReplay, sessionId) {
+    // _resetSessionId is only called if reactNativeSessionReplay not undefined, but the linter wasn't happy
+    if (reactNativeSessionReplay) {
+      reactNativeSessionReplay.endSession();
+      reactNativeSessionReplay.startSession(sessionId);
+    }
+  }
+  getSessionId() {
+    const sessionId = super.getSessionId();
+    if (!this._isEnableSessionReplay()) {
+      return sessionId;
+    }
+    // only rotate if there is a new sessionId and it is different from the current one
+    if (sessionId.length > 0 && this._currentSessionId && sessionId !== this._currentSessionId) {
+      if (OptionalReactNativeSessionReplay) {
+        try {
+          this._resetSessionId(OptionalReactNativeSessionReplay, sessionId);
+          this.logMsgIfDebug(() => console.info('PostHog Debug', `Session replay started with sessionId ${sessionId}.`));
+        } catch (e) {
+          this.logMsgIfDebug(() => console.error('PostHog Debug', `Session replay failed to start with sessionId: ${e}.`));
+        }
+      }
+      this._currentSessionId = sessionId;
+    } else {
+      this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay session id not rotated, sessionId ${sessionId} and currentSessionId ${this._currentSessionId}.`));
+    }
+    return sessionId;
+  }
+  resetSessionId() {
+    super.resetSessionId();
+    if (this._isEnableSessionReplay() && OptionalReactNativeSessionReplay) {
+      try {
+        OptionalReactNativeSessionReplay.endSession();
+        this.logMsgIfDebug(() => console.info('PostHog Debug', `Session replay ended.`));
+      } catch (e) {
+        this.logMsgIfDebug(() => console.error('PostHog Debug', `Session replay failed to end: ${e}.`));
+      }
+    }
+  }
+  identify(distinctId, properties, options) {
+    const previousDistinctId = this.getDistinctId();
+    super.identify(distinctId, properties, options);
+    if (this._isEnableSessionReplay() && OptionalReactNativeSessionReplay) {
+      try {
+        distinctId = distinctId || previousDistinctId;
+        OptionalReactNativeSessionReplay.identify(distinctId, this.getAnonymousId());
+        this.logMsgIfDebug(() => console.info('PostHog Debug', `Session replay identified with distinctId ${distinctId}.`));
+      } catch (e) {
+        this.logMsgIfDebug(() => console.error('PostHog Debug', `Session replay failed to identify: ${e}.`));
+      }
+    }
+  }
+  initReactNativeNavigation(options) {
+    return withReactNativeNavigation(this, options);
+  }
+  async getSurveys() {
+    if (this._disableSurveys === true) {
+      this.logMsgIfDebug(() => console.log('Loading surveys is disabled.'));
+      this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
+      return [];
+    }
+    const surveys = this.getPersistedProperty(PostHogPersistedProperty.Surveys);
+    if (surveys && surveys.length > 0) {
+      this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from storage: ', JSON.stringify(surveys)));
+      return surveys;
+    } else {
+      this.logMsgIfDebug(() => console.log('PostHog Debug', 'No surveys found in storage'));
+    }
+    if (this._disableRemoteConfig === true) {
+      const surveysFromApi = await super.getSurveysStateless();
+      if (surveysFromApi && surveysFromApi.length > 0) {
+        this.setPersistedProperty(PostHogPersistedProperty.Surveys, surveysFromApi);
+        return surveysFromApi;
+      }
+    }
+    return [];
+  }
+  async startSessionReplay(options) {
+    var _a, _b, _c, _d, _e;
+    this._enableSessionReplay = options === null || options === void 0 ? void 0 : options.enableSessionReplay;
+    if (!this._isEnableSessionReplay()) {
+      this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay is not enabled.'));
+      return;
+    }
+    const {
+      maskAllTextInputs = true,
+      maskAllImages = true,
+      maskAllSandboxedViews = true,
+      maskPhotoLibraryImages = false,
+      captureLog = true,
+      captureNetworkTelemetry = true,
+      iOSdebouncerDelayMs = 1000,
+      androidDebouncerDelayMs = 1000
+    } = (_a = options === null || options === void 0 ? void 0 : options.sessionReplayConfig) !== null && _a !== void 0 ? _a : {};
+    const sdkReplayConfig = {
+      maskAllTextInputs,
+      maskAllImages,
+      maskAllSandboxedViews,
+      maskPhotoLibraryImages,
+      captureLog,
+      captureNetworkTelemetry,
+      iOSdebouncerDelayMs,
+      androidDebouncerDelayMs
+    };
+    this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay sdk config: ${JSON.stringify(sdkReplayConfig)}`));
+    // if Decide has not returned yet, we will start session replay with default config.
+    const sessionReplay = (_b = this.getPersistedProperty(PostHogPersistedProperty.SessionReplay)) !== null && _b !== void 0 ? _b : {};
+    const featureFlags = (_c = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags)) !== null && _c !== void 0 ? _c : {};
+    const decideFeatureFlags = (_d = featureFlags) !== null && _d !== void 0 ? _d : {};
+    const decideReplayConfig = (_e = sessionReplay) !== null && _e !== void 0 ? _e : {};
+    this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay decide cached config: ${JSON.stringify(decideReplayConfig)}`));
+    let recordingActive = true;
+    const linkedFlag = decideReplayConfig['linkedFlag'];
+    if (typeof linkedFlag === 'string') {
+      const value = decideFeatureFlags[linkedFlag];
+      if (typeof value === 'boolean') {
+        recordingActive = value;
+      } else if (typeof value === 'string') {
+        // if its a multi-variant flag linked to "any"
+        recordingActive = true;
+      } else {
+        // disable recording if the flag does not exist/quota limited
+        recordingActive = false;
+      }
+      this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay ${linkedFlag} linked flag value: ${value}`));
+    } else if (linkedFlag && typeof linkedFlag === 'object') {
+      const flag = linkedFlag['flag'];
+      const variant = linkedFlag['variant'];
+      if (flag && variant) {
+        const value = decideFeatureFlags[flag];
+        recordingActive = value === variant;
+        this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay ${flag} linked flag variant: ${variant} and value ${value}`));
+      } else {
+        // disable recording if the flag does not exist/quota limited
+        recordingActive = false;
+      }
+    }
+    if (recordingActive) {
+      if (OptionalReactNativeSessionReplay) {
+        const sessionId = this.getSessionId();
+        if (sessionId.length === 0) {
+          this.logMsgIfDebug(() => console.warn('PostHog Debug', 'Session replay enabled but no sessionId found.'));
+          return;
+        }
+        const sdkOptions = {
+          apiKey: this.apiKey,
+          host: this.host,
+          debug: this.isDebug,
+          distinctId: this.getDistinctId(),
+          anonymousId: this.getAnonymousId(),
+          sdkVersion: this.getLibraryVersion(),
+          flushAt: this.flushAt
+        };
+        this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay sdk options: ${JSON.stringify(sdkOptions)}`));
+        try {
+          if (!(await OptionalReactNativeSessionReplay.isEnabled())) {
+            await OptionalReactNativeSessionReplay.start(sessionId, sdkOptions, sdkReplayConfig, decideReplayConfig);
+            this.logMsgIfDebug(() => console.info('PostHog Debug', `Session replay started with sessionId ${sessionId}.`));
+          } else {
+            // if somehow the SDK is already enabled with a different sessionId, we reset it
+            this._resetSessionId(OptionalReactNativeSessionReplay, sessionId);
+            this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay already started with sessionId ${sessionId}.`));
+          }
+          this._currentSessionId = sessionId;
+        } catch (e) {
+          this.logMsgIfDebug(() => console.error('PostHog Debug', `Session replay failed to start: ${e}.`));
+        }
+      } else {
+        this.logMsgIfDebug(() => console.warn('PostHog Debug', 'Session replay enabled but not installed.'));
+      }
+    } else {
+      this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay disabled.'));
+    }
+  }
+  async captureNativeAppLifecycleEvents() {
+    var _a;
+    const appBuild = this._appProperties.$app_build;
+    const appVersion = this._appProperties.$app_version;
+    const isMemoryPersistence = this._persistence === 'memory';
+    // version and build are deprecated, but we keep them for compatibility
+    // use $app_version and $app_build instead
+    const properties = {
+      version: appVersion,
+      build: appBuild
+    };
+    if (!isMemoryPersistence) {
+      const prevAppBuild = this.getPersistedProperty(PostHogPersistedProperty.InstalledAppBuild);
+      const prevAppVersion = this.getPersistedProperty(PostHogPersistedProperty.InstalledAppVersion);
+      if (!appBuild || !appVersion) {
+        this.logMsgIfDebug(() => console.warn('PostHog could not track installation/update/open, as the build and version were not set. ' + 'This can happen if some dependencies are not installed correctly, or if you have provided' + 'customAppProperties but not included $app_build or $app_version.'));
+      }
+      if (appBuild) {
+        if (!prevAppBuild) {
+          // new app install
+          this.capture('Application Installed', properties);
+        } else if (prevAppBuild !== appBuild) {
+          // app updated
+          this.capture('Application Updated', {
+            previous_version: prevAppVersion,
+            previous_build: prevAppBuild,
+            ...properties
+          });
+        }
+      }
+    } else {
+      this.logMsgIfDebug(() => console.warn('PostHog was initialised with persistence set to "memory", capturing native app events (Application Installed and Application Updated) is not supported.'));
+    }
+    const initialUrl = (_a = await Linking.getInitialURL()) !== null && _a !== void 0 ? _a : undefined;
+    this.capture('Application Opened', {
+      ...properties,
+      url: initialUrl
+    });
+    AppState.addEventListener('change', state => {
+      if (state === 'active') {
+        this.capture('Application Became Active');
+      } else if (state === 'background') {
+        this.capture('Application Backgrounded');
+      }
+    });
+  }
+  async persistAppVersion() {
+    const appBuild = this._appProperties.$app_build;
+    const appVersion = this._appProperties.$app_version;
+    this.setPersistedProperty(PostHogPersistedProperty.InstalledAppBuild, appBuild);
+    this.setPersistedProperty(PostHogPersistedProperty.InstalledAppVersion, appVersion);
+  }
+}
+
+let OptionalReactNativeNavigation = undefined;
+try {
+  // macos not supported
+  OptionalReactNativeNavigation = Platform.select({
+    macos: undefined,
+    // experimental support for web https://reactnavigation.org/docs/web-support/
+    default: require('@react-navigation/native')
+  });
+} catch (e) {}
+
+const PostHogContext = /*#__PURE__*/React.createContext({
+  client: undefined
+});
+
+const usePostHog = () => {
+  const {
+    client
+  } = React.useContext(PostHogContext);
+  return client;
+};
+
+function _useNavigationTrackerDisabled() {
+  return;
+}
+function _useNavigationTracker(options, navigationRef, client) {
+  const contextClient = usePostHog();
+  const posthog = client || contextClient;
+  if (!OptionalReactNativeNavigation) {
+    // NOTE: This is taken care of by the export, but we keep this here for TS
+    throw new Error('No OptionalReactNativeNavigation');
+  }
+  const routes = OptionalReactNativeNavigation.useNavigationState(state => state === null || state === void 0 ? void 0 : state.routes);
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const navigation = navigationRef || OptionalReactNativeNavigation.useNavigation();
+  const trackRoute = useCallback(() => {
+    var _a, _b, _c;
+    if (!navigation) {
+      return;
+    }
+    let currentRoute = undefined;
+    // NOTE: This method is not typed correctly but is available and takes care of parsing the router state correctly
+    try {
+      let isReady = false;
+      try {
+        isReady = navigation.isReady();
+      } catch (error) {
+        // keep compatibility with older versions of react-navigation
+        isReady = true;
+      }
+      if (!isReady) {
+        return;
+      }
+      currentRoute = navigation.getCurrentRoute();
+    } catch (error) {
+      return;
+    }
+    if (!currentRoute) {
+      return;
+    }
+    const {
+      state
+    } = currentRoute;
+    let {
+      name,
+      params
+    } = currentRoute;
+    if ((_a = state === null || state === void 0 ? void 0 : state.routes) === null || _a === void 0 ? void 0 : _a.length) {
+      const route = state.routes[state.routes.length - 1];
+      name = route.name;
+      params = route.params;
+    }
+    const currentRouteName = ((_b = options === null || options === void 0 ? void 0 : options.routeToName) === null || _b === void 0 ? void 0 : _b.call(options, name, params)) || name || 'Unknown';
+    if (currentRouteName) {
+      const properties = (_c = options === null || options === void 0 ? void 0 : options.routeToProperties) === null || _c === void 0 ? void 0 : _c.call(options, currentRouteName, params);
+      posthog.screen(currentRouteName, properties);
+    }
+  }, [navigation, options, posthog]);
+  useEffect(() => {
+    // NOTE: The navigation stacks may not be fully rendered initially. This means the first route can be missed (it doesn't update useNavigationState)
+    // If missing we simply wait a tick and call it again.
+    if (!routes) {
+      setTimeout(trackRoute, 1);
+      return;
+    }
+    trackRoute();
+  }, [routes, trackRoute]);
+}
+const useNavigationTracker = OptionalReactNativeNavigation ? _useNavigationTracker : _useNavigationTrackerDisabled;
+
+function useFeatureFlags(client) {
+  const contextClient = usePostHog();
+  const posthog = client || contextClient;
+  const [featureFlags, setFeatureFlags] = useState(posthog.getFeatureFlags());
+  useEffect(() => {
+    setFeatureFlags(posthog.getFeatureFlags());
+    return posthog.onFeatureFlags(flags => {
+      setFeatureFlags(flags);
+    });
+  }, [posthog]);
+  return featureFlags;
+}
+
+function useFeatureFlag(flag, client) {
+  const contextClient = usePostHog();
+  const posthog = client || contextClient;
+  const [featureFlag, setFeatureFlag] = useState(posthog.getFeatureFlag(flag));
+  useEffect(() => {
+    setFeatureFlag(posthog.getFeatureFlag(flag));
+    return posthog.onFeatureFlags(() => {
+      setFeatureFlag(posthog.getFeatureFlag(flag));
+    });
+  }, [posthog, flag]);
+  return featureFlag;
+}
+function useFeatureFlagWithPayload(flag, client) {
+  const contextClient = usePostHog();
+  const posthog = client || contextClient;
+  const [featureFlag, setFeatureFlag] = useState([undefined, undefined]);
+  useEffect(() => {
+    setFeatureFlag([posthog.getFeatureFlag(flag), posthog.getFeatureFlagPayload(flag)]);
+    return posthog.onFeatureFlags(() => {
+      setFeatureFlag([posthog.getFeatureFlag(flag), posthog.getFeatureFlagPayload(flag)]);
+    });
+  }, [posthog, flag]);
+  return featureFlag;
+}
+
+const flattenStyles = styles => {
+  const flattened = {};
+  if (Array.isArray(styles)) {
+    for (const style of styles) {
+      Object.assign(flattened, flattenStyles(style));
+    }
+  } else {
+    Object.assign(flattened, styles);
+  }
+  return flattened;
+};
+const stringifyStyle = styles => {
+  const flattened = flattenStyles(styles);
+  const str = Object.keys(flattened).map(x => `${x}:${flattened[x]}`).join(';');
+  return str;
+};
+const sanitiseLabel = label => {
+  return label.replace(/[^a-z0-9]+/gi, '-');
+};
+const defaultPostHogLabelProp = 'ph-label';
+const autocaptureFromTouchEvent = (e, posthog, options = {}) => {
+  var _a, _b;
+  const {
+    noCaptureProp = 'ph-no-capture',
+    customLabelProp = defaultPostHogLabelProp,
+    maxElementsCaptured = 20,
+    ignoreLabels = [],
+    propsToCapture = ['style', 'testID', 'accessibilityLabel', customLabelProp, 'children']
+  } = options;
+  if (!e._targetInst) {
+    return;
+  }
+  const elements = [];
+  let currentInst = e._targetInst;
+  while (currentInst &&
+  // maxComponentTreeSize will always be defined as we have a defaultProps. But ts needs a check so this is here.
+  elements.length < maxElementsCaptured) {
+    const el = {
+      tag_name: ''
+    };
+    const props = currentInst.memoizedProps;
+    if (props === null || props === void 0 ? void 0 : props[noCaptureProp]) {
+      // Immediately ignore events if a no capture is in the chain
+      return;
+    }
+    if (props) {
+      // Capture only props we have said to capture. By default this is only "safe" props
+      Object.keys(props).forEach(key => {
+        if (!propsToCapture.includes(key)) {
+          return;
+        }
+        const value = props[key];
+        if (key === 'style') {
+          el.attr__style = stringifyStyle(value);
+        } else if (['string', 'number', 'boolean'].includes(typeof value)) {
+          if (key === 'children') {
+            el.$el_text = typeof value === 'string' ? value : JSON.stringify(value);
+          } else {
+            el[`attr__${key}`] = value;
+          }
+        }
+      });
+    }
+    // Try and find a sensible label
+    const label = typeof (props === null || props === void 0 ? void 0 : props[customLabelProp]) !== 'undefined' ? `${props[customLabelProp]}` : ((_a = currentInst.elementType) === null || _a === void 0 ? void 0 : _a.displayName) || ((_b = currentInst.elementType) === null || _b === void 0 ? void 0 : _b.name);
+    if (label && !ignoreLabels.includes(label)) {
+      el.tag_name = sanitiseLabel(label);
+      elements.push(el);
+    }
+    currentInst = currentInst.return;
+  }
+  if (elements.length) {
+    // The element that was tapped, may be a child (or grandchild of an element with a customLabelProp (default: ph-label))
+    // In this case, the current labels applied obscure the customLabelProp (default: ph-label)
+    // To correct this, loop over the elements in reverse, and promote the customLabelProp (default: ph-label)
+    const elAttrLabelKey = `attr__${customLabelProp}`;
+    let lastLabel = undefined;
+    for (let i = elements.length - 1; i >= 0; i--) {
+      const element = elements[i];
+      if (element[elAttrLabelKey]) {
+        // this element had a customLabelProp (default: ph-label) set, promote it to the lastLabel
+        lastLabel = element[elAttrLabelKey];
+      }
+      // if lastLabel is set, update this elements tag_name
+      if (lastLabel) {
+        element['tag_name'] = lastLabel;
+      }
+    }
+    posthog.autocapture('touch', elements, {
+      $touch_x: e.nativeEvent.pageX,
+      $touch_y: e.nativeEvent.pageY
+    });
+  }
+};
+
+function PostHogNavigationHook({
+  options,
+  client
+}) {
+  useNavigationTracker(options === null || options === void 0 ? void 0 : options.navigation, options === null || options === void 0 ? void 0 : options.navigationRef, client);
+  return null;
+}
+const PostHogProvider = ({
+  children,
+  client,
+  options,
+  apiKey,
+  autocapture,
+  style,
+  debug = false
+}) => {
+  var _a;
+  if (!client && !apiKey) {
+    throw new Error('Either a PostHog client or an apiKey is required. If you want to use the PostHogProvider without a client, please provide an apiKey and the options={ disabled: true }.');
+  }
+  const captureAll = autocapture === true;
+  const captureNone = autocapture === false;
+  const posthog = useMemo(() => {
+    var _a;
+    if (client && apiKey) {
+      console.warn('You have provided both a client and an apiKey to PostHogProvider. The apiKey will be ignored in favour of the client.');
+    }
+    if (client) {
+      return client;
+    }
+    const parsedOptions = {
+      ...options,
+      // For backwards-compatible reasons, this information can be stored in two separate places
+      // Default to true if not set
+      captureNativeAppLifecycleEvents: (options === null || options === void 0 ? void 0 : options.captureNativeAppLifecycleEvents) !== undefined ? options.captureNativeAppLifecycleEvents : !captureNone && (captureAll || ((_a = autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.captureLifecycleEvents) !== null && _a !== void 0 ? _a : true))
+    };
+    return new PostHog(apiKey !== null && apiKey !== void 0 ? apiKey : '', parsedOptions);
+  }, [client, apiKey]); // eslint-disable-line react-hooks/exhaustive-deps
+  const autocaptureOptions = useMemo(() => autocapture && typeof autocapture !== 'boolean' ? autocapture : {}, [autocapture]);
+  const captureTouches = !captureNone && posthog && (captureAll || (autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.captureTouches));
+  const captureScreens = !captureNone && posthog && (captureAll || ((_a = autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.captureScreens) !== null && _a !== void 0 ? _a : true)); // Default to true if not set
+  const phLabelProp = (autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.customLabelProp) || defaultPostHogLabelProp;
+  useEffect(() => {
+    posthog.debug(debug);
+  }, [debug, posthog]);
+  const onTouch = useCallback((type, e) => {
+    // TODO: Improve this to ensure we only capture presses and not just ends of a drag for example
+    if (!captureTouches) {
+      return;
+    }
+    if (type === 'end') {
+      autocaptureFromTouchEvent(e, posthog, autocaptureOptions);
+    }
+  }, [captureTouches, posthog, autocaptureOptions]);
+  return /*#__PURE__*/React.createElement(View, {
+    [phLabelProp]: 'PostHogProvider',
+    // Dynamically setting customLabelProp (default: ph-label)
+    style: style || {
+      flex: 1
+    },
+    onTouchEndCapture: captureTouches ? e => onTouch('end', e) : undefined
+  }, /*#__PURE__*/React.createElement(PostHogContext.Provider, {
+    value: {
+      client: posthog
+    }
+  }, captureScreens && /*#__PURE__*/React.createElement(PostHogNavigationHook, {
+    options: autocaptureOptions,
+    client: posthog
+  }), children));
+};
+
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+const defaultBackgroundColor = '#eeeded';
+const defaultSurveyAppearance = {
+  backgroundColor: defaultBackgroundColor,
+  submitButtonColor: 'black',
+  submitButtonTextColor: 'white',
+  ratingButtonColor: 'white',
+  ratingButtonActiveColor: 'black',
+  borderColor: '#c9c6c6',
+  placeholder: 'Start typing...',
+  displayThankYouMessage: true,
+  thankYouMessageHeader: 'Thank you for your feedback!',
+  position: SurveyPosition.Right,
+  submitButtonText: 'Submit',
+  autoDisappear: false,
+  thankYouMessageDescription: '',
+  thankYouMessageDescriptionContentType: SurveyQuestionDescriptionContentType.Text,
+  thankYouMessageCloseButtonText: 'Close',
+  surveyPopupDelaySeconds: 0
+};
+const getDisplayOrderQuestions = survey => {
+  // retain the original questionIndex so we can correlate values in the webapp
+  survey.questions.forEach((question, idx) => {
+    question.originalQuestionIndex = idx;
+  });
+  // TODO: shuffle questions
+  return survey.questions;
+  // if (!survey.appearance?.shuffleQuestions) {
+  //   return survey.questions
+  // }
+  // return reverseIfUnshuffled(survey.questions, shuffle(survey.questions))
+};
+const hasEvents = survey => {
+  var _a, _b;
+  return ((_b = (_a = survey.conditions) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.values) !== undefined && survey.conditions.events.values.length > 0;
+};
+// export const hasActions = (survey: Survey): boolean => {
+//   return survey.conditions?.actions?.values.length !== undefined && survey.conditions.actions.values.length > 0
+// }
+const canActivateRepeatedly = survey => {
+  var _a, _b;
+  return !!(((_b = (_a = survey.conditions) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.repeatedActivation) && hasEvents(survey));
+};
+/**
+ * Use the Fisher-yates algorithm to shuffle this array
+ * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
+ */
+// export const shuffle = <T>(array: T[]): T[] => {
+//   return array
+//     .map((a) => ({ sort: Math.floor(Math.random() * 10), value: a }))
+//     .sort((a, b) => a.sort - b.sort)
+//     .map((a) => a.value)
+// }
+// const reverseIfUnshuffled = <T>(unshuffled: T[], shuffled: T[]): T[] => {
+//   if (unshuffled.length === shuffled.length && unshuffled.every((val, index) => val === shuffled[index])) {
+//     return shuffled.reverse()
+//   }
+//   return shuffled
+// }
+const getDisplayOrderChoices = question => {
+  // TODO: shuffle choices
+  return question.choices;
+  // if (!question.shuffleOptions) {
+  //   return question.choices
+  // }
+  // const displayOrderChoices = question.choices
+  // let openEndedChoice = ''
+  // if (question.hasOpenChoice && displayOrderChoices.length > 0) {
+  // if the question has an open-ended choice, its always the last element in the choices array.
+  // openEndedChoice = displayOrderChoices.pop()!
+  // }
+  // const shuffledOptions = reverseIfUnshuffled(displayOrderChoices, shuffle(displayOrderChoices))
+  // if (question.hasOpenChoice) {
+  //   question.choices.push(openEndedChoice)
+  //   shuffledOptions.push(openEndedChoice)
+  // }
+  // return shuffledOptions
+};
+function getContrastingTextColor(color) {
+  let rgb;
+  if (color.startsWith('#')) {
+    rgb = hex2rgb(color);
+  }
+  if (color.startsWith('rgb')) {
+    rgb = color;
+  }
+  // otherwise it's a color name
+  const nameColorToHex = nameToHex(color);
+  if (nameColorToHex) {
+    rgb = hex2rgb(nameColorToHex);
+  }
+  if (!rgb) {
+    return 'black';
+  }
+  const colorMatch = rgb.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?\)$/);
+  if (colorMatch) {
+    const r = parseInt(colorMatch[1], 10);
+    const g = parseInt(colorMatch[2], 10);
+    const b = parseInt(colorMatch[3], 10);
+    const hsp = Math.sqrt(0.299 * (r * r) + 0.587 * (g * g) + 0.114 * (b * b));
+    return hsp > 127.5 ? 'black' : 'white';
+  }
+  return 'black';
+}
+function hex2rgb(c) {
+  if (c.startsWith('#')) {
+    const hexColor = c.replace(/^#/, '');
+    if (!/^[0-9A-Fa-f]{6}$/.test(hexColor)) {
+      return 'rgb(255, 255, 255)';
+    }
+    const r = parseInt(hexColor.slice(0, 2), 16);
+    const g = parseInt(hexColor.slice(2, 4), 16);
+    const b = parseInt(hexColor.slice(4, 6), 16);
+    return `rgb(${r},${g},${b})`;
+  }
+  return 'rgb(255, 255, 255)';
+}
+function nameToHex(name) {
+  return {
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#00ffff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000000',
+    blanchedalmond: '#ffebcd',
+    blue: '#0000ff',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#00ffff',
+    darkblue: '#00008b',
+    darkcyan: '#008b8b',
+    darkgoldenrod: '#b8860b',
+    darkgray: '#a9a9a9',
+    darkgreen: '#006400',
+    darkkhaki: '#bdb76b',
+    darkmagenta: '#8b008b',
+    darkolivegreen: '#556b2f',
+    darkorange: '#ff8c00',
+    darkorchid: '#9932cc',
+    darkred: '#8b0000',
+    darksalmon: '#e9967a',
+    darkseagreen: '#8fbc8f',
+    darkslateblue: '#483d8b',
+    darkslategray: '#2f4f4f',
+    darkturquoise: '#00ced1',
+    darkviolet: '#9400d3',
+    deeppink: '#ff1493',
+    deepskyblue: '#00bfff',
+    dimgray: '#696969',
+    dodgerblue: '#1e90ff',
+    firebrick: '#b22222',
+    floralwhite: '#fffaf0',
+    forestgreen: '#228b22',
+    fuchsia: '#ff00ff',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    gold: '#ffd700',
+    goldenrod: '#daa520',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    'indianred ': '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    lavender: '#e6e6fa',
+    lavenderblush: '#fff0f5',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrodyellow: '#fafad2',
+    lightgrey: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#00ff00',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    mediumaquamarine: '#66cdaa',
+    mediumblue: '#0000cd',
+    mediumorchid: '#ba55d3',
+    mediumpurple: '#9370d8',
+    mediumseagreen: '#3cb371',
+    mediumslateblue: '#7b68ee',
+    mediumspringgreen: '#00fa9a',
+    mediumturquoise: '#48d1cc',
+    mediumvioletred: '#c71585',
+    midnightblue: '#191970',
+    mintcream: '#f5fffa',
+    mistyrose: '#ffe4e1',
+    moccasin: '#ffe4b5',
+    navajowhite: '#ffdead',
+    navy: '#000080',
+    oldlace: '#fdf5e6',
+    olive: '#808000',
+    olivedrab: '#6b8e23',
+    orange: '#ffa500',
+    orangered: '#ff4500',
+    orchid: '#da70d6',
+    palegoldenrod: '#eee8aa',
+    palegreen: '#98fb98',
+    paleturquoise: '#afeeee',
+    palevioletred: '#d87093',
+    papayawhip: '#ffefd5',
+    peachpuff: '#ffdab9',
+    peru: '#cd853f',
+    pink: '#ffc0cb',
+    plum: '#dda0dd',
+    powderblue: '#b0e0e6',
+    purple: '#800080',
+    red: '#ff0000',
+    rosybrown: '#bc8f8f',
+    royalblue: '#4169e1',
+    saddlebrown: '#8b4513',
+    salmon: '#fa8072',
+    sandybrown: '#f4a460',
+    seagreen: '#2e8b57',
+    seashell: '#fff5ee',
+    sienna: '#a0522d',
+    silver: '#c0c0c0',
+    skyblue: '#87ceeb',
+    slateblue: '#6a5acd',
+    slategray: '#708090',
+    snow: '#fffafa',
+    springgreen: '#00ff7f',
+    steelblue: '#4682b4',
+    tan: '#d2b48c',
+    teal: '#008080',
+    thistle: '#d8bfd8',
+    tomato: '#ff6347',
+    turquoise: '#40e0d0',
+    violet: '#ee82ee',
+    wheat: '#f5deb3',
+    white: '#ffffff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ffff00',
+    yellowgreen: '#9acd32'
+  }[name.toLowerCase()];
+}
+
+const SatisfiedEmoji = props => /*#__PURE__*/React.createElement(Svg, _extends({
+  height: "48",
+  viewBox: "0 -960 960 960",
+  width: "48"
+}, props), /*#__PURE__*/React.createElement(Path, {
+  d: "M626-533q22.5 0 38.25-15.75T680-587q0-22.5-15.75-38.25T626-641q-22.5 0-38.25 15.75T572-587q0 22.5 15.75 38.25T626-533Zm-292 0q22.5 0 38.25-15.75T388-587q0-22.5-15.75-38.25T334-641q-22.5 0-38.25 15.75T280-587q0 22.5 15.75 38.25T334-533Zm146 272q66 0 121.5-35.5T682-393h-52q-23 40-63 61.5T480.5-310q-46.5 0-87-21T331-393h-53q26 61 81 96.5T480-261Zm0 181q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-400Zm0 340q142.375 0 241.188-98.812Q820-337.625 820-480t-98.812-241.188Q622.375-820 480-820t-241.188 98.812Q140-622.375 140-480t98.812 241.188Q337.625-140 480-140Z"
+}));
+const NeutralEmoji = props => /*#__PURE__*/React.createElement(Svg, _extends({
+  height: "48",
+  viewBox: "0 -960 960 960",
+  width: "48"
+}, props), /*#__PURE__*/React.createElement(Path, {
+  d: "M626-533q22.5 0 38.25-15.75T680-587q0-22.5-15.75-38.25T626-641q-22.5 0-38.25 15.75T572-587q0 22.5 15.75 38.25T626-533Zm-292 0q22.5 0 38.25-15.75T388-587q0-22.5-15.75-38.25T334-641q-22.5 0-38.25 15.75T280-587q0 22.5 15.75 38.25T334-533Zm20 194h253v-49H354v49ZM480-80q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-400Zm0 340q142.375 0 241.188-98.812Q820-337.625 820-480t-98.812-241.188Q622.375-820 480-820t-241.188 98.812Q140-622.375 140-480t98.812 241.188Q337.625-140 480-140Z"
+}));
+const DissatisfiedEmoji = props => /*#__PURE__*/React.createElement(Svg, _extends({
+  height: "48",
+  viewBox: "0 -960 960 960",
+  width: "48"
+}, props), /*#__PURE__*/React.createElement(Path, {
+  d: "M626-533q22.5 0 38.25-15.75T680-587q0-22.5-15.75-38.25T626-641q-22.5 0-38.25 15.75T572-587q0 22.5 15.75 38.25T626-533Zm-292 0q22.5 0 38.25-15.75T388-587q0-22.5-15.75-38.25T334-641q-22.5 0-38.25 15.75T280-587q0 22.5 15.75 38.25T334-533Zm146.174 116Q413-417 358.5-379.5T278-280h53q22-42 62.173-65t87.5-23Q528-368 567.5-344.5T630-280h52q-25-63-79.826-100-54.826-37-122-37ZM480-80q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-400Zm0 340q142.375 0 241.188-98.812Q820-337.625 820-480t-98.812-241.188Q622.375-820 480-820t-241.188 98.812Q140-622.375 140-480t98.812 241.188Q337.625-140 480-140Z"
+}));
+const VeryDissatisfiedEmoji = props => /*#__PURE__*/React.createElement(Svg, _extends({
+  height: "48",
+  viewBox: "0 -960 960 960",
+  width: "48"
+}, props), /*#__PURE__*/React.createElement(Path, {
+  d: "M480-417q-67 0-121.5 37.5T278-280h404q-25-63-80-100t-122-37Zm-183-72 50-45 45 45 31-36-45-45 45-45-31-36-45 45-50-45-31 36 45 45-45 45 31 36Zm272 0 44-45 51 45 31-36-45-45 45-45-31-36-51 45-44-45-31 36 44 45-44 45 31 36ZM480-80q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-400Zm0 340q142 0 241-99t99-241q0-142-99-241t-241-99q-142 0-241 99t-99 241q0 142 99 241t241 99Z"
+}));
+const VerySatisfiedEmoji = props => /*#__PURE__*/React.createElement(Svg, _extends({
+  height: "48",
+  viewBox: "0 -960 960 960",
+  width: "48"
+}, props), /*#__PURE__*/React.createElement(Path, {
+  d: "M479.504-261Q537-261 585.5-287q48.5-26 78.5-72.4 6-11.6-.75-22.6-6.75-11-20.25-11H316.918Q303-393 296.5-382t-.5 22.6q30 46.4 78.5 72.4 48.5 26 105.004 26ZM347-578l27 27q7.636 8 17.818 8Q402-543 410-551q8-8 8-18t-8-18l-42-42q-8.8-9-20.9-9-12.1 0-21.1 9l-42 42q-8 7.636-8 17.818Q276-559 284-551q8 8 18 8t18-8l27-27Zm267 0 27 27q7.714 8 18 8t18-8q8-7.636 8-17.818Q685-579 677-587l-42-42q-8.8-9-20.9-9-12.1 0-21.1 9l-42 42q-8 7.714-8 18t8 18q7.636 8 17.818 8Q579-543 587-551l27-27ZM480-80q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-400Zm0 340q142.375 0 241.188-98.812Q820-337.625 820-480t-98.812-241.188Q622.375-820 480-820t-241.188 98.812Q140-622.375 140-480t98.812 241.188Q337.625-140 480-140Z"
+}));
+const CheckSVG = props => /*#__PURE__*/React.createElement(Svg, _extends({
+  width: "16",
+  height: "16",
+  viewBox: "0 0 16 12"
+}, props), /*#__PURE__*/React.createElement(Path, {
+  d: "M5.30769 10.6923L4.77736 11.2226C4.91801 11.3633 5.10878 11.4423 5.30769 11.4423C5.5066 11.4423 5.69737 11.3633 5.83802 11.2226L5.30769 10.6923ZM15.5303 1.53033C15.8232 1.23744 15.8232 0.762563 15.5303 0.46967C15.2374 0.176777 14.7626 0.176777 14.4697 0.46967L15.5303 1.53033ZM1.53033 5.85429C1.23744 5.56139 0.762563 5.56139 0.46967 5.85429C0.176777 6.14718 0.176777 6.62205 0.46967 6.91495L1.53033 5.85429ZM5.83802 11.2226L15.5303 1.53033L14.4697 0.46967L4.77736 10.162L5.83802 11.2226ZM0.46967 6.91495L4.77736 11.2226L5.83802 10.162L1.53033 5.85429L0.46967 6.91495Z"
+}));
+const CancelSVG = props => /*#__PURE__*/React.createElement(Svg, _extends({
+  width: "12",
+  height: "12",
+  viewBox: "0 0 12 12",
+  fill: "none"
+}, props), /*#__PURE__*/React.createElement(Path, {
+  "fill-rule": "evenodd",
+  "clip-rule": "evenodd",
+  d: "M0.164752 0.164752C0.384422 -0.0549175 0.740578 -0.0549175 0.960248 0.164752L6 5.20451L11.0398 0.164752C11.2594 -0.0549175 11.6156 -0.0549175 11.8352 0.164752C12.0549 0.384422 12.0549 0.740578 11.8352 0.960248L6.79549 6L11.8352 11.0398C12.0549 11.2594 12.0549 11.6156 11.8352 11.8352C11.6156 12.0549 11.2594 12.0549 11.0398 11.8352L6 6.79549L0.960248 11.8352C0.740578 12.0549 0.384422 12.0549 0.164752 11.8352C-0.0549175 11.6156 -0.0549175 11.2594 0.164752 11.0398L5.20451 6L0.164752 0.960248C-0.0549175 0.740578 -0.0549175 0.384422 0.164752 0.164752Z",
+  fill: "black"
+}));
+
+function BottomSection({
+  text,
+  submitDisabled,
+  appearance,
+  onSubmit,
+  link
+}) {
+  return /*#__PURE__*/React.createElement(View, {
+    style: styles$5.bottomSection
+  }, /*#__PURE__*/React.createElement(TouchableOpacity, {
+    style: [styles$5.button, {
+      backgroundColor: appearance.submitButtonColor
+    }],
+    disabled: submitDisabled,
+    onPress: () => {
+      onSubmit();
+      if (link) {
+        Linking.canOpenURL(link).then(supported => {
+          if (supported) {
+            Linking.openURL(link);
+          }
+        });
+      }
+    }
+  }, /*#__PURE__*/React.createElement(Text, {
+    style: [styles$5.buttonText, {
+      color: appearance.submitButtonTextColor
+    }]
+  }, text)));
+}
+const styles$5 = StyleSheet.create({
+  bottomSection: {
+    padding: 10
+  },
+  button: {
+    padding: 10,
+    borderRadius: 5,
+    alignItems: 'center'
+  },
+  buttonText: {
+    fontSize: 16
+  }
+});
+
+function QuestionHeader({
+  question,
+  description,
+  descriptionContentType
+}) {
+  return /*#__PURE__*/React.createElement(View, {
+    style: styles$4.container
+  }, /*#__PURE__*/React.createElement(Text, {
+    style: styles$4.question
+  }, question), description && descriptionContentType === SurveyQuestionDescriptionContentType.Text && /*#__PURE__*/React.createElement(Text, {
+    style: styles$4.description
+  }, description));
+}
+const styles$4 = StyleSheet.create({
+  container: {
+    padding: 10
+  },
+  question: {
+    fontSize: 18,
+    fontWeight: 'bold'
+  },
+  description: {
+    fontSize: 14,
+    marginTop: 5
+  }
+});
+
+function OpenTextQuestion({
+  question,
+  appearance,
+  onSubmit
+}) {
+  var _a;
+  const [text, setText] = useState('');
+  return /*#__PURE__*/React.createElement(View, null, /*#__PURE__*/React.createElement(QuestionHeader, {
+    question: question.question,
+    description: question.description,
+    descriptionContentType: question.descriptionContentType
+  }), /*#__PURE__*/React.createElement(View, {
+    style: styles$3.textInputContainer
+  }, /*#__PURE__*/React.createElement(TextInput, {
+    style: styles$3.textInput,
+    multiline: true,
+    numberOfLines: 4,
+    placeholder: appearance.placeholder,
+    onChangeText: setText,
+    value: text
+  })), /*#__PURE__*/React.createElement(BottomSection, {
+    text: (_a = question.buttonText) !== null && _a !== void 0 ? _a : appearance.submitButtonText,
+    submitDisabled: !text && !question.optional,
+    appearance: appearance,
+    onSubmit: () => onSubmit(text)
+  }));
+}
+function LinkQuestion({
+  question,
+  appearance,
+  onSubmit
+}) {
+  var _a, _b;
+  question = question;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(QuestionHeader, {
+    question: question.question,
+    description: question.description,
+    descriptionContentType: question.descriptionContentType
+  }), /*#__PURE__*/React.createElement(BottomSection, {
+    text: (_b = (_a = question.buttonText) !== null && _a !== void 0 ? _a : appearance.submitButtonText) !== null && _b !== void 0 ? _b : 'Submit',
+    submitDisabled: false,
+    link: question.link,
+    appearance: appearance,
+    onSubmit: () => onSubmit('link clicked')
+  }));
+}
+function RatingQuestion({
+  question,
+  appearance,
+  onSubmit
+}) {
+  var _a;
+  //const starting = question.scale === 10 ? 0 : 1;
+  const [rating, setRating] = useState(null);
+  question = question;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(QuestionHeader, {
+    question: question.question,
+    description: question.description,
+    descriptionContentType: question.descriptionContentType
+  }), /*#__PURE__*/React.createElement(View, {
+    style: styles$3.ratingSection
+  }, /*#__PURE__*/React.createElement(View, {
+    style: styles$3.ratingOptions
+  }, question.display === SurveyRatingDisplay.Emoji && /*#__PURE__*/React.createElement(View, {
+    style: styles$3.ratingOptionsEmoji
+  }, (question.scale === 3 ? threeScaleEmojis : fiveScaleEmojis).map((Emoji, idx) => {
+    const active = idx + 1 === rating;
+    return /*#__PURE__*/React.createElement(TouchableOpacity, {
+      key: idx,
+      style: styles$3.ratingsEmoji,
+      onPress: () => setRating(idx + 1)
+    }, /*#__PURE__*/React.createElement(Emoji, {
+      fill: active ? appearance.ratingButtonActiveColor : appearance.ratingButtonColor
+    }));
+  })), question.display === SurveyRatingDisplay.Number && /*#__PURE__*/React.createElement(View, {
+    style: [styles$3.ratingOptionsNumber, {
+      borderColor: appearance.borderColor
+    }]
+  }, getScaleNumbers(question.scale).map((number, idx) => {
+    const active = rating === number;
+    return /*#__PURE__*/React.createElement(RatingButton, {
+      key: idx,
+      index: idx,
+      active: active,
+      appearance: appearance,
+      num: number,
+      setActiveNumber: setRating
+    });
+  }))), /*#__PURE__*/React.createElement(View, {
+    style: styles$3.ratingText
+  }, /*#__PURE__*/React.createElement(Text, null, question.lowerBoundLabel), /*#__PURE__*/React.createElement(Text, null, question.upperBoundLabel))), /*#__PURE__*/React.createElement(BottomSection, {
+    text: (_a = question.buttonText) !== null && _a !== void 0 ? _a : appearance.submitButtonText,
+    submitDisabled: rating === null && !question.optional,
+    appearance: appearance,
+    onSubmit: () => onSubmit(rating)
+  }));
+}
+function RatingButton({
+  index,
+  num,
+  active,
+  appearance,
+  setActiveNumber
+}) {
+  const backgroundColor = active ? appearance.ratingButtonActiveColor : appearance.ratingButtonColor;
+  const textColor = getContrastingTextColor(backgroundColor);
+  return /*#__PURE__*/React.createElement(TouchableOpacity, {
+    style: [styles$3.ratingsNumber, index === 0 && {
+      borderLeftWidth: 0
+    }, {
+      backgroundColor,
+      borderColor: appearance.borderColor
+    }],
+    onPress: () => setActiveNumber(num)
+  }, /*#__PURE__*/React.createElement(Text, {
+    style: {
+      color: textColor
+    }
+  }, num));
+}
+function MultipleChoiceQuestion({
+  question,
+  appearance,
+  onSubmit
+}) {
+  var _a;
+  question = question;
+  const allowMultiple = question.type === SurveyQuestionType.MultipleChoice;
+  const openChoice = question.hasOpenChoice ? question.choices[question.choices.length - 1] : null;
+  const choices = useMemo(() => getDisplayOrderChoices(question), [question]);
+  const [selectedChoices, setSelectedChoices] = useState([]);
+  const [openEndedInput, setOpenEndedInput] = useState('');
+  return /*#__PURE__*/React.createElement(View, null, /*#__PURE__*/React.createElement(QuestionHeader, {
+    question: question.question,
+    description: question.description,
+    descriptionContentType: question.descriptionContentType
+  }), /*#__PURE__*/React.createElement(View, {
+    style: styles$3.multipleChoiceOptions
+  }, choices.map((choice, idx) => {
+    const isOpenChoice = choice === openChoice;
+    const isSelected = selectedChoices.includes(choice);
+    return /*#__PURE__*/React.createElement(Pressable, {
+      key: idx,
+      style: [styles$3.choiceOption, isSelected ? {
+        borderColor: 'black'
+      } : {}],
+      onPress: () => {
+        if (allowMultiple) {
+          setSelectedChoices(isSelected ? selectedChoices.filter(c => c !== choice) : [...selectedChoices, choice]);
+        } else {
+          setSelectedChoices([choice]);
+        }
+      }
+    }, /*#__PURE__*/React.createElement(View, {
+      style: styles$3.choiceText
+    }, /*#__PURE__*/React.createElement(Text, {
+      style: {
+        flexGrow: 1
+      }
+    }, choice, isOpenChoice ? ':' : ''), /*#__PURE__*/React.createElement(View, {
+      style: styles$3.rightCheckArea
+    }, isSelected && /*#__PURE__*/React.createElement(CheckSVG, null))), isOpenChoice && /*#__PURE__*/React.createElement(TextInput, {
+      style: styles$3.openEndedInput,
+      onChangeText: userValue => {
+        setOpenEndedInput(userValue);
+        if (!isSelected) {
+          setSelectedChoices(allowMultiple ? [...selectedChoices, choice] : [choice]);
+        }
+      }
+    }));
+  })), /*#__PURE__*/React.createElement(BottomSection, {
+    text: (_a = question.buttonText) !== null && _a !== void 0 ? _a : appearance.submitButtonText,
+    submitDisabled: !question.optional && (selectedChoices.length === 0 || openChoice !== null && selectedChoices.includes(openChoice) && openEndedInput.length === 0),
+    appearance: appearance,
+    onSubmit: () => {
+      // If open choice is selected, replace the choice name with the actual value entered
+      const result = selectedChoices.map(c => c === openChoice ? openEndedInput : c);
+      onSubmit(result.length === 1 ? result[0] : result);
+    }
+  }));
+}
+const threeScaleEmojis = [DissatisfiedEmoji, NeutralEmoji, SatisfiedEmoji];
+const fiveScaleEmojis = [VeryDissatisfiedEmoji, DissatisfiedEmoji, NeutralEmoji, SatisfiedEmoji, VerySatisfiedEmoji];
+const fiveScaleNumbers = [1, 2, 3, 4, 5];
+const sevenScaleNumbers = [1, 2, 3, 4, 5, 6, 7];
+const tenScaleNumbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+function getScaleNumbers(scale) {
+  switch (scale) {
+    case 5:
+      return fiveScaleNumbers;
+    case 7:
+      return sevenScaleNumbers;
+    case 10:
+      return tenScaleNumbers;
+    default:
+      return fiveScaleNumbers;
+  }
+}
+const styles$3 = StyleSheet.create({
+  textInputContainer: {
+    padding: 10
+  },
+  textInput: {
+    borderColor: '#ccc',
+    borderWidth: 1,
+    padding: 10,
+    marginVertical: 10,
+    backgroundColor: 'white',
+    fontSize: 16
+  },
+  ratingSection: {
+    marginVertical: 10
+  },
+  ratingOptions: {
+    flexDirection: 'row',
+    justifyContent: 'space-between'
+  },
+  ratingOptionsEmoji: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    flexWrap: 'wrap' // Allows items to wrap to a new line
+  },
+  ratingsEmoji: {
+    padding: 10
+  },
+  ratingOptionsNumber: {
+    margin: 10,
+    flexGrow: 1,
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    borderRadius: 5,
+    borderWidth: 1,
+    overflow: 'hidden'
+  },
+  ratingsNumber: {
+    flex: 1,
+    paddingVertical: 10,
+    alignItems: 'center',
+    borderLeftWidth: 1
+  },
+  ratingText: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    padding: 10
+  },
+  multipleChoiceOptions: {
+    padding: 10
+  },
+  choiceOption: {
+    flexDirection: 'column',
+    marginVertical: 5,
+    borderWidth: 1,
+    borderColor: 'grey',
+    borderRadius: 5,
+    padding: 10,
+    backgroundColor: 'white'
+  },
+  choiceText: {
+    flexDirection: 'row'
+  },
+  rightCheckArea: {
+    flexGrow: 0
+  },
+  openEndedInput: {
+    padding: 5
+  }
+});
+
+const getSurveyInteractionProperty = (survey, action) => {
+  let surveyProperty = `$survey_${action}/${survey.id}`;
+  if (survey.current_iteration && survey.current_iteration > 0) {
+    surveyProperty = `$survey_${action}/${survey.id}/${survey.current_iteration}`;
+  }
+  return surveyProperty;
+};
+const sendSurveyShownEvent = (survey, posthog) => {
+  posthog.capture('survey shown', {
+    $survey_name: survey.name,
+    $survey_id: survey.id,
+    $survey_iteration: survey.current_iteration,
+    $survey_iteration_start_date: survey.current_iteration_start_date
+  });
+};
+const sendSurveyEvent = (responses = {}, survey, posthog) => {
+  posthog.capture('survey sent', {
+    $survey_name: survey.name,
+    $survey_id: survey.id,
+    $survey_iteration: survey.current_iteration,
+    $survey_iteration_start_date: survey.current_iteration_start_date,
+    $survey_questions: survey.questions.map(question => question.question),
+    ...responses,
+    $set: {
+      [getSurveyInteractionProperty(survey, 'responded')]: true
+    }
+  });
+};
+const dismissedSurveyEvent = (survey, posthog) => {
+  posthog.capture('survey dismissed', {
+    $survey_name: survey.name,
+    $survey_id: survey.id,
+    $survey_iteration: survey.current_iteration,
+    $survey_iteration_start_date: survey.current_iteration_start_date,
+    $set: {
+      [getSurveyInteractionProperty(survey, 'dismissed')]: true
+    }
+  });
+};
+function Questions({
+  survey,
+  appearance,
+  styleOverrides,
+  onSubmit
+}) {
+  const [questionsResponses, setQuestionsResponses] = useState({});
+  const [currentQuestionIndex, setCurrentQuestionIndex] = useState(0);
+  const surveyQuestions = useMemo(() => getDisplayOrderQuestions(survey), [survey]);
+  const posthog = usePostHog();
+  const onNextButtonClick = ({
+    res,
+    originalQuestionIndex
+  }) => {
+    const responseKey = originalQuestionIndex === 0 ? `$survey_response` : `$survey_response_${originalQuestionIndex}`;
+    setQuestionsResponses({
+      ...questionsResponses,
+      [responseKey]: res
+    });
+    const isLastDisplayedQuestion = originalQuestionIndex === survey.questions.length - 1;
+    if (isLastDisplayedQuestion) {
+      sendSurveyEvent({
+        ...questionsResponses,
+        [responseKey]: res
+      }, survey, posthog);
+      onSubmit();
+    } else {
+      setCurrentQuestionIndex(originalQuestionIndex + 1);
+    }
+  };
+  const question = surveyQuestions[currentQuestionIndex];
+  return /*#__PURE__*/React.createElement(ScrollView, {
+    style: [styleOverrides, {
+      flexGrow: 0
+    }]
+  }, getQuestionComponent({
+    question,
+    appearance,
+    onSubmit: res => onNextButtonClick({
+      res,
+      originalQuestionIndex: question.originalQuestionIndex
+      // displayQuestionIndex: currentQuestionIndex,
+    })
+  }));
+}
+const getQuestionComponent = props => {
+  const questionComponents = {
+    open: OpenTextQuestion,
+    link: LinkQuestion,
+    rating: RatingQuestion,
+    multiple_choice: MultipleChoiceQuestion,
+    single_choice: MultipleChoiceQuestion
+  };
+  const Component = questionComponents[props.question.type];
+  return /*#__PURE__*/React.createElement(Component, _extends({
+    key: props.question.originalQuestionIndex
+  }, props));
+};
+
+const isMatchingRegex = function (value, pattern) {
+  if (!isValidRegex(pattern)) {
+    return false;
+  }
+  try {
+    return new RegExp(pattern).test(value);
+  } catch (_a) {
+    return false;
+  }
+};
+const isValidRegex = function (str) {
+  try {
+    new RegExp(str);
+  } catch (_a) {
+    return false;
+  }
+  return true;
+};
+const surveyValidationMap = {
+  icontains: (targets, value) => targets.some(target => value.toLowerCase().includes(target.toLowerCase())),
+  not_icontains: (targets, value) => targets.every(target => !value.toLowerCase().includes(target.toLowerCase())),
+  regex: (targets, value) => targets.some(target => isMatchingRegex(value, target)),
+  not_regex: (targets, value) => targets.every(target => !isMatchingRegex(value, target)),
+  exact: (targets, value) => targets.some(target => value === target),
+  is_not: (targets, value) => targets.every(target => value !== target)
+};
+function defaultMatchType(matchType) {
+  return matchType !== null && matchType !== void 0 ? matchType : SurveyMatchType.Icontains;
+}
+function doesSurveyDeviceTypesMatch(survey) {
+  var _a;
+  if (!((_a = survey.conditions) === null || _a === void 0 ? void 0 : _a.deviceTypes) || survey.conditions.deviceTypes.length === 0) {
+    return true;
+  }
+  const deviceType = currentDeviceType;
+  return surveyValidationMap[defaultMatchType(survey.conditions.deviceTypesMatchType)](survey.conditions.deviceTypes, deviceType);
+}
+function getActiveMatchingSurveys(surveys, flags, seenSurveys, activatedSurveys
+// lastSeenSurveyDate: Date | undefined
+) {
+  return surveys.filter(survey => {
+    var _a, _b;
+    // Is Active
+    if (!survey.start_date || survey.end_date) {
+      return false;
+    }
+    // device type check
+    if (!doesSurveyDeviceTypesMatch(survey)) {
+      return false;
+    }
+    if (seenSurveys.includes(survey.id) && !canActivateRepeatedly(survey)) {
+      return false;
+    }
+    // const surveyWaitPeriodInDays = survey.conditions?.seenSurveyWaitPeriodInDays
+    // if (surveyWaitPeriodInDays && lastSeenSurveyDate) {
+    //   const today = new Date()
+    //   const diff = Math.abs(today.getTime() - lastSeenSurveyDate.getTime())
+    //   const diffDaysFromToday = Math.ceil(diff / (1000 * 3600 * 24))
+    //   if (diffDaysFromToday < surveyWaitPeriodInDays) {
+    //     return false
+    //   }
+    // }
+    // URL and CSS selector conditions are currently ignored
+    if (!survey.linked_flag_key && !survey.targeting_flag_key && !survey.internal_targeting_flag_key && !((_a = survey.feature_flag_keys) === null || _a === void 0 ? void 0 : _a.length)) {
+      // Survey is targeting All Users with no conditions
+      return true;
+    }
+    const linkedFlagCheck = survey.linked_flag_key ? flags[survey.linked_flag_key] === true : true;
+    const targetingFlagCheck = survey.targeting_flag_key ? flags[survey.targeting_flag_key] === true : true;
+    const eventBasedTargetingFlagCheck = hasEvents(survey) ? activatedSurveys.has(survey.id) : true;
+    const internalTargetingFlagCheck = survey.internal_targeting_flag_key && !canActivateRepeatedly(survey) ? flags[survey.internal_targeting_flag_key] === true : true;
+    const flagsCheck = ((_b = survey.feature_flag_keys) === null || _b === void 0 ? void 0 : _b.length) ? survey.feature_flag_keys.every(({
+      key,
+      value
+    }) => {
+      return !key || !value || flags[value] === true;
+    }) : true;
+    return linkedFlagCheck && targetingFlagCheck && internalTargetingFlagCheck && eventBasedTargetingFlagCheck && flagsCheck;
+  });
+}
+
+function useSurveyStorage() {
+  const posthogStorage = usePostHog();
+  const [lastSeenSurveyDate, setLastSeenSurveyDate] = useState(undefined);
+  const [seenSurveys, setSeenSurveys] = useState([]);
+  useEffect(() => {
+    posthogStorage.ready().then(() => {
+      const lastSeenSurveyDate = posthogStorage.getPersistedProperty(PostHogPersistedProperty.SurveyLastSeenDate);
+      if (typeof lastSeenSurveyDate === 'string') {
+        setLastSeenSurveyDate(new Date(lastSeenSurveyDate));
+      }
+      const serialisedSeenSurveys = posthogStorage.getPersistedProperty(PostHogPersistedProperty.SurveysSeen);
+      if (typeof serialisedSeenSurveys === 'string') {
+        const parsedSeenSurveys = JSON.parse(serialisedSeenSurveys);
+        if (Array.isArray(parsedSeenSurveys) && typeof parsedSeenSurveys[0] === 'string') {
+          setSeenSurveys(parsedSeenSurveys);
+        }
+      }
+    });
+  }, [posthogStorage]);
+  return {
+    seenSurveys,
+    setSeenSurvey: useCallback(surveyId => {
+      setSeenSurveys(current => {
+        // To keep storage bounded, only keep the last 20 seen surveys
+        const newValue = [surveyId, ...current.filter(id => id !== surveyId)];
+        posthogStorage.setPersistedProperty(PostHogPersistedProperty.SurveysSeen, JSON.stringify(newValue.slice(0, 20)));
+        return newValue;
+      });
+    }, [posthogStorage]),
+    lastSeenSurveyDate,
+    setLastSeenSurveyDate: useCallback(date => {
+      setLastSeenSurveyDate(date);
+      posthogStorage.setPersistedProperty(PostHogPersistedProperty.SurveyLastSeenDate, date.toISOString());
+    }, [posthogStorage])
+  };
+}
+
+const SURVEY_SHOWN_EVENT_NAME = 'survey shown';
+function useActivatedSurveys(posthog, surveys) {
+  const [activatedSurveys, setActivatedSurveys] = useState(new Set());
+  const eventMap = useMemo(() => {
+    var _a, _b, _c, _d;
+    const newEventMap = new Map();
+    for (const survey of surveys.filter(hasEvents)) {
+      for (const event of (_c = (_b = (_a = survey.conditions) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.values) !== null && _c !== void 0 ? _c : []) {
+        const knownSurveys = (_d = newEventMap.get(event.name)) !== null && _d !== void 0 ? _d : [];
+        knownSurveys.push(survey.id);
+        newEventMap.set(event.name, knownSurveys);
+      }
+    }
+    return newEventMap;
+  }, [surveys]);
+  useEffect(() => {
+    if (eventMap.size > 0) {
+      return posthog.on('capture', payload => {
+        var _a;
+        if (eventMap.has(payload.event)) {
+          setActivatedSurveys(current => {
+            var _a;
+            return new Set([...current, ...((_a = eventMap.get(payload.event)) !== null && _a !== void 0 ? _a : [])]);
+          });
+        } else if (payload.event === SURVEY_SHOWN_EVENT_NAME) {
+          // remove survey that from activatedSurveys here.
+          const surveyId = (_a = payload.properties) === null || _a === void 0 ? void 0 : _a.$survey_id;
+          if (surveyId) {
+            setActivatedSurveys(current => {
+              if (!current.has(surveyId)) {
+                return current;
+              }
+              const next = new Set(current);
+              next.delete(surveyId);
+              return next;
+            });
+          }
+        }
+      });
+    }
+  }, [eventMap, posthog]);
+  return activatedSurveys;
+}
+
+function Cancel({
+  onPress,
+  appearance
+}) {
+  return /*#__PURE__*/React.createElement(TouchableOpacity, {
+    style: [styles$2.cancelBtnWrapper, {
+      borderColor: appearance.borderColor
+    }],
+    onPress: onPress
+  }, /*#__PURE__*/React.createElement(CancelSVG, null));
+}
+const styles$2 = StyleSheet.create({
+  cancelBtnWrapper: {
+    width: 40,
+    height: 40,
+    borderRadius: 20,
+    borderWidth: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: 'white'
+  }
+});
+
+function ConfirmationMessage({
+  appearance,
+  header,
+  description,
+  contentType,
+  onClose,
+  styleOverrides,
+  isModal
+}) {
+  const textColor = getContrastingTextColor(appearance.backgroundColor);
+  return /*#__PURE__*/React.createElement(View, {
+    style: styleOverrides
+  }, /*#__PURE__*/React.createElement(View, {
+    style: styles$1.thankYouMessageContainer
+  }, /*#__PURE__*/React.createElement(Text, {
+    style: [styles$1.thankYouMessageHeader, {
+      color: textColor
+    }]
+  }, header), description && contentType === SurveyQuestionDescriptionContentType.Text && /*#__PURE__*/React.createElement(Text, null, description)), isModal && /*#__PURE__*/React.createElement(BottomSection, {
+    text: appearance.thankYouMessageCloseButtonText,
+    submitDisabled: false,
+    appearance: appearance,
+    onSubmit: onClose
+  }));
+}
+const styles$1 = StyleSheet.create({
+  thankYouMessageContainer: {
+    padding: 10
+  },
+  thankYouMessageHeader: {
+    fontSize: 18,
+    fontWeight: 'bold'
+  }
+});
+
+let OptionalRNSafeArea = undefined;
+try {
+  OptionalRNSafeArea = require('react-native-safe-area-context');
+} catch (e) {}
+function createDefaultInsets() {
+  // If the library isn't available, fall back to a default which should cover most devices
+  return {
+    top: 60,
+    bottom: 30,
+    left: 0,
+    right: 0
+  };
+}
+const useOptionalSafeAreaInsets = () => {
+  var _a;
+  const useSafeAreaInsets = (_a = OptionalRNSafeArea === null || OptionalRNSafeArea === void 0 ? void 0 : OptionalRNSafeArea.useSafeAreaInsets) !== null && _a !== void 0 ? _a : createDefaultInsets;
+  try {
+    return useSafeAreaInsets();
+  } catch (err) {
+    return createDefaultInsets();
+  }
+};
+
+function SurveyModal(props) {
+  var _a;
+  const {
+    survey,
+    appearance,
+    onShow
+  } = props;
+  const [isSurveySent, setIsSurveySent] = useState(false);
+  const onClose = useCallback(() => props.onClose(isSurveySent), [isSurveySent, props]);
+  const insets = useOptionalSafeAreaInsets();
+  const [isVisible] = useState(true);
+  const shouldShowConfirmation = isSurveySent && appearance.thankYouMessageHeader;
+  useEffect(() => {
+    if (isVisible) {
+      onShow();
+    }
+  }, [isVisible, onShow]);
+  if (!isVisible) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(Modal, {
+    animationType: "fade",
+    transparent: true,
+    onRequestClose: onClose,
+    statusBarTranslucent: true
+  }, /*#__PURE__*/React.createElement(KeyboardAvoidingView, {
+    behavior: Platform.OS === 'ios' ? 'padding' : 'height',
+    style: {
+      flex: 1,
+      justifyContent: 'flex-end'
+    },
+    keyboardVerticalOffset: Platform.OS === 'ios' ? 10 : 0
+  }, /*#__PURE__*/React.createElement(TouchableWithoutFeedback, {
+    onPress: Keyboard.dismiss,
+    accessible: false
+  }, /*#__PURE__*/React.createElement(View, {
+    style: styles.modalBackdrop
+  }, /*#__PURE__*/React.createElement(Pressable, {
+    onPress: onClose,
+    accessible: false
+  }, /*#__PURE__*/React.createElement(View, {
+    style: [styles.modalContent, {
+      borderColor: appearance.borderColor,
+      backgroundColor: appearance.backgroundColor,
+      marginBottom: insets.bottom + 10,
+      marginHorizontal: 10
+    }]
+  }, !shouldShowConfirmation ? /*#__PURE__*/React.createElement(Questions, {
+    survey: survey,
+    appearance: appearance,
+    onSubmit: () => setIsSurveySent(true)
+  }) : /*#__PURE__*/React.createElement(ConfirmationMessage, {
+    appearance: appearance,
+    header: appearance.thankYouMessageHeader,
+    description: appearance.thankYouMessageDescription,
+    contentType: (_a = appearance.thankYouMessageDescriptionContentType) !== null && _a !== void 0 ? _a : SurveyQuestionDescriptionContentType.Text,
+    onClose: onClose,
+    isModal: true
+  }), /*#__PURE__*/React.createElement(View, {
+    style: styles.topIconContainer
+  }, /*#__PURE__*/React.createElement(Cancel, {
+    onPress: onClose,
+    appearance: appearance
+  }))))))));
+}
+const styles = StyleSheet.create({
+  modalBackdrop: {
+    flex: 1,
+    justifyContent: 'flex-end'
+  },
+  modalContent: {
+    borderRadius: 10,
+    borderWidth: 1,
+    padding: 20,
+    width: '90%',
+    maxWidth: 400,
+    marginHorizontal: 20
+  },
+  topIconContainer: {
+    position: 'absolute',
+    right: -20,
+    top: -20
+  }
+});
+
+const ActiveSurveyContext = /*#__PURE__*/React.createContext(undefined);
+// export const useActiveSurvey = (): ActiveSurveyContextType => React.useContext(ActiveSurveyContext)
+// type FeedbackSurveyHook = {
+//   survey: Survey
+//   showSurveyModal: () => void
+//   hideSurveyModal: () => void
+// }
+const FeedbackSurveyContext = /*#__PURE__*/React.createContext(undefined);
+function PostHogSurveyProvider(props) {
+  var _a;
+  const posthogFromHook = usePostHog();
+  const posthog = (_a = props.client) !== null && _a !== void 0 ? _a : posthogFromHook;
+  const {
+    seenSurveys,
+    setSeenSurvey,
+    setLastSeenSurveyDate
+  } = useSurveyStorage();
+  const [surveys, setSurveys] = useState([]);
+  const [activeSurvey, setActiveSurvey] = useState(undefined);
+  const activatedSurveys = useActivatedSurveys(posthog, surveys);
+  const flags = useFeatureFlags(posthog);
+  // Load surveys once
+  useEffect(() => {
+    // TODO: for the first time, sometimes the surveys are not fetched from storage, so we need to fetch them from the API
+    // because the remote config is still being fetched from the API
+    posthog.ready().then(() => posthog.getSurveys()).then(setSurveys).catch(() => {});
+  }, [posthog]);
+  // Whenever state changes and there's no active survey, check if there is a new survey to show
+  useEffect(() => {
+    if (activeSurvey) {
+      return;
+    }
+    const activeSurveys = getActiveMatchingSurveys(surveys, flags !== null && flags !== void 0 ? flags : {}, seenSurveys, activatedSurveys
+    // lastSeenSurveyDate
+    );
+    const popoverSurveys = activeSurveys.filter(survey => survey.type === SurveyType.Popover);
+    // TODO: sort by appearance delay, implement delay
+    // const popoverSurveyQueue = sortSurveysByAppearanceDelay(popoverSurveys)
+    if (popoverSurveys.length > 0) {
+      setActiveSurvey(popoverSurveys[0]);
+    }
+  }, [activeSurvey, flags, surveys, seenSurveys, activatedSurveys]);
+  // Merge survey appearance so that components and hooks can use a consistent model
+  const surveyAppearance = useMemo(() => {
+    var _a, _b, _c, _d, _e;
+    if (props.overrideAppearanceWithDefault || !activeSurvey) {
+      return {
+        ...defaultSurveyAppearance,
+        ...((_a = props.defaultSurveyAppearance) !== null && _a !== void 0 ? _a : {})
+      };
+    }
+    return {
+      ...defaultSurveyAppearance,
+      ...((_b = props.defaultSurveyAppearance) !== null && _b !== void 0 ? _b : {}),
+      ...((_c = activeSurvey.appearance) !== null && _c !== void 0 ? _c : {}),
+      // If submitButtonColor is set by PostHog, ensure submitButtonTextColor is also set to contrast
+      ...(((_d = activeSurvey.appearance) === null || _d === void 0 ? void 0 : _d.submitButtonColor) ? {
+        submitButtonTextColor: (_e = activeSurvey.appearance.submitButtonTextColor) !== null && _e !== void 0 ? _e : getContrastingTextColor(activeSurvey.appearance.submitButtonColor)
+      } : {})
+    };
+  }, [activeSurvey, props.defaultSurveyAppearance, props.overrideAppearanceWithDefault]);
+  const activeContext = useMemo(() => {
+    if (!activeSurvey) {
+      return undefined;
+    }
+    return {
+      survey: activeSurvey,
+      onShow: () => {
+        sendSurveyShownEvent(activeSurvey, posthog);
+        setLastSeenSurveyDate(new Date());
+      },
+      onClose: submitted => {
+        setSeenSurvey(activeSurvey.id);
+        setActiveSurvey(undefined);
+        if (!submitted) {
+          dismissedSurveyEvent(activeSurvey, posthog);
+        }
+      }
+    };
+  }, [activeSurvey, posthog, setLastSeenSurveyDate, setSeenSurvey]);
+  // Modal is shown for PopOver surveys or if automaticSurveyModal is true, and for all widget surveys
+  // because these would have been invoked by the useFeedbackSurvey hook's showSurveyModal() method
+  const shouldShowModal = activeContext && activeContext.survey.type === SurveyType.Popover;
+  return /*#__PURE__*/React.createElement(ActiveSurveyContext.Provider, {
+    value: activeContext
+  }, /*#__PURE__*/React.createElement(FeedbackSurveyContext.Provider, {
+    value: {
+      surveys,
+      activeSurvey,
+      setActiveSurvey
+    }
+  }, props.children, shouldShowModal && /*#__PURE__*/React.createElement(SurveyModal, _extends({
+    appearance: surveyAppearance
+  }, activeContext))));
+}
+// function sortSurveysByAppearanceDelay(surveys: Survey[]): Survey[] {
+//   return surveys.sort(
+//     (a, b) => (a.appearance?.surveyPopupDelaySeconds ?? 0) - (b.appearance?.surveyPopupDelaySeconds ?? 0)
+//   )
+// }
+
+export { PostHog, PostHogProvider, PostHogSurveyProvider, Questions, SurveyModal, PostHog as default, useFeatureFlag, useFeatureFlagWithPayload, useFeatureFlags, useNavigationTracker, usePostHog };
+//# sourceMappingURL=index.esm.js.map