wisetrack 2.0.0

package/dist/cdn/sdk.bundle.js

@@ -0,0 +1,3604 @@
+var WiseTrackSDK = (function (exports) {
+    'use strict';
+
+    /******************************************************************************
+    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, SuppressedError, Symbol, Iterator */
+
+
+    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());
+        });
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    /** @internal */
+    const WTConstants = {
+        SDK: {
+            HASH: "997bfbb583c1245a426a53dc1899ec779ff354f9",
+            PLATFORM: "web",
+            VERSION: "2.0.0",
+        },
+        CONFIG: {
+            BASE_URL: "https://config.wisetrack.io",
+            DEFAULT_ENVIRONMENT: "debug",
+        },
+        DEFAULTS: {
+            LOG_LEVEL: "debug",
+            SESSION_INTERVAL: '1800000', // 30 minutes
+            SUBSESSION_INTERVAL: '300000'},
+    };
+
+    /** @internal */
+    const WTSDKEnvironment = {
+        DEBUG: "debug",
+        STAGE: "stage",
+        PRODUCTION: "production",
+    };
+    /** @internal */
+    const EnvironmentUtils = {
+        sdkEnvironment: WTConstants.CONFIG.DEFAULT_ENVIRONMENT,
+        needAppSettings() {
+            return this.sdkEnvironment !== WTSDKEnvironment.PRODUCTION;
+        },
+        baseUrl() {
+            switch (this.sdkEnvironment) {
+                case WTSDKEnvironment.DEBUG:
+                    return "https://core.debug.wisetrackdev.ir";
+                case WTSDKEnvironment.STAGE:
+                    return "https://core.stage.wisetrackdev.ir";
+                case WTSDKEnvironment.PRODUCTION:
+                    return "https://core.wisetrack.io";
+                default:
+                    throw new Error(`Unknown environment: ${this.sdkEnvironment}`);
+            }
+        },
+    };
+
+    /** @internal */
+    const WTEndpoints = {
+        EVENTS: "/api/v1/events",
+        SESSIONS: "/api/v1/sessions",
+        SDK_CLICKS: "/api/v1/sdk_clicks",
+        SDK_INFOS: "/api/v1/sdk_infos",
+        ATTRIBUTIONS: "/api/v1/attributions",
+        APP_SETTINGS: "/api/v1/app_settings",
+    };
+
+    /** @internal */
+    class WTAppSettings {
+        constructor(events, sessions, sdkClicks, sdkInfos, attributions, sessionInterval = WTConstants.DEFAULTS.SESSION_INTERVAL, subsessionInterval = WTConstants.DEFAULTS.SUBSESSION_INTERVAL) {
+            this.events = events;
+            this.sessions = sessions;
+            this.sdkClicks = sdkClicks;
+            this.sdkInfos = sdkInfos;
+            this.attributions = attributions;
+            this.sessionInterval = sessionInterval;
+            this.subsessionInterval = subsessionInterval;
+        }
+        static fromConfig(config) {
+            return new WTAppSettings(config.events, config.sessions, config.sdkClicks, config.sdkInfos, config.attributions, config.sessionInterval, config.subsessionInterval);
+        }
+        static fromJson(json) {
+            var _a, _b;
+            return new WTAppSettings(json.events, json.sessions, json.sdk_clicks, json.sdk_infos, json.attributions, (_a = json.session_interval) !== null && _a !== void 0 ? _a : WTConstants.DEFAULTS.SESSION_INTERVAL, (_b = json.subsession_interval) !== null && _b !== void 0 ? _b : WTConstants.DEFAULTS.SUBSESSION_INTERVAL);
+        }
+        static get defaultValue() {
+            return new WTAppSettings(WTEndpoints.EVENTS, WTEndpoints.SESSIONS, WTEndpoints.SDK_CLICKS, WTEndpoints.SDK_INFOS, WTEndpoints.ATTRIBUTIONS, WTConstants.DEFAULTS.SESSION_INTERVAL, WTConstants.DEFAULTS.SUBSESSION_INTERVAL);
+        }
+    }
+
+    /** @internal */
+    class WTConfig {
+        constructor(baseUrl, events, sessions, sdkClicks, sdkInfos, attributions, appSettings, sdkEnabled = true, forceUpdate = false, sdkUpdate = false, sessionInterval = WTConstants.DEFAULTS.SESSION_INTERVAL, subsessionInterval = WTConstants.DEFAULTS.SUBSESSION_INTERVAL) {
+            this.baseUrl = baseUrl;
+            this.events = events;
+            this.sessions = sessions;
+            this.sdkClicks = sdkClicks;
+            this.sdkInfos = sdkInfos;
+            this.attributions = attributions;
+            this.appSettings = appSettings;
+            this.sdkEnabled = sdkEnabled;
+            this.forceUpdate = forceUpdate;
+            this.sdkUpdate = sdkUpdate;
+            this.sessionInterval = sessionInterval;
+            this.subsessionInterval = subsessionInterval;
+        }
+        static fromJson(json) {
+            var _a, _b, _c, _d, _e;
+            return new WTConfig(json.base_url, json.events, json.sessions, json.sdk_clicks, json.sdk_infos, json.attributions, json.app_settings, (_a = json.sdk_enabled) !== null && _a !== void 0 ? _a : true, (_b = json.force_update) !== null && _b !== void 0 ? _b : false, (_c = json.sdk_update) !== null && _c !== void 0 ? _c : false, (_d = json.session_interval) !== null && _d !== void 0 ? _d : WTConstants.DEFAULTS.SESSION_INTERVAL, (_e = json.subsession_interval) !== null && _e !== void 0 ? _e : WTConstants.DEFAULTS.SUBSESSION_INTERVAL);
+        }
+        static get defaultValue() {
+            return new WTConfig(EnvironmentUtils.baseUrl(), WTEndpoints.EVENTS, WTEndpoints.SESSIONS, WTEndpoints.SDK_CLICKS, WTEndpoints.SDK_INFOS, WTEndpoints.ATTRIBUTIONS, WTEndpoints.APP_SETTINGS);
+        }
+    }
+
+    /** @internal */
+    class WTLogEngine {
+    }
+    /** @internal */
+    class ConsoleLogEngine extends WTLogEngine {
+        log(level, prefix, ...args) {
+            switch (level) {
+                case "debug":
+                    console.debug(prefix, ...args);
+                    break;
+                case "info":
+                    console.info(prefix, ...args);
+                    break;
+                case "warn":
+                    console.warn(prefix, ...args);
+                    break;
+                case "error":
+                    console.error(prefix, ...args);
+                    break;
+                default:
+                    console.log(prefix, ...args);
+                    break;
+            }
+        }
+    }
+    /**
+     * Defines the available log levels for the SDK.
+     *
+     * - `DEBUG`: Logs everything, including debug info.
+     * - `INFO`: Logs general information.
+     * - `WARN`: Logs warnings.
+     * - `ERROR`: Logs errors only.
+     * - `NONE`: Disables logging.
+     */
+    const WTLogLevel = {
+        DEBUG: "debug",
+        INFO: "info",
+        WARN: "warn",
+        ERROR: "error",
+        NONE: "none",
+    };
+    /** @internal */
+    class WTLogger {
+        static setLevel(level) {
+            this.level = level;
+        }
+        static setPrefix(prefix) {
+            this.prefix = prefix;
+        }
+        static addOutputEngine(engine) {
+            this.outputEngines.push(engine);
+        }
+        static shouldLog(type) {
+            const levels = ["debug", "info", "warn", "error"];
+            const currentIndex = levels.indexOf(this.level);
+            const typeIndex = levels.indexOf(type);
+            return typeIndex >= currentIndex;
+        }
+        static log(level, ...args) {
+            if (!this.shouldLog(level))
+                return;
+            const prefix = `[${this.prefix}-${level.toUpperCase()}]`;
+            for (const output of this.outputEngines) {
+                output.log(level, prefix, ...args);
+            }
+        }
+        static debug(...args) {
+            this.log("debug", ...args);
+        }
+        static info(...args) {
+            this.log("info", ...args);
+        }
+        static warn(...args) {
+            this.log("warn", ...args);
+        }
+        static error(...args) {
+            this.log("error", ...args);
+        }
+    }
+    WTLogger.level = WTConstants.DEFAULTS.LOG_LEVEL;
+    WTLogger.prefix = "WT";
+    WTLogger.outputEngines = [new ConsoleLogEngine()];
+
+    const WTStorageKeys = {
+        DEVICE_ID: "WT.DeviceId",
+        INITIAL_DATE: "WT.InitialDate",
+        INITIAL_CONFIG: "WT.InitialConfigs",
+        CONFIG: "WT.Configs",
+        APP_SETTINGS: "WT.AppSettings",
+        SDK_CLICK_SUBMIT: "WT.SdkClickSubmit",
+        FIRST_SESSION_SUBMIT: "WT.FirstSessionSubmit",
+        SDK_ENABLED: "WT.SdkEnabled",
+        FCM_TOKEN: "WT.FcmToken", // used for calling push token request
+        PUSH_TOKEN: "WT.PushToken", // used in request param fields as "push_token"
+        EVENT_COUNT: "WT.EventCount",
+        SESSION_COUNT: "WT.SessionCount",
+        SESSION_LENGTH: "WT.SessionLenght", // ACTIVE_DURATION
+        SUBSESSION_COUNT: "WT.SubSessionCount",
+        ACTIVE_TIME: "WT.ActiveTime",
+        INACTIVE_TIME: "WT.InactiveTime",
+        INACTIVE_DURATION: "WT.InactiveDuration",
+        REQUEST_QUEUE: "WT.RequestQueue",
+        PENDING_REQUEST_QUEUE: "WT.PendingRequestQueue",
+    };
+    class StorageManager {
+        clear() {
+            localStorage.clear();
+        }
+        setJson(key, obj) {
+            if (!obj) {
+                localStorage.removeItem(key);
+                return;
+            }
+            try {
+                const encoded = JSON.stringify(obj);
+                localStorage.setItem(key, encoded);
+            }
+            catch (error) {
+                WTLogger.error(`Error in encoding object for key '${key}'`, error);
+            }
+        }
+        getJson(key) {
+            const data = localStorage.getItem(key);
+            if (!data) {
+                return null;
+            }
+            try {
+                const decoded = JSON.parse(data);
+                return decoded;
+            }
+            catch (error) {
+                WTLogger.error(`Error in JSON decoding for key '${key}': ${error}`, error);
+                return null;
+            }
+        }
+        optionalNumber(key) {
+            const value = localStorage.getItem(key);
+            if (value === null) {
+                return null;
+            }
+            const num = Number(value);
+            return isNaN(num) ? null : num;
+        }
+        optionalBool(key) {
+            const value = localStorage.getItem(key);
+            if (value === null) {
+                return null;
+            }
+            return value === "true" ? true : value === "false" ? false : null;
+        }
+        get deviceId() {
+            return localStorage.getItem(WTStorageKeys.DEVICE_ID);
+        }
+        set deviceId(value) {
+            if (value) {
+                localStorage.setItem(WTStorageKeys.DEVICE_ID, value);
+            }
+            else {
+                localStorage.removeItem(WTStorageKeys.DEVICE_ID);
+            }
+        }
+        get initialDate() {
+            return this.getJson(WTStorageKeys.INITIAL_DATE);
+        }
+        set initialDate(value) {
+            this.setJson(WTStorageKeys.INITIAL_DATE, value);
+        }
+        get initialConfig() {
+            return this.getJson(WTStorageKeys.INITIAL_CONFIG);
+        }
+        set initialConfig(value) {
+            this.setJson(WTStorageKeys.INITIAL_CONFIG, value);
+        }
+        get config() {
+            return this.getJson(WTStorageKeys.CONFIG);
+        }
+        set config(value) {
+            this.setJson(WTStorageKeys.CONFIG, value);
+        }
+        get appSettings() {
+            return this.getJson(WTStorageKeys.APP_SETTINGS);
+        }
+        set appSettings(value) {
+            this.setJson(WTStorageKeys.APP_SETTINGS, value);
+        }
+        get sdkEnabled() {
+            var _a;
+            return (_a = this.optionalBool(WTStorageKeys.SDK_ENABLED)) !== null && _a !== void 0 ? _a : false;
+        }
+        set sdkEnabled(value) {
+            localStorage.setItem(WTStorageKeys.SDK_ENABLED, value.toString());
+        }
+        get sdkClickSubmit() {
+            var _a;
+            return (_a = this.optionalBool(WTStorageKeys.SDK_CLICK_SUBMIT)) !== null && _a !== void 0 ? _a : false;
+        }
+        set sdkClickSubmit(value) {
+            localStorage.setItem(WTStorageKeys.SDK_CLICK_SUBMIT, value.toString());
+        }
+        get firstSessionSubmit() {
+            var _a;
+            return (_a = this.optionalBool(WTStorageKeys.FIRST_SESSION_SUBMIT)) !== null && _a !== void 0 ? _a : false;
+        }
+        set firstSessionSubmit(value) {
+            localStorage.setItem(WTStorageKeys.FIRST_SESSION_SUBMIT, value.toString());
+        }
+        get fcmToken() {
+            return localStorage.getItem(WTStorageKeys.FCM_TOKEN);
+        }
+        set fcmToken(value) {
+            if (value) {
+                localStorage.setItem(WTStorageKeys.FCM_TOKEN, value);
+            }
+            else {
+                localStorage.removeItem(WTStorageKeys.FCM_TOKEN);
+            }
+        }
+        get pushToken() {
+            return localStorage.getItem(WTStorageKeys.PUSH_TOKEN);
+        }
+        set pushToken(value) {
+            if (value) {
+                localStorage.setItem(WTStorageKeys.PUSH_TOKEN, value);
+            }
+            else {
+                localStorage.removeItem(WTStorageKeys.PUSH_TOKEN);
+            }
+        }
+        get sessionCount() {
+            var _a;
+            return (_a = this.optionalNumber(WTStorageKeys.SESSION_COUNT)) !== null && _a !== void 0 ? _a : 1;
+        }
+        set sessionCount(value) {
+            localStorage.setItem(WTStorageKeys.SESSION_COUNT, value.toString());
+        }
+        get subSessionCount() {
+            var _a;
+            return (_a = this.optionalNumber(WTStorageKeys.SUBSESSION_COUNT)) !== null && _a !== void 0 ? _a : 1;
+        }
+        set subSessionCount(value) {
+            localStorage.setItem(WTStorageKeys.SUBSESSION_COUNT, value.toString());
+        }
+        get activeDuration() {
+            var _a;
+            return (_a = this.optionalNumber(WTStorageKeys.SESSION_LENGTH)) !== null && _a !== void 0 ? _a : 0;
+        }
+        set activeDuration(value) {
+            localStorage.setItem(WTStorageKeys.SESSION_LENGTH, value.toString());
+        }
+        get inactiveDuration() {
+            var _a;
+            return (_a = this.optionalNumber(WTStorageKeys.INACTIVE_DURATION)) !== null && _a !== void 0 ? _a : 0;
+        }
+        set inactiveDuration(value) {
+            localStorage.setItem(WTStorageKeys.INACTIVE_DURATION, value.toString());
+        }
+        get inactiveTime() {
+            return this.optionalNumber(WTStorageKeys.ACTIVE_TIME);
+        }
+        set inactiveTime(value) {
+            if (value !== null) {
+                localStorage.setItem(WTStorageKeys.ACTIVE_TIME, value.toString());
+            }
+            else {
+                localStorage.removeItem(WTStorageKeys.ACTIVE_TIME);
+            }
+        }
+        get activeTime() {
+            return this.optionalNumber(WTStorageKeys.INACTIVE_TIME);
+        }
+        set activeTime(value) {
+            if (value !== null) {
+                localStorage.setItem(WTStorageKeys.INACTIVE_TIME, value.toString());
+            }
+            else {
+                localStorage.removeItem(WTStorageKeys.INACTIVE_TIME);
+            }
+        }
+        get requestRecords() {
+            var _a;
+            return (_a = this.getJson(WTStorageKeys.REQUEST_QUEUE)) !== null && _a !== void 0 ? _a : [];
+        }
+        set requestRecords(value) {
+            this.setJson(WTStorageKeys.REQUEST_QUEUE, value);
+        }
+        get pendingRequestRecords() {
+            var _a;
+            return (_a = this.getJson(WTStorageKeys.PENDING_REQUEST_QUEUE)) !== null && _a !== void 0 ? _a : [];
+        }
+        set pendingRequestRecords(value) {
+            this.setJson(WTStorageKeys.PENDING_REQUEST_QUEUE, value);
+        }
+        get eventCount() {
+            var _a;
+            return (_a = this.optionalNumber(WTStorageKeys.EVENT_COUNT)) !== null && _a !== void 0 ? _a : 0;
+        }
+        set eventCount(value) {
+            localStorage.setItem(WTStorageKeys.EVENT_COUNT, value.toString());
+        }
+    }
+    /** @internal */
+    const storageManager = new StorageManager();
+
+    /** @internal */
+    var ApiError;
+    (function (ApiError) {
+        class InvalidUrl extends Error {
+            constructor(url) {
+                super(`Invalid URL: ${url}`);
+                this.name = "InvalidUrl";
+            }
+        }
+        ApiError.InvalidUrl = InvalidUrl;
+        class ServerError extends Error {
+            constructor(statusCode, message) {
+                super(`ServerError ${statusCode}: ${message}`);
+                this.statusCode = statusCode;
+                this.message = message;
+                this.name = "ServerError";
+            }
+        }
+        ApiError.ServerError = ServerError;
+        class NetworkError extends Error {
+            constructor(message) {
+                super(`NetworkError: ${message}`);
+                this.name = "NetworkFailure";
+            }
+        }
+        ApiError.NetworkError = NetworkError;
+        class DecodingError extends Error {
+            constructor(message) {
+                super(`DecodingError: ${message}`);
+                this.name = "DecodingError";
+            }
+        }
+        ApiError.DecodingError = DecodingError;
+    })(ApiError || (ApiError = {}));
+
+    /** @internal */
+    class RetryPolicy {
+        constructor(maxRetries = 3, retryInterval = 2000 // milliseconds
+        ) {
+            this.maxRetries = maxRetries;
+            this.retryInterval = retryInterval;
+        }
+        canRetry(attempt) {
+            return attempt < this.maxRetries;
+        }
+        waitBeforeRetry() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((res) => setTimeout(res, this.retryInterval));
+            });
+        }
+    }
+
+    /** @internal */
+    const networkManager = {
+        retryPolicy() {
+            return new RetryPolicy();
+        },
+        sendRequest(endpoint_1) {
+            return __awaiter(this, arguments, void 0, function* (endpoint, options = {}) {
+                const retryAttempt = options.retryAttempt || 1;
+                WTLogger.debug(`🚀 REQUEST (${retryAttempt}) => ${options.method} ${endpoint}`);
+                WTLogger.debug("-- PARAMETERS =>", options.params || options.formData || {});
+                let body;
+                const requestHeaders = Object.assign({ Accept: "application/json" }, options.headers);
+                if (options.formData) {
+                    const form = new FormData();
+                    for (const key in options.formData) {
+                        form.append(key, options.formData[key]);
+                    }
+                    body = form;
+                }
+                else if (options.params) {
+                    requestHeaders["Content-Type"] = "application/json";
+                    body = JSON.stringify(options.params);
+                }
+                try {
+                    const response = yield fetch(endpoint, {
+                        method: options.method,
+                        headers: requestHeaders,
+                        body,
+                    });
+                    if (!response.ok) {
+                        let json = yield response.json();
+                        let errorText = json.message || (yield response.text());
+                        WTLogger.warn(`❌ API ERROR (${response.status}) =>`, errorText);
+                        throw new ApiError.ServerError(response.status, json.message || "Server error");
+                    }
+                    try {
+                        const result = yield response.json();
+                        WTLogger.debug(`✅ API SUCCESS (${response.status}) =>`, result.message || "Request successful");
+                        return result;
+                    }
+                    catch (error) {
+                        throw new ApiError.DecodingError(error.message || String(error));
+                    }
+                }
+                catch (err) {
+                    if (err instanceof ApiError.ServerError ||
+                        err instanceof ApiError.DecodingError) {
+                        throw err;
+                    }
+                    WTLogger.error("Error executing request", err);
+                    if (this.retryPolicy().canRetry(retryAttempt)) {
+                        yield this.retryPolicy().waitBeforeRetry();
+                        return this.sendRequest(endpoint, Object.assign(Object.assign({}, options), { retryAttempt: retryAttempt + 1 }));
+                    }
+                    throw new ApiError.NetworkError(err.message || "Unknown error");
+                }
+            });
+        },
+    };
+
+    /** @internal */
+    const apiClient = {
+        doGetConfig() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const initialConfig = storageManager.initialConfig;
+                if (!initialConfig) {
+                    throw "Initial Config is not set";
+                }
+                const params = {
+                    app_token: initialConfig.appToken,
+                    app_version: initialConfig.appVersion,
+                    framework: initialConfig.appFrameWork,
+                    env: EnvironmentUtils.sdkEnvironment,
+                    sdk_hash: WTConstants.SDK.HASH,
+                    package_name: window.location.hostname,
+                    platform: WTConstants.SDK.PLATFORM,
+                    store_name: "other",
+                };
+                const response = yield networkManager.sendRequest(WTConstants.CONFIG.BASE_URL, {
+                    method: "POST",
+                    formData: params,
+                });
+                return WTConfig.fromJson(response.result);
+            });
+        },
+        doGetAppSettings() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const initialConfig = storageManager.initialConfig;
+                const wtConfig = storageManager.config;
+                if (!initialConfig)
+                    throw "Initial Config is not set";
+                if (!wtConfig)
+                    throw "SDK Config is not set";
+                if (!wtConfig.appSettings)
+                    throw "AppSettings Url is not set";
+                const params = {
+                    app_token: initialConfig.appToken,
+                    app_version: initialConfig.appVersion,
+                    framework: initialConfig.appFrameWork,
+                    env: EnvironmentUtils.sdkEnvironment,
+                    sdk_hash: WTConstants.SDK.HASH,
+                    package_name: window.location.hostname,
+                    platform: WTConstants.SDK.PLATFORM,
+                    store_name: "other",
+                };
+                const response = yield networkManager.sendRequest(wtConfig.baseUrl + wtConfig.appSettings, {
+                    method: "POST",
+                    formData: params,
+                });
+                return WTAppSettings.fromJson(response.result);
+            });
+        },
+        doCallRequest(endpoint, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const initialConfig = storageManager.initialConfig;
+                const wtConfig = storageManager.config;
+                if (!initialConfig)
+                    throw "Initial Config is not set";
+                if (!wtConfig)
+                    throw "SDK Config is not set";
+                params.updated_at = new Date().toISOString();
+                const response = yield networkManager.sendRequest(wtConfig.baseUrl + endpoint, {
+                    method: "POST",
+                    params: {
+                        needs_response_details: EnvironmentUtils.sdkEnvironment != WTSDKEnvironment.PRODUCTION,
+                        parameters: params,
+                    },
+                });
+                return response.success;
+            });
+        },
+    };
+
+    // import { WTLogger } from "./logger";
+    class ActivityTicker {
+        constructor() {
+            this.tickerDelay = 1000;
+            this.isPaused = false;
+        }
+        start() {
+            if (this.tickerJob) {
+                clearInterval(this.tickerJob);
+            }
+            this.tickerJob = setInterval(() => {
+                if (this.isPaused)
+                    return;
+                if (document.hidden)
+                    return;
+                if (!document.hasFocus())
+                    return;
+                console.log(`ActivityTicker: active duration= ${storageManager.activeDuration / 1000}s, inactive duration= ${storageManager.inactiveDuration / 1000}s`);
+                storageManager.activeTime = Date.now();
+                storageManager.activeDuration += this.tickerDelay;
+            }, this.tickerDelay);
+        }
+        stop() {
+            clearInterval(this.tickerJob);
+            this.tickerJob = undefined;
+        }
+        pause() {
+            this.isPaused = true;
+        }
+        resume() {
+            this.isPaused = false;
+        }
+    }
+    /** @internal */
+    const activityTicker = new ActivityTicker();
+
+    /** @internal */
+    class CountryFinder {
+        constructor() {
+            this._country = null;
+        }
+        getCountryCode() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this._country) {
+                    this._country = yield this.tryAllEndpoints();
+                }
+                return this._country;
+            });
+        }
+        tryAllEndpoints() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const endpoints = [
+                    () => __awaiter(this, void 0, void 0, function* () {
+                        const res = yield this.fetchWithTimeout("https://api.country.is");
+                        if (!res.ok)
+                            throw new Error("country.is failed");
+                        const json = yield res.json();
+                        return json.country || null;
+                    }),
+                    () => __awaiter(this, void 0, void 0, function* () {
+                        const res = yield this.fetchWithTimeout("https://free.freeipapi.com/api/json");
+                        if (!res.ok)
+                            throw new Error("country.is failed");
+                        const json = yield res.json();
+                        return json.countryCode || null;
+                    }),
+                    () => __awaiter(this, void 0, void 0, function* () {
+                        const res = yield this.fetchWithTimeout("https://ipwho.is/");
+                        if (!res.ok)
+                            throw new Error("ipwho.is failed");
+                        const json = yield res.json();
+                        return json.country_code || null;
+                    }),
+                ];
+                for (const tryFetch of endpoints) {
+                    try {
+                        const countryCode = yield tryFetch();
+                        if (countryCode)
+                            return countryCode;
+                    }
+                    catch (_) {
+                        // Try next API
+                    }
+                }
+                return null;
+            });
+        }
+        fetchWithTimeout(url_1) {
+            return __awaiter(this, arguments, void 0, function* (url, timeout = 2000) {
+                const controller = new AbortController();
+                const id = setTimeout(() => controller.abort(), timeout);
+                return fetch(url, { signal: controller.signal }).finally(() => clearTimeout(id));
+            });
+        }
+    }
+    /** @internal */
+    const countryFinder = new CountryFinder();
+
+    /** @internal */
+    const cryptoHelper = {
+        generateDeviceUUID() {
+            return crypto.randomUUID();
+        }
+    };
+
+    /** @internal */
+    class RequestRecord {
+        constructor(endpoint, parameters) {
+            this.retryCount = 0;
+            this.maxRetries = 3;
+            this.id = crypto.randomUUID();
+            this.endpoint = endpoint;
+            this.parameters = parameters;
+            this.createdAt = Date.now();
+        }
+    }
+    /** @internal */
+    class Mutex {
+        constructor() {
+            this.locked = false;
+            this.waitingQueue = [];
+        }
+        acquire() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve) => {
+                    if (!this.locked) {
+                        this.locked = true;
+                        resolve();
+                    }
+                    else {
+                        this.waitingQueue.push(resolve);
+                    }
+                });
+            });
+        }
+        release() {
+            if (this.waitingQueue.length > 0) {
+                const next = this.waitingQueue.shift();
+                next();
+            }
+            else {
+                this.locked = false;
+            }
+        }
+    }
+
+    /** @internal */
+    class RequestsQueueManager {
+        constructor() {
+            this.isInitialized = false;
+            this.isProcessing = false;
+            this.isCurrentlyProcessing = false;
+            this.mutex = new Mutex();
+            this.processingInterval = null;
+            this.PROCESSING_INTERVAL_MS = 100; // Check queue every 100ms
+            // Backoff strategy properties
+            this.failedRequestDelay = 0;
+            this.MAX_DELAY_MS = 30000; // 30 seconds max delay
+            this.BACKOFF_MULTIPLIER = 2;
+            this.BASE_DELAY_MS = 1000; // Start with 1 second
+        }
+        initialize() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Initialize the queue manager if needed
+                this.isInitialized = true;
+                if (!this.isProcessing) {
+                    yield this.startProcessing();
+                }
+            });
+        }
+        shutdown() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isInitialized) {
+                    return; // Nothing to shutdown
+                }
+                yield this.stopProcessing();
+                this.isInitialized = false;
+            });
+        }
+        startProcessing() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isInitialized) {
+                    WTLogger.warn("Queue Manager is not initialized. Call initialize() first.");
+                    return;
+                }
+                yield this.mutex.acquire();
+                try {
+                    if (this.isProcessing) {
+                        return;
+                    }
+                    this.isProcessing = true;
+                    // Start the processing loop
+                    this.processingInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            yield this.processQueues();
+                        }
+                        catch (error) {
+                            WTLogger.error("Error in processing loop:", error);
+                        }
+                    }), this.PROCESSING_INTERVAL_MS);
+                }
+                finally {
+                    this.mutex.release();
+                }
+                // Process immediately after releasing the mutex
+                yield this.processQueues();
+            });
+        }
+        stopProcessing() {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.mutex.acquire();
+                try {
+                    this.isProcessing = false;
+                    if (this.processingInterval) {
+                        clearInterval(this.processingInterval);
+                        this.processingInterval = null;
+                    }
+                }
+                finally {
+                    this.mutex.release();
+                }
+            });
+        }
+        addRequest(request) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.mutex.acquire();
+                try {
+                    const mainQueue = this.getMainQueue();
+                    mainQueue.push(request);
+                    this.saveMainQueue(mainQueue);
+                    // Reset delay when new request is added (optional - gives fresh chance)
+                    this.failedRequestDelay = 0;
+                    // Start processing if not already started
+                    if (!this.isProcessing) {
+                        // Release mutex before starting processing
+                        this.mutex.release();
+                        yield this.startProcessing();
+                        return; // Exit early since mutex was already released
+                    }
+                }
+                finally {
+                    // Only release if we haven't already released above
+                    if (this.isProcessing) {
+                        this.mutex.release();
+                    }
+                }
+            });
+        }
+        addPendingRequest(request) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.mutex.acquire();
+                try {
+                    const mainRequestsSent = this.getMainRequestsSentFlag();
+                    if (mainRequestsSent) {
+                        // Main requests have been sent, add to main queue directly
+                        const mainQueue = this.getMainQueue();
+                        mainQueue.push(request);
+                        this.saveMainQueue(mainQueue);
+                    }
+                    else {
+                        // Main requests not sent yet, add to pending queue
+                        const pendingQueue = this.getPendingQueue();
+                        pendingQueue.push(request);
+                        this.savePendingQueue(pendingQueue);
+                    }
+                    // Reset delay when new request is added
+                    this.failedRequestDelay = 0;
+                    // Start processing if not already started
+                    if (!this.isProcessing) {
+                        // Release mutex before starting processing
+                        this.mutex.release();
+                        yield this.startProcessing();
+                        return; // Exit early since mutex was already released
+                    }
+                }
+                finally {
+                    // Only release if we haven't already released above
+                    if (this.isProcessing) {
+                        this.mutex.release();
+                    }
+                }
+            });
+        }
+        processQueues() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isProcessing || this.isCurrentlyProcessing) {
+                    return;
+                }
+                // Check if we're in delay period
+                if (this.failedRequestDelay > 0) {
+                    if (Date.now() < this.failedRequestDelay) {
+                        return; // Still in delay period
+                    }
+                    // Delay period ended
+                    this.failedRequestDelay = 0;
+                    WTLogger.debug("⏰ Backoff delay ended, resuming queue processing");
+                }
+                this.isCurrentlyProcessing = true;
+                yield this.mutex.acquire();
+                try {
+                    yield this.processMainQueue();
+                    yield this.processPendingQueue();
+                }
+                finally {
+                    this.mutex.release();
+                    this.isCurrentlyProcessing = false;
+                }
+            });
+        }
+        processMainQueue() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const mainQueue = this.getMainQueue();
+                if (mainQueue.length === 0) {
+                    return;
+                }
+                // Take the first request
+                const request = mainQueue[0];
+                try {
+                    const success = yield this.sendRequest(request);
+                    if (success) {
+                        // Remove the processed request from queue
+                        mainQueue.shift();
+                        this.saveMainQueue(mainQueue);
+                        // Set flag that main requests have been sent
+                        this.postRequestCheck(request);
+                        WTLogger.debug(`✅ Request ${request.id} processed successfully`);
+                    }
+                    else {
+                        // Update retry count in the queue (not just in memory)
+                        mainQueue[0].retryCount++;
+                        if (mainQueue[0].retryCount >= mainQueue[0].maxRetries) {
+                            // Calculate backoff delay
+                            const delayMs = this.calculateBackoffDelay(mainQueue[0].retryCount);
+                            this.failedRequestDelay = Date.now() + delayMs;
+                            WTLogger.warn(`⏳ Request ${request.id} failed after ${request.maxRetries} attempts. ` +
+                                `Applying backoff delay of ${delayMs}ms`);
+                        }
+                        else {
+                            WTLogger.warn(`⚠️ Request ${request.id} failed. Retry ${mainQueue[0].retryCount}/${mainQueue[0].maxRetries}`);
+                        }
+                        // Save the updated queue with new retry count
+                        this.saveMainQueue(mainQueue);
+                    }
+                }
+                catch (error) {
+                    WTLogger.error(`Error sending request ${request.endpoint}:`, error);
+                    // Update retry count in storage
+                    mainQueue[0].retryCount++;
+                    if (mainQueue[0].retryCount >= mainQueue[0].maxRetries) {
+                        // Apply backoff delay instead of removing
+                        const delayMs = this.calculateBackoffDelay(mainQueue[0].retryCount);
+                        this.failedRequestDelay = Date.now() + delayMs;
+                        WTLogger.warn(`⏳ Request ${request.id} failed with error after ${mainQueue[0].maxRetries} attempts. ` +
+                            `Applying backoff delay of ${delayMs}ms`);
+                    }
+                    // Save the updated queue
+                    this.saveMainQueue(mainQueue);
+                }
+            });
+        }
+        calculateBackoffDelay(retryCount) {
+            // Exponential backoff: baseDelay * (multiplier ^ (retryCount - 1))
+            const delay = this.BASE_DELAY_MS * Math.pow(this.BACKOFF_MULTIPLIER, retryCount - 1);
+            return Math.min(delay, this.MAX_DELAY_MS);
+        }
+        processPendingQueue() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const mainRequestsSent = this.getMainRequestsSentFlag();
+                if (!mainRequestsSent) {
+                    return; // Main requests haven't been sent yet
+                }
+                const pendingQueue = this.getPendingQueue();
+                if (pendingQueue.length === 0) {
+                    return;
+                }
+                // Move all pending requests to main queue
+                const mainQueue = this.getMainQueue();
+                mainQueue.push(...pendingQueue);
+                // Clear pending queue
+                this.saveMainQueue(mainQueue);
+                this.savePendingQueue([]);
+                console.log(`📦 Moved ${pendingQueue.length} pending requests to main queue`);
+            });
+        }
+        sendRequest(request_1) {
+            return __awaiter(this, arguments, void 0, function* (request, attempt = 1) {
+                WTLogger.debug(`💥 Sending request (${request.endpoint}): id=${request.id}`);
+                let result = false;
+                try {
+                    result = yield apiClient.doCallRequest(request.endpoint, request.parameters);
+                }
+                catch (error) {
+                    WTLogger.error(`❌ Request ${request.endpoint} failed`, error);
+                }
+                return result;
+            });
+        }
+        getMainQueue() {
+            return storageManager.requestRecords;
+        }
+        saveMainQueue(queue) {
+            storageManager.requestRecords = queue;
+        }
+        getPendingQueue() {
+            return storageManager.pendingRequestRecords;
+        }
+        savePendingQueue(queue) {
+            storageManager.pendingRequestRecords = queue;
+        }
+        getMainRequestsSentFlag() {
+            return storageManager.sdkClickSubmit;
+        }
+        postRequestCheck(request) {
+            switch (request.endpoint) {
+                case WTEndpoints.SDK_CLICKS:
+                    storageManager.sdkClickSubmit = true;
+                    break;
+                case WTEndpoints.SESSIONS:
+                    if (storageManager.firstSessionSubmit) {
+                        storageManager.activeDuration = 0;
+                        storageManager.inactiveDuration = 0;
+                        storageManager.subSessionCount = 1;
+                    }
+                    else {
+                        storageManager.firstSessionSubmit = true;
+                    }
+                    break;
+                case WTEndpoints.SDK_INFOS:
+                    storageManager.fcmToken = request.parameters.push_token;
+                    break;
+            }
+        }
+        getQueueStatus() {
+            return {
+                mainQueueLength: this.getMainQueue().length,
+                pendingQueueLength: this.getPendingQueue().length,
+                isProcessing: this.isProcessing,
+                mainRequestsSent: this.getMainRequestsSentFlag(),
+                isInBackoffDelay: this.failedRequestDelay > 0 && Date.now() < this.failedRequestDelay,
+                backoffEndsAt: this.failedRequestDelay > 0 ? this.failedRequestDelay : null,
+            };
+        }
+        /**
+         * Manually reset backoff delay (useful for testing or manual recovery)
+         */
+        resetBackoffDelay() {
+            this.failedRequestDelay = 0;
+            WTLogger.debug("🔄 Backoff delay manually reset");
+        }
+        /**
+         * Get current backoff delay configuration
+         */
+        getBackoffConfig() {
+            return {
+                baseDelayMs: this.BASE_DELAY_MS,
+                multiplier: this.BACKOFF_MULTIPLIER,
+                maxDelayMs: this.MAX_DELAY_MS,
+            };
+        }
+    }
+    /** @internal */
+    const queueManager = new RequestsQueueManager();
+
+    // Generated ESM version of ua-parser-js
+    // DO NOT EDIT THIS FILE!
+    // Source: /src/main/ua-parser.js
+
+    /////////////////////////////////////////////////////////////////////////////////
+    /* UAParser.js v2.0.4
+       Copyright © 2012-2025 Faisal Salman <f@faisalman.com>
+       AGPLv3 License *//*
+       Detect Browser, Engine, OS, CPU, and Device type/model from User-Agent data.
+       Supports browser & node.js environment. 
+       Demo   : https://uaparser.dev
+       Source : https://github.com/faisalman/ua-parser-js */
+    /////////////////////////////////////////////////////////////////////////////////
+
+    /* jshint esversion: 6 */ 
+    /* globals window */
+
+
+        
+        //////////////
+        // Constants
+        /////////////
+
+        var LIBVERSION  = '2.0.4',
+            UA_MAX_LENGTH = 500,
+            USER_AGENT  = 'user-agent',
+            EMPTY       = '',
+            UNKNOWN     = '?',
+
+            // typeof
+            FUNC_TYPE   = 'function',
+            UNDEF_TYPE  = 'undefined',
+            OBJ_TYPE    = 'object',
+            STR_TYPE    = 'string',
+
+            // properties
+            UA_BROWSER  = 'browser',
+            UA_CPU      = 'cpu',
+            UA_DEVICE   = 'device',
+            UA_ENGINE   = 'engine',
+            UA_OS       = 'os',
+            UA_RESULT   = 'result',
+            
+            NAME        = 'name',
+            TYPE        = 'type',
+            VENDOR      = 'vendor',
+            VERSION     = 'version',
+            ARCHITECTURE= 'architecture',
+            MAJOR       = 'major',
+            MODEL       = 'model',
+
+            // device types
+            CONSOLE     = 'console',
+            MOBILE      = 'mobile',
+            TABLET      = 'tablet',
+            SMARTTV     = 'smarttv',
+            WEARABLE    = 'wearable',
+            XR          = 'xr',
+            EMBEDDED    = 'embedded',
+
+            // browser types
+            INAPP       = 'inapp',
+
+            // client hints
+            BRANDS      = 'brands',
+            FORMFACTORS = 'formFactors',
+            FULLVERLIST = 'fullVersionList',
+            PLATFORM    = 'platform',
+            PLATFORMVER = 'platformVersion',
+            BITNESS     = 'bitness',
+            CH_HEADER   = 'sec-ch-ua',
+            CH_HEADER_FULL_VER_LIST = CH_HEADER + '-full-version-list',
+            CH_HEADER_ARCH      = CH_HEADER + '-arch',
+            CH_HEADER_BITNESS   = CH_HEADER + '-' + BITNESS,
+            CH_HEADER_FORM_FACTORS = CH_HEADER + '-form-factors',
+            CH_HEADER_MOBILE    = CH_HEADER + '-' + MOBILE,
+            CH_HEADER_MODEL     = CH_HEADER + '-' + MODEL,
+            CH_HEADER_PLATFORM  = CH_HEADER + '-' + PLATFORM,
+            CH_HEADER_PLATFORM_VER = CH_HEADER_PLATFORM + '-version',
+            CH_ALL_VALUES       = [BRANDS, FULLVERLIST, MOBILE, MODEL, PLATFORM, PLATFORMVER, ARCHITECTURE, FORMFACTORS, BITNESS],
+
+            // device vendors
+            AMAZON      = 'Amazon',
+            APPLE       = 'Apple',
+            ASUS        = 'ASUS',
+            BLACKBERRY  = 'BlackBerry',
+            GOOGLE      = 'Google',
+            HUAWEI      = 'Huawei',
+            LENOVO      = 'Lenovo',
+            HONOR       = 'Honor',
+            LG          = 'LG',
+            MICROSOFT   = 'Microsoft',
+            MOTOROLA    = 'Motorola',
+            NVIDIA      = 'Nvidia',
+            ONEPLUS     = 'OnePlus',
+            OPPO        = 'OPPO',
+            SAMSUNG     = 'Samsung',
+            SHARP       = 'Sharp',
+            SONY        = 'Sony',
+            XIAOMI      = 'Xiaomi',
+            ZEBRA       = 'Zebra',
+
+            // browsers
+            CHROME      = 'Chrome',
+            CHROMIUM    = 'Chromium',
+            CHROMECAST  = 'Chromecast',
+            EDGE        = 'Edge',
+            FIREFOX     = 'Firefox',
+            OPERA       = 'Opera',
+            FACEBOOK    = 'Facebook',
+            SOGOU       = 'Sogou',
+
+            PREFIX_MOBILE  = 'Mobile ',
+            SUFFIX_BROWSER = ' Browser',
+
+            // os
+            WINDOWS     = 'Windows';
+       
+        var isWindow            = typeof window !== UNDEF_TYPE,
+            NAVIGATOR           = (isWindow && window.navigator) ? 
+                                    window.navigator : 
+                                    undefined,
+            NAVIGATOR_UADATA    = (NAVIGATOR && NAVIGATOR.userAgentData) ? 
+                                    NAVIGATOR.userAgentData : 
+                                    undefined;
+
+        ///////////
+        // Helper
+        //////////
+
+        var extend = function (defaultRgx, extensions) {
+                var mergedRgx = {};
+                var extraRgx = extensions;
+                if (!isExtensions(extensions)) {
+                    extraRgx = {};
+                    for (var i in extensions) {
+                        for (var j in extensions[i]) {
+                            extraRgx[j] = extensions[i][j].concat(extraRgx[j] ? extraRgx[j] : []);
+                        }
+                    }
+                }
+                for (var k in defaultRgx) {
+                    mergedRgx[k] = extraRgx[k] && extraRgx[k].length % 2 === 0 ? extraRgx[k].concat(defaultRgx[k]) : defaultRgx[k];
+                }
+                return mergedRgx;
+            },
+            enumerize = function (arr) {
+                var enums = {};
+                for (var i=0; i<arr.length; i++) {
+                    enums[arr[i].toUpperCase()] = arr[i];
+                }
+                return enums;
+            },
+            has = function (str1, str2) {
+                if (typeof str1 === OBJ_TYPE && str1.length > 0) {
+                    for (var i in str1) {
+                        if (lowerize(str2) == lowerize(str1[i])) return true;
+                    }
+                    return false;
+                }
+                return isString(str1) ? lowerize(str2) == lowerize(str1) : false;
+            },
+            isExtensions = function (obj, deep) {
+                for (var prop in obj) {
+                    return /^(browser|cpu|device|engine|os)$/.test(prop) || (deep ? isExtensions(obj[prop]) : false);
+                }
+            },
+            isString = function (val) {
+                return typeof val === STR_TYPE;
+            },
+            itemListToArray = function (header) {
+                if (!header) return undefined;
+                var arr = [];
+                var tokens = strip(/\\?\"/g, header).split(',');
+                for (var i = 0; i < tokens.length; i++) {
+                    if (tokens[i].indexOf(';') > -1) {
+                        var token = trim(tokens[i]).split(';v=');
+                        arr[i] = { brand : token[0], version : token[1] };
+                    } else {
+                        arr[i] = trim(tokens[i]);
+                    }
+                }
+                return arr;
+            },
+            lowerize = function (str) {
+                return isString(str) ? str.toLowerCase() : str;
+            },
+            majorize = function (version) {
+                return isString(version) ? strip(/[^\d\.]/g, version).split('.')[0] : undefined;
+            },
+            setProps = function (arr) {
+                for (var i in arr) {
+                    var propName = arr[i];
+                    if (typeof propName == OBJ_TYPE && propName.length == 2) {
+                        this[propName[0]] = propName[1];
+                    } else {
+                        this[propName] = undefined;
+                    }
+                }
+                return this;
+            },
+            strip = function (pattern, str) {
+                return isString(str) ? str.replace(pattern, EMPTY) : str;
+            },
+            stripQuotes = function (str) {
+                return strip(/\\?\"/g, str); 
+            },
+            trim = function (str, len) {
+                if (isString(str)) {
+                    str = strip(/^\s\s*/, str);
+                    return typeof len === UNDEF_TYPE ? str : str.substring(0, UA_MAX_LENGTH);
+                }
+        };
+
+        ///////////////
+        // Map helper
+        //////////////
+
+        var rgxMapper = function (ua, arrays) {
+
+                if(!ua || !arrays) return;
+
+                var i = 0, j, k, p, q, matches, match;
+
+                // loop through all regexes maps
+                while (i < arrays.length && !matches) {
+
+                    var regex = arrays[i],       // even sequence (0,2,4,..)
+                        props = arrays[i + 1];   // odd sequence (1,3,5,..)
+                    j = k = 0;
+
+                    // try matching uastring with regexes
+                    while (j < regex.length && !matches) {
+
+                        if (!regex[j]) { break; }
+                        matches = regex[j++].exec(ua);
+
+                        if (!!matches) {
+                            for (p = 0; p < props.length; p++) {
+                                match = matches[++k];
+                                q = props[p];
+                                // check if given property is actually array
+                                if (typeof q === OBJ_TYPE && q.length > 0) {
+                                    if (q.length === 2) {
+                                        if (typeof q[1] == FUNC_TYPE) {
+                                            // assign modified match
+                                            this[q[0]] = q[1].call(this, match);
+                                        } else {
+                                            // assign given value, ignore regex match
+                                            this[q[0]] = q[1];
+                                        }
+                                    } else if (q.length >= 3) {
+                                        // Check whether q[1] FUNCTION or REGEX
+                                        if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {
+                                            if (q.length > 3) {
+                                                this[q[0]] = match ? q[1].apply(this, q.slice(2)) : undefined;
+                                            } else {
+                                                // call function (usually string mapper)
+                                                this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;
+                                            }
+                                        } else {
+                                            if (q.length == 3) {
+                                                // sanitize match using given regex
+                                                this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;
+                                            } else if (q.length == 4) {
+                                                this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;
+                                            } else if (q.length > 4) {
+                                                this[q[0]] = match ? q[3].apply(this, [match.replace(q[1], q[2])].concat(q.slice(4))) : undefined;
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    this[q] = match ? match : undefined;
+                                }
+                            }
+                        }
+                    }
+                    i += 2;
+                }
+            },
+
+            strMapper = function (str, map) {
+
+                for (var i in map) {
+                    // check if current value is array
+                    if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {
+                        for (var j = 0; j < map[i].length; j++) {
+                            if (has(map[i][j], str)) {
+                                return (i === UNKNOWN) ? undefined : i;
+                            }
+                        }
+                    } else if (has(map[i], str)) {
+                        return (i === UNKNOWN) ? undefined : i;
+                    }
+                }
+                return map.hasOwnProperty('*') ? map['*'] : str;
+        };
+
+        ///////////////
+        // String map
+        //////////////
+
+        var windowsVersionMap = {
+                'ME'    : '4.90',
+                'NT 3.51': '3.51',
+                'NT 4.0': '4.0',
+                '2000'  : ['5.0', '5.01'],
+                'XP'    : ['5.1', '5.2'],
+                'Vista' : '6.0',
+                '7'     : '6.1',
+                '8'     : '6.2',
+                '8.1'   : '6.3',
+                '10'    : ['6.4', '10.0'],
+                'NT'    : ''
+            },
+            
+            formFactorsMap = {
+                'embedded'  : 'Automotive',
+                'mobile'    : 'Mobile',
+                'tablet'    : ['Tablet', 'EInk'],
+                'smarttv'   : 'TV',
+                'wearable'  : 'Watch',
+                'xr'        : ['VR', 'XR'],
+                '?'         : ['Desktop', 'Unknown'],
+                '*'         : undefined
+            },
+
+            browserHintsMap = {
+                'Chrome'        : 'Google Chrome',
+                'Edge'          : 'Microsoft Edge',
+                'Edge WebView2' : 'Microsoft Edge WebView2',
+                'Chrome WebView': 'Android WebView',
+                'Chrome Headless':'HeadlessChrome',
+                'Huawei Browser': 'HuaweiBrowser',
+                'MIUI Browser'  : 'Miui Browser',
+                'Opera Mobi'    : 'OperaMobile',
+                'Yandex'        : 'YaBrowser'
+        };
+
+        //////////////
+        // Regex map
+        /////////////
+
+        var defaultRegexes = {
+
+            browser : [[
+
+                // Most common regardless engine
+                /\b(?:crmo|crios)\/([\w\.]+)/i                                      // Chrome for Android/iOS
+                ], [VERSION, [NAME, PREFIX_MOBILE + 'Chrome']], [
+                /webview.+edge\/([\w\.]+)/i                                         // Microsoft Edge
+                ], [VERSION, [NAME, EDGE+' WebView']], [
+                /edg(?:e|ios|a)?\/([\w\.]+)/i                                       
+                ], [VERSION, [NAME, 'Edge']], [
+
+                // Presto based
+                /(opera mini)\/([-\w\.]+)/i,                                        // Opera Mini
+                /(opera [mobiletab]{3,6})\b.+version\/([-\w\.]+)/i,                 // Opera Mobi/Tablet
+                /(opera)(?:.+version\/|[\/ ]+)([\w\.]+)/i                           // Opera
+                ], [NAME, VERSION], [
+                /opios[\/ ]+([\w\.]+)/i                                             // Opera mini on iphone >= 8.0
+                ], [VERSION, [NAME, OPERA+' Mini']], [
+                /\bop(?:rg)?x\/([\w\.]+)/i                                          // Opera GX
+                ], [VERSION, [NAME, OPERA+' GX']], [
+                /\bopr\/([\w\.]+)/i                                                 // Opera Webkit
+                ], [VERSION, [NAME, OPERA]], [
+
+                // Mixed
+                /\bb[ai]*d(?:uhd|[ub]*[aekoprswx]{5,6})[\/ ]?([\w\.]+)/i            // Baidu
+                ], [VERSION, [NAME, 'Baidu']], [
+                /\b(?:mxbrowser|mxios|myie2)\/?([-\w\.]*)\b/i                       // Maxthon
+                ], [VERSION, [NAME, 'Maxthon']], [
+                /(kindle)\/([\w\.]+)/i,                                             // Kindle
+                /(lunascape|maxthon|netfront|jasmine|blazer|sleipnir)[\/ ]?([\w\.]*)/i,      
+                                                                                    // Lunascape/Maxthon/Netfront/Jasmine/Blazer/Sleipnir
+                // Trident based
+                /(avant|iemobile|slim(?:browser|boat|jet))[\/ ]?([\d\.]*)/i,        // Avant/IEMobile/SlimBrowser/SlimBoat/Slimjet
+                /(?:ms|\()(ie) ([\w\.]+)/i,                                         // Internet Explorer
+
+                // Blink/Webkit/KHTML based                                         // Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser/QupZilla/Falkon/LG Browser/Otter/qutebrowser/Dooble
+                /(flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|qupzilla|falkon|rekonq|puffin|brave|whale(?!.+naver)|qqbrowserlite|duckduckgo|klar|helio|(?=comodo_)?dragon|otter|dooble|(?:lg |qute)browser)\/([-\w\.]+)/i,
+                                                                                    // Rekonq/Puffin/Brave/Whale/QQBrowserLite/QQ//Vivaldi/DuckDuckGo/Klar/Helio/Dragon
+                /(heytap|ovi|115|surf)browser\/([\d\.]+)/i,                         // HeyTap/Ovi/115/Surf
+                /(ecosia|weibo)(?:__| \w+@)([\d\.]+)/i                              // Ecosia/Weibo
+                ], [NAME, VERSION], [
+                /quark(?:pc)?\/([-\w\.]+)/i                                         // Quark
+                ], [VERSION, [NAME, 'Quark']], [
+                /\bddg\/([\w\.]+)/i                                                 // DuckDuckGo
+                ], [VERSION, [NAME, 'DuckDuckGo']], [
+                /(?:\buc? ?browser|(?:juc.+)ucweb)[\/ ]?([\w\.]+)/i                 // UCBrowser
+                ], [VERSION, [NAME, 'UCBrowser']], [
+                /microm.+\bqbcore\/([\w\.]+)/i,                                     // WeChat Desktop for Windows Built-in Browser
+                /\bqbcore\/([\w\.]+).+microm/i,
+                /micromessenger\/([\w\.]+)/i                                        // WeChat
+                ], [VERSION, [NAME, 'WeChat']], [
+                /konqueror\/([\w\.]+)/i                                             // Konqueror
+                ], [VERSION, [NAME, 'Konqueror']], [
+                /trident.+rv[: ]([\w\.]{1,9})\b.+like gecko/i                       // IE11
+                ], [VERSION, [NAME, 'IE']], [
+                /ya(?:search)?browser\/([\w\.]+)/i                                  // Yandex
+                ], [VERSION, [NAME, 'Yandex']], [
+                /slbrowser\/([\w\.]+)/i                                             // Smart Lenovo Browser
+                ], [VERSION, [NAME, 'Smart ' + LENOVO + SUFFIX_BROWSER]], [
+                /(avast|avg)\/([\w\.]+)/i                                           // Avast/AVG Secure Browser
+                ], [[NAME, /(.+)/, '$1 Secure' + SUFFIX_BROWSER], VERSION], [
+                /\bfocus\/([\w\.]+)/i                                               // Firefox Focus
+                ], [VERSION, [NAME, FIREFOX+' Focus']], [
+                /\bopt\/([\w\.]+)/i                                                 // Opera Touch
+                ], [VERSION, [NAME, OPERA+' Touch']], [
+                /coc_coc\w+\/([\w\.]+)/i                                            // Coc Coc Browser
+                ], [VERSION, [NAME, 'Coc Coc']], [
+                /dolfin\/([\w\.]+)/i                                                // Dolphin
+                ], [VERSION, [NAME, 'Dolphin']], [
+                /coast\/([\w\.]+)/i                                                 // Opera Coast
+                ], [VERSION, [NAME, OPERA+' Coast']], [
+                /miuibrowser\/([\w\.]+)/i                                           // MIUI Browser
+                ], [VERSION, [NAME, 'MIUI' + SUFFIX_BROWSER]], [
+                /fxios\/([\w\.-]+)/i                                                // Firefox for iOS
+                ], [VERSION, [NAME, PREFIX_MOBILE + FIREFOX]], [
+                /\bqihoobrowser\/?([\w\.]*)/i                                       // 360
+                ], [VERSION, [NAME, '360']], [
+                /\b(qq)\/([\w\.]+)/i                                                // QQ
+                ], [[NAME, /(.+)/, '$1Browser'], VERSION], [
+                /(oculus|sailfish|huawei|vivo|pico)browser\/([\w\.]+)/i
+                ], [[NAME, /(.+)/, '$1' + SUFFIX_BROWSER], VERSION], [              // Oculus/Sailfish/HuaweiBrowser/VivoBrowser/PicoBrowser
+                /samsungbrowser\/([\w\.]+)/i                                        // Samsung Internet
+                ], [VERSION, [NAME, SAMSUNG + ' Internet']], [
+                /metasr[\/ ]?([\d\.]+)/i                                            // Sogou Explorer
+                ], [VERSION, [NAME, SOGOU + ' Explorer']], [
+                /(sogou)mo\w+\/([\d\.]+)/i                                          // Sogou Mobile
+                ], [[NAME, SOGOU + ' Mobile'], VERSION], [
+                /(electron)\/([\w\.]+) safari/i,                                    // Electron-based App
+                /(tesla)(?: qtcarbrowser|\/(20\d\d\.[-\w\.]+))/i,                   // Tesla
+                /m?(qqbrowser|2345(?=browser|chrome|explorer))\w*[\/ ]?v?([\w\.]+)/i   // QQ/2345
+                ], [NAME, VERSION], [
+                /(lbbrowser|rekonq)/i                                               // LieBao Browser/Rekonq
+                ], [NAME], [
+                /ome\/([\w\.]+) \w* ?(iron) saf/i,                                  // Iron
+                /ome\/([\w\.]+).+qihu (360)[es]e/i                                  // 360
+                ], [VERSION, NAME], [
+
+                // WebView
+                /((?:fban\/fbios|fb_iab\/fb4a)(?!.+fbav)|;fbav\/([\w\.]+);)/i       // Facebook App for iOS & Android
+                ], [[NAME, FACEBOOK], VERSION, [TYPE, INAPP]], [
+                /(kakao(?:talk|story))[\/ ]([\w\.]+)/i,                             // Kakao App
+                /(naver)\(.*?(\d+\.[\w\.]+).*\)/i,                                  // Naver InApp
+                /(daum)apps[\/ ]([\w\.]+)/i,                                        // Daum App
+                /safari (line)\/([\w\.]+)/i,                                        // Line App for iOS
+                /\b(line)\/([\w\.]+)\/iab/i,                                        // Line App for Android
+                /(alipay)client\/([\w\.]+)/i,                                       // Alipay
+                /(twitter)(?:and| f.+e\/([\w\.]+))/i,                               // Twitter
+                /(instagram|snapchat|klarna)[\/ ]([-\w\.]+)/i                       // Instagram/Snapchat/Klarna
+                ], [NAME, VERSION, [TYPE, INAPP]], [
+                /\bgsa\/([\w\.]+) .*safari\//i                                      // Google Search Appliance on iOS
+                ], [VERSION, [NAME, 'GSA'], [TYPE, INAPP]], [
+                /musical_ly(?:.+app_?version\/|_)([\w\.]+)/i                        // TikTok
+                ], [VERSION, [NAME, 'TikTok'], [TYPE, INAPP]], [
+                /\[(linkedin)app\]/i                                                // LinkedIn App for iOS & Android
+                ], [NAME, [TYPE, INAPP]], [
+
+                /(chromium)[\/ ]([-\w\.]+)/i                                        // Chromium
+                ], [NAME, VERSION], [
+
+                /headlesschrome(?:\/([\w\.]+)| )/i                                  // Chrome Headless
+                ], [VERSION, [NAME, CHROME+' Headless']], [
+
+                /wv\).+chrome\/([\w\.]+).+edgw\//i                                  // Edge WebView2
+                ], [VERSION, [NAME, EDGE+' WebView2']], [
+
+                / wv\).+(chrome)\/([\w\.]+)/i                                       // Chrome WebView
+                ], [[NAME, CHROME+' WebView'], VERSION], [
+
+                /droid.+ version\/([\w\.]+)\b.+(?:mobile safari|safari)/i           // Android Browser
+                ], [VERSION, [NAME, 'Android' + SUFFIX_BROWSER]], [
+
+                /chrome\/([\w\.]+) mobile/i                                         // Chrome Mobile
+                ], [VERSION, [NAME, PREFIX_MOBILE + 'Chrome']], [
+
+                /(chrome|omniweb|arora|[tizenoka]{5} ?browser)\/v?([\w\.]+)/i       // Chrome/OmniWeb/Arora/Tizen/Nokia
+                ], [NAME, VERSION], [
+
+                /version\/([\w\.\,]+) .*mobile(?:\/\w+ | ?)safari/i                 // Safari Mobile
+                ], [VERSION, [NAME, PREFIX_MOBILE + 'Safari']], [
+                /iphone .*mobile(?:\/\w+ | ?)safari/i
+                ], [[NAME, PREFIX_MOBILE + 'Safari']], [
+                /version\/([\w\.\,]+) .*(safari)/i                                  // Safari
+                ], [VERSION, NAME], [
+                /webkit.+?(mobile ?safari|safari)(\/[\w\.]+)/i                      // Safari < 3.0
+                ], [NAME, [VERSION, '1']], [
+
+                /(webkit|khtml)\/([\w\.]+)/i
+                ], [NAME, VERSION], [
+
+                // Gecko based
+                /(?:mobile|tablet);.*(firefox)\/([\w\.-]+)/i                        // Firefox Mobile
+                ], [[NAME, PREFIX_MOBILE + FIREFOX], VERSION], [
+                /(navigator|netscape\d?)\/([-\w\.]+)/i                              // Netscape
+                ], [[NAME, 'Netscape'], VERSION], [
+                /(wolvic|librewolf)\/([\w\.]+)/i                                    // Wolvic/LibreWolf
+                ], [NAME, VERSION], [
+                /mobile vr; rv:([\w\.]+)\).+firefox/i                               // Firefox Reality
+                ], [VERSION, [NAME, FIREFOX+' Reality']], [
+                /ekiohf.+(flow)\/([\w\.]+)/i,                                       // Flow
+                /(swiftfox)/i,                                                      // Swiftfox
+                /(icedragon|iceweasel|camino|chimera|fennec|maemo browser|minimo|conkeror)[\/ ]?([\w\.\+]+)/i,
+                                                                                    // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror
+                /(seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\/([-\w\.]+)$/i,
+                                                                                    // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix
+                /(firefox)\/([\w\.]+)/i,                                            // Other Firefox-based
+                /(mozilla)\/([\w\.]+) .+rv\:.+gecko\/\d+/i,                         // Mozilla
+
+                // Other
+                /(amaya|dillo|doris|icab|ladybird|lynx|mosaic|netsurf|obigo|polaris|w3m|(?:go|ice|up)[\. ]?browser)[-\/ ]?v?([\w\.]+)/i,
+                                                                                    // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Obigo/Mosaic/Go/ICE/UP.Browser/Ladybird
+                /\b(links) \(([\w\.]+)/i                                            // Links
+                ], [NAME, [VERSION, /_/g, '.']], [
+                
+                /(cobalt)\/([\w\.]+)/i                                              // Cobalt
+                ], [NAME, [VERSION, /[^\d\.]+./, EMPTY]]
+            ],
+
+            cpu : [[
+
+                /\b((amd|x|x86[-_]?|wow|win)64)\b/i                                 // AMD64 (x64)
+                ], [[ARCHITECTURE, 'amd64']], [
+
+                /(ia32(?=;))/i,                                                     // IA32 (quicktime)
+                /\b((i[346]|x)86)(pc)?\b/i                                          // IA32 (x86)
+                ], [[ARCHITECTURE, 'ia32']], [
+
+                /\b(aarch64|arm(v?[89]e?l?|_?64))\b/i                               // ARM64
+                ], [[ARCHITECTURE, 'arm64']], [
+
+                /\b(arm(v[67])?ht?n?[fl]p?)\b/i                                     // ARMHF
+                ], [[ARCHITECTURE, 'armhf']], [
+
+                // PocketPC mistakenly identified as PowerPC
+                /( (ce|mobile); ppc;|\/[\w\.]+arm\b)/i
+                ], [[ARCHITECTURE, 'arm']], [
+
+                /((ppc|powerpc)(64)?)( mac|;|\))/i                                  // PowerPC
+                ], [[ARCHITECTURE, /ower/, EMPTY, lowerize]], [
+
+                / sun4\w[;\)]/i                                                     // SPARC
+                ], [[ARCHITECTURE, 'sparc']], [
+
+                /\b(avr32|ia64(?=;)|68k(?=\))|\barm(?=v([1-7]|[5-7]1)l?|;|eabi)|(irix|mips|sparc)(64)?\b|pa-risc)/i
+                                                                                    // IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC
+                ], [[ARCHITECTURE, lowerize]]
+            ],
+
+            device : [[
+
+                //////////////////////////
+                // MOBILES & TABLETS
+                /////////////////////////
+
+                // Samsung
+                /\b(sch-i[89]0\d|shw-m380s|sm-[ptx]\w{2,4}|gt-[pn]\d{2,4}|sgh-t8[56]9|nexus 10)/i
+                ], [MODEL, [VENDOR, SAMSUNG], [TYPE, TABLET]], [
+                /\b((?:s[cgp]h|gt|sm)-(?![lr])\w+|sc[g-]?[\d]+a?|galaxy nexus)/i,
+                /samsung[- ]((?!sm-[lr]|browser)[-\w]+)/i,
+                /sec-(sgh\w+)/i
+                ], [MODEL, [VENDOR, SAMSUNG], [TYPE, MOBILE]], [
+
+                // Apple
+                /(?:\/|\()(ip(?:hone|od)[\w, ]*)(?:\/|;)/i                          // iPod/iPhone
+                ], [MODEL, [VENDOR, APPLE], [TYPE, MOBILE]], [
+                /\((ipad);[-\w\),; ]+apple/i,                                       // iPad
+                /applecoremedia\/[\w\.]+ \((ipad)/i,
+                /\b(ipad)\d\d?,\d\d?[;\]].+ios/i
+                ], [MODEL, [VENDOR, APPLE], [TYPE, TABLET]], [
+                /(macintosh);/i
+                ], [MODEL, [VENDOR, APPLE]], [
+
+                // Sharp
+                /\b(sh-?[altvz]?\d\d[a-ekm]?)/i
+                ], [MODEL, [VENDOR, SHARP], [TYPE, MOBILE]], [
+
+                // Honor
+                /\b((?:brt|eln|hey2?|gdi|jdn)-a?[lnw]09|(?:ag[rm]3?|jdn2|kob2)-a?[lw]0[09]hn)(?: bui|\)|;)/i
+                ], [MODEL, [VENDOR, HONOR], [TYPE, TABLET]], [
+                /honor([-\w ]+)[;\)]/i
+                ], [MODEL, [VENDOR, HONOR], [TYPE, MOBILE]], [
+
+                // Huawei
+                /\b((?:ag[rs][2356]?k?|bah[234]?|bg[2o]|bt[kv]|cmr|cpn|db[ry]2?|jdn2|got|kob2?k?|mon|pce|scm|sht?|[tw]gr|vrd)-[ad]?[lw][0125][09]b?|605hw|bg2-u03|(?:gem|fdr|m2|ple|t1)-[7a]0[1-4][lu]|t1-a2[13][lw]|mediapad[\w\. ]*(?= bui|\)))\b(?!.+d\/s)/i
+                ], [MODEL, [VENDOR, HUAWEI], [TYPE, TABLET]], [
+                /(?:huawei)([-\w ]+)[;\)]/i,
+                /\b(nexus 6p|\w{2,4}e?-[atu]?[ln][\dx][012359c][adn]?)\b(?!.+d\/s)/i
+                ], [MODEL, [VENDOR, HUAWEI], [TYPE, MOBILE]], [
+
+                // Xiaomi
+                /oid[^\)]+; (2[\dbc]{4}(182|283|rp\w{2})[cgl]|m2105k81a?c)(?: bui|\))/i,
+                /\b((?:red)?mi[-_ ]?pad[\w- ]*)(?: bui|\))/i                                // Mi Pad tablets
+                ],[[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, TABLET]], [
+
+                /\b(poco[\w ]+|m2\d{3}j\d\d[a-z]{2})(?: bui|\))/i,                  // Xiaomi POCO
+                /\b; (\w+) build\/hm\1/i,                                           // Xiaomi Hongmi 'numeric' models
+                /\b(hm[-_ ]?note?[_ ]?(?:\d\w)?) bui/i,                             // Xiaomi Hongmi
+                /\b(redmi[\-_ ]?(?:note|k)?[\w_ ]+)(?: bui|\))/i,                   // Xiaomi Redmi
+                /oid[^\)]+; (m?[12][0-389][01]\w{3,6}[c-y])( bui|; wv|\))/i,        // Xiaomi Redmi 'numeric' models
+                /\b(mi[-_ ]?(?:a\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\d?\w?)[_ ]?(?:plus|se|lite|pro)?)(?: bui|\))/i, // Xiaomi Mi
+                / ([\w ]+) miui\/v?\d/i
+                ], [[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, MOBILE]], [
+
+                // OnePlus
+                /droid.+; (cph2[3-6]\d[13579]|((gm|hd)19|(ac|be|in|kb)20|(d[en]|eb|le|mt)21|ne22)[0-2]\d|p[g-k]\w[1m]10)\b/i,
+                /(?:one)?(?:plus)? (a\d0\d\d)(?: b|\))/i
+                ], [MODEL, [VENDOR, ONEPLUS], [TYPE, MOBILE]], [
+
+                // OPPO
+                /; (\w+) bui.+ oppo/i,
+                /\b(cph[12]\d{3}|p(?:af|c[al]|d\w|e[ar])[mt]\d0|x9007|a101op)\b/i
+                ], [MODEL, [VENDOR, OPPO], [TYPE, MOBILE]], [
+                /\b(opd2(\d{3}a?))(?: bui|\))/i
+                ], [MODEL, [VENDOR, strMapper, { 'OnePlus' : ['203', '304', '403', '404', '413', '415'], '*' : OPPO }], [TYPE, TABLET]], [
+
+                // BLU
+                /(vivo (5r?|6|8l?|go|one|s|x[il]?[2-4]?)[\w\+ ]*)(?: bui|\))/i  // Vivo series
+                ], [MODEL, [VENDOR, 'BLU'], [TYPE, MOBILE]], [    
+
+                // Vivo
+                /; vivo (\w+)(?: bui|\))/i,
+                /\b(v[12]\d{3}\w?[at])(?: bui|;)/i
+                ], [MODEL, [VENDOR, 'Vivo'], [TYPE, MOBILE]], [
+
+                // Realme
+                /\b(rmx[1-3]\d{3})(?: bui|;|\))/i
+                ], [MODEL, [VENDOR, 'Realme'], [TYPE, MOBILE]], [
+
+                // Lenovo
+                /(ideatab[-\w ]+|602lv|d-42a|a101lv|a2109a|a3500-hv|s[56]000|pb-6505[my]|tb-?x?\d{3,4}(?:f[cu]|xu|[av])|yt\d?-[jx]?\d+[lfmx])( bui|;|\)|\/)/i,
+                /lenovo ?(b[68]0[08]0-?[hf]?|tab(?:[\w- ]+?)|tb[\w-]{6,7})( bui|;|\)|\/)/i
+                ], [MODEL, [VENDOR, LENOVO], [TYPE, TABLET]], [            
+                /lenovo[-_ ]?([-\w ]+?)(?: bui|\)|\/)/i
+                ], [MODEL, [VENDOR, LENOVO], [TYPE, MOBILE]], [
+
+                // Motorola
+                /\b(milestone|droid(?:[2-4x]| (?:bionic|x2|pro|razr))?:?( 4g)?)\b[\w ]+build\//i,
+                /\bmot(?:orola)?[- ]([\w\s]+)(\)| bui)/i,
+                /((?:moto(?! 360)[-\w\(\) ]+|xt\d{3,4}[cgkosw\+]?[-\d]*|nexus 6)(?= bui|\)))/i
+                ], [MODEL, [VENDOR, MOTOROLA], [TYPE, MOBILE]], [
+                /\b(mz60\d|xoom[2 ]{0,2}) build\//i
+                ], [MODEL, [VENDOR, MOTOROLA], [TYPE, TABLET]], [
+
+                // LG
+                /((?=lg)?[vl]k\-?\d{3}) bui| 3\.[-\w; ]{10}lg?-([06cv9]{3,4})/i
+                ], [MODEL, [VENDOR, LG], [TYPE, TABLET]], [
+                /(lm(?:-?f100[nv]?|-[\w\.]+)(?= bui|\))|nexus [45])/i,
+                /\blg[-e;\/ ]+(?!.*(?:browser|netcast|android tv|watch|webos))(\w+)/i,
+                /\blg-?([\d\w]+) bui/i
+                ], [MODEL, [VENDOR, LG], [TYPE, MOBILE]], [
+
+                // Nokia
+                /(nokia) (t[12][01])/i
+                ], [VENDOR, MODEL, [TYPE, TABLET]], [
+                /(?:maemo|nokia).*(n900|lumia \d+|rm-\d+)/i,
+                /nokia[-_ ]?(([-\w\. ]*))/i
+                ], [[MODEL, /_/g, ' '], [TYPE, MOBILE], [VENDOR, 'Nokia']], [
+
+                // Google
+                /(pixel (c|tablet))\b/i                                             // Google Pixel C/Tablet
+                ], [MODEL, [VENDOR, GOOGLE], [TYPE, TABLET]], [
+                                                                                    // Google Pixel
+                /droid.+;(?: google)? (g(01[13]a|020[aem]|025[jn]|1b60|1f8f|2ybb|4s1m|576d|5nz6|8hhn|8vou|a02099|c15s|d1yq|e2ae|ec77|gh2x|kv4x|p4bc|pj41|r83y|tt9q|ur25|wvk6)|pixel[\d ]*a?( pro)?( xl)?( fold)?( \(5g\))?)( bui|\))/i
+                ], [MODEL, [VENDOR, GOOGLE], [TYPE, MOBILE]], [
+                /(google) (pixelbook( go)?)/i
+                ], [VENDOR, MODEL], [
+
+                // Sony
+                /droid.+; (a?\d[0-2]{2}so|[c-g]\d{4}|so[-gl]\w+|xq-\w\w\d\d)(?= bui|\).+chrome\/(?![1-6]{0,1}\d\.))/i
+                ], [MODEL, [VENDOR, SONY], [TYPE, MOBILE]], [
+                /sony tablet [ps]/i,
+                /\b(?:sony)?sgp\w+(?: bui|\))/i
+                ], [[MODEL, 'Xperia Tablet'], [VENDOR, SONY], [TYPE, TABLET]], [
+
+                // Amazon
+                /(alexa)webm/i,
+                /(kf[a-z]{2}wi|aeo(?!bc)\w\w)( bui|\))/i,                           // Kindle Fire without Silk / Echo Show
+                /(kf[a-z]+)( bui|\)).+silk\//i                                      // Kindle Fire HD
+                ], [MODEL, [VENDOR, AMAZON], [TYPE, TABLET]], [
+                /((?:sd|kf)[0349hijorstuw]+)( bui|\)).+silk\//i                     // Fire Phone
+                ], [[MODEL, /(.+)/g, 'Fire Phone $1'], [VENDOR, AMAZON], [TYPE, MOBILE]], [
+
+                // BlackBerry
+                /(playbook);[-\w\),; ]+(rim)/i                                      // BlackBerry PlayBook
+                ], [MODEL, VENDOR, [TYPE, TABLET]], [
+                /\b((?:bb[a-f]|st[hv])100-\d)/i,
+                /\(bb10; (\w+)/i                                                    // BlackBerry 10
+                ], [MODEL, [VENDOR, BLACKBERRY], [TYPE, MOBILE]], [
+
+                // Asus
+                /(?:\b|asus_)(transfo[prime ]{4,10} \w+|eeepc|slider \w+|nexus 7|padfone|p00[cj])/i
+                ], [MODEL, [VENDOR, ASUS], [TYPE, TABLET]], [
+                / (z[bes]6[027][012][km][ls]|zenfone \d\w?)\b/i
+                ], [MODEL, [VENDOR, ASUS], [TYPE, MOBILE]], [
+
+                // HTC
+                /(nexus 9)/i                                                        // HTC Nexus 9
+                ], [MODEL, [VENDOR, 'HTC'], [TYPE, TABLET]], [
+                /(htc)[-;_ ]{1,2}([\w ]+(?=\)| bui)|\w+)/i,                         // HTC
+
+                // ZTE
+                /(zte)[- ]([\w ]+?)(?: bui|\/|\))/i,
+                /(alcatel|geeksphone|nexian|panasonic(?!(?:;|\.))|sony(?!-bra))[-_ ]?([-\w]*)/i         // Alcatel/GeeksPhone/Nexian/Panasonic/Sony
+                ], [VENDOR, [MODEL, /_/g, ' '], [TYPE, MOBILE]], [
+
+                // TCL
+                /tcl (xess p17aa)/i,
+                /droid [\w\.]+; ((?:8[14]9[16]|9(?:0(?:48|60|8[01])|1(?:3[27]|66)|2(?:6[69]|9[56])|466))[gqswx])(_\w(\w|\w\w))?(\)| bui)/i
+                ], [MODEL, [VENDOR, 'TCL'], [TYPE, TABLET]], [
+                /droid [\w\.]+; (418(?:7d|8v)|5087z|5102l|61(?:02[dh]|25[adfh]|27[ai]|56[dh]|59k|65[ah])|a509dl|t(?:43(?:0w|1[adepqu])|50(?:6d|7[adju])|6(?:09dl|10k|12b|71[efho]|76[hjk])|7(?:66[ahju]|67[hw]|7[045][bh]|71[hk]|73o|76[ho]|79w|81[hks]?|82h|90[bhsy]|99b)|810[hs]))(_\w(\w|\w\w))?(\)| bui)/i
+                ], [MODEL, [VENDOR, 'TCL'], [TYPE, MOBILE]], [
+
+                // itel
+                /(itel) ((\w+))/i
+                ], [[VENDOR, lowerize], MODEL, [TYPE, strMapper, { 'tablet' : ['p10001l', 'w7001'], '*' : 'mobile' }]], [
+
+                // Acer
+                /droid.+; ([ab][1-7]-?[0178a]\d\d?)/i
+                ], [MODEL, [VENDOR, 'Acer'], [TYPE, TABLET]], [
+
+                // Meizu
+                /droid.+; (m[1-5] note) bui/i,
+                /\bmz-([-\w]{2,})/i
+                ], [MODEL, [VENDOR, 'Meizu'], [TYPE, MOBILE]], [
+                    
+                // Ulefone
+                /; ((?:power )?armor(?:[\w ]{0,8}))(?: bui|\))/i
+                ], [MODEL, [VENDOR, 'Ulefone'], [TYPE, MOBILE]], [
+
+                // Energizer
+                /; (energy ?\w+)(?: bui|\))/i,
+                /; energizer ([\w ]+)(?: bui|\))/i
+                ], [MODEL, [VENDOR, 'Energizer'], [TYPE, MOBILE]], [
+
+                // Cat
+                /; cat (b35);/i,
+                /; (b15q?|s22 flip|s48c|s62 pro)(?: bui|\))/i
+                ], [MODEL, [VENDOR, 'Cat'], [TYPE, MOBILE]], [
+
+                // Smartfren
+                /((?:new )?andromax[\w- ]+)(?: bui|\))/i
+                ], [MODEL, [VENDOR, 'Smartfren'], [TYPE, MOBILE]], [
+
+                // Nothing
+                /droid.+; (a(in)?(0(15|59|6[35])|142)p?)/i
+                ], [MODEL, [VENDOR, 'Nothing'], [TYPE, MOBILE]], [
+
+                // Archos
+                /; (x67 5g|tikeasy \w+|ac[1789]\d\w+)( b|\))/i,
+                /archos ?(5|gamepad2?|([\w ]*[t1789]|hello) ?\d+[\w ]*)( b|\))/i
+                ], [MODEL, [VENDOR, 'Archos'], [TYPE, TABLET]], [
+                /archos ([\w ]+)( b|\))/i,
+                /; (ac[3-6]\d\w{2,8})( b|\))/i 
+                ], [MODEL, [VENDOR, 'Archos'], [TYPE, MOBILE]], [
+
+                // HMD
+                /; (n159v)/i
+                ], [MODEL, [VENDOR, 'HMD'], [TYPE, MOBILE]], [
+
+                // MIXED
+                /(imo) (tab \w+)/i,                                                 // IMO
+                /(infinix|tecno) (x1101b?|p904|dp(7c|8d|10a)( pro)?|p70[1-3]a?|p904|t1101)/i                     // Infinix XPad / Tecno
+                ], [VENDOR, MODEL, [TYPE, TABLET]], [
+
+                /(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus(?! zenw)|dell|jolla|meizu|motorola|polytron|tecno|micromax|advan)[-_ ]?([-\w]*)/i,
+                                                                                    // BlackBerry/BenQ/Palm/Sony-Ericsson/Acer/Asus/Dell/Meizu/Motorola/Polytron/Tecno/Micromax/Advan
+                /; (blu|hmd|imo|infinix|lava|oneplus|tcl)[_ ]([\w\+ ]+?)(?: bui|\)|; r)/i,  // BLU/HMD/IMO/Infinix/Lava/OnePlus/TCL
+                /(hp) ([\w ]+\w)/i,                                                 // HP iPAQ
+                /(microsoft); (lumia[\w ]+)/i,                                      // Microsoft Lumia
+                /(oppo) ?([\w ]+) bui/i                                             // OPPO
+                ], [VENDOR, MODEL, [TYPE, MOBILE]], [
+
+                /(kobo)\s(ereader|touch)/i,                                         // Kobo
+                /(hp).+(touchpad(?!.+tablet)|tablet)/i,                             // HP TouchPad
+                /(kindle)\/([\w\.]+)/i                                              // Kindle
+                ], [VENDOR, MODEL, [TYPE, TABLET]], [
+
+                /(surface duo)/i                                                    // Surface Duo
+                ], [MODEL, [VENDOR, MICROSOFT], [TYPE, TABLET]], [
+                /droid [\d\.]+; (fp\du?)(?: b|\))/i                                 // Fairphone
+                ], [MODEL, [VENDOR, 'Fairphone'], [TYPE, MOBILE]], [
+                /((?:tegranote|shield t(?!.+d tv))[\w- ]*?)(?: b|\))/i              // Nvidia Tablets
+                ], [MODEL, [VENDOR, NVIDIA], [TYPE, TABLET]], [
+                /(sprint) (\w+)/i                                                   // Sprint Phones
+                ], [VENDOR, MODEL, [TYPE, MOBILE]], [
+                /(kin\.[onetw]{3})/i                                                // Microsoft Kin
+                ], [[MODEL, /\./g, ' '], [VENDOR, MICROSOFT], [TYPE, MOBILE]], [
+                /droid.+; ([c6]+|et5[16]|mc[239][23]x?|vc8[03]x?)\)/i               // Zebra
+                ], [MODEL, [VENDOR, ZEBRA], [TYPE, TABLET]], [
+                /droid.+; (ec30|ps20|tc[2-8]\d[kx])\)/i
+                ], [MODEL, [VENDOR, ZEBRA], [TYPE, MOBILE]], [
+
+                ///////////////////
+                // SMARTTVS
+                ///////////////////
+
+                /smart-tv.+(samsung)/i                                              // Samsung
+                ], [VENDOR, [TYPE, SMARTTV]], [
+                /hbbtv.+maple;(\d+)/i
+                ], [[MODEL, /^/, 'SmartTV'], [VENDOR, SAMSUNG], [TYPE, SMARTTV]], [
+                /(vizio)(?: |.+model\/)(\w+-\w+)/i,                                 // Vizio
+                /tcast.+(lg)e?. ([-\w]+)/i                                          // LG SmartTV
+                ], [VENDOR, MODEL, [TYPE, SMARTTV]], [
+                /(nux; netcast.+smarttv|lg (netcast\.tv-201\d|android tv))/i
+                ], [[VENDOR, LG], [TYPE, SMARTTV]], [
+                /(apple) ?tv/i                                                      // Apple TV
+                ], [VENDOR, [MODEL, APPLE+' TV'], [TYPE, SMARTTV]], [
+                /crkey.*devicetype\/chromecast/i                                    // Google Chromecast Third Generation
+                ], [[MODEL, CHROMECAST+' Third Generation'], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [
+                /crkey.*devicetype\/([^/]*)/i                                       // Google Chromecast with specific device type
+                ], [[MODEL, /^/, 'Chromecast '], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [
+                /fuchsia.*crkey/i                                                   // Google Chromecast Nest Hub
+                ], [[MODEL, CHROMECAST+' Nest Hub'], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [
+                /crkey/i                                                            // Google Chromecast, Linux-based or unknown
+                ], [[MODEL, CHROMECAST], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [
+                /(portaltv)/i                                                       // Facebook Portal TV
+                ], [MODEL, [VENDOR, FACEBOOK], [TYPE, SMARTTV]], [
+                /droid.+aft(\w+)( bui|\))/i                                         // Fire TV
+                ], [MODEL, [VENDOR, AMAZON], [TYPE, SMARTTV]], [
+                /(shield \w+ tv)/i                                                  // Nvidia Shield TV
+                ], [MODEL, [VENDOR, NVIDIA], [TYPE, SMARTTV]], [
+                /\(dtv[\);].+(aquos)/i,
+                /(aquos-tv[\w ]+)\)/i                                               // Sharp
+                ], [MODEL, [VENDOR, SHARP], [TYPE, SMARTTV]],[
+                /(bravia[\w ]+)( bui|\))/i                                          // Sony
+                ], [MODEL, [VENDOR, SONY], [TYPE, SMARTTV]], [
+                /(mi(tv|box)-?\w+) bui/i                                            // Xiaomi
+                ], [MODEL, [VENDOR, XIAOMI], [TYPE, SMARTTV]], [
+                /Hbbtv.*(technisat) (.*);/i                                         // TechniSAT
+                ], [VENDOR, MODEL, [TYPE, SMARTTV]], [
+                /\b(roku)[\dx]*[\)\/]((?:dvp-)?[\d\.]*)/i,                          // Roku
+                /hbbtv\/\d+\.\d+\.\d+ +\([\w\+ ]*; *([\w\d][^;]*);([^;]*)/i         // HbbTV devices
+                ], [[VENDOR, /.+\/(\w+)/, '$1', strMapper, {'LG':'lge'}], [MODEL, trim], [TYPE, SMARTTV]], [
+                                                                                    // SmartTV from Unidentified Vendors
+                /droid.+; ([\w- ]+) (?:android tv|smart[- ]?tv)/i
+                ], [MODEL, [TYPE, SMARTTV]], [
+                /\b(android tv|smart[- ]?tv|opera tv|tv; rv:|large screen[\w ]+safari)\b/i
+                ], [[TYPE, SMARTTV]], [
+
+                ///////////////////
+                // CONSOLES
+                ///////////////////
+
+                /(playstation \w+)/i                                                // Playstation
+                ], [MODEL, [VENDOR, SONY], [TYPE, CONSOLE]], [
+                /\b(xbox(?: one)?(?!; xbox))[\); ]/i                                // Microsoft Xbox
+                ], [MODEL, [VENDOR, MICROSOFT], [TYPE, CONSOLE]], [
+                /(ouya)/i,                                                          // Ouya
+                /(nintendo) (\w+)/i,                                                // Nintendo
+                /(retroid) (pocket ([^\)]+))/i                                      // Retroid Pocket
+                ], [VENDOR, MODEL, [TYPE, CONSOLE]], [
+                /droid.+; (shield)( bui|\))/i                                       // Nvidia Portable
+                ], [MODEL, [VENDOR, NVIDIA], [TYPE, CONSOLE]], [
+
+                ///////////////////
+                // WEARABLES
+                ///////////////////
+
+                /\b(sm-[lr]\d\d[0156][fnuw]?s?|gear live)\b/i                       // Samsung Galaxy Watch
+                ], [MODEL, [VENDOR, SAMSUNG], [TYPE, WEARABLE]], [
+                /((pebble))app/i,                                                   // Pebble
+                /(asus|google|lg|oppo) ((pixel |zen)?watch[\w ]*)( bui|\))/i        // Asus ZenWatch / LG Watch / Pixel Watch
+                ], [VENDOR, MODEL, [TYPE, WEARABLE]], [
+                /(ow(?:19|20)?we?[1-3]{1,3})/i                                      // Oppo Watch
+                ], [MODEL, [VENDOR, OPPO], [TYPE, WEARABLE]], [
+                /(watch)(?: ?os[,\/]|\d,\d\/)[\d\.]+/i                              // Apple Watch
+                ], [MODEL, [VENDOR, APPLE], [TYPE, WEARABLE]], [
+                /(opwwe\d{3})/i                                                     // OnePlus Watch
+                ], [MODEL, [VENDOR, ONEPLUS], [TYPE, WEARABLE]], [
+                /(moto 360)/i                                                       // Motorola 360
+                ], [MODEL, [VENDOR, MOTOROLA], [TYPE, WEARABLE]], [
+                /(smartwatch 3)/i                                                   // Sony SmartWatch
+                ], [MODEL, [VENDOR, SONY], [TYPE, WEARABLE]], [
+                /(g watch r)/i                                                      // LG G Watch R
+                ], [MODEL, [VENDOR, LG], [TYPE, WEARABLE]], [
+                /droid.+; (wt63?0{2,3})\)/i
+                ], [MODEL, [VENDOR, ZEBRA], [TYPE, WEARABLE]], [
+
+                ///////////////////
+                // XR
+                ///////////////////
+
+                /droid.+; (glass) \d/i                                              // Google Glass
+                ], [MODEL, [VENDOR, GOOGLE], [TYPE, XR]], [
+                /(pico) (4|neo3(?: link|pro)?)/i                                    // Pico
+                ], [VENDOR, MODEL, [TYPE, XR]], [
+                /(quest( \d| pro)?s?).+vr/i                                         // Meta Quest
+                ], [MODEL, [VENDOR, FACEBOOK], [TYPE, XR]], [
+                /mobile vr; rv.+firefox/i                                           // Unidentifiable VR device using Firefox Reality / Wolvic
+                ], [[TYPE, XR]], [
+
+                ///////////////////
+                // EMBEDDED
+                ///////////////////
+
+                /(tesla)(?: qtcarbrowser|\/[-\w\.]+)/i                              // Tesla
+                ], [VENDOR, [TYPE, EMBEDDED]], [
+                /(aeobc)\b/i                                                        // Echo Dot
+                ], [MODEL, [VENDOR, AMAZON], [TYPE, EMBEDDED]], [
+                /(homepod).+mac os/i                                                // Apple HomePod
+                ], [MODEL, [VENDOR, APPLE], [TYPE, EMBEDDED]], [
+                /windows iot/i                                                      // Unidentifiable embedded device using Windows IoT
+                ], [[TYPE, EMBEDDED]], [
+
+                ////////////////////
+                // MIXED (GENERIC)
+                ///////////////////
+
+                /droid .+?; ([^;]+?)(?: bui|; wv\)|\) applew).+?(mobile|vr|\d) safari/i
+                ], [MODEL, [TYPE, strMapper, { 'mobile' : 'Mobile', 'xr' : 'VR', '*' : TABLET }]], [
+                /\b((tablet|tab)[;\/]|focus\/\d(?!.+mobile))/i                      // Unidentifiable Tablet
+                ], [[TYPE, TABLET]], [
+                /(phone|mobile(?:[;\/]| [ \w\/\.]*safari)|pda(?=.+windows ce))/i    // Unidentifiable Mobile
+                ], [[TYPE, MOBILE]], [
+                /droid .+?; ([\w\. -]+)( bui|\))/i                                  // Generic Android Device
+                ], [MODEL, [VENDOR, 'Generic']]
+            ],
+
+            engine : [[
+
+                /windows.+ edge\/([\w\.]+)/i                                       // EdgeHTML
+                ], [VERSION, [NAME, EDGE+'HTML']], [
+
+                /(arkweb)\/([\w\.]+)/i                                              // ArkWeb
+                ], [NAME, VERSION], [
+
+                /webkit\/537\.36.+chrome\/(?!27)([\w\.]+)/i                         // Blink
+                ], [VERSION, [NAME, 'Blink']], [
+
+                /(presto)\/([\w\.]+)/i,                                             // Presto
+                /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna|servo)\/([\w\.]+)/i, // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m/Goanna/Servo
+                /ekioh(flow)\/([\w\.]+)/i,                                          // Flow
+                /(khtml|tasman|links)[\/ ]\(?([\w\.]+)/i,                           // KHTML/Tasman/Links
+                /(icab)[\/ ]([23]\.[\d\.]+)/i,                                      // iCab
+
+                /\b(libweb)/i                                                       // LibWeb
+                ], [NAME, VERSION], [
+                /ladybird\//i
+                ], [[NAME, 'LibWeb']], [
+
+                /rv\:([\w\.]{1,9})\b.+(gecko)/i                                     // Gecko
+                ], [VERSION, NAME]
+            ],
+
+            os : [[
+
+                // Windows
+                /(windows nt) (6\.[23]); arm/i                                      // Windows RT
+                ], [[NAME, /N/, 'R'], [VERSION, strMapper, windowsVersionMap]], [
+                /(windows (?:phone|mobile|iot))(?: os)?[\/ ]?([\d\.]*( se)?)/i,     // Windows IoT/Mobile/Phone
+                                                                                    // Windows NT/3.1/95/98/ME/2000/XP/Vista/7/8/8.1/10/11
+                /(windows)[\/ ](1[01]|2000|3\.1|7|8(\.1)?|9[58]|me|server 20\d\d( r2)?|vista|xp)/i
+                ], [NAME, VERSION], [
+                /windows nt ?([\d\.\)]*)(?!.+xbox)/i,
+                /\bwin(?=3| ?9|n)(?:nt| 9x )?([\d\.;]*)/i
+                ], [[VERSION, /(;|\))/g, '', strMapper, windowsVersionMap], [NAME, WINDOWS]], [
+                /(windows ce)\/?([\d\.]*)/i                                         // Windows CE
+                ], [NAME, VERSION], [
+
+                // iOS/macOS
+                /[adehimnop]{4,7}\b(?:.*os ([\w]+) like mac|; opera)/i,             // iOS
+                /(?:ios;fbsv\/|iphone.+ios[\/ ])([\d\.]+)/i,
+                /cfnetwork\/.+darwin/i
+                ], [[VERSION, /_/g, '.'], [NAME, 'iOS']], [
+                /(mac os x) ?([\w\. ]*)/i,
+                /(macintosh|mac_powerpc\b)(?!.+(haiku|morphos))/i                   // Mac OS
+                ], [[NAME, 'macOS'], [VERSION, /_/g, '.']], [
+
+                // Google Chromecast
+                /android ([\d\.]+).*crkey/i                                         // Google Chromecast, Android-based
+                ], [VERSION, [NAME, CHROMECAST + ' Android']], [
+                /fuchsia.*crkey\/([\d\.]+)/i                                        // Google Chromecast, Fuchsia-based
+                ], [VERSION, [NAME, CHROMECAST + ' Fuchsia']], [
+                /crkey\/([\d\.]+).*devicetype\/smartspeaker/i                       // Google Chromecast, Linux-based Smart Speaker
+                ], [VERSION, [NAME, CHROMECAST + ' SmartSpeaker']], [
+                /linux.*crkey\/([\d\.]+)/i                                          // Google Chromecast, Legacy Linux-based
+                ], [VERSION, [NAME, CHROMECAST + ' Linux']], [
+                /crkey\/([\d\.]+)/i                                                 // Google Chromecast, unknown
+                ], [VERSION, [NAME, CHROMECAST]], [
+
+                // Mobile OSes
+                /droid ([\w\.]+)\b.+(android[- ]x86)/i                              // Android-x86
+                ], [VERSION, NAME], [                                               
+                /(ubuntu) ([\w\.]+) like android/i                                  // Ubuntu Touch
+                ], [[NAME, /(.+)/, '$1 Touch'], VERSION], [
+                /(harmonyos)[\/ ]?([\d\.]*)/i,                                      // HarmonyOS
+                                                                                    // Android/Blackberry/WebOS/QNX/Bada/RIM/KaiOS/Maemo/MeeGo/S40/Sailfish OS/OpenHarmony/Tizen
+                /(android|bada|blackberry|kaios|maemo|meego|openharmony|qnx|rim tablet os|sailfish|series40|symbian|tizen)\w*[-\/\.; ]?([\d\.]*)/i
+                ], [NAME, VERSION], [
+                /\(bb(10);/i                                                        // BlackBerry 10
+                ], [VERSION, [NAME, BLACKBERRY]], [
+                /(?:symbian ?os|symbos|s60(?=;)|series ?60)[-\/ ]?([\w\.]*)/i       // Symbian
+                ], [VERSION, [NAME, 'Symbian']], [
+                /mozilla\/[\d\.]+ \((?:mobile|tablet|tv|mobile; [\w ]+); rv:.+ gecko\/([\w\.]+)/i // Firefox OS
+                ], [VERSION, [NAME, FIREFOX+' OS']], [
+                /\b(?:hp)?wos(?:browser)?\/([\w\.]+)/i,                             // WebOS
+                /webos(?:[ \/]?|\.tv-20(?=2[2-9]))(\d[\d\.]*)/i
+                ], [VERSION, [NAME, 'webOS']], [
+                /web0s;.+?(?:chr[o0]me|safari)\/(\d+)/i
+                                                                                    // https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine
+                ], [[VERSION, strMapper, {'25':'120','24':'108','23':'94','22':'87','6':'79','5':'68','4':'53','3':'38','2':'538','1':'537','*':'TV'}], [NAME, 'webOS']], [                   
+                /watch(?: ?os[,\/]|\d,\d\/)([\d\.]+)/i                              // watchOS
+                ], [VERSION, [NAME, 'watchOS']], [
+
+                // Google ChromeOS
+                /(cros) [\w]+(?:\)| ([\w\.]+)\b)/i                                  // Chromium OS
+                ], [[NAME, "Chrome OS"], VERSION],[
+
+                // Smart TVs
+                /panasonic;(viera)/i,                                               // Panasonic Viera
+                /(netrange)mmh/i,                                                   // Netrange
+                /(nettv)\/(\d+\.[\w\.]+)/i,                                         // NetTV
+
+                // Console
+                /(nintendo|playstation) (\w+)/i,                                    // Nintendo/Playstation
+                /(xbox); +xbox ([^\);]+)/i,                                         // Microsoft Xbox (360, One, X, S, Series X, Series S)
+                /(pico) .+os([\w\.]+)/i,                                            // Pico
+
+                // Other
+                /\b(joli|palm)\b ?(?:os)?\/?([\w\.]*)/i,                            // Joli/Palm
+                /linux.+(mint)[\/\(\) ]?([\w\.]*)/i,                                // Mint
+                /(mageia|vectorlinux|fuchsia|arcaos|arch(?= ?linux))[;l ]([\d\.]*)/i,  // Mageia/VectorLinux/Fuchsia/ArcaOS/Arch
+                /([kxln]?ubuntu|debian|suse|opensuse|gentoo|slackware|fedora|mandriva|centos|pclinuxos|red ?hat|zenwalk|linpus|raspbian|plan 9|minix|risc os|contiki|deepin|manjaro|elementary os|sabayon|linspire|knoppix)(?: gnu[\/ ]linux)?(?: enterprise)?(?:[- ]linux)?(?:-gnu)?[-\/ ]?(?!chrom|package)([-\w\.]*)/i,
+                                                                                    // Ubuntu/Debian/SUSE/Gentoo/Slackware/Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus/Raspbian/Plan9/Minix/RISCOS/Contiki/Deepin/Manjaro/elementary/Sabayon/Linspire/Knoppix
+                /((?:open)?solaris)[-\/ ]?([\w\.]*)/i,                              // Solaris
+                /\b(aix)[; ]([1-9\.]{0,4})/i,                                       // AIX
+                /(hurd|linux|morphos)(?: (?:arm|x86|ppc)\w*| ?)([\w\.]*)/i,         // Hurd/Linux/MorphOS
+                /(gnu) ?([\w\.]*)/i,                                                // GNU
+                /\b([-frentopcghs]{0,5}bsd|dragonfly)[\/ ]?(?!amd|[ix346]{1,2}86)([\w\.]*)/i, // FreeBSD/NetBSD/OpenBSD/PC-BSD/GhostBSD/DragonFly
+                /(haiku) ?(r\d)?/i                                                  // Haiku
+                ], [NAME, VERSION], [
+                /(sunos) ?([\d\.]*)/i                                               // Solaris
+                ], [[NAME, 'Solaris'], VERSION], [
+                /\b(beos|os\/2|amigaos|openvms|hp-ux|serenityos)/i,                 // BeOS/OS2/AmigaOS/OpenVMS/HP-UX/SerenityOS
+                /(unix) ?([\w\.]*)/i                                                // UNIX
+                ], [NAME, VERSION]
+            ]
+        };
+
+        /////////////////
+        // Factories
+        ////////////////
+
+        var defaultProps = (function () {
+                var props = { init : {}, isIgnore : {}, isIgnoreRgx : {}, toString : {}};
+                setProps.call(props.init, [
+                    [UA_BROWSER, [NAME, VERSION, MAJOR, TYPE]],
+                    [UA_CPU, [ARCHITECTURE]],
+                    [UA_DEVICE, [TYPE, MODEL, VENDOR]],
+                    [UA_ENGINE, [NAME, VERSION]],
+                    [UA_OS, [NAME, VERSION]]
+                ]);
+                setProps.call(props.isIgnore, [
+                    [UA_BROWSER, [VERSION, MAJOR]],
+                    [UA_ENGINE, [VERSION]],
+                    [UA_OS, [VERSION]]
+                ]);
+                setProps.call(props.isIgnoreRgx, [
+                    [UA_BROWSER, / ?browser$/i],
+                    [UA_OS, / ?os$/i]
+                ]);
+                setProps.call(props.toString, [
+                    [UA_BROWSER, [NAME, VERSION]],
+                    [UA_CPU, [ARCHITECTURE]],
+                    [UA_DEVICE, [VENDOR, MODEL]],
+                    [UA_ENGINE, [NAME, VERSION]],
+                    [UA_OS, [NAME, VERSION]]
+                ]);
+                return props;
+        })();
+
+        var createIData = function (item, itemType) {
+
+            var init_props = defaultProps.init[itemType],
+                is_ignoreProps = defaultProps.isIgnore[itemType] || 0,
+                is_ignoreRgx = defaultProps.isIgnoreRgx[itemType] || 0,
+                toString_props = defaultProps.toString[itemType] || 0;
+
+            function IData () {
+                setProps.call(this, init_props);
+            }
+
+            IData.prototype.getItem = function () {
+                return item;
+            };
+
+            IData.prototype.withClientHints = function () {
+
+                // nodejs / non-client-hints browsers
+                if (!NAVIGATOR_UADATA) {
+                    return item
+                            .parseCH()
+                            .get();
+                }
+
+                // browsers based on chromium 85+
+                return NAVIGATOR_UADATA
+                        .getHighEntropyValues(CH_ALL_VALUES)
+                        .then(function (res) {
+                            return item
+                                    .setCH(new UACHData(res, false))
+                                    .parseCH()
+                                    .get();
+                });
+            };
+
+            IData.prototype.withFeatureCheck = function () {
+                return item.detectFeature().get();
+            };
+
+            if (itemType != UA_RESULT) {
+                IData.prototype.is = function (strToCheck) {
+                    var is = false;
+                    for (var i in this) {
+                        if (this.hasOwnProperty(i) && !has(is_ignoreProps, i) && lowerize(is_ignoreRgx ? strip(is_ignoreRgx, this[i]) : this[i]) == lowerize(is_ignoreRgx ? strip(is_ignoreRgx, strToCheck) : strToCheck)) {
+                            is = true;
+                            if (strToCheck != UNDEF_TYPE) break;
+                        } else if (strToCheck == UNDEF_TYPE && is) {
+                            is = !is;
+                            break;
+                        }
+                    }
+                    return is;
+                };
+                IData.prototype.toString = function () {
+                    var str = EMPTY;
+                    for (var i in toString_props) {
+                        if (typeof(this[toString_props[i]]) !== UNDEF_TYPE) {
+                            str += (str ? ' ' : EMPTY) + this[toString_props[i]];
+                        }
+                    }
+                    return str || UNDEF_TYPE;
+                };
+            }
+
+            if (!NAVIGATOR_UADATA) {
+                IData.prototype.then = function (cb) { 
+                    var that = this;
+                    var IDataResolve = function () {
+                        for (var prop in that) {
+                            if (that.hasOwnProperty(prop)) {
+                                this[prop] = that[prop];
+                            }
+                        }
+                    };
+                    IDataResolve.prototype = {
+                        is : IData.prototype.is,
+                        toString : IData.prototype.toString
+                    };
+                    var resolveData = new IDataResolve();
+                    cb(resolveData);
+                    return resolveData;
+                };
+            }
+
+            return new IData();
+        };
+
+        /////////////////
+        // Constructor
+        ////////////////
+
+        function UACHData (uach, isHttpUACH) {
+            uach = uach || {};
+            setProps.call(this, CH_ALL_VALUES);
+            if (isHttpUACH) {
+                setProps.call(this, [
+                    [BRANDS, itemListToArray(uach[CH_HEADER])],
+                    [FULLVERLIST, itemListToArray(uach[CH_HEADER_FULL_VER_LIST])],
+                    [MOBILE, /\?1/.test(uach[CH_HEADER_MOBILE])],
+                    [MODEL, stripQuotes(uach[CH_HEADER_MODEL])],
+                    [PLATFORM, stripQuotes(uach[CH_HEADER_PLATFORM])],
+                    [PLATFORMVER, stripQuotes(uach[CH_HEADER_PLATFORM_VER])],
+                    [ARCHITECTURE, stripQuotes(uach[CH_HEADER_ARCH])],
+                    [FORMFACTORS, itemListToArray(uach[CH_HEADER_FORM_FACTORS])],
+                    [BITNESS, stripQuotes(uach[CH_HEADER_BITNESS])]
+                ]);
+            } else {
+                for (var prop in uach) {
+                    if(this.hasOwnProperty(prop) && typeof uach[prop] !== UNDEF_TYPE) this[prop] = uach[prop];
+                }
+            }
+        }
+
+        function UAItem (itemType, ua, rgxMap, uaCH) {
+
+            this.get = function (prop) {
+                if (!prop) return this.data;
+                return this.data.hasOwnProperty(prop) ? this.data[prop] : undefined;
+            };
+
+            this.set = function (prop, val) {
+                this.data[prop] = val;
+                return this;
+            };
+
+            this.setCH = function (ch) {
+                this.uaCH = ch;
+                return this;
+            };
+
+            this.detectFeature = function () {
+                if (NAVIGATOR && NAVIGATOR.userAgent == this.ua) {
+                    switch (this.itemType) {
+                        case UA_BROWSER:
+                            // Brave-specific detection
+                            if (NAVIGATOR.brave && typeof NAVIGATOR.brave.isBrave == FUNC_TYPE) {
+                                this.set(NAME, 'Brave');
+                            }
+                            break;
+                        case UA_DEVICE:
+                            // Chrome-specific detection: check for 'mobile' value of navigator.userAgentData
+                            if (!this.get(TYPE) && NAVIGATOR_UADATA && NAVIGATOR_UADATA[MOBILE]) {
+                                this.set(TYPE, MOBILE);
+                            }
+                            // iPadOS-specific detection: identified as Mac, but has some iOS-only properties
+                            if (this.get(MODEL) == 'Macintosh' && NAVIGATOR && typeof NAVIGATOR.standalone !== UNDEF_TYPE && NAVIGATOR.maxTouchPoints && NAVIGATOR.maxTouchPoints > 2) {
+                                this.set(MODEL, 'iPad')
+                                    .set(TYPE, TABLET);
+                            }
+                            break;
+                        case UA_OS:
+                            // Chrome-specific detection: check for 'platform' value of navigator.userAgentData
+                            if (!this.get(NAME) && NAVIGATOR_UADATA && NAVIGATOR_UADATA[PLATFORM]) {
+                                this.set(NAME, NAVIGATOR_UADATA[PLATFORM]);
+                            }
+                            break;
+                        case UA_RESULT:
+                            var data = this.data;
+                            var detect = function (itemType) {
+                                return data[itemType]
+                                        .getItem()
+                                        .detectFeature()
+                                        .get();
+                            };
+                            this.set(UA_BROWSER, detect(UA_BROWSER))
+                                .set(UA_CPU, detect(UA_CPU))
+                                .set(UA_DEVICE, detect(UA_DEVICE))
+                                .set(UA_ENGINE, detect(UA_ENGINE))
+                                .set(UA_OS, detect(UA_OS));
+                    }
+                }
+                return this;
+            };
+
+            this.parseUA = function () {
+                if (this.itemType != UA_RESULT) {
+                    rgxMapper.call(this.data, this.ua, this.rgxMap);
+                }
+                if (this.itemType == UA_BROWSER) {
+                    this.set(MAJOR, majorize(this.get(VERSION)));
+                }
+                return this;
+            };
+
+            this.parseCH = function () {
+                var uaCH = this.uaCH,
+                    rgxMap = this.rgxMap;
+        
+                switch (this.itemType) {
+                    case UA_BROWSER:
+                    case UA_ENGINE:
+                        var brands = uaCH[FULLVERLIST] || uaCH[BRANDS], prevName;
+                        if (brands) {
+                            for (var i in brands) {
+                                var brandName = brands[i].brand || brands[i],
+                                    brandVersion = brands[i].version;
+                                if (this.itemType == UA_BROWSER && 
+                                    !/not.a.brand/i.test(brandName) && 
+                                    (!prevName || 
+                                        (/Chrom/.test(prevName) && brandName != CHROMIUM) || 
+                                        (prevName == EDGE && /WebView2/.test(brandName))
+                                    )) {
+                                        brandName = strMapper(brandName, browserHintsMap);
+                                        prevName = this.get(NAME);
+                                        if (!(prevName && !/Chrom/.test(prevName) && /Chrom/.test(brandName))) {
+                                            this.set(NAME, brandName)
+                                                .set(VERSION, brandVersion)
+                                                .set(MAJOR, majorize(brandVersion));
+                                        }
+                                        prevName = brandName;
+                                }
+                                if (this.itemType == UA_ENGINE && brandName == CHROMIUM) {
+                                    this.set(VERSION, brandVersion);
+                                }
+                            }
+                        }
+                        break;
+                    case UA_CPU:
+                        var archName = uaCH[ARCHITECTURE];
+                        if (archName) {
+                            if (archName && uaCH[BITNESS] == '64') archName += '64';
+                            rgxMapper.call(this.data, archName + ';', rgxMap);
+                        }
+                        break;
+                    case UA_DEVICE:
+                        if (uaCH[MOBILE]) {
+                            this.set(TYPE, MOBILE);
+                        }
+                        if (uaCH[MODEL]) {
+                            this.set(MODEL, uaCH[MODEL]);
+                            if (!this.get(TYPE) || !this.get(VENDOR)) {
+                                var reParse = {};
+                                rgxMapper.call(reParse, 'droid 9; ' + uaCH[MODEL] + ')', rgxMap);
+                                if (!this.get(TYPE) && !!reParse.type) {
+                                    this.set(TYPE, reParse.type);
+                                }
+                                if (!this.get(VENDOR) && !!reParse.vendor) {
+                                    this.set(VENDOR, reParse.vendor);
+                                }
+                            }
+                        }
+                        if (uaCH[FORMFACTORS]) {
+                            var ff;
+                            if (typeof uaCH[FORMFACTORS] !== 'string') {
+                                var idx = 0;
+                                while (!ff && idx < uaCH[FORMFACTORS].length) {
+                                    ff = strMapper(uaCH[FORMFACTORS][idx++], formFactorsMap);
+                                }
+                            } else {
+                                ff = strMapper(uaCH[FORMFACTORS], formFactorsMap);
+                            }
+                            this.set(TYPE, ff);
+                        }
+                        break;
+                    case UA_OS:
+                        var osName = uaCH[PLATFORM];
+                        if(osName) {
+                            var osVersion = uaCH[PLATFORMVER];
+                            if (osName == WINDOWS) osVersion = (parseInt(majorize(osVersion), 10) >= 13 ? '11' : '10');
+                            this.set(NAME, osName)
+                                .set(VERSION, osVersion);
+                        }
+                        // Xbox-Specific Detection
+                        if (this.get(NAME) == WINDOWS && uaCH[MODEL] == 'Xbox') {
+                            this.set(NAME, 'Xbox')
+                                .set(VERSION, undefined);
+                        }           
+                        break;
+                    case UA_RESULT:
+                        var data = this.data;
+                        var parse = function (itemType) {
+                            return data[itemType]
+                                    .getItem()
+                                    .setCH(uaCH)
+                                    .parseCH()
+                                    .get();
+                        };
+                        this.set(UA_BROWSER, parse(UA_BROWSER))
+                            .set(UA_CPU, parse(UA_CPU))
+                            .set(UA_DEVICE, parse(UA_DEVICE))
+                            .set(UA_ENGINE, parse(UA_ENGINE))
+                            .set(UA_OS, parse(UA_OS));
+                }
+                return this;
+            };
+
+            setProps.call(this, [
+                ['itemType', itemType],
+                ['ua', ua],
+                ['uaCH', uaCH],
+                ['rgxMap', rgxMap],
+                ['data', createIData(this, itemType)]
+            ]);
+
+            return this;
+        }
+
+        function UAParser (ua, extensions, headers) {
+
+            if (typeof ua === OBJ_TYPE) {
+                if (isExtensions(ua, true)) {
+                    if (typeof extensions === OBJ_TYPE) {
+                        headers = extensions;               // case UAParser(extensions, headers)           
+                    }
+                    extensions = ua;                        // case UAParser(extensions)
+                } else {
+                    headers = ua;                           // case UAParser(headers)
+                    extensions = undefined;
+                }
+                ua = undefined;
+            } else if (typeof ua === STR_TYPE && !isExtensions(extensions, true)) {
+                headers = extensions;                       // case UAParser(ua, headers)
+                extensions = undefined;
+            }
+
+            // Convert Headers object into a plain object
+            if (headers && typeof headers.append === FUNC_TYPE) {
+                var kv = {};
+                headers.forEach(function (v, k) { kv[k] = v; });
+                headers = kv;
+            }
+            
+            if (!(this instanceof UAParser)) {
+                return new UAParser(ua, extensions, headers).getResult();
+            }
+
+            var userAgent = typeof ua === STR_TYPE ? ua :                                       // Passed user-agent string
+                                    (headers && headers[USER_AGENT] ? headers[USER_AGENT] :     // User-Agent from passed headers
+                                    ((NAVIGATOR && NAVIGATOR.userAgent) ? NAVIGATOR.userAgent : // navigator.userAgent
+                                        EMPTY)),                                                // empty string
+
+                httpUACH = new UACHData(headers, true),
+                regexMap = extensions ? 
+                            extend(defaultRegexes, extensions) : 
+                            defaultRegexes,
+
+                createItemFunc = function (itemType) {
+                    if (itemType == UA_RESULT) {
+                        return function () {
+                            return new UAItem(itemType, userAgent, regexMap, httpUACH)
+                                        .set('ua', userAgent)
+                                        .set(UA_BROWSER, this.getBrowser())
+                                        .set(UA_CPU, this.getCPU())
+                                        .set(UA_DEVICE, this.getDevice())
+                                        .set(UA_ENGINE, this.getEngine())
+                                        .set(UA_OS, this.getOS())
+                                        .get();
+                        };
+                    } else {
+                        return function () {
+                            return new UAItem(itemType, userAgent, regexMap[itemType], httpUACH)
+                                        .parseUA()
+                                        .get();
+                        };
+                    }
+                };
+                
+            // public methods
+            setProps.call(this, [
+                ['getBrowser', createItemFunc(UA_BROWSER)],
+                ['getCPU', createItemFunc(UA_CPU)],
+                ['getDevice', createItemFunc(UA_DEVICE)],
+                ['getEngine', createItemFunc(UA_ENGINE)],
+                ['getOS', createItemFunc(UA_OS)],
+                ['getResult', createItemFunc(UA_RESULT)],
+                ['getUA', function () { return userAgent; }],
+                ['setUA', function (ua) {
+                    if (isString(ua))
+                        userAgent = ua.length > UA_MAX_LENGTH ? trim(ua, UA_MAX_LENGTH) : ua;
+                    return this;
+                }]
+            ])
+            .setUA(userAgent);
+
+            return this;
+        }
+
+        UAParser.VERSION = LIBVERSION;
+        UAParser.BROWSER =  enumerize([NAME, VERSION, MAJOR, TYPE]);
+        UAParser.CPU = enumerize([ARCHITECTURE]);
+        UAParser.DEVICE = enumerize([MODEL, VENDOR, TYPE, CONSOLE, MOBILE, SMARTTV, TABLET, WEARABLE, EMBEDDED]);
+        UAParser.ENGINE = UAParser.OS = enumerize([NAME, VERSION]);
+
+    class DeviceDetector {
+        getDeviceInfo() {
+            const parser = new UAParser();
+            const result = parser.getResult();
+            return {
+                browser: result.browser,
+                os: result.os,
+                device: result.device,
+                engine: result.engine,
+                cpu: result.cpu,
+                ua: result.ua,
+            };
+        }
+        get screenDensity() {
+            if (window.devicePixelRatio >= 3)
+                return "high";
+            if (window.devicePixelRatio >= 2)
+                return "medium";
+            return "low";
+        }
+        get screenFormat() {
+            return window.innerHeight > window.innerWidth ? "long" : "normal";
+        }
+        get screenSize() {
+            const width = window.innerWidth;
+            if (width < 480)
+                return "small";
+            else if (width < 768)
+                return "normal";
+            else if (width < 1440)
+                return "large";
+            else
+                return "xlarge";
+        }
+        get uiMode() {
+            var _a, _b, _c;
+            const deviceInfo = this.getDeviceInfo();
+            const deviceType = ((_a = deviceInfo.device) === null || _a === void 0 ? void 0 : _a.type) || ""; // 'mobile', 'tablet', 'smarttv', 'console', 'wearable', 'embedded'
+            const model = ((_c = (_b = deviceInfo.device) === null || _b === void 0 ? void 0 : _b.model) === null || _c === void 0 ? void 0 : _c.toLowerCase()) || "";
+            const ua = deviceInfo.ua.toLowerCase();
+            if (deviceType === "wearable" || model.includes("watch")) {
+                return 6; // UI_MODE_TYPE_WATCH
+            }
+            if (deviceType === "smarttv" ||
+                ua.includes("smart-tv") ||
+                ua.includes("hbbtv") ||
+                ua.includes("netcast") ||
+                ua.includes("googletv") ||
+                ua.includes("appletv")) {
+                return 4; // UI_MODE_TYPE_TELEVISION
+            }
+            if (deviceType === "console" ||
+                ua.includes("playstation") ||
+                ua.includes("xbox") ||
+                ua.includes("nintendo")) {
+                return 5; // UI_MODE_TYPE_APPLIANCE
+            }
+            if (ua.includes("car") ||
+                ua.includes("android auto") ||
+                ua.includes("carplay")) {
+                return 3; // UI_MODE_TYPE_CAR
+            }
+            if (ua.includes("oculus") ||
+                ua.includes("vive") ||
+                ua.includes("vr") ||
+                deviceType === "embedded") {
+                return 7; // UI_MODE_TYPE_VR_HEADSET
+            }
+            if (deviceType === "mobile" || deviceType === "tablet") {
+                return 1; // UI_MODE_TYPE_NORMAL
+            }
+            if (deviceType === "" || deviceType === "desktop") {
+                return 2; // UI_MODE_TYPE_DESK
+            }
+            return 0; // UI_MODE_TYPE_UNDEFINED
+        }
+        get uiStyle() {
+            const isDarkMode = window.matchMedia &&
+                window.matchMedia("(prefers-color-scheme: dark)").matches;
+            return isDarkMode ? "1" : "0";
+        }
+        get displaySize() {
+            const dpr = window.devicePixelRatio || 1;
+            const pixelWidth = screen.width * dpr;
+            const pixelHeight = screen.height * dpr;
+            const assumedDPI = 160;
+            const widthInInches = pixelWidth / assumedDPI;
+            const heightInInches = pixelHeight / assumedDPI;
+            const diagonal = Math.sqrt(Math.pow(widthInInches, 2) + Math.pow(heightInInches, 2));
+            return diagonal.toFixed(2);
+        }
+        get screenType() {
+            return "ontouchstart" in window || navigator.maxTouchPoints > 0
+                ? "touch"
+                : "pointer";
+        }
+    }
+    /** @internal */
+    const deviceDetector = new DeviceDetector();
+
+    class StorageSupport {
+        constructor() {
+            this.supportResults = null;
+        }
+        getSupportResult() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.supportResults)
+                    return this.supportResults;
+                const localStorageSupported = this.isLocalStorageSupported();
+                const sessionStorageSupported = this.isSessionStorageSupported();
+                const indexedDBSupported = yield this.isIndexedDBSupported();
+                this.supportResults = {
+                    localStorage: localStorageSupported,
+                    sessionStorage: sessionStorageSupported,
+                    indexedDB: indexedDBSupported,
+                };
+                return this.supportResults;
+            });
+        }
+        getStorageSizeBytes(storage) {
+            let total = 0;
+            for (let i = 0; i < storage.length; i++) {
+                const key = storage.key(i);
+                if (!key)
+                    continue;
+                const value = storage.getItem(key);
+                if (value == null)
+                    continue;
+                total += key.length * 2;
+                total += value.length * 2;
+            }
+            return total;
+        }
+        isLocalStorageSupported() {
+            try {
+                const testKey = "__test__";
+                localStorage.setItem(testKey, "1");
+                localStorage.removeItem(testKey);
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        isSessionStorageSupported() {
+            try {
+                const testKey = "__test__";
+                sessionStorage.setItem(testKey, "1");
+                sessionStorage.removeItem(testKey);
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        isIndexedDBSupported() {
+            if (!("indexedDB" in window))
+                return Promise.resolve(false);
+            return new Promise((resolve) => {
+                try {
+                    const request = indexedDB.open("__test__check__");
+                    request.onerror = () => resolve(false);
+                    request.onsuccess = () => {
+                        request.result.close();
+                        indexedDB.deleteDatabase("__test__check__");
+                        resolve(true);
+                    };
+                }
+                catch (_a) {
+                    resolve(false);
+                }
+            });
+        }
+    }
+    /** @internal */
+    const storageSupport = new StorageSupport();
+
+    /** @internal */
+    class Utils {
+        static getUTMParamsString() {
+            const params = new URLSearchParams(window.location.search);
+            const utmParams = {};
+            for (const [key, value] of params.entries()) {
+                if (key.startsWith("utm_") && value) {
+                    utmParams[key] = value;
+                }
+            }
+            if (!utmParams["utm_source"]) {
+                const referrer = document.referrer;
+                utmParams["utm_source"] = referrer ? new URL(referrer).hostname : "other";
+            }
+            if (!utmParams["utm_medium"]) {
+                utmParams["utm_medium"] = "organic";
+            }
+            return Object.entries(utmParams)
+                .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+                .join("&");
+        }
+    }
+    Utils.detectWebFramework = () => {
+        // Next.js (React)
+        if (!!document.querySelector("script[id=__NEXT_DATA__]") ||
+            [...document.scripts].some((s) => s.src.includes("/_next/")))
+            return "Next.js";
+        // React (if next.js dosn't exists)
+        if (!!window.React ||
+            !!document.querySelector("[data-reactroot], [data-reactid]") ||
+            Array.from(document.querySelectorAll("*")).some((e) => e._reactRootContainer !== undefined ||
+                Object.keys(e).some((k) => k.startsWith("__reactContainer"))) ||
+            window.__REACT_DEVTOOLS_GLOBAL_HOOK__)
+            return "React";
+        // Vue / Nuxt.js
+        if ([...document.scripts].some((s) => s.src.includes("/_nuxt/")))
+            return "Nuxt.js";
+        if (window.__VUE__ ||
+            window.Vue ||
+            document.querySelector("[data-v-app], [data-v-]"))
+            return "Vue.js";
+        // Gatsby.js
+        if (!!document.querySelector("[id=___gatsby]"))
+            return "Gatsby.js";
+        // Angular
+        if (!!window ||
+            !!document.querySelector(".ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]") ||
+            !!document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]') ||
+            window.ng ||
+            document.querySelector("[ng-version]"))
+            return "Angular";
+        // Svelte
+        if ([...document.scripts].some((s) => { var _a; return s.src.includes("svelte") || ((_a = s.textContent) === null || _a === void 0 ? void 0 : _a.includes("svelte")); }))
+            return "Svelte";
+        // Alpine.js
+        if (document.querySelector("[x-data], [x-init], [x-bind]"))
+            return "Alpine.js";
+        // jQuery
+        if (window.jQuery)
+            return "jQuery";
+        // Backbone
+        if (!!window.Backbone)
+            return "Backbone.js";
+        // Meteor
+        if (!!window.Meteor)
+            return "Meteor.js";
+        // Zepto
+        if (!!window.Zepto)
+            return "Zepto.js";
+        // WordPress (CMS)
+        if (document.querySelector('meta[name="generator"][content*="WordPress"]') ||
+            [...document.scripts].some((s) => s.src.includes("wp-content") || s.src.includes("wp-includes")))
+            return "WordPress";
+        // Laravel
+        if ([...document.scripts].some((s) => s.src.includes("/js/app.js") || s.src.includes("mix-manifest.json")))
+            return "Laravel";
+        // Drupal (CMS)
+        if (document.querySelector('meta[name="generator"][content*="Drupal"]') ||
+            document.documentElement.innerHTML.includes("drupal-settings-json"))
+            return "Drupal";
+        // Shopify
+        if (document.documentElement.innerHTML.includes("cdn.shopify.com"))
+            return "Shopify";
+        // Squarespace
+        if ([...document.scripts].some((s) => s.src.includes("static.squarespace.com")))
+            return "Squarespace";
+        // Wix
+        if ([...document.scripts].some((s) => s.src.includes("wix.com")))
+            return "Wix";
+        // Ghost CMS
+        if (document.querySelector('meta[name="generator"][content*="Ghost"]'))
+            return "Ghost CMS";
+        return undefined;
+    };
+
+    /** @internal */
+    class DeviceFingerprint {
+        static isWebGLSupported() {
+            try {
+                const canvas = document.createElement("canvas");
+                return !!(canvas.getContext("webgl") || canvas.getContext("experimental-webgl"));
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        static getWebGLFingerprint() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const canvas = document.createElement("canvas");
+                const gl = (canvas.getContext("webgl") ||
+                    canvas.getContext("experimental-webgl"));
+                if (!gl)
+                    return undefined;
+                const info = {
+                    version: gl.getParameter(gl.VERSION),
+                    shadingLangVersion: gl.getParameter(gl.SHADING_LANGUAGE_VERSION),
+                    maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
+                    maxRenderBufferSize: gl.getParameter(gl.MAX_RENDERBUFFER_SIZE),
+                    supportedExtensions: gl.getSupportedExtensions(),
+                };
+                try {
+                    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+                    info.vendor = debugInfo
+                        ? gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL)
+                        : gl.getParameter(gl.VENDOR);
+                }
+                catch (_) {
+                    info.vendor = gl.getParameter(gl.VENDOR);
+                }
+                try {
+                    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+                    info.renderer = debugInfo
+                        ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
+                        : gl.getParameter(gl.RENDERER);
+                }
+                catch (_) {
+                    info.renderer = gl.getParameter(gl.RENDERER);
+                }
+                return yield this.hashData(JSON.stringify(info));
+            });
+        }
+        static getCanvasFingerprint() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const canvas = document.createElement("canvas");
+                canvas.width = 200;
+                canvas.height = 50;
+                const ctx = canvas.getContext("2d");
+                if (!ctx)
+                    return undefined;
+                ctx.textBaseline = "top";
+                ctx.font = "14px 'Arial'";
+                ctx.fillStyle = "#f60";
+                ctx.fillRect(0, 0, 200, 50);
+                ctx.fillStyle = "#069";
+                ctx.fillText("WiseTrack WebGL Fingerprint!", 2, 2);
+                return yield this.hashData(canvas.toDataURL());
+            });
+        }
+        //   static async generateFingerprint(): Promise<string> {
+        //     const webglData = this.getWebGLFingerprint();
+        //     const canvasData = this.getCanvasFingerprint();
+        //     const combined = webglData + "|" + canvasData;
+        //     const encoder = new TextEncoder();
+        //     const data = encoder.encode(combined);
+        //     const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+        //     const hashArray = Array.from(new Uint8Array(hashBuffer));
+        //     const hashHex = hashArray
+        //       .map((b) => b.toString(16).padStart(2, "0"))
+        //       .join("");
+        //     return hashHex;
+        //   }
+        static hashData(input) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const str = typeof input === "string" ? input : JSON.stringify(input);
+                const encoder = new TextEncoder();
+                const data = encoder.encode(str);
+                const hashBuffer = yield crypto.subtle.digest("SHA-256", data);
+                const hashArray = Array.from(new Uint8Array(hashBuffer));
+                const hashHex = hashArray
+                    .map((b) => b.toString(16).padStart(2, "0"))
+                    .join("");
+                return hashHex;
+            });
+        }
+    }
+
+    /** @internal */
+    class FieldsBuilder {
+        build() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const startTime = window.performance.now();
+                let fields = {};
+                fields.created_at = new Date().toISOString();
+                Object.assign(fields, this.getLocalFields());
+                Object.assign(fields, yield this.getApplicationFields());
+                Object.assign(fields, this.getDeviceFields());
+                fields.time_spent = (window.performance.now() - startTime).toFixed(1);
+                {
+                    fields = Object.fromEntries(Object.entries(fields).filter(([_, value]) => value !== null && value !== undefined));
+                }
+                return fields;
+            });
+        }
+        getApplicationFields() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const storageSupportResult = yield storageSupport.getSupportResult();
+                return {
+                    connectivity_type: navigator.onLine ? "1" : "-1",
+                    country: yield countryFinder.getCountryCode(),
+                    package_name: window.location.hostname,
+                    session_storage_enabled: storageSupportResult.sessionStorage,
+                    indexed_db_enabled: storageSupportResult.indexedDB,
+                    local_storage_enabled: storageSupportResult.localStorage,
+                    session_storage: storageSupport
+                        .getStorageSizeBytes(sessionStorage)
+                        .toFixed(0),
+                    local_storage: storageSupport
+                        .getStorageSizeBytes(localStorage)
+                        .toFixed(0),
+                    web_gl_support: DeviceFingerprint.isWebGLSupported(),
+                    web_gl_fingerprint: yield DeviceFingerprint.getWebGLFingerprint(),
+                    web_gl_canvas_fingerprint: yield DeviceFingerprint.getCanvasFingerprint(),
+                };
+            });
+        }
+        getLocalFields() {
+            const initialConfig = storageManager.initialConfig;
+            if (!initialConfig)
+                return {};
+            return {
+                uuid: storageManager.deviceId,
+                app_token: initialConfig.appToken,
+                environment: initialConfig.userEnvironment,
+                store_name: "other",
+                app_version: initialConfig.appVersion,
+                push_token: storageManager.pushToken,
+                custom_device_id: initialConfig.customDeviceId,
+                default_tracker: initialConfig.defaultTracker,
+                platform: WTConstants.SDK.PLATFORM,
+                framework: initialConfig.appFrameWork.toLowerCase(),
+                initiated_by: `${WTConstants.SDK.PLATFORM}_${initialConfig.appFrameWork.toLowerCase()}`,
+                initiated_version: WTConstants.SDK.VERSION,
+                referrer: Utils.getUTMParamsString(),
+                installed_at: storageManager.initialDate,
+                session_count: storageManager.sessionCount.toString(),
+                session_length: parseInt((storageManager.activeDuration / 1000).toString()).toString(),
+                subsession_count: parseInt((storageManager.subSessionCount / 1000).toString()).toString(),
+                last_interval: parseInt((storageManager.inactiveDuration / 1000).toString()).toString(),
+            };
+        }
+        getDeviceFields() {
+            const deviceInfo = deviceDetector.getDeviceInfo();
+            return {
+                browser_version: deviceInfo.browser.version,
+                device_manufacturer: deviceInfo.device.vendor,
+                device_name: deviceInfo.device.model,
+                device_type: deviceInfo.device.type,
+                os_name: deviceInfo.os.name,
+                os_version: deviceInfo.os.version,
+                cpu_type: deviceInfo.cpu.architecture,
+                web_user_agent: deviceInfo.ua,
+                display_height: window.innerHeight.toFixed(0),
+                display_width: window.innerWidth.toFixed(0),
+                language: navigator.language.split("-")[0],
+                screen_density: deviceDetector.screenDensity,
+                screen_format: deviceDetector.screenFormat,
+                screen_size: deviceDetector.screenSize,
+                ui_mode: deviceDetector.uiMode.toString(),
+                cpu_lpc: navigator.hardwareConcurrency.toString(),
+                ui_style: deviceDetector.uiStyle,
+                wout_width: window.outerWidth.toString(),
+                wout_height: window.outerHeight.toString(),
+                web_engine: deviceInfo.engine.name,
+                web_engine_version: deviceInfo.engine.version,
+                display_size: deviceDetector.displaySize,
+                screen_type: deviceDetector.screenType,
+            };
+        }
+    }
+    /** @internal */
+    const fieldsBuilder = new FieldsBuilder();
+
+    /** @internal */
+    class EventFieldsBuilder extends FieldsBuilder {
+        constructor(event) {
+            super();
+            this.event = event;
+        }
+        build() {
+            const _super = Object.create(null, {
+                build: { get: () => super.build }
+            });
+            return __awaiter(this, void 0, void 0, function* () {
+                const fields = yield _super.build.call(this);
+                return new Promise((resolve) => {
+                    resolve(Object.assign(Object.assign({}, fields), this.event.toJSON()));
+                });
+            });
+        }
+    }
+
+    /** @internal */
+    class WTTracker {
+        constructor() {
+            this.isRunning = false;
+            this.initialized = false;
+        }
+        get isEnabled() {
+            return storageManager.sdkEnabled;
+        }
+        initialize() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.getCountryCode();
+                yield this.setActivityTimes();
+                this.createDeviceID();
+                this.addObservers();
+                this.initialized = true;
+            });
+        }
+        startTracking() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isEnabled) {
+                    WTLogger.warn("SDK is not enabled to start tracking!");
+                    return;
+                }
+                WTLogger.debug("WT Tracker started");
+                yield queueManager.initialize();
+                yield this.checkSdkClicks();
+                yield this.checkFirstSession();
+                yield this.createAttribution();
+                this.isRunning = true;
+            });
+        }
+        stopTracking() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.isRunning = false;
+                activityTicker.stop();
+                yield queueManager.shutdown();
+                WTLogger.debug("WT Tracker stopped");
+            });
+        }
+        checkPushToken(token) {
+            return __awaiter(this, void 0, void 0, function* () {
+                storageManager.pushToken = token;
+                if (!this.isEnabled) {
+                    WTLogger.warn("CheckPushToken: SDK is not enabled");
+                    return;
+                }
+                if (storageManager.fcmToken === token) {
+                    WTLogger.info("This Notification token has sent to server previously");
+                    return;
+                }
+                yield this.createRequest({
+                    endpoint: WTEndpoints.SDK_INFOS,
+                    queueType: "pending",
+                });
+            });
+        }
+        trackEvent(event) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isEnabled) {
+                    WTLogger.warn("trackEvent: SDK is not enabled");
+                    return;
+                }
+                if (!this.initialized) {
+                    WTLogger.warn("trackEvent: SDK is not initialized yet");
+                    return;
+                }
+                storageManager.eventCount += 1;
+                yield this.createRequest({
+                    endpoint: WTEndpoints.EVENTS,
+                    fBuilder: new EventFieldsBuilder(event),
+                    queueType: "pending",
+                });
+            });
+        }
+        // =======================================================================
+        getCountryCode() {
+            countryFinder.getCountryCode();
+        }
+        createAttribution() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isEnabled) {
+                    WTLogger.warn("Creating Attribution: SDK is not enabled!");
+                    return;
+                }
+                yield this.createRequest({
+                    endpoint: WTEndpoints.ATTRIBUTIONS,
+                    queueType: "pending",
+                });
+            });
+        }
+        checkFirstSession() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isEnabled) {
+                    WTLogger.warn("Creating First Session: SDK is not enabled!");
+                    return;
+                }
+                if (storageManager.firstSessionSubmit) {
+                    WTLogger.debug("Creating Session: First-Session has already submitted");
+                    return;
+                }
+                yield this.createRequest({
+                    endpoint: WTEndpoints.SESSIONS,
+                    queueType: storageManager.sdkClickSubmit ? "main" : "pending",
+                });
+            });
+        }
+        checkSdkClicks() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isEnabled) {
+                    WTLogger.warn("Creating Install: SDK is not enabled!");
+                    return;
+                }
+                if (storageManager.sdkClickSubmit) {
+                    WTLogger.debug("Creating Install: SDK-Clicks has already submitted");
+                    return;
+                }
+                yield this.createRequest({
+                    endpoint: WTEndpoints.SDK_CLICKS,
+                });
+            });
+        }
+        createRequest(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ endpoint, fBuilder = fieldsBuilder, queueType = "main", }) {
+                const fields = yield fBuilder.build();
+                const request = new RequestRecord(endpoint, fields);
+                if (queueType === "pending") {
+                    WTLogger.info(`Add ${endpoint} request to pending queue`);
+                    yield queueManager.addPendingRequest(request);
+                }
+                else {
+                    WTLogger.info(`Add ${endpoint} request to main queue`);
+                    yield queueManager.addRequest(request);
+                }
+                const queueStatus = queueManager.getQueueStatus();
+                console.log(JSON.stringify(queueStatus));
+            });
+        }
+        createDeviceID() {
+            if (!storageManager.deviceId) {
+                storageManager.deviceId = cryptoHelper.generateDeviceUUID();
+            }
+            if (!storageManager.initialDate) {
+                storageManager.initialDate = new Date().toISOString();
+            }
+        }
+        setActivityTimes() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Update inactive time to last stored active time
+                if (storageManager.activeTime) {
+                    storageManager.inactiveTime = storageManager.activeTime;
+                    const inteval = Date.now() - storageManager.inactiveTime;
+                    storageManager.inactiveDuration += inteval;
+                    console.log(`User was inactived for ${inteval / 1000}s | (${storageManager.inactiveDuration / 1000}s Totaly)`);
+                    yield this.checkSessionIntervals();
+                }
+                // update active time to now and start ticker for update active time/duration per 1s
+                storageManager.activeTime = Date.now();
+                activityTicker.start();
+            });
+        }
+        checkSessionIntervals() {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const inactiveTime = storageManager.inactiveTime;
+                const sessionInterval = (_a = storageManager.appSettings) === null || _a === void 0 ? void 0 : _a.sessionInterval;
+                const subsessionInterval = (_b = storageManager.appSettings) === null || _b === void 0 ? void 0 : _b.subsessionInterval;
+                if (!this.isEnabled) {
+                    WTLogger.warn("Creating Session: SDK is not enabled!");
+                    return;
+                }
+                if (!inactiveTime || !sessionInterval || !subsessionInterval) {
+                    return;
+                }
+                const interval = Date.now() - inactiveTime;
+                if (interval > parseInt(sessionInterval)) {
+                    storageManager.sessionCount += 1;
+                    yield this.createRequest({
+                        endpoint: WTEndpoints.SESSIONS,
+                        queueType: storageManager.sdkClickSubmit ? "main" : "pending",
+                    });
+                }
+                else if (interval > parseInt(subsessionInterval)) {
+                    storageManager.subSessionCount += 1;
+                }
+            });
+        }
+        isVisibleFocused() {
+            return document.visibilityState === "visible" && document.hasFocus();
+        }
+        addObservers() {
+            // document.addEventListener("load", () => {
+            //   this.setActivityTimes();
+            // });
+            window.addEventListener("beforeunload", () => {
+                activityTicker.stop();
+            });
+            document.addEventListener("visibilitychange", () => {
+                if (this.isVisibleFocused()) {
+                    this.createAttribution();
+                    this.setActivityTimes();
+                }
+                else {
+                    activityTicker.stop();
+                }
+            });
+            window.addEventListener("focus", () => {
+                if (this.isVisibleFocused()) {
+                    this.createAttribution();
+                    this.setActivityTimes();
+                }
+            });
+            window.addEventListener("blur", () => {
+                activityTicker.stop();
+            });
+        }
+    }
+    /** @internal */
+    const tracker = new WTTracker();
+
+    /**
+     * The main entry point for the WiseTrack Web SDK.
+     *
+     * Use this singleton to initialize the SDK, configure its behavior, and track events.
+     *
+     * @example
+     * ```ts
+     * const initialConfig: WTInitialConfig = {
+     *  appToken: appToken ?? "rMN5ZCwpOzY7",
+     *  appFrameWork: "native",
+     *  appVersion: "1.0.0",
+     * };
+     * await WiseTrack.instance.init(initialConfig);
+     * ```
+     */
+    class WiseTrack {
+        /**
+         * Returns the singleton instance of the WiseTrack SDK.
+         */
+        static get instance() {
+            if (!WiseTrack._instance) {
+                WiseTrack._instance = new WiseTrack();
+            }
+            return WiseTrack._instance;
+        }
+        constructor() {
+            this.sdkInitialized = false;
+        }
+        /**
+         * Initializes the WiseTrack SDK with the given configuration.
+         *
+         * This method must be called before using any tracking features.
+         *
+         * @param initConfig - The initial configuration object.
+         *
+         * @example
+         * ```ts
+         * const initialConfig: WTInitialConfig = {
+         *  appToken: appToken ?? "rMN5ZCwpOzY7",
+         *  appFrameWork: "native", // your current web app framework (native, reactjs, nextjs, ...)
+         *  appVersion: "1.0.0", // your current web app version
+         * };
+         *
+         * ```
+         */
+        init(initConfig) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const config = yield this.getConfig(initConfig);
+                this.checkSdkEnabled(config);
+                this.checkSdkUpdate(config);
+                this.setEnabled(true);
+                yield this.updateAppSettings(config);
+                this.sdkInitialized = true;
+                yield tracker.initialize();
+                const autoStart = (_a = initConfig.startTrackerAutomatically) !== null && _a !== void 0 ? _a : true;
+                if (autoStart) {
+                    setTimeout(() => this.startTracking(), ((_b = initConfig.trackingWaitingTime) !== null && _b !== void 0 ? _b : 0) * 1000);
+                }
+            });
+        }
+        /**
+         * Sets the log level for internal SDK logging.
+         *
+         * @param level - The desired log level.
+         *
+         * @example
+         * ```ts
+         * WiseTrack.instance.setLogLevel(WTLogLevel.WARN)
+         * // or
+         * WiseTrack.instance.setLogLevel("warn")
+         *
+         * ```
+         */
+        setLogLevel(level) {
+            WTLogger.setLevel(level);
+        }
+        /**
+         * Clears all stored data and stops the tracker.
+         */
+        flush() {
+            WTLogger.info("Clearing Data and stop tracker!");
+            storageManager.clear();
+            this.stopTracking();
+        }
+        /**
+         * Returns whether the SDK is currently enabled.
+         */
+        isEnabled() {
+            return storageManager.sdkEnabled;
+        }
+        /**
+         * Enables or disables the SDK.
+         *
+         * Throws an error if the SDK is disabled by the server or needs an update.
+         *
+         * @param enabled - Whether to enable the SDK.
+         * @throws If the server has disabled the SDK or a forced update is required.
+         */
+        setEnabled(enabled) {
+            const config = storageManager.config;
+            if (!config) {
+                throw new Error("Config is not set!");
+            }
+            if (!config.sdkEnabled) {
+                throw new Error("SDK is disabled form server, contact your adminstrator!");
+            }
+            if (config.forceUpdate) {
+                throw new Error("The version you are currently using has expired and is no longer supported. Please update to the latest version to continue using the SDK");
+            }
+            storageManager.sdkEnabled = enabled;
+        }
+        /**
+         * Starts the tracking process.
+         *
+         * @remarks
+         * The SDK must be initialized and enabled before calling this method.
+         *
+         * NOTE: call this method just if you set startTrackerAutomatically=false in WTInitialConfig
+         */
+        startTracking() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.sdkInitialized) {
+                    WTLogger.warn("‼️ Start Tracking: SDK is not initialized yet");
+                    return;
+                }
+                if (!this.isEnabled()) {
+                    WTLogger.warn("Start Tracking: SDK is not enabled!");
+                    return;
+                }
+                yield tracker.startTracking();
+            });
+        }
+        /**
+         * Stops the tracking process.
+         */
+        stopTracking() {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield tracker.stopTracking();
+            });
+        }
+        /**
+         * Sets the Firebase Cloud Messaging (FCM) push token for server.
+         *
+         * @param token - The FCM token.
+         */
+        setFCMToken(token) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.sdkInitialized) {
+                    WTLogger.warn("‼️ Set Fcm Token: SDK is not initialized yet");
+                    return;
+                }
+                if (!this.isEnabled()) {
+                    WTLogger.warn("Set Fcm Token: SDK is not enabled!");
+                    return;
+                }
+                yield tracker.checkPushToken(token);
+            });
+        }
+        /**
+         * Tracks a custom event or revenue event.
+         *
+         * @param event - The event object to be tracked.
+         *
+         * @example
+         * ```ts
+         * // Create a Default Event
+         * const defaultEvent = new WTEvent.Default("default-event");
+         * defaultEvent.addParam("key1", "value1");
+         * defaultEvent.addParam("key2", 123);
+         * defaultEvent.addParam("key3", true);
+         * await WiseTrack.instance.trackEvent(defaultEvent);
+         *
+         * // Create a Revenue Event
+         * const revenueEvent = new WTEvent.Revenue("revenue-event", 100, "USD");
+         * revenueEvent.addParam("item_id", "item123");
+         * revenueEvent.addParam("quantity", 2);
+         * await WiseTrack.instance.trackEvent(revenueEvent);
+         * ```
+         */
+        trackEvent(event) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.sdkInitialized) {
+                    WTLogger.warn("‼️ Track Event: SDK is not initialized yet");
+                    return;
+                }
+                if (!this.isEnabled()) {
+                    WTLogger.warn("Track Event: SDK is not enabled!");
+                    return;
+                }
+                yield tracker.trackEvent(event);
+            });
+        }
+        // ===========================================================================
+        /** @internal */
+        getConfig(initConfig) {
+            return __awaiter(this, void 0, void 0, function* () {
+                storageManager.initialConfig = initConfig;
+                let config;
+                try {
+                    config = yield apiClient.doGetConfig();
+                }
+                catch (error) {
+                    if (!(error instanceof ApiError.NetworkError)) {
+                        WTLogger.info("‼️ SDK Config NOT set!, check errors.");
+                        throw error;
+                    }
+                    config = storageManager.config || WTConfig.defaultValue;
+                }
+                storageManager.config = config;
+                WTLogger.info("SDK Config set");
+                return config;
+            });
+        }
+        /** @internal */
+        updateAppSettings(config) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let appSettings;
+                if (!EnvironmentUtils.needAppSettings()) {
+                    appSettings = WTAppSettings.fromConfig(config);
+                }
+                else {
+                    WTLogger.debug(`Need to get app-settings for ${EnvironmentUtils.sdkEnvironment} environment`);
+                    try {
+                        appSettings = yield apiClient.doGetAppSettings();
+                    }
+                    catch (error) {
+                        if (!(error instanceof ApiError.NetworkError)) {
+                            WTLogger.info("‼️ App Settings NOT set!, check errors.");
+                            throw error;
+                        }
+                        appSettings = WTAppSettings.defaultValue;
+                    }
+                }
+                storageManager.appSettings = appSettings;
+                WTLogger.info("App Settings set");
+                return appSettings;
+            });
+        }
+        /** @internal */
+        checkSdkEnabled(config) {
+            if (!config.sdkEnabled) {
+                const message = "SDK is disabled form server, contact your adminstrator!";
+                WTLogger.error(message);
+                throw new Error(message);
+            }
+        }
+        /** @internal */
+        checkSdkUpdate(config) {
+            if (config.forceUpdate) {
+                const message = "The version you are currently using has expired and is no longer supported. Please update to the latest version to continue using the SDK";
+                WTLogger.error(message);
+                throw new Error(message);
+            }
+            if (config.sdkUpdate) {
+                WTLogger.warn("A new version of the SDK is available. It is recommended to update to the latest version to enjoy improved features and better performance.");
+            }
+        }
+    }
+
+    exports.WTEvent = void 0;
+    (function (WTEvent) {
+        /**
+         * Represents a generic custom event.
+         *
+         * Use this class to log custom actions performed by the user.
+         *
+         * @example
+         * ```ts
+         * const event = new WTEvent.Default("signup");
+         * event.addParam("method", "Google");
+         * WiseTrack.instance.trackEvent(event);
+         * ```
+         */
+        class Default {
+            /**
+             * Creates a new custom event.
+             * @param name - The name of the event.
+             */
+            constructor(name) {
+                /**
+                 * The type of event.
+                 * @internal
+                 */
+                this.type = "default";
+                this.name = name;
+            }
+            /**
+             * Adds a parameter to the event.
+             *
+             * @param key - The parameter key.
+             * @param value - The parameter value.
+             */
+            addParam(key, value) {
+                var _a;
+                let _params = (_a = this.params) !== null && _a !== void 0 ? _a : {};
+                _params[key] = value;
+                this.params = _params;
+            }
+            /** @internal */
+            toJSON() {
+                return {
+                    event_type: this.type,
+                    event_name: this.name,
+                    partner_params: this.params,
+                };
+            }
+        }
+        WTEvent.Default = Default;
+        /**
+         * Represents a revenue event with an amount and currency.
+         *
+         * Use this class to log purchases or monetary transactions.
+         *
+         * @example
+         * ```ts
+         * const purchase = new WTEvent.Revenue("order_complete", 49.99, RevenueCurrency.USD);
+         * purchase.addParam("item_count", "3");
+         * WiseTrack.instance.trackEvent(purchase);
+         * ```
+         */
+        class Revenue extends Default {
+            /**
+             * Creates a new revenue event.
+             *
+             * @param name - The name of the revenue event.
+             * @param amount - The amount of revenue.
+             * @param currency - The currency of the revenue.
+             */
+            constructor(name, amount, currency) {
+                super(name);
+                /**
+                 * The type of event.
+                 * @internal
+                 */
+                this.type = "revenue";
+                this.amount = amount;
+                this.currency = currency;
+            }
+            /** @internal */
+            toJSON() {
+                return {
+                    event_type: this.type,
+                    event_name: this.name,
+                    revenue: this.amount,
+                    currency: this.currency,
+                    partner_params: this.params,
+                };
+            }
+        }
+        WTEvent.Revenue = Revenue;
+    })(exports.WTEvent || (exports.WTEvent = {}));
+
+    exports.WTLogEngine = WTLogEngine;
+    exports.WTLogLevel = WTLogLevel;
+    exports.WTLogger = WTLogger;
+    exports.WiseTrack = WiseTrack;
+
+    return exports;
+
+})({});
+//# sourceMappingURL=sdk.bundle.js.map