posthog-react-native 1.1.5 → 2.0.0-alpha12

package/lib/index.cjs.js

@@ -0,0 +1,1804 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reactNative = require('react-native');
+var ExpoApplication = require('expo-application');
+var ExpoDevice = require('expo-device');
+var ExpoLocalization = require('expo-localization');
+var FileSystem = require('expo-file-system');
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var ExpoApplication__namespace = /*#__PURE__*/_interopNamespace(ExpoApplication);
+var ExpoDevice__namespace = /*#__PURE__*/_interopNamespace(ExpoDevice);
+var ExpoLocalization__namespace = /*#__PURE__*/_interopNamespace(ExpoLocalization);
+var FileSystem__namespace = /*#__PURE__*/_interopNamespace(FileSystem);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+var extendStatics = function (d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b)
+            if (Object.prototype.hasOwnProperty.call(b, p))
+                d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+var __assign = function () {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s)
+                if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try {
+            step(generator.next(value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function rejected(value) { try {
+            step(generator["throw"](value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function () { if (t[0] & 1)
+            throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (_)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return { value: op[1], done: false };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [0];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [6, e];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var PostHogPersistedProperty;
+(function (PostHogPersistedProperty) {
+    PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
+    PostHogPersistedProperty["DistinctId"] = "distinct_id";
+    PostHogPersistedProperty["Props"] = "props";
+    PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
+    PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
+    PostHogPersistedProperty["Queue"] = "queue";
+    PostHogPersistedProperty["OptedOut"] = "opted_out";
+    PostHogPersistedProperty["SessionId"] = "session_id";
+    PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
+})(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
+
+function assert(truthyValue, message) {
+    if (!truthyValue) {
+        throw new Error(message);
+    }
+}
+function removeTrailingSlash(url) {
+    return url === null || url === void 0 ? void 0 : url.replace(/\/+$/, '');
+}
+function retriable(fn, props) {
+    if (props === void 0) { props = {}; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, retryCount, _b, retryDelay, _c, retryCheck, lastError, i, res, e_1;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _a = props.retryCount, retryCount = _a === void 0 ? 3 : _a, _b = props.retryDelay, retryDelay = _b === void 0 ? 5000 : _b, _c = props.retryCheck, retryCheck = _c === void 0 ? function () { return true; } : _c;
+                    lastError = null;
+                    i = 0;
+                    _d.label = 1;
+                case 1:
+                    if (!(i < retryCount + 1)) return [3 /*break*/, 8];
+                    _d.label = 2;
+                case 2:
+                    _d.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, fn()];
+                case 3:
+                    res = _d.sent();
+                    return [2 /*return*/, res];
+                case 4:
+                    e_1 = _d.sent();
+                    lastError = e_1;
+                    if (!retryCheck(e_1)) {
+                        throw e_1;
+                    }
+                    return [3 /*break*/, 5];
+                case 5: return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, retryDelay); })];
+                case 6:
+                    _d.sent();
+                    _d.label = 7;
+                case 7:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 8: throw lastError;
+            }
+        });
+    });
+}
+// https://stackoverflow.com/a/8809472
+function generateUUID(globalThis) {
+    // Public Domain/MIT
+    var d = new Date().getTime(); //Timestamp
+    var d2 = (globalThis && globalThis.performance && globalThis.performance.now && globalThis.performance.now() * 1000) || 0; //Time in microseconds since page-load or 0 if unsupported
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        var r = Math.random() * 16; //random number between 0 and 16
+        if (d > 0) {
+            //Use timestamp until depleted
+            r = (d + r) % 16 | 0;
+            d = Math.floor(d / 16);
+        }
+        else {
+            //Use microseconds since page-load if supported
+            r = (d2 + r) % 16 | 0;
+            d2 = Math.floor(d2 / 16);
+        }
+        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+    });
+}
+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.
+    var 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;
+}
+
+// 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
+var f = String.fromCharCode;
+var keyStrBase64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+var baseReverseDic = {};
+function getBaseValue(alphabet, character) {
+    if (!baseReverseDic[alphabet]) {
+        baseReverseDic[alphabet] = {};
+        for (var i = 0; i < alphabet.length; i++) {
+            baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+        }
+    }
+    return baseReverseDic[alphabet][character];
+}
+var LZString = {
+    compressToBase64: function (input) {
+        if (input == null) {
+            return '';
+        }
+        var 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 '';
+        }
+        var context_dictionary = {}, context_dictionaryToCreate = {}, context_data = [];
+        var 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) {
+        var dictionary = [], result = [], data = { val: getNextValue(0), position: resetValue, index: 1 };
+        var 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++;
+            }
+        }
+    },
+};
+
+var SimpleEventEmitter = /** @class */ (function () {
+    function SimpleEventEmitter() {
+        this.events = {};
+        this.events = {};
+    }
+    SimpleEventEmitter.prototype.on = function (event, listener) {
+        var _this = this;
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        this.events[event].push(listener);
+        return function () {
+            _this.events[event] = _this.events[event].filter(function (x) { return x !== listener; });
+        };
+    };
+    SimpleEventEmitter.prototype.emit = function (event, payload) {
+        for (var _i = 0, _a = this.events[event] || []; _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener(payload);
+        }
+        for (var _b = 0, _c = this.events['*'] || []; _b < _c.length; _b++) {
+            var listener = _c[_b];
+            listener(event, payload);
+        }
+    };
+    return SimpleEventEmitter;
+}());
+
+var PostHogCore = /** @class */ (function () {
+    function PostHogCore(apiKey, options) {
+        var _this = this;
+        var _a, _b, _c, _d, _e;
+        this.flagCallReported = {};
+        // internal
+        this._events = new SimpleEventEmitter();
+        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://app.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.flushInterval = (_a = options === null || options === void 0 ? void 0 : options.flushInterval) !== null && _a !== void 0 ? _a : 10000;
+        this.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'form';
+        this.sendFeatureFlagEvent = (_b = options === null || options === void 0 ? void 0 : options.sendFeatureFlagEvent) !== null && _b !== void 0 ? _b : true;
+        // If enable is explicitly set to false we override the optout
+        this._optoutOverride = (options === null || options === void 0 ? void 0 : options.enable) === false;
+        this._retryOptions = {
+            retryCount: (_c = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _c !== void 0 ? _c : 3,
+            retryDelay: (_d = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _d !== void 0 ? _d : 3000,
+        };
+        this._sessionExpirationTimeSeconds = (_e = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _e !== void 0 ? _e : 1800; // 30 minutes
+        // NOTE: It is important we don't initiate anything in the constructor as some async IO may still be underway on the parent
+        if ((options === null || options === void 0 ? void 0 : options.preloadFeatureFlags) !== false) {
+            safeSetTimeout(function () {
+                void _this.reloadFeatureFlagsAsync();
+            }, 1);
+        }
+    }
+    PostHogCore.prototype.getCommonEventProperties = function () {
+        var featureFlags = this.getFeatureFlags();
+        return {
+            $lib: this.getLibraryId(),
+            $lib_version: this.getLibraryVersion(),
+            $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined,
+            $enabled_feature_flags: featureFlags,
+        };
+    };
+    Object.defineProperty(PostHogCore.prototype, "props", {
+        // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
+        get: function () {
+            if (!this._props) {
+                this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
+            }
+            return this._props || {};
+        },
+        set: function (val) {
+            this._props = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PostHogCore.prototype, "optedOut", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.getPersistedProperty(PostHogPersistedProperty.OptedOut)) !== null && _a !== void 0 ? _a : this._optoutOverride) !== null && _b !== void 0 ? _b : false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PostHogCore.prototype.optIn = function () {
+        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, false);
+    };
+    PostHogCore.prototype.optOut = function () {
+        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, true);
+    };
+    PostHogCore.prototype.on = function (event, cb) {
+        return this._events.on(event, cb);
+    };
+    PostHogCore.prototype.reset = function () {
+        for (var key in PostHogPersistedProperty) {
+            this.setPersistedProperty(PostHogPersistedProperty[key], null);
+        }
+    };
+    PostHogCore.prototype.debug = function (enabled) {
+        var _a;
+        if (enabled === void 0) { enabled = true; }
+        (_a = this.removeDebugCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (enabled) {
+            this.removeDebugCallback = this.on('*', function (event, payload) { return console.log('PostHog Debug', event, payload); });
+        }
+    };
+    PostHogCore.prototype.buildPayload = function (payload) {
+        return {
+            distinct_id: payload.distinct_id || this.getDistinctId(),
+            event: payload.event,
+            properties: __assign(__assign(__assign(__assign({}, this.props), (payload.properties || {})), this.getCommonEventProperties()), { $session_id: this.getSessionId() }),
+        };
+    };
+    PostHogCore.prototype.getSessionId = function () {
+        var sessionId = this.getPersistedProperty(PostHogPersistedProperty.SessionId);
+        var sessionTimestamp = this.getPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp) || 0;
+        if (!sessionId || Date.now() - sessionTimestamp > this._sessionExpirationTimeSeconds * 1000) {
+            sessionId = generateUUID(globalThis);
+            this.setPersistedProperty(PostHogPersistedProperty.SessionId, sessionId);
+        }
+        this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, Date.now());
+        return sessionId;
+    };
+    PostHogCore.prototype.resetSessionId = function () {
+        this.setPersistedProperty(PostHogPersistedProperty.SessionId, null);
+    };
+    PostHogCore.prototype.getAnonymousId = function () {
+        var anonId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
+        if (!anonId) {
+            anonId = generateUUID(globalThis);
+            this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, anonId);
+        }
+        return anonId;
+    };
+    PostHogCore.prototype.getDistinctId = function () {
+        return this.getPersistedProperty(PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
+    };
+    PostHogCore.prototype.register = function (properties) {
+        this.props = __assign(__assign({}, this.props), properties);
+        this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+    };
+    PostHogCore.prototype.unregister = function (property) {
+        delete this.props[property];
+        this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+    };
+    /***
+     *** TRACKING
+     ***/
+    PostHogCore.prototype.identify = function (distinctId, properties) {
+        var previousDistinctId = this.getDistinctId();
+        distinctId = distinctId || previousDistinctId;
+        if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
+            this.groups(properties.$groups);
+        }
+        var payload = __assign(__assign({}, this.buildPayload({
+            distinct_id: distinctId,
+            event: '$identify',
+            properties: __assign(__assign({}, (properties || {})), { $anon_distinct_id: this.getAnonymousId() }),
+        })), { $set: properties });
+        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);
+            if (this.getFeatureFlags()) {
+                void this.reloadFeatureFlagsAsync();
+            }
+        }
+        this.enqueue('identify', payload);
+        return this;
+    };
+    PostHogCore.prototype.capture = function (event, properties) {
+        if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
+            this.groups(properties.$groups);
+        }
+        var payload = this.buildPayload({ event: event, properties: properties });
+        this.enqueue('capture', payload);
+        return this;
+    };
+    PostHogCore.prototype.alias = function (alias) {
+        var distinctId = this.getDistinctId();
+        var payload = this.buildPayload({
+            event: '$create_alias',
+            properties: {
+                distinct_id: distinctId,
+                alias: alias,
+            },
+        });
+        this.enqueue('alias', payload);
+        return this;
+    };
+    PostHogCore.prototype.autocapture = function (eventType, elements, properties) {
+        if (properties === void 0) { properties = {}; }
+        var payload = this.buildPayload({
+            event: '$autocapture',
+            properties: __assign(__assign({}, properties), { $event_type: eventType, $elements: elements }),
+        });
+        this.enqueue('autocapture', payload);
+        return this;
+    };
+    /***
+     *** GROUPS
+     ***/
+    PostHogCore.prototype.groups = function (groups) {
+        // Get persisted groups
+        var existingGroups = this.props.$groups || {};
+        // NOTE: Should we do the same for groups listed in identify / capture?
+        this.register({
+            $groups: __assign(__assign({}, existingGroups), groups),
+        });
+        if (Object.keys(groups).find(function (type) { return existingGroups[type] !== groups[type]; }) && this.getFeatureFlags()) {
+            void this.reloadFeatureFlagsAsync();
+        }
+        return this;
+    };
+    PostHogCore.prototype.group = function (groupType, groupKey, groupProperties) {
+        var _a;
+        this.groups((_a = {},
+            _a[groupType] = groupKey,
+            _a));
+        if (groupProperties) {
+            this.groupIdentify(groupType, groupKey, groupProperties);
+        }
+        return this;
+    };
+    PostHogCore.prototype.groupIdentify = function (groupType, groupKey, groupProperties) {
+        var payload = {
+            event: '$groupidentify',
+            distinctId: "$".concat(groupType, "_").concat(groupKey),
+            properties: __assign({ $group_type: groupType, $group_key: groupKey, $group_set: groupProperties || {} }, this.getCommonEventProperties()),
+        };
+        this.enqueue('capture', payload);
+        return this;
+    };
+    /***
+     *** FEATURE FLAGS
+     ***/
+    PostHogCore.prototype.decideAsync = function () {
+        if (this._decideResponsePromise) {
+            return this._decideResponsePromise;
+        }
+        return this._decideAsync();
+    };
+    PostHogCore.prototype._decideAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, distinctId, groups, fetchOptions;
+            var _this = this;
+            return __generator(this, function (_a) {
+                url = "".concat(this.host, "/decide/?v=2");
+                distinctId = this.getDistinctId();
+                groups = this.props.$groups || {};
+                fetchOptions = {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        token: this.apiKey,
+                        distinct_id: distinctId,
+                        $anon_distinct_id: this.getAnonymousId(),
+                        groups: groups,
+                    }),
+                };
+                this._decideResponsePromise = this.fetchWithRetry(url, fetchOptions)
+                    .then(function (r) { return r.json(); })
+                    .then(function (res) {
+                    if (res.featureFlags) {
+                        _this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, res.featureFlags);
+                        _this._events.emit('featureflags', res.featureFlags);
+                    }
+                    return res;
+                })
+                    .finally(function () {
+                    _this._decideResponsePromise = undefined;
+                });
+                return [2 /*return*/, this._decideResponsePromise];
+            });
+        });
+    };
+    PostHogCore.prototype.getFeatureFlag = function (key, defaultResult) {
+        var _a;
+        if (defaultResult === void 0) { defaultResult = false; }
+        var featureFlags = this.getFeatureFlags();
+        if (!featureFlags) {
+            // If we haven't loaded flags yet we respond undefined to indicate this
+            return undefined;
+        }
+        if (this.sendFeatureFlagEvent && !this.flagCallReported[key]) {
+            this.flagCallReported[key] = true;
+            this.capture('$feature_flag_called', {
+                $feature_flag: key,
+                $feature_flag_response: featureFlags[key],
+            });
+        }
+        // If we have flags we either return the value (true or string) or the defaultResult
+        return (_a = featureFlags[key]) !== null && _a !== void 0 ? _a : defaultResult;
+    };
+    PostHogCore.prototype.getFeatureFlags = function () {
+        var flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+        var overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
+        if (!overriddenFlags) {
+            return flags;
+        }
+        flags = flags || {};
+        for (var key in overriddenFlags) {
+            if (!overriddenFlags[key]) {
+                delete flags[key];
+            }
+            else {
+                flags[key] = overriddenFlags[key];
+            }
+        }
+        return flags;
+    };
+    PostHogCore.prototype.isFeatureEnabled = function (key, defaultResult) {
+        var _a;
+        if (defaultResult === void 0) { defaultResult = false; }
+        var flag = (_a = this.getFeatureFlag(key, defaultResult)) !== null && _a !== void 0 ? _a : defaultResult;
+        return !!flag;
+    };
+    PostHogCore.prototype.reloadFeatureFlagsAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.decideAsync()];
+                    case 1: return [2 /*return*/, (_a.sent()).featureFlags];
+                }
+            });
+        });
+    };
+    PostHogCore.prototype.onFeatureFlags = function (cb) {
+        var _this = this;
+        return this.on('featureflags', function () { return __awaiter(_this, void 0, void 0, function () {
+            var flags;
+            return __generator(this, function (_a) {
+                flags = this.getFeatureFlags();
+                if (flags) {
+                    cb(flags);
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    PostHogCore.prototype.onFeatureFlag = function (key, cb) {
+        var _this = this;
+        return this.on('featureflags', function () { return __awaiter(_this, void 0, void 0, function () {
+            var flagResponse;
+            return __generator(this, function (_a) {
+                flagResponse = this.getFeatureFlag(key);
+                if (flagResponse !== undefined) {
+                    cb(flagResponse);
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    PostHogCore.prototype.overrideFeatureFlag = function (flags) {
+        if (flags === null) {
+            return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, null);
+        }
+        return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
+    };
+    /***
+     *** QUEUEING AND FLUSHING
+     ***/
+    PostHogCore.prototype.enqueue = function (type, _message) {
+        var _this = this;
+        if (this.optedOut) {
+            return;
+        }
+        var message = __assign(__assign({}, _message), { type: type, library: this.getLibraryId(), library_version: this.getLibraryVersion(), timestamp: _message.timestamp ? _message.timestamp : currentISOTime() });
+        if (message.distinctId) {
+            message.distinct_id = message.distinctId;
+            delete message.distinctId;
+        }
+        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        queue.push({ message: 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.flush();
+        }
+        if (this.flushInterval && !this._flushTimer) {
+            this._flushTimer = safeSetTimeout(function () { return _this.flush(); }, this.flushInterval);
+        }
+    };
+    PostHogCore.prototype.flushAsync = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.flush(function (err, data) { return (err ? reject(err) : resolve(data)); });
+        });
+    };
+    PostHogCore.prototype.flush = function (callback) {
+        var _this = this;
+        if (this.optedOut) {
+            return callback && safeSetTimeout(callback, 0);
+        }
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = null;
+        }
+        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        if (!queue.length) {
+            return callback && safeSetTimeout(callback, 0);
+        }
+        var items = queue.splice(0, this.flushAt);
+        this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
+        var messages = items.map(function (item) { return item.message; });
+        var data = {
+            api_key: this.apiKey,
+            batch: messages,
+            sent_at: currentISOTime(),
+        };
+        var done = function (err) {
+            callback === null || callback === void 0 ? void 0 : callback(err, messages);
+            _this._events.emit('flush', messages);
+        };
+        // 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.
+        this.getCustomUserAgent();
+        var payload = JSON.stringify(data);
+        var url = this.captureMode === 'form'
+            ? "".concat(this.host, "/e/?ip=1&_=").concat(currentTimestamp(), "&v=").concat(this.getLibraryVersion())
+            : "".concat(this.host, "/batch/");
+        var fetchOptions = this.captureMode === 'form'
+            ? {
+                method: 'POST',
+                mode: 'no-cors',
+                credentials: 'omit',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: "data=".concat(encodeURIComponent(LZString.compressToBase64(payload)), "&compression=lz64"),
+            }
+            : {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: payload,
+            };
+        this.fetchWithRetry(url, fetchOptions)
+            .then(function () { return done(); })
+            .catch(function (err) {
+            if (err.response) {
+                var error = new Error(err.response.statusText);
+                return done(error);
+            }
+            done(err);
+        });
+    };
+    PostHogCore.prototype.fetchWithRetry = function (url, options, retryOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, retriable(function () { return _this.fetch(url, options); }, retryOptions || this._retryOptions)];
+            });
+        });
+    };
+    PostHogCore.prototype.shutdownAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        clearTimeout(this._flushTimer);
+                        return [4 /*yield*/, this.flushAsync()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostHogCore.prototype.shutdown = function () {
+        void this.shutdownAsync();
+    };
+    return PostHogCore;
+}());
+
+var PostHogMemoryStorage = /** @class */ (function () {
+    function PostHogMemoryStorage() {
+        this._memoryStorage = {};
+    }
+    PostHogMemoryStorage.prototype.getProperty = function (key) {
+        return this._memoryStorage[key];
+    };
+    PostHogMemoryStorage.prototype.setProperty = function (key, value) {
+        this._memoryStorage[key] = value !== null ? value : undefined;
+    };
+    return PostHogMemoryStorage;
+}());
+
+var getLegacyValues = function () {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var posthogFileDirectory, posthogDistinctIdFile, posthogAnonymousIdFile, res, _a, _b, _c, _d, _e, _f;
+
+    return __generator(this, function (_g) {
+      switch (_g.label) {
+        case 0:
+          if (!(reactNative.Platform.OS === 'ios')) return [3
+          /*break*/
+          , 8];
+          posthogFileDirectory = "".concat(FileSystem__namespace.documentDirectory, "../Library/Application%20Support/").concat(ExpoApplication__namespace.applicationId, "/");
+          posthogDistinctIdFile = posthogFileDirectory + 'posthog.distinctId';
+          posthogAnonymousIdFile = posthogFileDirectory + 'posthog.anonymousId';
+          res = {
+            distinctId: undefined,
+            anonymousId: undefined
+          };
+          _g.label = 1;
+
+        case 1:
+          _g.trys.push([1, 3,, 4]);
+
+          _a = res;
+          _c = (_b = JSON).parse;
+          return [4
+          /*yield*/
+          , FileSystem__namespace.readAsStringAsync(posthogDistinctIdFile)];
+
+        case 2:
+          _a.distinctId = _c.apply(_b, [_g.sent()])['posthog.distinctId'];
+          return [3
+          /*break*/
+          , 4];
+
+        case 3:
+          _g.sent();
+          return [3
+          /*break*/
+          , 4];
+
+        case 4:
+          _g.trys.push([4, 6,, 7]);
+
+          _d = res;
+          _f = (_e = JSON).parse;
+          return [4
+          /*yield*/
+          , FileSystem__namespace.readAsStringAsync(posthogAnonymousIdFile)];
+
+        case 5:
+          _d.anonymousId = _f.apply(_e, [_g.sent()])['posthog.anonymousId'];
+          return [3
+          /*break*/
+          , 7];
+
+        case 6:
+          _g.sent();
+          return [3
+          /*break*/
+          , 7];
+
+        case 7:
+          return [2
+          /*return*/
+          , res];
+
+        case 8:
+          return [2
+          /*return*/
+          ];
+      }
+    });
+  });
+};
+
+var POSTHOG_STORAGE_KEY = '.posthog-rn.json';
+var POSTHOG_STORAGE_VERSION = 'v1';
+
+var loadStorageAsync = function () {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var uri, stringContent;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          uri = FileSystem__namespace.documentDirectory + POSTHOG_STORAGE_KEY;
+          _a.label = 1;
+
+        case 1:
+          _a.trys.push([1, 3,, 4]);
+
+          return [4
+          /*yield*/
+          , FileSystem__namespace.readAsStringAsync(uri)];
+
+        case 2:
+          stringContent = _a.sent();
+          return [2
+          /*return*/
+          , JSON.parse(stringContent).content];
+
+        case 3:
+          _a.sent();
+          return [2
+          /*return*/
+          , {}];
+
+        case 4:
+          return [2
+          /*return*/
+          ];
+      }
+    });
+  });
+};
+
+var persitStorageAsync = function (content) {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var uri, data;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          uri = FileSystem__namespace.documentDirectory + POSTHOG_STORAGE_KEY;
+          data = {
+            version: POSTHOG_STORAGE_VERSION,
+            content: content
+          };
+          return [4
+          /*yield*/
+          , FileSystem__namespace.writeAsStringAsync(uri, JSON.stringify(data)).catch(function (e) {
+            console.error('PostHog failed to persist data to storage', e);
+          })];
+
+        case 1:
+          _a.sent();
+
+          return [2
+          /*return*/
+          ];
+      }
+    });
+  });
+}; // NOTE: The core prefers a synchronous storage so we mimic this by pre-loading all keys
+
+
+var _memoryCache = {};
+var SemiAsyncStorage = {
+  getItem: function (key) {
+    return _memoryCache[key];
+  },
+  setItem: function (key, value) {
+    _memoryCache[key] = value;
+    void persitStorageAsync(_memoryCache);
+  },
+  removeItem: function (key) {
+    delete _memoryCache[key];
+    void persitStorageAsync(_memoryCache);
+  },
+  clear: function () {
+    for (var key in _memoryCache) {
+      delete _memoryCache[key];
+    }
+
+    void persitStorageAsync(_memoryCache);
+  },
+  getAllKeys: function () {
+    return Object.keys(_memoryCache);
+  }
+};
+
+var _preloadSemiAsyncStoragePromise;
+
+var preloadSemiAsyncStorage = function () {
+  if (_preloadSemiAsyncStoragePromise) {
+    return _preloadSemiAsyncStoragePromise;
+  }
+
+  _preloadSemiAsyncStoragePromise = loadStorageAsync().then(function (res) {
+    for (var key in res) {
+      _memoryCache[key] = res[key];
+    }
+  });
+  return _preloadSemiAsyncStoragePromise;
+};
+
+var version = "2.0.0-alpha12";
+
+var PostHog =
+/** @class */
+function (_super) {
+  __extends(PostHog, _super);
+
+  function PostHog(apiKey, options) {
+    var _this = _super.call(this, apiKey, options) || this;
+
+    _this._memoryStorage = new PostHogMemoryStorage();
+    _this._persistence = options === null || options === void 0 ? void 0 : options.persistence;
+    reactNative.AppState.addEventListener('change', function () {
+      _this.flush();
+    }); // Ensure the async storage has been preloaded (this call is cached)
+    // It is possible that the old library was used so we try to get the legacy distinctID
+
+    void preloadSemiAsyncStorage().then(function () {
+      if (!SemiAsyncStorage.getItem(PostHogPersistedProperty.AnonymousId)) {
+        getLegacyValues().then(function (legacyValues) {
+          if (legacyValues === null || legacyValues === void 0 ? void 0 : legacyValues.distinctId) {
+            SemiAsyncStorage.setItem(PostHogPersistedProperty.DistinctId, legacyValues.distinctId);
+            SemiAsyncStorage.setItem(PostHogPersistedProperty.AnonymousId, legacyValues.anonymousId);
+          }
+        });
+      }
+    });
+    return _this;
+  }
+
+  PostHog.initAsync = function () {
+    return preloadSemiAsyncStorage();
+  };
+
+  PostHog.prototype.getPersistedProperty = function (key) {
+    if (this._persistence === 'memory') {
+      return this._memoryStorage.getProperty(key);
+    }
+
+    return SemiAsyncStorage.getItem(key) || undefined;
+  };
+
+  PostHog.prototype.setPersistedProperty = function (key, value) {
+    if (this._persistence === 'memory') {
+      return this._memoryStorage.getProperty(key);
+    }
+
+    return value !== null ? SemiAsyncStorage.setItem(key, value) : SemiAsyncStorage.removeItem(key);
+  };
+
+  PostHog.prototype.fetch = function (url, options) {
+    return fetch(url, options);
+  };
+
+  PostHog.prototype.getLibraryId = function () {
+    return 'posthog-react-native';
+  };
+
+  PostHog.prototype.getLibraryVersion = function () {
+    return version;
+  };
+
+  PostHog.prototype.getCustomUserAgent = function () {
+    // TODO
+    return;
+  };
+
+  PostHog.prototype.getCommonEventProperties = function () {
+    console.log('DeviceInfo', ExpoDevice__namespace);
+    return __assign(__assign({}, _super.prototype.getCommonEventProperties.call(this)), {
+      $app_build: '1',
+      $app_name: ExpoApplication__namespace.applicationName,
+      $app_namespace: ExpoApplication__namespace.applicationId,
+      $app_version: ExpoApplication__namespace.nativeApplicationVersion,
+      // "$device_id": "F31C35E8-5B28-4626-8AFC-213D1C655FF9",
+      $device_manufacturer: ExpoDevice__namespace.manufacturer,
+      //     "$device_model": "x86_64",
+      $device_name: ExpoDevice__namespace.modelName,
+      // "$device_type": "ios",
+      $locale: ExpoLocalization__namespace.locale,
+      //     "$network_cellular": false,
+      //     "$network_wifi": true,
+      $os_name: ExpoDevice__namespace.osName,
+      $os_version: ExpoDevice__namespace.osVersion,
+      $screen_height: reactNative.Dimensions.get('screen').height,
+      $screen_width: reactNative.Dimensions.get('screen').width,
+      $timezone: ExpoLocalization__namespace.timezone
+    });
+  }; // Custom methods
+
+
+  PostHog.prototype.screen = function (name, properties) {
+    return this.capture('$screen', __assign(__assign({}, properties), {
+      $screen_name: name
+    }));
+  };
+
+  return PostHog;
+}(PostHogCore);
+// is used
+
+void PostHog.initAsync();
+
+var PostHogContext = /*#__PURE__*/React__default["default"].createContext({
+  client: undefined
+});
+
+var usePostHog = function () {
+  var client = React__default["default"].useContext(PostHogContext).client;
+  return client;
+};
+
+function useLifecycleTracker(client) {
+  var openTrackedRef = React.useRef(false);
+  var contextClient = usePostHog();
+  var posthog = client || contextClient;
+  return React.useEffect(function () {
+    if (!posthog) {
+      return;
+    }
+
+    if (!openTrackedRef.current) {
+      openTrackedRef.current = true;
+      posthog.capture('Application Opened');
+    }
+
+    var subscription = reactNative.AppState.addEventListener('change', function (nextAppState) {
+      switch (nextAppState) {
+        case 'active':
+          return posthog.capture('Application Became Active');
+
+        case 'background':
+          return posthog.capture('Application Backgrounded');
+
+        default:
+          return;
+      }
+    });
+    return function () {
+      return subscription.remove();
+    };
+  }, [posthog]);
+}
+
+var _OptionalReactNativeNavigation = undefined;
+
+var warn = function (name) {
+  console.warn("PostHog: Missing ".concat(name, " optional dependency. Some functions may not work as expected..."));
+};
+
+try {
+  _OptionalReactNativeNavigation = require('@react-navigation/native');
+} catch (e) {
+  warn('@react-navigation/native');
+}
+
+var OptionalReactNativeNavigation = _OptionalReactNativeNavigation;
+
+function _useNavigationTrackerDisabled() {
+  return;
+}
+
+function _useNavigationTracker(options, client) {
+  var contextClient = usePostHog();
+  var posthog = client || contextClient;
+
+  if (!OptionalReactNativeNavigation) {
+    // NOTE: This is taken care of by the export but we keep this here for TS
+    return;
+  }
+
+  var routes = OptionalReactNativeNavigation.useNavigationState(function (state) {
+    return state === null || state === void 0 ? void 0 : state.routes;
+  });
+  var navigation = OptionalReactNativeNavigation.useNavigation();
+
+  var trackRoute = function () {
+    var _a, _b, _c;
+
+    if (!posthog) {
+      return;
+    } // NOTE: This method is not typed correctly but is available and takes care of parsing the router state correctly
+
+
+    var currentRoute = navigation.getCurrentRoute();
+
+    if (!currentRoute) {
+      return;
+    }
+
+    var state = currentRoute.state;
+    var name = currentRoute.name,
+        params = currentRoute.params;
+
+    if ((_a = state === null || state === void 0 ? void 0 : state.routes) === null || _a === void 0 ? void 0 : _a.length) {
+      var route = state.routes[state.routes.length - 1];
+      name = route.name;
+      params = route.params;
+    }
+
+    var 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) {
+      var 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);
+    }
+  };
+
+  React.useEffect(function () {
+    // 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]);
+}
+
+var useNavigationTracker = OptionalReactNativeNavigation ? _useNavigationTracker : _useNavigationTrackerDisabled;
+
+function useFeatureFlags(client) {
+  var contextClient = usePostHog();
+  var posthog = client || contextClient;
+
+  var _a = React.useState(posthog === null || posthog === void 0 ? void 0 : posthog.getFeatureFlags()),
+      featureFlags = _a[0],
+      setFeatureFlags = _a[1];
+
+  if (!posthog) {
+    return featureFlags;
+  }
+
+  React.useEffect(function () {
+    setFeatureFlags(posthog.getFeatureFlags());
+    return posthog.onFeatureFlags(function (flags) {
+      setFeatureFlags(flags);
+    });
+  }, [posthog]);
+  return featureFlags;
+}
+
+function useFeatureFlag(flag, defaultValue) {
+  var posthog = usePostHog();
+
+  var _a = React.useState(posthog === null || posthog === void 0 ? void 0 : posthog.getFeatureFlag(flag, defaultValue)),
+      featureFlag = _a[0],
+      setFeatureFlag = _a[1];
+
+  if (!posthog) {
+    return featureFlag;
+  }
+
+  React.useEffect(function () {
+    setFeatureFlag(posthog.getFeatureFlag(flag, defaultValue));
+    return posthog.onFeatureFlags(function () {
+      setFeatureFlag(posthog.getFeatureFlag(flag, defaultValue));
+    });
+  }, [posthog, flag, defaultValue]);
+  return featureFlag;
+}
+
+var flattenStyles = function (styles) {
+  var flattened = {};
+
+  if (Array.isArray(styles)) {
+    for (var _i = 0, styles_1 = styles; _i < styles_1.length; _i++) {
+      var style = styles_1[_i];
+      Object.assign(flattened, flattenStyles(style));
+    }
+  } else {
+    Object.assign(flattened, styles);
+  }
+
+  return flattened;
+};
+
+var stringifyStyle = function (styles) {
+  var flattened = flattenStyles(styles);
+  var str = Object.keys(flattened).map(function (x) {
+    return "".concat(x, ":").concat(flattened[x]);
+  }).join(';');
+  return str;
+};
+
+var sanitiseLabel = function (label) {
+  return label.replace(/[^a-z0-9]+/gi, '-');
+};
+
+var autocaptureFromTouchEvent = function (e, posthog, options) {
+  var _a, _b;
+
+  if (options === void 0) {
+    options = {};
+  }
+
+  var _c = options.noCaptureProp,
+      noCaptureProp = _c === void 0 ? 'ph-no-capture' : _c,
+      _d = options.customLabelProp,
+      customLabelProp = _d === void 0 ? 'ph-label' : _d,
+      _e = options.maxElementsCaptured,
+      maxElementsCaptured = _e === void 0 ? 20 : _e,
+      _f = options.ignoreLabels,
+      ignoreLabels = _f === void 0 ? [] : _f,
+      _g = options.propsToCapture,
+      propsToCapture = _g === void 0 ? ['style', 'testID', 'accessibilityLabel', 'ph-label'] : _g;
+
+  if (!e._targetInst) {
+    return;
+  }
+
+  var elements = [];
+  var currentInst = e._targetInst;
+
+  var _loop_1 = function () {
+    var el = {
+      tag_name: ''
+    };
+    var props = currentInst.memoizedProps;
+
+    if (props === null || props === void 0 ? void 0 : props[noCaptureProp]) {
+      return {
+        value: void 0
+      };
+    }
+
+    if (props) {
+      // Capture only props we have said to capture. By default this is only "safe" props
+      Object.keys(props).forEach(function (key) {
+        if (!propsToCapture.includes(key)) {
+          return;
+        }
+
+        var 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__".concat(key)] = value;
+          }
+        }
+      });
+    } // Try and find a sensible label
+
+
+    var label = typeof (props === null || props === void 0 ? void 0 : props[customLabelProp]) !== 'undefined' ? "".concat(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;
+  };
+
+  while (currentInst && // maxComponentTreeSize will always be defined as we have a defaultProps. But ts needs a check so this is here.
+  elements.length < maxElementsCaptured) {
+    var state_1 = _loop_1();
+
+    if (typeof state_1 === "object") return state_1.value;
+  }
+
+  if (elements.length) {
+    posthog.autocapture('touch', elements, {
+      $touch_x: e.nativeEvent.pageX,
+      $touch_y: e.nativeEvent.pageY
+    });
+  }
+};
+
+function PostHogHooks(_a) {
+  var options = _a.options;
+  useNavigationTracker(options === null || options === void 0 ? void 0 : options.navigation);
+  useLifecycleTracker();
+  return null;
+}
+
+var PostHogProvider = function (_a) {
+  var children = _a.children,
+      client = _a.client,
+      options = _a.options,
+      apiKey = _a.apiKey,
+      autocapture = _a.autocapture,
+      style = _a.style;
+  var posthogRef = React.useRef();
+
+  if (!posthogRef.current) {
+    posthogRef.current = client ? client : apiKey ? new PostHog(apiKey, options) : undefined;
+  }
+
+  var autocaptureEnabled = !!autocapture;
+  var autocaptureOptions = autocapture && typeof autocapture !== 'boolean' ? autocapture : {};
+  var posthog = posthogRef.current;
+  var captureTouches = posthog && (autocapture === true || (autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.captureTouches));
+  var onTouch = React.useCallback(function (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);
+    }
+  }, [posthog, autocapture]); // TODO: Improve this to ensure we only capture presses and not just ends of a drag for example
+
+  return /*#__PURE__*/React__default["default"].createElement(reactNative.View, {
+    "ph-label": "PostHogProvider",
+    style: style || {
+      flex: 1
+    },
+    onTouchEndCapture: captureTouches ? function (e) {
+      return onTouch('end', e);
+    } : undefined
+  }, /*#__PURE__*/React__default["default"].createElement(PostHogContext.Provider, {
+    value: {
+      client: posthogRef.current
+    }
+  }, autocaptureEnabled ? /*#__PURE__*/React__default["default"].createElement(PostHogHooks, {
+    options: autocaptureOptions
+  }) : null, children));
+};
+
+exports.PostHog = PostHog;
+exports.PostHogProvider = PostHogProvider;
+exports["default"] = PostHog;
+exports.useFeatureFlag = useFeatureFlag;
+exports.useFeatureFlags = useFeatureFlags;
+exports.useLifecycleTracker = useLifecycleTracker;
+exports.useNavigationTracker = useNavigationTracker;
+exports.usePostHog = usePostHog;
+//# sourceMappingURL=index.cjs.js.map