native-fn/dist/plugin/appearance/index.mjs

var Appearances;
(function (Appearances) {
    Appearances["Unknown"] = "unknown";
    Appearances["Light"] = "light";
    Appearances["Dark"] = "dark";
})(Appearances || (Appearances = {}));
var FALLBACK_MEDIA_QUERY_LIST = {
    matches: false,
    media: 'not all',
    onchange: null,
    addListener: function () {
    },
    removeListener: function () {
    },
    addEventListener: function () {
    },
    removeEventListener: function () {
    },
    dispatchEvent: function () {
        return false;
    },
};
var MEDIA_QUERY_LIST = typeof globalThis.matchMedia !== 'undefined' ? globalThis.matchMedia('(prefers-color-scheme: dark)') : FALLBACK_MEDIA_QUERY_LIST;
var SUPPORT_PREFERS_COLOR_SCHEME = MEDIA_QUERY_LIST.media !== 'not all';
var CONTEXT = 'document' in globalThis ? globalThis.document.createElement('canvas').getContext('2d', { willReadFrequently: true }) : null;
var SVG_PIXEL_DATA_URL = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxIiBoZWlnaHQ9IjEiPjxwYXRoIGZpbGw9IiNmZmYiIGQ9Ik0wIDBoMXYxSDB6Ii8+PC9zdmc+';
var ENTRIES = [];

function compareVersion(lhs, rhs) {
    var pa = lhs.split('.');
    var pb = rhs.split('.');
    var length = Math.max(pa.length, pb.length);
    for (var i = 0; i < length; i++) {
        var a = void 0;
        var b = void 0;
        if (i < pa.length)
            a = parseInt(pa[i], 10);
        else
            a = 0;
        if (i < pb.length)
            b = parseInt(pb[i], 10);
        else
            b = 0;
        if (a > b)
            return 1;
        if (a < b)
            return -1;
    }
    return 0;
}

var OS;
(function (OS) {
    OS["Unknown"] = "Unknown";
    OS["Android"] = "Android";
    OS["iOS"] = "iOS";
    OS["Windows"] = "Windows";
    OS["MacOS"] = "MacOS";
})(OS || (OS = {}));
var Devices;
(function (Devices) {
    Devices["Unknown"] = "Unknown";
    Devices["Mobile"] = "Mobile";
    Devices["Desktop"] = "Desktop";
})(Devices || (Devices = {}));
var Engines;
(function (Engines) {
    Engines["Unknown"] = "Unknown";
    Engines["EdgeHTML"] = "EdgeHTML";
    Engines["ArkWeb"] = "ArkWeb";
    Engines["Blink"] = "Blink";
    Engines["Presto"] = "Presto";
    Engines["WebKit"] = "WebKit";
    Engines["Trident"] = "Trident";
    Engines["NetFront"] = "NetFront";
    Engines["KHTML"] = "KHTML";
    Engines["Tasman"] = "Tasman";
    Engines["Gecko"] = "Gecko";
})(Engines || (Engines = {}));
var Browsers;
(function (Browsers) {
    Browsers["Unknown"] = "Unknown";
    Browsers["Chrome"] = "Chrome";
    Browsers["Safari"] = "Safari";
    Browsers["Edge"] = "Edge";
    Browsers["Firefox"] = "Firefox";
    Browsers["Opera"] = "Opera";
    Browsers["IE"] = "IE";
    Browsers["SamsungInternet"] = "SamsungInternet";
})(Browsers || (Browsers = {}));
var CrossPlatformFramework;
(function (CrossPlatformFramework) {
    CrossPlatformFramework["Unknown"] = "Unknown";
    CrossPlatformFramework["ReactNative"] = "ReactNative";
    CrossPlatformFramework["Electron"] = "Electron";
    CrossPlatformFramework["Cordova"] = "Cordova";
})(CrossPlatformFramework || (CrossPlatformFramework = {}));
var USER_AGENT = typeof globalThis.navigator !== 'undefined' && typeof globalThis.navigator.userAgent === 'string' ? globalThis.navigator.userAgent : '';
var HIGH_ENTROPY_BRAND_NAME_MAP = {
    'Google Chrome': 'Chrome',
    'Microsoft Edge': 'Edge',
    'Microsoft Edge WebView2': 'Edge WebView2',
    'Android WebView': 'Chrome WebView',
    'HeadlessChrome': 'Chrome Headless',
    'OperaMobile': 'Opera Mobi',
};

var readyState = 'loading';
var readyCallback = [];
var pendingTasks = 0;
var Platform = {
    os: { name: OS.Unknown, version: '' },
    engine: { name: Engines.Unknown, version: '' },
    browser: { name: Browsers.Unknown, version: '' },
    crossPlatformFramework: CrossPlatformFramework.Unknown,
    userAgent: USER_AGENT,
    get readyState() {
        return readyState;
    },
    get locale() {
        return getLocale();
    },
    get device() {
        if (this.os.name === OS.iOS || this.os.name === OS.Android)
            return Devices.Mobile;
        if (this.os.name === OS.Windows || this.os.name === OS.MacOS)
            return Devices.Desktop;
        return Devices.Unknown;
    },
    get renderer() {
        return getRenderer();
    },
    get isWebview() {
        return /; ?wv|applewebkit(?!.*safari)/i.test(this.userAgent);
    },
    get isNode() {
        return typeof globalThis.process !== 'undefined' && typeof globalThis.process.versions !== 'undefined' && typeof globalThis.process.versions.node !== 'undefined';
    },
    get isStandalone() {
        if (this.os.name === OS.iOS)
            return 'standalone' in globalThis.navigator && !!globalThis.navigator.standalone;
        if (!('matchMedia' in globalThis))
            return false;
        return globalThis.matchMedia('(display-mode: standalone)').matches;
    },
    onready: function (callback) {
        if (this.readyState === 'complete') {
            try {
                callback(this);
            }
            catch (_) {
            }
        }
        else {
            readyCallback.push(callback);
        }
    }
};
function resolveWindowsVersion(string) {
    if (typeof string === 'undefined')
        return '';
    var mapped = {
        '4.90': 'ME',
        'NT3.51': 'NT 3.11',
        'NT4.0': 'NT 4.0',
        'NT 5.0': '2000',
        'NT 5.1': 'XP',
        'NT 5.2': 'XP',
        'NT 6.0': 'Vista',
        'NT 6.1': '7',
        'NT 6.2': '8',
        'NT 6.3': '8.1',
        'NT 6.4': '10',
        'NT 10.0': '10',
        'ARM': 'RT'
    }[string];
    if (typeof mapped !== 'undefined')
        return mapped;
    return string;
}
function resolveUnderscoreVersion(string) {
    if (typeof string === 'undefined')
        return '';
    return string.replace(/_/g, '.');
}
var OS_RESOLVER_MAP = [
    [/windows nt (6\.[23]); arm/i, OS.Windows, resolveWindowsVersion],
    [/windows (?:phone|mobile|iot)(?: os)?[\/ ]?([\d.]*( se)?)/i, OS.Windows, resolveWindowsVersion],
    [/windows[\/ ](1[01]|2000|3\.1|7|8(\.1)?|9[58]|me|server 20\d\d( r2)?|vista|xp)/i, OS.Windows, resolveWindowsVersion],
    [/windows nt ?([\d.)]*)(?!.+xbox)/i, OS.Windows, resolveWindowsVersion],
    [/\bwin(?=3| ?9|n)(?:nt| 9x )?([\d.;]*)/i, OS.Windows, resolveWindowsVersion],
    [/windows ce\/?([\d.]*)/i, OS.Windows, resolveWindowsVersion],
    [/[adehimnop]{4,7}\b(?:.*os (\w+) like mac|; opera)/i, OS.iOS, resolveUnderscoreVersion],
    [/(?:ios;fbsv|ios(?=.+ip(?:ad|hone))|ip(?:ad|hone)(?: |.+i(?:pad)?)os)[\/ ]([\w.]+)/i, OS.iOS, resolveUnderscoreVersion],
    [/cfnetwork\/.+darwin/i, OS.iOS, resolveUnderscoreVersion],
    [/mac os x ?([\w. ]*)/i, OS.MacOS, resolveUnderscoreVersion],
    [/(?:macintosh|mac_powerpc\b)(?!.+(haiku|morphos))/i, OS.MacOS, resolveUnderscoreVersion],
    [/droid ([\w.]+)\b.+(android[- ]x86)/i, OS.Android],
    [/android\w*[-\/.; ]?([\d.]*)/i, OS.Android],
];
var ENGINE_RESOLVER_MAP = [
    [/windows.+ edge\/([\w.]+)/i, Engines.EdgeHTML],
    [/arkweb\/([\w.]+)/i, Engines.ArkWeb],
    [/webkit\/537\.36.+chrome\/(?!27)([\w.]+)/i, Engines.Blink],
    [/presto\/([\w.]+)/i, Engines.Presto],
    [/webkit\/([\w.]+)/i, Engines.WebKit],
    [/trident\/([\w.]+)/i, Engines.Trident],
    [/netfront\/([\w.]+)/i, Engines.NetFront],
    [/khtml[\/ ]\(?([\w.]+)/i, Engines.KHTML],
    [/tasman[\/ ]\(?([\w.]+)/i, Engines.Tasman],
    [/rv:([\w.]{1,9})\b.+gecko/i, Engines.Gecko]
];
var BROWSER_RESOLVER_MAP = [
    [/\b(?:crmo|crios)\/([\w.]+)/i, Browsers.Chrome],
    [/webview.+edge\/([\w.]+)/i, Browsers.Edge],
    [/edg(?:e|ios|a)?\/([\w.]+)/i, Browsers.Edge],
    [/opera mini\/([-\w.]+)/i, Browsers.Opera],
    [/opera [mobileta]{3,6}\b.+version\/([-\w.]+)/i, Browsers.Opera],
    [/opera(?:.+version\/|[\/ ]+)([\w.]+)/i, Browsers.Opera],
    [/opios[\/ ]+([\w.]+)/i, Browsers.Opera],
    [/\bop(?:rg)?x\/([\w.]+)/i, Browsers.Opera],
    [/\bopr\/([\w.]+)/i, Browsers.Opera],
    [/iemobile(?:browser|boat|jet)[\/ ]?([\d.]*)/i, Browsers.IE],
    [/(?:ms|\()ie ([\w.]+)/i, Browsers.IE],
    [/trident.+rv[: ]([\w.]{1,9})\b.+like gecko/i, Browsers.IE],
    [/\bfocus\/([\w.]+)/i, Browsers.Firefox],
    [/\bopt\/([\w.]+)/i, Browsers.Opera],
    [/coast\/([\w.]+)/i, Browsers.Opera],
    [/fxios\/([\w.-]+)/i, Browsers.Firefox],
    [/samsungbrowser\/([\w.]+)/i, Browsers.SamsungInternet],
    [/headlesschrome(?:\/([\w.]+)| )/i, Browsers.Chrome],
    [/wv\).+chrome\/([\w.]+).+edgw\//i, Browsers.Edge],
    [/ wv\).+(chrome)\/([\w.]+)/i, Browsers.Chrome],
    [/chrome\/([\w.]+) mobile/i, Browsers.Chrome],
    [/chrome\/v?([\w.]+)/i, Browsers.Chrome],
    [/version\/([\w.,]+) .*mobile(?:\/\w+ | ?)safari/i, Browsers.Safari],
    [/iphone .*mobile(?:\/\w+ | ?)safari/i, Browsers.Safari],
    [/version\/([\w.,]+) .*safari/i, Browsers.Safari],
    [/webkit.+?(?:mobile ?safari|safari)(\/[\w.]+)/i, Browsers.Safari, '1'],
    [/(?:mobile|tablet);.*firefox\/([\w.-]+)/i, Browsers.Firefox],
    [/mobile vr; rv:([\w.]+)\).+firefox/i, Browsers.Firefox],
    [/firefox\/([\w.]+)/i, Browsers.Firefox],
];
function incrementPendingTasks() {
    pendingTasks++;
}
function decrementPendingTasks() {
    pendingTasks--;
    checkReady();
}
function checkReady() {
    if (pendingTasks === 0 && readyState === 'loading') {
        readyState = 'complete';
        for (var i = 0; i < readyCallback.length; i++) {
            try {
                readyCallback[i](Platform);
            }
            catch (_) {
            }
        }
        readyCallback.length = 0;
    }
}
function resolveSemanticWindowsVersion(version, defaultValue) {
    if (version.major === 10 && version.minor === 0 && version.build >= 22000)
        return '11';
    if (version.major === 10 && version.minor === 0 && version.build < 22000)
        return '10';
    if (version.major === 6 && version.minor === 3)
        return '8.1';
    if (version.major === 6 && version.minor === 2)
        return '8';
    if (version.major === 6 && version.minor === 1)
        return '7';
    if (version.major === 6 && version.minor === 0)
        return 'Vista';
    if (version.major === 5 && version.minor === 1)
        return 'XP';
    if (version.major === 5 && version.minor === 2)
        return 'XP';
    if (version.major === 5 && version.minor === 0)
        return '2000';
    if (version.major === 4 && version.minor === 90)
        return 'ME';
    if (version.major === 4 && version.minor === 0)
        return 'NT 4.0';
    if (version.major === 3 && version.minor === 51)
        return 'NT 3.11';
    return defaultValue;
}
function resolveSemanticDarwinVersion(version, defaultValue) {
    if (version.major >= 24)
        return '' + (version.major - 9) + '.' + version.minor + '.' + version.build;
    if (version.major === 23)
        return '14.' + version.minor + '.' + version.build;
    if (version.major === 22)
        return '13.' + version.minor + '.' + version.build;
    if (version.major === 21)
        return '12.' + version.minor + '.' + version.build;
    if (version.major === 20)
        return '11.' + version.minor + '.' + version.build;
    if (version.major === 19)
        return '10.15.' + version.minor;
    if (version.major === 18)
        return '10.14.' + version.minor;
    if (version.major === 17)
        return '10.13.' + version.minor;
    if (version.major === 16)
        return '10.12.' + version.minor;
    if (version.major === 15)
        return '10.11.' + version.minor;
    if (version.major === 14)
        return '10.10.' + version.minor;
    if (version.major === 13)
        return '10.9.' + version.minor;
    if (version.major >= 5 && version.major <= 12)
        return '10.' + (version.major - 4) + '.' + version.minor;
    return defaultValue;
}
function resolveSemanticAndroidVersion(version, defaultValue) {
    if (version.major >= 36)
        return '16';
    if (version.major === 35)
        return '15';
    if (version.major === 34)
        return '14';
    if (version.major === 33)
        return '13';
    if (version.major === 32)
        return '12.1';
    if (version.major === 31)
        return '12';
    if (version.major === 30)
        return '11';
    if (version.major === 29)
        return '10';
    if (version.major === 28)
        return '9';
    if (version.major === 27)
        return '8.1';
    if (version.major === 26)
        return '8.0';
    if (version.major === 25)
        return '7.1';
    if (version.major === 24)
        return '7.0';
    if (version.major === 23)
        return '6.0';
    if (version.major === 22)
        return '5.1';
    if (version.major === 21)
        return '5.0';
    if (version.major === 20)
        return '4.4';
    if (version.major === 19)
        return '4.4';
    if (version.major === 18)
        return '4.3';
    if (version.major === 17)
        return '4.2';
    if (version.major === 16)
        return '4.1';
    if (version.major === 15)
        return '4.0.3';
    if (version.major === 14)
        return '4.0';
    if (version.major === 13)
        return '3.2';
    if (version.major === 12)
        return '3.1';
    if (version.major === 11)
        return '3.0';
    if (version.major === 10)
        return '2.3.3';
    if (version.major === 9)
        return '2.3';
    if (version.major === 8)
        return '2.2';
    if (version.major === 7)
        return '2.1';
    if (version.major === 6)
        return '2.0.1';
    if (version.major === 5)
        return '2.0';
    if (version.major === 4)
        return '1.6';
    if (version.major === 3)
        return '1.5';
    if (version.major === 2)
        return '1.1';
    if (version.major === 1)
        return '1.0';
    return defaultValue;
}
function resolveVersion(string, resolver) {
    if (typeof resolver === 'function')
        return resolver(string);
    if (typeof resolver === 'string')
        return resolver;
    if (typeof string === 'undefined')
        return '';
    return string;
}
function normalizeBrand(entry) {
    if (entry === null || typeof entry === 'undefined')
        return { brand: '', version: '' };
    if (typeof entry === 'string')
        return { brand: entry, version: '' };
    return { brand: entry.brand, version: entry.version };
}
function getSemanticVersion(string) {
    var parts = string.split('.');
    return {
        major: parseInt(parts[0] || '0'),
        minor: parseInt(parts[1] || '0'),
        build: parseInt(parts[2] || '0')
    };
}
function parseOSFromCordova() {
    Platform.crossPlatformFramework = CrossPlatformFramework.Cordova;
    if (typeof globalThis.device !== 'undefined') {
        switch (globalThis.device.platform) {
            case 'Android':
                Platform.os = {
                    name: OS.Android,
                    version: globalThis.device.version,
                };
                break;
            case 'iOS':
                Platform.os = {
                    name: OS.iOS,
                    version: globalThis.device.version,
                };
                break;
        }
    }
    decrementPendingTasks();
}
function getRenderer() {
    if (typeof globalThis.document === 'undefined')
        return '';
    var canvas = globalThis.document.createElement('canvas');
    if (typeof canvas.getContext !== 'function')
        return '';
    var context = canvas.getContext('webgl2') || canvas.getContext('experimental-webgl') || canvas.getContext('webgl');
    if (context === null)
        return '';
    if (context instanceof WebGLRenderingContext || 'getParameter' in context && typeof context.getParameter === 'function') {
        var extension = context.getExtension('WEBGL_debug_renderer_info');
        if (extension === null)
            return context.getParameter(context.RENDERER);
        else
            return context.getParameter(extension.UNMASKED_RENDERER_WEBGL);
    }
    else {
        return '';
    }
}
function normalizeLocale(locale) {
    if (locale === null || typeof locale === 'undefined')
        return locale;
    if (locale.length === 0)
        return null;
    locale = locale.replace(/_/g, '-');
    if (locale === 'C' || locale.toLowerCase() === 'posix')
        return 'en-US';
    if (locale.indexOf('.') !== -1)
        return normalizeLocale(locale.split('.')[0]);
    if (locale.indexOf('@') !== -1)
        return normalizeLocale(locale.split('@')[0]);
    var parts = locale.split('-');
    if (parts.length === 0)
        return null;
    parts[0] = parts[0].toLowerCase();
    if (parts.length > 1 && parts[1].length === 2)
        parts[1] = parts[1].toUpperCase();
    if (parts.length > 2 && parts[1].length === 4)
        parts[1] = parts[1].charAt(0).toUpperCase() + parts[1].slice(1).toLowerCase();
    return parts.join('-');
}
function getLocale() {
    var locale = {
        language: null,
        languages: [],
        timezone: null,
        timezoneOffset: 0,
    };
    function addLanguages(language) {
        for (var i = 0; i < language.length; i++)
            addLanguage(language[i]);
    }
    function addLanguage(language) {
        language = normalizeLocale(language);
        if (typeof language === "string" && locale.languages.indexOf(language) === -1) {
            if (locale.language === null)
                locale.language = language;
            locale.languages.push(language);
        }
    }
    if (Platform.crossPlatformFramework === CrossPlatformFramework.ReactNative) {
        try {
            var reactNative = require('react-native');
            var nativeModules = reactNative.NativeModules;
            if (typeof nativeModules.SettingsManager !== 'undefined') {
                var settingManager = nativeModules.SettingsManager;
                if (typeof settingManager !== 'undefined') {
                    var constant = typeof settingManager.getConstants === 'function'
                        ? settingManager.getConstants()
                        : settingManager;
                    if (typeof constant !== 'undefined' && typeof constant.settings !== 'undefined') {
                        var settings = constant.settings;
                        if (typeof settings.AppleLocale === 'string')
                            addLanguage(settings.AppleLocale);
                        if (Array.isArray(settings.AppleLanguages) && settings.AppleLanguages.length > 0)
                            addLanguages(settings.AppleLanguages);
                    }
                }
            }
            if (typeof nativeModules.I18nManager !== 'undefined') {
                var i18nManager = nativeModules.I18nManager;
                if (typeof i18nManager !== 'undefined') {
                    var constant = typeof i18nManager.getConstants === 'function'
                        ? i18nManager.getConstants()
                        : i18nManager;
                    if (typeof constant !== 'undefined' && typeof constant.localeIdentifier !== 'undefined')
                        addLanguage(constant.localeIdentifier);
                }
            }
        }
        catch (_) {
        }
    }
    if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron) {
        try {
            var electron = require('electron');
            var app = electron.app;
            if (typeof app.getLocale !== 'undefined')
                addLanguage(app.getLocale());
            if (typeof app.getSystemLocale !== 'undefined')
                addLanguage(app.getSystemLocale());
            if (typeof app.getPreferredSystemLanguages !== 'undefined')
                addLanguages(app.getPreferredSystemLanguages());
        }
        catch (_) {
        }
    }
    if (typeof Intl !== 'undefined') {
        try {
            addLanguage(Intl.DateTimeFormat().resolvedOptions().locale);
        }
        catch (_) {
        }
        try {
            locale.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
        }
        catch (_) {
        }
    }
    if (typeof globalThis.navigator !== 'undefined') {
        if (typeof globalThis.navigator.languages !== 'undefined')
            addLanguages(globalThis.navigator.languages);
        if (typeof globalThis.navigator.language !== 'undefined')
            addLanguage(globalThis.navigator.language);
        if (typeof globalThis.navigator.userLanguage !== 'undefined')
            addLanguage(globalThis.navigator.userLanguage);
        if (typeof globalThis.navigator.browserLanguage !== 'undefined')
            addLanguage(globalThis.navigator.browserLanguage);
        if (typeof globalThis.navigator.systemLanguage !== 'undefined')
            addLanguage(globalThis.navigator.systemLanguage);
    }
    try {
        locale.timezoneOffset = new Date().getTimezoneOffset();
    }
    catch (_) {
    }
    return locale;
}
function init() {
    if ((typeof globalThis.process !== 'undefined' && typeof globalThis.process.versions !== 'undefined' && typeof globalThis.process.versions.electron !== 'undefined') || (/ electron\//i.test(USER_AGENT)))
        Platform.crossPlatformFramework = CrossPlatformFramework.Electron;
    if (typeof globalThis.navigator !== 'undefined' && globalThis.navigator.product === 'ReactNative')
        Platform.crossPlatformFramework = CrossPlatformFramework.ReactNative;
    for (var i = 0; i < OS_RESOLVER_MAP.length; i++) {
        var map = OS_RESOLVER_MAP[i];
        var regexp = map[0];
        var os = map[1];
        var resolver = map[2];
        var matched = Platform.userAgent.match(regexp);
        if (matched !== null) {
            Platform.os = {
                name: os,
                version: resolveVersion(matched[1], resolver),
            };
            break;
        }
    }
    if (Platform.os.name === OS.iOS && compareVersion(Platform.os.version, '18.6') === 0) {
        var version = /\) Version\/([\d.]+)/.exec(Platform.userAgent);
        if (version !== null && parseInt(version[1].substring(0, 2), 10) >= 26)
            Platform.os.version = version[1];
    }
    for (var i = 0; i < ENGINE_RESOLVER_MAP.length; i++) {
        var map = ENGINE_RESOLVER_MAP[i];
        var regexp = map[0];
        var engine = map[1];
        var resolver = map[2];
        var matched = Platform.userAgent.match(regexp);
        if (matched !== null) {
            Platform.engine = {
                name: engine,
                version: resolveVersion(matched[1], resolver),
            };
            break;
        }
    }
    for (var i = 0; i < BROWSER_RESOLVER_MAP.length; i++) {
        var map = BROWSER_RESOLVER_MAP[i];
        var regexp = map[0];
        var browser = map[1];
        var resolver = map[2];
        var matched = Platform.userAgent.match(regexp);
        if (matched !== null) {
            Platform.browser = {
                name: browser,
                version: resolveVersion(matched[1], resolver),
            };
            break;
        }
    }
    if (Platform.crossPlatformFramework === CrossPlatformFramework.ReactNative) {
        try {
            var reactNative = require('react-native');
            var platform = reactNative.Platform;
            var os = platform.OS;
            var release = '' + platform.Version;
            var version = getSemanticVersion(release);
            switch (os) {
                case 'android':
                    Platform.os = {
                        name: OS.Android,
                        version: resolveSemanticAndroidVersion(version, release),
                    };
                    break;
                case 'ios':
                    Platform.os = {
                        name: OS.iOS,
                        version: release,
                    };
                    break;
                case 'windows':
                    Platform.os = {
                        name: OS.Windows,
                        version: resolveSemanticWindowsVersion(version, release),
                    };
                    break;
                case 'macos':
                    Platform.os = {
                        name: OS.MacOS,
                        version: release,
                    };
                    break;
            }
        }
        catch (_) {
        }
        finally {
        }
    }
    if (Platform.isNode) {
        try {
            var os = require('os');
            var platform = os.platform();
            var release = os.release();
            var version = getSemanticVersion(release);
            switch (platform) {
                case 'win32':
                    Platform.os = {
                        name: OS.Windows,
                        version: resolveSemanticWindowsVersion(version, release),
                    };
                    break;
                case 'darwin':
                    Platform.os = {
                        name: OS.MacOS,
                        version: resolveSemanticDarwinVersion(version, release),
                    };
                    break;
                case 'android':
                    Platform.os = {
                        name: OS.Android,
                        version: release,
                    };
                    break;
                case 'linux':
                    if (/android/i.test(release)) {
                        Platform.os = {
                            name: OS.Android,
                            version: release,
                        };
                    }
                    break;
            }
        }
        catch (_) {
        }
        finally {
        }
    }
    if (typeof globalThis.document !== 'undefined') {
        if (typeof globalThis.device !== 'undefined') {
            parseOSFromCordova();
        }
        else {
            globalThis.document.addEventListener("deviceready", parseOSFromCordova, false);
        }
    }
    if (typeof globalThis.navigator !== 'undefined' && typeof globalThis.navigator.userAgentData !== 'undefined' && typeof globalThis.navigator.userAgentData.getHighEntropyValues !== 'undefined') {
        incrementPendingTasks();
        globalThis.navigator.userAgentData.getHighEntropyValues(['brands', 'fullVersionList', 'mobile', 'model', 'platform', 'platformVersion', 'architecture', 'formFactors', 'bitness', 'uaFullVersion', 'wow64'])
            .then(function (result) {
            try {
                var brands = result.fullVersionList || result.brands || [];
                var platformVersion = result.platformVersion;
                var platform = result.platform;
                var browserName = Platform.browser.name;
                var prevBrandName = null;
                for (var i = 0; i < brands.length; i++) {
                    var brand = normalizeBrand(brands[i]);
                    var brandVersion = brand.version;
                    var brandName = brand.brand;
                    if (/not.a.brand/i.test(brandName))
                        continue;
                    if (prevBrandName === null || (/Chrom/.test(prevBrandName) && brandName !== 'Chromium') || (prevBrandName === 'Edge' && /WebView2/.test(brandName))) {
                        brandName = HIGH_ENTROPY_BRAND_NAME_MAP[brandName] || brandName;
                        prevBrandName = browserName;
                        if (prevBrandName === null || /Chrom/.test(prevBrandName) || !/Chrom/.test(brandName)) {
                            browserName = brandName;
                            if (browserName === 'Chrome' || browserName === 'Chrome WebView' || browserName === 'Chrome Headless')
                                Platform.browser.name = Browsers.Chrome;
                            else if (browserName === 'Edge' || browserName === 'Edge WebView2')
                                Platform.browser.name = Browsers.Edge;
                            else if (browserName === 'Opera Mobi')
                                Platform.browser.name = Browsers.Opera;
                            Platform.browser.version = brandVersion;
                        }
                        prevBrandName = brandName;
                    }
                    if (brandName === 'Chromium')
                        Platform.engine.version = brandVersion;
                }
                if (typeof platformVersion === 'string') {
                    if (Platform.os.name === OS.Windows)
                        Platform.os.version = parseInt(platformVersion.split('.')[0], 10) >= 13 ? '11' : '10';
                    else
                        Platform.os.version = platformVersion;
                }
                if (typeof platform === 'string') {
                    if (/android/i.test(platform))
                        Platform.os.name = OS.Android;
                    else if (/ios|iphone|ipad/i.test(platform))
                        Platform.os.name = OS.iOS;
                    else if (/windows|win32/i.test(platform))
                        Platform.os.name = OS.Windows;
                    else if (/macos|macintel/i.test(platform))
                        Platform.os.name = OS.MacOS;
                }
                if (result.mobile === true)
                    Platform.device = Devices.Mobile;
            }
            catch (_) {
            }
            finally {
                decrementPendingTasks();
            }
        });
    }
    checkReady();
}
init();

var currentAppearance = null;
var appearanceIntervalId = null;
var Appearance = {
    get value() {
        return getAppearance();
    },
    set value(appearance) {
        setAppearance(appearance);
    },
    onchange: onchange,
};
function getAppearanceFromEngine() {
    var img = new Image();
    img.src = SVG_PIXEL_DATA_URL;
    if (CONTEXT === null)
        return Appearances.Light;
    CONTEXT.drawImage(img, 0, 0);
    var data = CONTEXT.getImageData(0, 0, 1, 1).data;
    if ((data[0] & data[1] & data[2]) < 255)
        return Appearances.Dark;
    else
        return Appearances.Light;
}
function getAppearanceFromMediaQuery() {
    if (!SUPPORT_PREFERS_COLOR_SCHEME)
        return Appearances.Unknown;
    if (MEDIA_QUERY_LIST.matches)
        return Appearances.Dark;
    return Appearances.Light;
}
function getAppearanceFromReactNative() {
    try {
        var reactNative = require('react-native');
        return reactNative.Appearance.getColorScheme() || Appearances.Unknown;
    }
    catch (_) {
        return Appearances.Unknown;
    }
}
function getAppearanceFromElectron() {
    try {
        var electron = require('electron');
        return electron.nativeTheme.shouldUseDarkColors ? Appearances.Dark : Appearances.Light;
    }
    catch (_) {
        return Appearances.Unknown;
    }
}
function getAppearance() {
    if (Platform.crossPlatformFramework === CrossPlatformFramework.ReactNative)
        return getAppearanceFromReactNative();
    if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron)
        return getAppearanceFromElectron();
    if (Platform.browser.name === Browsers.SamsungInternet)
        return getAppearanceFromEngine();
    return getAppearanceFromMediaQuery();
}
function setAppearance(appearance) {
    if (Platform.crossPlatformFramework === CrossPlatformFramework.ReactNative) {
        try {
            var reactNative = require('react-native');
            reactNative.Appearance.setColorScheme(appearance);
            return;
        }
        catch (_) {
        }
    }
    if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron) {
        try {
            var electron = require('electron');
            electron.nativeTheme.themeSource = appearance || 'system';
            return;
        }
        catch (_) {
        }
    }
}
function startPolling() {
    currentAppearance = getAppearanceFromEngine();
    appearanceIntervalId = globalThis.setInterval(function () {
        var appearance = getAppearanceFromEngine();
        if (appearance !== currentAppearance) {
            currentAppearance = appearance;
            notify(appearance);
        }
    }, 2000);
}
function stopPolling() {
    currentAppearance = null;
    if (appearanceIntervalId !== null) {
        clearInterval(appearanceIntervalId);
        appearanceIntervalId = null;
    }
}
function addListener(capture) {
    currentAppearance = getAppearanceFromMediaQuery();
    if (typeof MEDIA_QUERY_LIST.addEventListener === 'function')
        MEDIA_QUERY_LIST.addEventListener('change', onMediaChange, capture);
    else if (typeof MEDIA_QUERY_LIST.addListener === 'function')
        MEDIA_QUERY_LIST.addListener(onMediaChange);
}
function removeListener(capture) {
    currentAppearance = null;
    if (typeof MEDIA_QUERY_LIST.removeEventListener === 'function')
        MEDIA_QUERY_LIST.removeEventListener('change', onMediaChange, capture);
    else if (typeof MEDIA_QUERY_LIST.removeListener === 'function')
        MEDIA_QUERY_LIST.removeListener(onMediaChange);
}
function onMediaChange(ev) {
    var appearance;
    if (ev.matches)
        appearance = Appearances.Dark;
    else
        appearance = Appearances.Light;
    if (appearance !== currentAppearance)
        notify(currentAppearance = appearance);
}
function notify(appearance) {
    for (var i = 0; i < ENTRIES.length; i++) {
        var entry = ENTRIES[i];
        entry.fn(appearance);
        if (entry.once)
            removeEntry(entry);
    }
}
function removeEntry(entry) {
    var index = indexOfEntry(entry);
    if (index !== -1)
        ENTRIES.splice(index, 1);
    if (ENTRIES.length === 0) {
        if (Platform.browser.name === Browsers.SamsungInternet)
            stopPolling();
        else
            removeListener(entry.capture);
    }
}
function indexOfEntry(entry) {
    for (var i = 0; i < ENTRIES.length; i++)
        if (ENTRIES[i].fn === entry.fn && ENTRIES[i].capture === entry.capture)
            return i;
    return -1;
}
function onchangeReactNative(entry) {
    try {
        var reactNative = require('react-native');
        var isRemoved_1 = false;
        var listener = function (preferences) {
            if (isRemoved_1)
                return;
            entry.fn(preferences.colorScheme || Appearances.Unknown);
            if (entry.once)
                cleanup_1();
        };
        var cleanup_1 = function () {
            if (isRemoved_1)
                return;
            if (typeof entry.signal !== 'undefined')
                entry.signal.removeEventListener('abort', cleanup_1);
            isRemoved_1 = true;
            subscription_1.remove();
        };
        if (typeof entry.signal !== 'undefined') {
            if (entry.signal.aborted) {
                return function () {
                };
            }
            entry.signal.addEventListener('abort', cleanup_1);
        }
        var subscription_1 = reactNative.Appearance.addChangeListener(listener);
        return function () {
            subscription_1.remove();
        };
    }
    catch (_) {
    }
    return function () {
    };
}
function onchangeElectron(entry) {
    try {
        var electron = require('electron');
        var nativeTheme_1 = electron.nativeTheme;
        var isRemoved_2 = false;
        var listener_1 = function () {
            if (isRemoved_2)
                return;
            entry.fn(getAppearanceFromElectron());
            if (entry.once)
                cleanup_2();
        };
        var cleanup_2 = function () {
            if (isRemoved_2)
                return;
            if (typeof entry.signal !== 'undefined')
                entry.signal.removeEventListener('abort', cleanup_2);
            isRemoved_2 = true;
            nativeTheme_1.removeListener('updated', listener_1);
        };
        if (typeof entry.signal !== 'undefined') {
            if (entry.signal.aborted) {
                return function () {
                };
            }
            entry.signal.addEventListener('abort', cleanup_2);
        }
        nativeTheme_1.on('updated', listener_1);
        return function () {
            nativeTheme_1.removeListener('updated', listener_1);
        };
    }
    catch (_) {
    }
    return function () {
    };
}
function onchange(listener, options) {
    if (options === void 0) { options = false; }
    var entry = { fn: listener, capture: false, once: false };
    if (typeof options === 'boolean')
        options = { capture: options };
    if (typeof options.capture !== 'undefined')
        entry.capture = options.capture;
    if (typeof options.once !== 'undefined')
        entry.once = options.once;
    if (typeof options.signal !== 'undefined')
        entry.signal = options.signal;
    if (Platform.crossPlatformFramework === CrossPlatformFramework.ReactNative)
        return onchangeReactNative(entry);
    if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron)
        return onchangeElectron(entry);
    var index = indexOfEntry(entry);
    if (index === -1) {
        ENTRIES.push(entry);
        if (ENTRIES.length === 1) {
            if (Platform.browser.name === Browsers.SamsungInternet)
                startPolling();
            else
                addListener(entry.capture);
        }
    }
    else if (ENTRIES[index].once && !entry.once) {
        ENTRIES[index].once = false;
    }
    if (typeof entry.signal !== 'undefined') {
        if (entry.signal.aborted) {
            removeEntry(entry);
        }
        else {
            entry.signal.addEventListener('abort', function onAbort() {
                if (typeof entry.signal !== 'undefined')
                    entry.signal.removeEventListener('abort', onAbort);
                removeEntry(entry);
            });
        }
    }
    return function () {
        removeEntry(entry);
    };
}

var NativeAppearancePlugin = {
    installed: false,
    name: 'Appearance',
    module: Appearance,
    Constants: {
        Appearances: Appearances,
    },
    Errors: {}
};

export { NativeAppearancePlugin as default };