native-fn 1.0.63 → 1.0.64

package/dist/plugin/appearance/index.umd.js

@@ -0,0 +1,770 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Appearance = factory());
+})(this, (function () { 'use strict';
+
+    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,PHN2ZyB3aWR0aD0iMSIgaGVpZ2h0PSIxIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxyZWN0IHdpZHRoPSIxIiBoZWlnaHQ9IjEiIGZpbGw9IndoaXRlIi8+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 userAgent = typeof globalThis.navigator !== 'undefined' && typeof globalThis.navigator.userAgent === 'string' ? globalThis.navigator.userAgent : '';
+    var IS_NODE_JS = typeof globalThis.process !== 'undefined' && typeof globalThis.process.versions !== 'undefined' && globalThis.process.versions.node !== undefined;
+    var IS_ELECTRON = (typeof globalThis.process !== 'undefined' && typeof globalThis.process.versions !== 'undefined' && globalThis.process.versions.electron !== undefined) || (/ electron\//i.test(userAgent));
+    var IS_REACT_NATIVE = typeof globalThis.navigator !== 'undefined' && globalThis.navigator.product === 'ReactNative';
+    var Platform = {
+        device: Devices.Unknown,
+        os: OS.Unknown,
+        osVersion: '',
+        engine: Engines.Unknown,
+        engineVersion: '',
+        browser: Browsers.Unknown,
+        browserVersion: '',
+        renderer: getRenderer(),
+        userAgent: userAgent,
+        isMobile: false,
+        isDesktop: false,
+        isStandalone: false,
+        isWebview: /; ?wv|applewebkit(?!.*safari)/i.test(userAgent),
+    };
+    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 resolveWindowsVersion(string) {
+        if (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 (mapped !== undefined)
+            return mapped;
+        return string;
+    }
+    function resolveUnderscoreVersion(string) {
+        if (string === undefined)
+            return '';
+        return string.replace(/_/g, '.');
+    }
+    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 (string === undefined)
+            return '';
+        return string;
+    }
+    function normalizeBrand(entry) {
+        if (entry === null || entry === undefined)
+            return { brand: '', version: '' };
+        if (typeof entry === 'string')
+            return { brand: entry, version: '' };
+        return { brand: entry.brand, version: entry.version };
+    }
+    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 getIsStandalone(os) {
+        if (!('matchMedia' in globalThis))
+            return false;
+        if (os === OS.iOS)
+            return 'standalone' in navigator && !!navigator.standalone;
+        return globalThis.matchMedia('(display-mode: standalone)').matches;
+    }
+    function getSemanticVersion(string) {
+        var parts = string.split('.');
+        return {
+            major: parseInt(parts[0] || '0'),
+            minor: parseInt(parts[1] || '0'),
+            build: parseInt(parts[2] || '0')
+        };
+    }
+    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 = os;
+            Platform.osVersion = resolveVersion(matched[1], resolver);
+            break;
+        }
+    }
+    if (Platform.os === OS.iOS && compareVersion(Platform.osVersion, '18.6') === 0) {
+        var version = /\) Version\/([\d.]+)/.exec(Platform.userAgent);
+        if (version !== null && parseInt(version[1].substring(0, 2), 10) >= 26)
+            Platform.osVersion = 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 = engine;
+            Platform.engineVersion = 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 = browser;
+            Platform.browserVersion = resolveVersion(matched[1], resolver);
+            break;
+        }
+    }
+    if (IS_REACT_NATIVE) {
+        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 = OS.Android;
+                    Platform.osVersion = resolveSemanticAndroidVersion(version, release);
+                    break;
+                case 'ios':
+                    Platform.os = OS.iOS;
+                    Platform.osVersion = release;
+                    break;
+                case 'windows':
+                    Platform.os = OS.Windows;
+                    Platform.osVersion = resolveSemanticWindowsVersion(version, release);
+                    break;
+                case 'macos':
+                    Platform.os = OS.MacOS;
+                    Platform.osVersion = release;
+                    break;
+            }
+        }
+        catch (_) {
+        }
+    }
+    if (IS_NODE_JS) {
+        try {
+            var os = require('os');
+            var platform = os.platform();
+            var release = os.release();
+            var version = getSemanticVersion(release);
+            switch (platform) {
+                case 'win32':
+                    Platform.os = OS.Windows;
+                    Platform.osVersion = resolveSemanticWindowsVersion(version, release);
+                    break;
+                case 'darwin':
+                    Platform.os = OS.MacOS;
+                    Platform.osVersion = resolveSemanticDarwinVersion(version, release);
+                    break;
+                case 'android':
+                    Platform.os = OS.Android;
+                    Platform.osVersion = release;
+                    break;
+                case 'linux':
+                    if (/android/i.test(release)) {
+                        Platform.os = OS.Android;
+                        Platform.osVersion = release;
+                    }
+                    break;
+            }
+        }
+        catch (_) {
+        }
+    }
+    document.addEventListener("deviceready", function () {
+        if (Platform.os === OS.Unknown && typeof globalThis.device !== 'undefined') {
+            switch (globalThis.device.platform) {
+                case 'Android':
+                    Platform.os = OS.Android;
+                    break;
+                case 'iOS':
+                    Platform.os = OS.iOS;
+                    break;
+            }
+            Platform.osVersion = globalThis.device.version;
+        }
+    }, false);
+    if (navigator.userAgentData !== undefined && navigator.userAgentData.getHighEntropyValues !== undefined) {
+        navigator
+            .userAgentData
+            .getHighEntropyValues(['brands', 'fullVersionList', 'mobile', 'model', 'platform', 'platformVersion', 'architecture', 'formFactors', 'bitness', 'uaFullVersion', 'wow64'])
+            .then(function (result) {
+            var brands = result.fullVersionList || result.brands || [];
+            var platformVersion = result.platformVersion;
+            for (var i = 0; i < brands.length; i++) {
+                var brand = normalizeBrand(brands[i]);
+                var brandName = brand.brand;
+                var brandVersion = brand.version;
+                if (/not.a.brand/i.test(brandName))
+                    continue;
+                if (brandName === "Chromium")
+                    Platform.engineVersion = brandVersion;
+            }
+            if (typeof platformVersion === 'string') {
+                if (Platform.os === OS.Windows && parseInt(platformVersion.replace(/[^\d.]/g, '').split('.')[0], 10) >= 13)
+                    Platform.osVersion = '11';
+                else
+                    Platform.osVersion = platformVersion;
+            }
+        });
+    }
+    Platform.device = Platform.os === OS.iOS || Platform.os === OS.Android ? Devices.Mobile : Platform.os === OS.Windows || Platform.os === OS.MacOS ? Devices.Desktop : Devices.Unknown;
+    Platform.isMobile = Platform.device === Devices.Mobile;
+    Platform.isDesktop = Platform.device === Devices.Desktop;
+    Platform.isStandalone = getIsStandalone(Platform.os);
+
+    var currentAppearance = null;
+    var appearanceIntervalId = null;
+    var Appearance = {
+        get value() {
+            return getAppearance();
+        },
+        set value(appearance) {
+            setAppearance(appearance);
+        },
+        onchange: onchange,
+    };
+    function getAppearanceFromEngine() {
+        return new Promise(function (resolve) {
+            var img = new Image();
+            img.onload = function () {
+                if (CONTEXT === null)
+                    return resolve(Appearances.Light);
+                CONTEXT.drawImage(img, 0, 0);
+                var data = CONTEXT.getImageData(0, 0, 1, 1).data;
+                if ((data[0] & data[1] & data[2]) < 255)
+                    resolve(Appearances.Dark);
+                else
+                    resolve(Appearances.Light);
+            };
+            img.onerror = function () {
+                resolve(Appearances.Unknown);
+            };
+            img.src = SVG_PIXEL_DATA_URL;
+        });
+    }
+    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 (IS_REACT_NATIVE)
+            return new Promise(function (resolve) {
+                resolve(getAppearanceFromReactNative());
+            });
+        if (IS_ELECTRON)
+            return new Promise(function (resolve) {
+                resolve(getAppearanceFromElectron());
+            });
+        if (Platform.browser === Browsers.SamsungInternet)
+            return getAppearanceFromEngine();
+        return new Promise(function (resolve) {
+            resolve(getAppearanceFromMediaQuery());
+        });
+    }
+    function setAppearance(appearance) {
+        if (IS_REACT_NATIVE) {
+            try {
+                var reactNative = require('react-native');
+                reactNative.Appearance.setColorScheme(appearance);
+                return;
+            }
+            catch (_) {
+            }
+        }
+        if (IS_ELECTRON) {
+            try {
+                var electron = require('electron');
+                electron.nativeTheme.themeSource = appearance || 'system';
+                return;
+            }
+            catch (_) {
+            }
+        }
+    }
+    function startPolling() {
+        getAppearanceFromEngine()
+            .then(function (appearance) {
+            currentAppearance = appearance;
+        });
+        appearanceIntervalId = globalThis.setInterval(function () {
+            getAppearanceFromEngine()
+                .then(function (appearance) {
+                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 === 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 onchange(listener, options) {
+        if (options === void 0) { options = false; }
+        if (IS_REACT_NATIVE) {
+            try {
+                var reactNative = require('react-native');
+                var subscription_1 = reactNative.Appearance.addChangeListener(function (preferences) {
+                    listener(preferences.colorScheme || Appearances.Unknown);
+                });
+                return function () {
+                    subscription_1.remove();
+                };
+            }
+            catch (_) {
+            }
+        }
+        if (IS_ELECTRON) {
+            try {
+                var electron_1 = require('electron');
+                var handleThemeChange_1 = function () {
+                    listener(getAppearanceFromElectron());
+                };
+                if (typeof electron_1.nativeTheme.on !== 'undefined') {
+                    electron_1.nativeTheme.on('updated', handleThemeChange_1);
+                }
+                return function () {
+                    if (typeof electron_1.nativeTheme.removeListener !== 'undefined')
+                        electron_1.nativeTheme.removeListener('updated', handleThemeChange_1);
+                };
+            }
+            catch (_) {
+            }
+        }
+        var entry = { fn: listener, capture: false, once: false };
+        if (typeof options === 'boolean')
+            options = { capture: options };
+        if (options.capture !== undefined)
+            entry.capture = options.capture;
+        if (options.once !== undefined)
+            entry.once = options.once;
+        if (options.signal !== undefined)
+            entry.signal = options.signal;
+        var index = indexOfEntry(entry);
+        if (index === -1) {
+            ENTRIES.push(entry);
+            if (ENTRIES.length === 1) {
+                if (Platform.browser === Browsers.SamsungInternet)
+                    startPolling();
+                else
+                    addListener(entry.capture);
+            }
+            this.getAppearance()
+                .then(notify);
+        }
+        else if (ENTRIES[index].once && !entry.once) {
+            ENTRIES[index].once = false;
+        }
+        if (entry.signal !== undefined) {
+            if (entry.signal.aborted) {
+                removeEntry(entry);
+            }
+            else {
+                entry.signal.addEventListener('abort', function onAbort() {
+                    if (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: {}
+    };
+
+    return NativeAppearancePlugin;
+
+}));