wisetrack 2.0.0

package/dist/cjs/index.js

@@ -0,0 +1,3599 @@
+'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;
+//# sourceMappingURL=index.js.map