native-fn 1.0.82 → 1.0.84

package/dist/plugin/dimension/index.cjs

@@ -1,6 +1,986 @@
 'use strict';
 
-var Dimension = {};
+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 ENTRIES = [];
+var FALLBACK_DIMENSION = {
+    innerWidth: -1,
+    innerHeight: -1,
+    outerWidth: -1,
+    outerHeight: -1,
+    scale: 1,
+};
+
+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 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 currentDimension = null;
+var Dimension = {
+    get value() {
+        return getDimension();
+    },
+    onchange: onchange,
+};
+function getDimensionFromWindow() {
+    if (typeof globalThis.innerWidth !== 'undefined') {
+        return {
+            innerWidth: globalThis.innerWidth,
+            innerHeight: globalThis.innerHeight,
+            outerWidth: globalThis.outerWidth,
+            outerHeight: globalThis.outerHeight,
+            scale: globalThis.devicePixelRatio || 1
+        };
+    }
+    return FALLBACK_DIMENSION;
+}
+function getDimensionFromReactNative() {
+    try {
+        var reactNative = require('react-native');
+        var dimensions = reactNative.Dimensions;
+        var pixelRatio = reactNative.PixelRatio;
+        var screenDimensions = dimensions.get('screen');
+        var windowDimensions = dimensions.get('window');
+        return {
+            innerWidth: screenDimensions.width,
+            innerHeight: screenDimensions.height,
+            outerWidth: windowDimensions.width,
+            outerHeight: windowDimensions.height,
+            scale: pixelRatio.get()
+        };
+    }
+    catch (_) {
+    }
+    return FALLBACK_DIMENSION;
+}
+function getDimensionFromElectron() {
+    try {
+        var electron = require('electron');
+        var screen_1 = electron.screen;
+        var browserWindow = electron.BrowserWindow;
+        var focusedWindow = browserWindow.getFocusedWindow() || browserWindow.getAllWindows()[0];
+        if (typeof focusedWindow !== 'undefined') {
+            var contentSize = focusedWindow.getContentSize();
+            var size = focusedWindow.getSize();
+            return {
+                innerWidth: contentSize[0],
+                innerHeight: contentSize[1],
+                outerWidth: size[0],
+                outerHeight: size[1],
+                scale: screen_1.getDisplayMatching(focusedWindow.getBounds()).scaleFactor,
+            };
+        }
+    }
+    catch (_) {
+    }
+    return FALLBACK_DIMENSION;
+}
+function getDimension() {
+    if (Platform.crossPlatformFramework === CrossPlatformFramework.ReactNative)
+        return getDimensionFromReactNative();
+    if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron)
+        return getDimensionFromElectron();
+    return getDimensionFromWindow();
+}
+function addListener(capture) {
+    currentDimension = getDimension();
+    if (typeof globalThis.addEventListener === 'function')
+        globalThis.addEventListener('resize', onResize, capture);
+}
+function removeListener(capture) {
+    currentDimension = null;
+    if (typeof globalThis.removeEventListener === 'function')
+        globalThis.removeEventListener('resize', onResize, capture);
+}
+function onResize() {
+    var dimension = getDimension();
+    if (currentDimension === null || dimension.innerWidth !== currentDimension.innerWidth || dimension.innerHeight !== currentDimension.innerHeight || dimension.outerWidth !== currentDimension.outerWidth || dimension.outerHeight !== currentDimension.outerHeight || dimension.scale !== currentDimension.scale) {
+        currentDimension = dimension;
+        notify(dimension);
+    }
+}
+function notify(dimension) {
+    for (var i = 0; i < ENTRIES.length; i++) {
+        var entry = ENTRIES[i];
+        entry.fn(dimension);
+        if (entry.once)
+            removeEntry(entry);
+    }
+}
+function removeEntry(entry) {
+    var index = indexOfEntry(entry);
+    if (index !== -1)
+        ENTRIES.splice(index, 1);
+    if (ENTRIES.length === 0)
+        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 (dimensions) {
+            if (isRemoved_1)
+                return;
+            entry.fn(getDimensionFromReactNative());
+            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.Dimensions.addEventListener('change', listener);
+        return function () {
+            subscription_1.remove();
+        };
+    }
+    catch (_) {
+    }
+    return function () {
+    };
+}
+function onchangeElectron(entry) {
+    try {
+        var electron = require('electron');
+        var browserWindow = electron.BrowserWindow;
+        var focusedWindow_1 = browserWindow.getFocusedWindow() || browserWindow.getAllWindows()[0];
+        if (typeof focusedWindow_1 !== 'undefined') {
+            var isRemoved_2 = false;
+            var listener_1 = function () {
+                if (isRemoved_2)
+                    return;
+                entry.fn(getDimensionFromElectron());
+                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;
+                focusedWindow_1.removeListener('resize', listener_1);
+            };
+            if (typeof entry.signal !== 'undefined') {
+                if (entry.signal.aborted) {
+                    return function () {
+                    };
+                }
+                entry.signal.addEventListener('abort', cleanup_2);
+            }
+            focusedWindow_1.on('resize', listener_1);
+            return function () {
+                focusedWindow_1.removeListener('resize', 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)
+            addListener(entry.capture);
+    }
+    else if (ENTRIES[index].once && !entry.once) {
+        ENTRIES[index].once = false;
+    }
+    var cleanup = function () {
+        if (typeof entry.signal !== 'undefined')
+            entry.signal.removeEventListener('abort', cleanup);
+        removeEntry(entry);
+    };
+    if (typeof entry.signal !== 'undefined') {
+        if (entry.signal.aborted)
+            removeEntry(entry);
+        else
+            entry.signal.addEventListener('abort', cleanup);
+    }
+    return function () {
+        removeEntry(entry);
+    };
+}
 
 var NativeDimensionPlugin = {
     installed: false,