native-fn 1.0.89 → 1.0.90

package/dist/native.cjs

@@ -1,27 +1,402 @@
 'use strict';
 
-var version = "1.0.89";
+var version = "1.0.90";
 var packageJSON = {
 	version: version};
 
-function assign() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var to = Object(args[0]);
-    for (var i = 1; i < args.length; i++) {
-        var src = args[i];
-        if (src == null)
-            continue;
-        for (var key in src) {
-            if (!Object.prototype.hasOwnProperty.call(src, key) || key === '__proto__' || key === 'constructor' || key === 'prototype')
-                continue;
-            to[key] = src[key];
-        }
-    }
-    return to;
+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;
+(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 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 RTL_LANGUAGES = ['ae', 'ar', 'arc', 'bcc', 'bqi', 'ckb', 'dv', 'fa', 'glk', 'he', 'iw', 'ku', 'mzn', 'nqo', 'pnb', 'ps', 'sd', 'ug', 'ur', 'yi'];
+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],
+];
+var BOT_REGEXP = [
+    / daum[ /]/i,
+    / deusu\//i,
+    /(?:^|[^g])news(?!sapphire)/i,
+    /(?<! (?:channel\/|google\/))google(?!(app|\/google| pixel))/i,
+    /(?<! cu)bots?(?:\b|_)/i,
+    /(?<!lib)http/i,
+    /(?<![hg]m)score/i,
+    /(?<!cam)scan/i,
+    /24x7/i,
+    /@[a-z][\w-]+\./i,
+    /\(\)/i,
+    /\.com\b/i,
+    /\b\w+\.ai/i,
+    /\bmanus-user\//i,
+    /\bort\//i,
+    /\bperl\b/i,
+    /\bsecurityheaders\b/i,
+    /\btime\//i,
+    /\|/i,
+    /^[\w .\-(?:)%]+(?:\/v?\d+(?:\.\d+)?(?:\.\d{1,10})*?)?(?:,|$)/i,
+    /^[^ ]{50,}$/i,
+    /^\d+\b/i,
+    /^\W/i,
+    /^\w*search\b/i,
+    /^\w+\/[\w()]*$/i,
+    /^\w+\/\d\.\d\s\([\w@]+\)$/i,
+    /^active/i,
+    /^ad muncher/i,
+    /^amaya/i,
+    /^apache\//i,
+    /^avsdevicesdk\//i,
+    /^azure/i,
+    /^biglotron/i,
+    /^bot/i,
+    /^bw\//i,
+    /^clamav[ /]/i,
+    /^client\//i,
+    /^cobweb\//i,
+    /^custom/i,
+    /^ddg[_-]android/i,
+    /^discourse/i,
+    /^dispatch\/\d/i,
+    /^downcast\//i,
+    /^duckduckgo/i,
+    /^email/i,
+    /^facebook/i,
+    /^getright\//i,
+    /^gozilla\//i,
+    /^hobbit/i,
+    /^hotzonu/i,
+    /^hwcdn\//i,
+    /^igetter\//i,
+    /^jeode\//i,
+    /^jetty\//i,
+    /^jigsaw/i,
+    /^microsoft bits/i,
+    /^movabletype/i,
+    /^mozilla\/\d\.\d\s[\w.-]+$/i,
+    /^mozilla\/\d\.\d\s\(compatible;?(?:\s[\w-.]+\/\d+\.\d+)?\)$/i,
+    /^navermailapp/i,
+    /^netsurf/i,
+    /^offline/i,
+    /^openai\//i,
+    /^owler/i,
+    /^php/i,
+    /^postman/i,
+    /^python/i,
+    /^rank/i,
+    /^read/i,
+    /^reed/i,
+    /^rest/i,
+    /^rss/i,
+    /^snapchat/i,
+    /^space bison/i,
+    /^svn/i,
+    /^swcd /i,
+    /^taringa/i,
+    /^thumbor\//i,
+    /^track/i,
+    /^w3c/i,
+    /^webbandit\//i,
+    /^webcopier/i,
+    /^wget/i,
+    /^whatsapp/i,
+    /^wordpress/i,
+    /^xenu link sleuth/i,
+    /^yahoo/i,
+    /^yandex/i,
+    /^zdm\/\d/i,
+    /^zoom marketplace\//i,
+    /advisor/i,
+    /agent\b/i,
+    /analyzer/i,
+    /archive/i,
+    /ask jeeves\/teoma/i,
+    /audit/i,
+    /bit\.ly\//i,
+    /bluecoat drtr/i,
+    /browsex/i,
+    /burpcollaborator/i,
+    /capture/i,
+    /catch/i,
+    /check\b/i,
+    /checker/i,
+    /chrome-lighthouse/i,
+    /chromeframe/i,
+    /classifier/i,
+    /cloudflare/i,
+    /convertify/i,
+    /crawl/i,
+    /cypress\//i,
+    /dareboost/i,
+    /datanyze/i,
+    /dejaclick/i,
+    /detect/i,
+    /dmbrowser/i,
+    /download/i,
+    /exaleadcloudview/i,
+    /feed/i,
+    /fetcher/i,
+    /firephp/i,
+    /functionize/i,
+    /grab/i,
+    /headless/i,
+    /httrack/i,
+    /hubspot marketing grader/i,
+    /ibisbrowser/i,
+    /infrawatch/i,
+    /insight/i,
+    /inspect/i,
+    /iplabel/i,
+    /java(?!;)/i,
+    /library/i,
+    /linkcheck/i,
+    /mail\.ru\//i,
+    /manager/i,
+    /measure/i,
+    /neustar wpm/i,
+    /node\b/i,
+    /nutch/i,
+    /offbyone/i,
+    /onetrust/i,
+    /optimize/i,
+    /pageburst/i,
+    /pagespeed/i,
+    /parser/i,
+    /phantomjs/i,
+    /pingdom/i,
+    /powermarks/i,
+    /preview/i,
+    /proxy/i,
+    /ptst[ /]\d/i,
+    /retriever/i,
+    /rexx;/i,
+    /rigor/i,
+    /rss\b/i,
+    /scrape/i,
+    /server/i,
+    /sogou/i,
+    /sparkler\//i,
+    /speedcurve/i,
+    /spider/i,
+    /splash/i,
+    /statuscake/i,
+    /supercleaner/i,
+    /synapse/i,
+    /synthetic/i,
+    /tools/i,
+    /torrent/i,
+    /transcoder/i,
+    /url/i,
+    /validator/i,
+    /virtuoso/i,
+    /wappalyzer/i,
+    /webglance/i,
+    /webkit2png/i,
+    /whatcms\//i,
+    /xtate\//i
+];
+
+var _a$1, _b, _c, _d, _e;
+var AppOpenState;
+(function (AppOpenState) {
+    AppOpenState[AppOpenState["Scheme"] = 0] = "Scheme";
+    AppOpenState[AppOpenState["Universal"] = 1] = "Universal";
+    AppOpenState[AppOpenState["Intent"] = 2] = "Intent";
+    AppOpenState[AppOpenState["Fallback"] = 3] = "Fallback";
+    AppOpenState[AppOpenState["Store"] = 4] = "Store";
+})(AppOpenState || (AppOpenState = {}));
+var MessengerType;
+(function (MessengerType) {
+    MessengerType["Telephone"] = "telephone";
+    MessengerType["Message"] = "message";
+    MessengerType["Mail"] = "mail";
+})(MessengerType || (MessengerType = {}));
+var SettingType;
+(function (SettingType) {
+    SettingType["General"] = "general";
+    SettingType["Network"] = "network";
+    SettingType["Display"] = "display";
+    SettingType["Appearance"] = "appearance";
+    SettingType["Accessibility"] = "accessibility";
+    SettingType["Battery"] = "battery";
+    SettingType["Datetime"] = "datetime";
+    SettingType["Language"] = "language";
+    SettingType["Accounts"] = "accounts";
+    SettingType["Storage"] = "storage";
+})(SettingType || (SettingType = {}));
+var SETTING_URL = (_a$1 = {},
+    _a$1[OS.Android] = (_b = {},
+        _b[SettingType.General] = 'intent:#Intent;action=android.settings.SETTINGS;end',
+        _b[SettingType.Network] = 'intent:#Intent;action=android.settings.WIFI_SETTINGS;end',
+        _b[SettingType.Display] = 'intent:#Intent;action=android.settings.DISPLAY_SETTINGS;end',
+        _b[SettingType.Appearance] = 'intent:#Intent;action=android.settings.DISPLAY_SETTINGS;end',
+        _b[SettingType.Accessibility] = 'intent:#Intent;action=android.settings.ACCESSIBILITY_SETTINGS;end',
+        _b[SettingType.Battery] = 'intent:#Intent;action=android.settings.BATTERY_SAVER_SETTINGS;end',
+        _b[SettingType.Datetime] = 'intent:#Intent;action=android.settings.DATE_SETTINGS;end',
+        _b[SettingType.Language] = 'intent:#Intent;action=android.settings.LOCALE_SETTINGS;end',
+        _b[SettingType.Accounts] = 'intent:#Intent;action=android.settings.SYNC_SETTINGS;end',
+        _b[SettingType.Storage] = 'intent:#Intent;action=android.settings.INTERNAL_STORAGE_SETTINGS;end',
+        _b),
+    _a$1[OS.Windows] = (_c = {},
+        _c[SettingType.General] = 'ms-settings:system',
+        _c[SettingType.Network] = 'ms-settings:network',
+        _c[SettingType.Display] = 'ms-settings:display',
+        _c[SettingType.Appearance] = 'ms-settings:colors',
+        _c[SettingType.Accessibility] = 'ms-settings:easeofaccess',
+        _c[SettingType.Battery] = 'ms-settings:batterysaver',
+        _c[SettingType.Datetime] = 'ms-settings:dateandtime',
+        _c[SettingType.Language] = 'ms-settings:regionlanguage',
+        _c[SettingType.Accounts] = 'ms-settings:emailandaccounts',
+        _c[SettingType.Storage] = 'ms-settings:storagesense',
+        _c),
+    _a$1[OS.MacOS] = (_d = {},
+        _d[SettingType.General] = 'x-apple.systempreferences:',
+        _d[SettingType.Network] = 'x-apple.systempreferences:com.apple.preference.network',
+        _d[SettingType.Display] = 'x-apple.systempreferences:com.apple.preference.displays',
+        _d[SettingType.Appearance] = 'x-apple.systempreferences:com.apple.preference.general',
+        _d[SettingType.Accessibility] = 'x-apple.systempreferences:com.apple.preference.universalaccess',
+        _d[SettingType.Battery] = 'x-apple.systempreferences:com.apple.preference.energysaver',
+        _d[SettingType.Datetime] = 'x-apple.systempreferences:com.apple.preference.datetime',
+        _d[SettingType.Language] = 'x-apple.systempreferences:com.apple.Localization',
+        _d[SettingType.Accounts] = 'x-apple.systempreferences:com.apple.preferences.internetaccounts',
+        _d[SettingType.Storage] = 'x-apple.systempreferences:',
+        _d),
+    _a$1['MacOS13+'] = (_e = {},
+        _e[SettingType.General] = 'x-apple.systempreferences:com.apple.General-Settings.extension',
+        _e[SettingType.Network] = 'x-apple.systempreferences:com.apple.Network-Settings.extension',
+        _e[SettingType.Display] = 'x-apple.systempreferences:com.apple.Displays-Settings.extension',
+        _e[SettingType.Appearance] = 'x-apple.systempreferences:com.apple.Appearance-Settings.extension',
+        _e[SettingType.Accessibility] = 'x-apple.systempreferences:com.apple.Accessibility-Settings.extension',
+        _e[SettingType.Battery] = 'x-apple.systempreferences:com.apple.Battery-Settings.extension',
+        _e[SettingType.Datetime] = 'x-apple.systempreferences:com.apple.Date-Time-Settings.extension',
+        _e[SettingType.Language] = 'x-apple.systempreferences:com.apple.Localization-Settings.extension',
+        _e[SettingType.Accounts] = 'x-apple.systempreferences:com.apple.Internet-Accounts-Settings.extension',
+        _e[SettingType.Storage] = 'x-apple.systempreferences:com.apple.settings.Storage',
+        _e),
+    _a$1);
 
 function createCustomError(name, Base) {
     if (Base === void 0) { Base = Error; }
@@ -101,42 +476,2362 @@ function createCustomError(name, Base) {
     return CustomError;
 }
 
-var PluginNotExtendedError = createCustomError('PluginNotExtendedError');
+var URLOpenError = createCustomError('URLOpenError');
 
-(function () {
-    if (typeof globalThis === 'object')
-        return;
-    Object.defineProperty(Object.prototype, '__getGlobalThis__', {
-        get: function () { return this; },
-        configurable: true
-    });
+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;
+}
+
+function getTopmostWindow() {
     try {
-        var global = __getGlobalThis__;
-        Object.defineProperty(global, 'globalThis', {
-            value: global,
-            writable: true,
-            configurable: true
+        if (globalThis.top && globalThis.top !== window) {
+            void globalThis.top.location.href;
+            return globalThis.top;
+        }
+    }
+    catch (_) {
+    }
+    return window;
+}
+
+function createHiddenElement(tagName, focusable) {
+    if (focusable === void 0) { focusable = true; }
+    if (typeof globalThis.document === 'undefined')
+        return undefined;
+    var element = globalThis.document.createElement(tagName);
+    if ('width' in element)
+        element.width = '0';
+    if ('height' in element)
+        element.height = '0';
+    if ('border' in element)
+        element.border = '0';
+    if ('frameBorder' in element)
+        element.frameBorder = '0';
+    if ('scrolling' in element)
+        element.scrolling = 'no';
+    if ('cellPadding' in element)
+        element.cellPadding = '0';
+    if ('cellSpacing' in element)
+        element.cellSpacing = '0';
+    if ('frame' in element)
+        element.frame = 'void';
+    if ('rules' in element)
+        element.rules = 'none';
+    if ('noWrap' in element)
+        element.noWrap = true;
+    element.tabIndex = -1;
+    element.setAttribute('role', 'presentation');
+    if (focusable) {
+        element.style.width = '1px';
+        element.style.height = '1px';
+    }
+    else {
+        element.setAttribute('aria-hidden', 'true');
+        element.style.width = '0';
+        element.style.height = '0';
+        element.style.zIndex = '-9999';
+        element.style.display = 'none';
+        element.style.visibility = 'hidden';
+        element.style.pointerEvents = 'none';
+    }
+    element.style.position = 'absolute';
+    element.style.top = '0';
+    element.style.left = '0';
+    element.style.padding = '0';
+    element.style.margin = '0';
+    element.style.border = 'none';
+    element.style.outline = 'none';
+    element.style.clip = 'rect(1px, 1px, 1px, 1px)';
+    element.style.clipPath = 'inset(50%)';
+    element.style.overflow = 'hidden';
+    element.style.whiteSpace = 'nowrap';
+    return element;
+}
+
+function dispatchClickEvent(element, view) {
+    if (view === void 0) { view = window; }
+    var fake;
+    try {
+        fake = new MouseEvent('click', {
+            bubbles: true,
+            cancelable: true,
+            view: view
         });
     }
-    finally {
-        delete Object.prototype.__getGlobalThis__;
+    catch (_) {
+        fake = globalThis.document.createEvent('MouseEvents');
+        fake.initMouseEvent('click', true, true, view, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
     }
-}());
-var Native = {
-    Version: packageJSON.version,
-    Constants: {},
-    Errors: {
-        PluginNotExtendedError: PluginNotExtendedError
+    element.dispatchEvent(fake);
+}
+
+function capitalize(_) {
+    var groups = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        groups[_i - 1] = arguments[_i];
+    }
+    var result = '';
+    for (var i = 0; i < groups.length - 2; i++) {
+        var arg = groups[i];
+        if (typeof arg !== 'undefined')
+            result = result + arg.charAt(0).toUpperCase() + arg.slice(1);
+    }
+    return result;
+}
+function preventDefaultPolyfill() {
+    this.returnValue = false;
+}
+function stopPropagationPolyfill() {
+    this.cancelBubble = true;
+}
+var EVENT_TYPE_REGEXP = /(animation)(start|iteration|end|cancel)|(transition)(start|run|end|cancel)|(fullscreen)(change|error)|(lost|got)(pointer)(capture)|(pointer)(lock)(change|error)|(pointer)(cancel|down|enter|leave|move|out|over|up)/i;
+var VENDORS = ['', 'webkit', 'moz', 'ms', 'MS', 'o', 'O'];
+var LEGACY_TYPE_MAP = {
+    'wheel': ['wheel', 'mousewheel', 'DOMMouseScroll'],
+    'focus': ['focus', 'focusin'],
+    'blur': ['blur', 'focusout'],
+    'beforeinput': ['beforeinput', 'textInput'],
+};
+var EventListenerUtils = {
+    useStd: typeof globalThis.document !== 'undefined' && typeof globalThis.document.addEventListener === 'function',
+    add: function (target, eventListenerOptions) {
+        if (eventListenerOptions === void 0) { eventListenerOptions = { callback: null, options: false }; }
+        var callback = eventListenerOptions.callback;
+        if (typeof target === 'undefined' || callback === null)
+            return;
+        var type = EventListenerUtils.withVender(target, eventListenerOptions.type);
+        var options = eventListenerOptions.options;
+        if (typeof target.addEventListener === 'function') {
+            try {
+                return target.addEventListener(type, callback, options);
+            }
+            catch (_) {
+            }
+        }
+        if (typeof target.addListener === 'function') {
+            if (typeof target.matches === 'boolean') {
+                try {
+                    return target.addListener(callback);
+                }
+                catch (_) {
+                }
+            }
+            else {
+                try {
+                    return target.addListener(type, callback);
+                }
+                catch (_) {
+                }
+            }
+        }
+        function wrapper(event) {
+            if (typeof event === 'undefined')
+                event = globalThis.event;
+            if (typeof event === 'undefined')
+                return;
+            event.currentTarget = target;
+            if (typeof event.preventDefault !== 'function')
+                event.preventDefault = preventDefaultPolyfill;
+            if (typeof event.stopPropagation !== 'function')
+                event.stopPropagation = stopPropagationPolyfill;
+            if (typeof callback === 'function')
+                callback.call(target, event);
+            else if (callback && typeof callback.handleEvent === 'function')
+                callback.handleEvent.call(target, event);
+        }
+        if (typeof target.attachEvent === 'function') {
+            if (callback.__ieWrapper)
+                return target.attachEvent('on' + type, callback.__ieWrapper);
+            return target.attachEvent('on' + type, callback.__ieWrapper = wrapper);
+        }
     },
-    extends: function (plugin) {
-        if (plugin.installed)
-            return this;
-        this.Constants = assign(this.Constants, plugin.Constants);
-        this.Errors = assign(this.Errors, plugin.Errors);
-        this[plugin.name] = plugin.module;
-        plugin.installed = true;
-        return this;
+    remove: function (target, eventListenerOptions) {
+        if (eventListenerOptions === void 0) { eventListenerOptions = { callback: null, options: false }; }
+        var callback = eventListenerOptions.callback;
+        if (typeof target === 'undefined' || callback === null)
+            return;
+        var type = EventListenerUtils.withVender(target, eventListenerOptions.type);
+        var options = eventListenerOptions.options;
+        if (typeof target.removeEventListener === 'function') {
+            try {
+                return target.removeEventListener(type, callback, options);
+            }
+            catch (_) {
+            }
+        }
+        if (typeof target.removeListener === 'function') {
+            if (typeof target.matches === 'boolean') {
+                try {
+                    return target.removeListener(callback);
+                }
+                catch (_) {
+                }
+            }
+            else {
+                try {
+                    return target.removeListener(type, callback);
+                }
+                catch (_) {
+                }
+            }
+        }
+        if (typeof target.detachEvent === 'function') {
+            var wrapper = callback.__ieWrapper;
+            if (typeof wrapper !== 'undefined') {
+                target.detachEvent('on' + type, wrapper);
+                delete callback.__ieWrapper;
+            }
+            return;
+        }
+    },
+    withVender: function (target, type) {
+        if (typeof type === 'undefined')
+            return '';
+        if (target === globalThis.document && ['deviceready', 'pause', 'resume', 'backbutton', 'menubutton', 'searchbutton', 'startcallbutton', 'endcallbutton', 'volumedownbutton', 'volumeupbutton', 'activated', 'cordovacallbackerror'].indexOf(type) > -1)
+            return type;
+        if (typeof target.webkitEnterFullscreen !== 'undefined' && ['webkitbeginfullscreen', 'webkitendfullscreen', 'webkitpresentationmodechanged'].indexOf(type) > -1)
+            return type;
+        var types;
+        if (type in LEGACY_TYPE_MAP)
+            types = LEGACY_TYPE_MAP[type];
+        else if (EVENT_TYPE_REGEXP.test(type))
+            types = [type, type.replace(EVENT_TYPE_REGEXP, capitalize)];
+        else
+            types = [type];
+        for (var i = 0; i < VENDORS.length; i++) {
+            for (var j = 0; j < types.length; j++) {
+                var name_1 = VENDORS[i] + types[j];
+                if (typeof target['on' + name_1] !== 'undefined')
+                    return name_1;
+            }
+        }
+        return '';
+    }
+};
+
+var userAgent = USER_AGENT;
+var Platform = {
+    get os() {
+        return getOS();
+    },
+    get engine() {
+        return getEngine();
+    },
+    get browser() {
+        return getBrowser();
+    },
+    get userAgent() {
+        return userAgent;
+    },
+    set userAgent(value) {
+        userAgent = value;
+    },
+    get locale() {
+        return getLocale();
+    },
+    get device() {
+        return getDevice();
+    },
+    get renderer() {
+        return getRenderer();
+    },
+    get isWebview() {
+        return getIsWebview();
+    },
+    get isNode() {
+        return getIsNode();
+    },
+    get isStandalone() {
+        return getIsStandalone();
+    },
+    get isBot() {
+        return getIsBot();
+    },
+    Constants: {
+        OS: OS,
+        Engines: Engines,
+        Browsers: Browsers,
+        Devices: Devices,
+    },
+    Errors: {},
+};
+var parsedFromHighEntropyValuesOS = {};
+var parsedFromHighEntropyValuesBrowser = {};
+var parsedFromHighEntropyValuesEngine = {};
+var parsedFromHighEntropyValuesDevice = null;
+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 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 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 getLocale() {
+    var locale = {
+        language: null,
+        languages: [],
+        timezone: null,
+        offset: 0,
+        isRTL: false,
+    };
+    var isRTL = null;
+    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 (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.offset = new Date().getTimezoneOffset() * -1;
+    }
+    catch (_) {
+    }
+    if (typeof locale.language === 'string') {
+        if (typeof Intl !== 'undefined' && typeof Intl.Locale !== 'undefined') {
+            try {
+                var intlLocale = new Intl.Locale(locale.language);
+                if (typeof intlLocale.getTextInfo === 'function')
+                    isRTL = intlLocale.getTextInfo().direction === 'rtl';
+                else if (typeof intlLocale.textInfo !== 'undefined')
+                    isRTL = intlLocale.textInfo.direction === 'rtl';
+            }
+            catch (_) {
+            }
+        }
+        if (typeof isRTL !== 'boolean') {
+            var matched = /^([A-Za-z]{1,8})(?:[-_][A-Za-z0-9]{1,8})*$/.exec(locale.language);
+            if (matched !== null) {
+                var language = matched[1].toLowerCase();
+                for (var i = 0; i < RTL_LANGUAGES.length; i++) {
+                    if (RTL_LANGUAGES[i] === language) {
+                        isRTL = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (typeof isRTL === 'boolean')
+        locale.isRTL = isRTL;
+    return locale;
+}
+function getOS() {
+    var result = { name: OS.Unknown, version: '' };
+    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) {
+            result.name = os;
+            result.version = resolveVersion(matched[1], resolver);
+            break;
+        }
+    }
+    if (result.name === OS.iOS && compareVersion(result.version, '18.6') === 0) {
+        var version = /\) Version\/([\d.]+)/.exec(Platform.userAgent);
+        if (version !== null && parseInt(version[1].substring(0, 2), 10) >= 26)
+            result.version = version[1];
+    }
+    if (Platform.userAgent === USER_AGENT) {
+        if (typeof parsedFromHighEntropyValuesOS.name !== 'undefined')
+            result.name = parsedFromHighEntropyValuesOS.name;
+        if (typeof parsedFromHighEntropyValuesOS.version !== 'undefined')
+            result.version = parsedFromHighEntropyValuesOS.version;
+    }
+    return result;
+}
+function getEngine() {
+    var result = { name: Engines.Unknown, version: '' };
+    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) {
+            result.name = engine;
+            result.version = resolveVersion(matched[1], resolver);
+            break;
+        }
+    }
+    if (Platform.userAgent === USER_AGENT) {
+        if (typeof parsedFromHighEntropyValuesEngine.name !== 'undefined')
+            result.name = parsedFromHighEntropyValuesEngine.name;
+        if (typeof parsedFromHighEntropyValuesEngine.version !== 'undefined')
+            result.version = parsedFromHighEntropyValuesEngine.version;
+    }
+    return result;
+}
+function getBrowser() {
+    var result = { name: Browsers.Unknown, version: '' };
+    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) {
+            result.name = browser;
+            result.version = resolveVersion(matched[1], resolver);
+            break;
+        }
+    }
+    if (Platform.userAgent === USER_AGENT) {
+        if (typeof parsedFromHighEntropyValuesBrowser.name !== 'undefined')
+            result.name = parsedFromHighEntropyValuesBrowser.name;
+        if (typeof parsedFromHighEntropyValuesBrowser.version !== 'undefined')
+            result.version = parsedFromHighEntropyValuesBrowser.version;
+    }
+    return result;
+}
+function getDevice() {
+    if (Platform.userAgent === USER_AGENT && parsedFromHighEntropyValuesDevice !== null)
+        return parsedFromHighEntropyValuesDevice;
+    if (Platform.os.name === OS.iOS || Platform.os.name === OS.Android)
+        return Devices.Mobile;
+    if (Platform.os.name === OS.Windows || Platform.os.name === OS.MacOS)
+        return Devices.Desktop;
+    return Devices.Unknown;
+}
+function getIsWebview() {
+    return /; ?wv|applewebkit(?!.*safari)/i.test(Platform.userAgent);
+}
+function getIsNode() {
+    return typeof globalThis.process !== 'undefined' && typeof globalThis.process.versions !== 'undefined' && typeof globalThis.process.versions.node !== 'undefined';
+}
+function getIsStandalone() {
+    if (Platform.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;
+}
+function getIsBot() {
+    for (var i = 0; i < BOT_REGEXP.length; i++)
+        if (BOT_REGEXP[i].test(Platform.userAgent))
+            return true;
+    return false;
+}
+function parseFromHighEntropyValues() {
+    if (typeof globalThis.navigator !== 'undefined' && typeof globalThis.navigator.userAgentData !== 'undefined' && typeof globalThis.navigator.userAgentData.getHighEntropyValues !== 'undefined') {
+        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')
+                                parsedFromHighEntropyValuesBrowser.name = Browsers.Chrome;
+                            else if (browserName === 'Edge' || browserName === 'Edge WebView2')
+                                parsedFromHighEntropyValuesBrowser.name = Browsers.Edge;
+                            else if (browserName === 'Opera Mobi')
+                                parsedFromHighEntropyValuesBrowser.name = Browsers.Opera;
+                            parsedFromHighEntropyValuesBrowser.version = brandVersion;
+                        }
+                        prevBrandName = brandName;
+                    }
+                    if (brandName === 'Chromium')
+                        parsedFromHighEntropyValuesEngine.version = brandVersion;
+                }
+                if (typeof platformVersion === 'string') {
+                    if (Platform.os.name === OS.Windows)
+                        parsedFromHighEntropyValuesOS.version = parseInt(platformVersion.split('.')[0], 10) >= 13 ? '11' : '10';
+                    else
+                        parsedFromHighEntropyValuesOS.version = platformVersion;
+                }
+                if (typeof platform === 'string') {
+                    if (/android/i.test(platform))
+                        parsedFromHighEntropyValuesOS.name = OS.Android;
+                    else if (/ios|iphone|ipad/i.test(platform))
+                        parsedFromHighEntropyValuesOS.name = OS.iOS;
+                    else if (/windows|win32/i.test(platform))
+                        parsedFromHighEntropyValuesOS.name = OS.Windows;
+                    else if (/macos|macintel/i.test(platform))
+                        parsedFromHighEntropyValuesOS.name = OS.MacOS;
+                }
+                if (result.mobile === true)
+                    parsedFromHighEntropyValuesDevice = Devices.Mobile;
+            }
+            catch (_) {
+            }
+        });
+    }
+}
+parseFromHighEntropyValues();
+
+var _a;
+var App = {
+    open: open,
+    messenger: (_a = {},
+        _a[MessengerType.Telephone] = openMessengerTelephone,
+        _a[MessengerType.Message] = openMessengerMessage,
+        _a[MessengerType.Mail] = openMessengerMail,
+        _a),
+    setting: setting,
+    file: file,
+    contact: contact,
+    Constants: {
+        AppOpenState: AppOpenState,
+        MessengerType: MessengerType,
+        SettingType: SettingType
+    },
+    Errors: {
+        URLOpenError: URLOpenError,
+    }
+};
+function getTrackId(bundle) {
+    try {
+        var xhr = new XMLHttpRequest();
+        xhr.open('GET', 'https://itunes.apple.com/lookup?bundleId=' + bundle, false);
+        xhr.send();
+        if (xhr.status === 200) {
+            try {
+                return parseLookupBundleIdResponse(JSON.parse(xhr.response));
+            }
+            catch (_) {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+function parseLookupBundleIdResponse(response) {
+    if (typeof response.results === 'undefined')
+        return undefined;
+    var results = response.results;
+    if (results.length === 0)
+        return undefined;
+    var result = results[0];
+    if (typeof result === 'undefined')
+        return undefined;
+    return "" + result.trackId;
+}
+function createIntentURL(scheme, packageName, fallback) {
+    var split = scheme.split('://');
+    var prefix = split[0];
+    var suffix = split[1];
+    var intent = 'intent://';
+    if (typeof suffix !== 'undefined')
+        intent = intent + suffix;
+    intent = intent + '#Intent;'
+        + 'scheme=' + prefix + ';'
+        + 'action=android.intent.action.VIEW;'
+        + 'category=android.intent.category.BROWSABLE;';
+    if (typeof packageName !== 'undefined')
+        intent = intent + 'package=' + packageName + ';';
+    if (typeof fallback !== 'undefined' && typeof fallback === 'string')
+        intent = intent + 'S.browser_fallback_url=' + encodeURIComponent(fallback) + ';';
+    else if (typeof packageName !== 'undefined')
+        intent = intent + 'S.browser_fallback_url=' + encodeURIComponent(createAppStoreURL(packageName, OS.Android)) + ';';
+    return intent + 'end';
+}
+function parseIntentURL(intent) {
+    var parsed = {};
+    var split = intent.split('#Intent;');
+    var host = split[0].substring(9);
+    var suffix = split[1];
+    var parameterString = suffix.substring(0, suffix.length - 4);
+    var parameters = parameterString.split(';');
+    var extras = {};
+    for (var i = 0; i < parameters.length; i++) {
+        var part = parameters[i];
+        var index = part.indexOf('=');
+        if (index !== -1)
+            extras[part.substring(0, index)] = part.substring(index + 1);
+    }
+    if (typeof extras['scheme'] !== 'undefined')
+        parsed.scheme = (extras['scheme'] + '://' + host);
+    if (typeof extras['package'] !== 'undefined')
+        parsed.packageName = extras['package'];
+    if (typeof extras['S.browser_fallback_url'] !== 'undefined')
+        parsed.fallback = extras['S.browser_fallback_url'];
+    return parsed;
+}
+function createAppStoreURL(packageName, os) {
+    if (typeof packageName === 'undefined')
+        return undefined;
+    switch (os) {
+        case OS.Android:
+            return 'market://details?id=' + packageName;
+        case OS.iOS:
+            return 'itms-apps://itunes.apple.com/app/id' + packageName + '?mt=8';
+        case OS.Windows:
+            return 'ms-windows-store://pdp/?ProductId=' + packageName;
+        case OS.MacOS:
+            return 'macappstore://itunes.apple.com/app/id' + packageName + '?mt=12';
+        default:
+            throw new URLOpenError('Unsupported OS: \"' + Platform.userAgent + '\"');
+    }
+}
+function createWebStoreURL(packageName, os) {
+    if (typeof packageName === 'undefined')
+        return undefined;
+    switch (os) {
+        case OS.Android:
+            return 'https://play.google.com/store/apps/details?id=' + packageName;
+        case OS.iOS:
+            return 'https://itunes.apple.com/app/id' + packageName + '?mt=8';
+        case OS.Windows:
+            return 'https://apps.microsoft.com/detail/' + packageName;
+        case OS.MacOS:
+            return 'https://apps.apple.com/app/id' + packageName + '?mt=12';
+        default:
+            throw new URLOpenError('Unsupported OS: \"' + Platform.userAgent + '\"');
+    }
+}
+function getDefaultTimeoutByOS(os) {
+    switch (os) {
+        case OS.iOS:
+            return 2000;
+        case OS.Android:
+            return 1000;
+        default:
+            return 750;
+    }
+}
+function canOpenIntentURL() {
+    if (Platform.os.name !== OS.Android)
+        return false;
+    var version = Platform.browser.version;
+    if (Platform.browser.name === Browsers.SamsungInternet && compareVersion(version, '17.0.1.69') >= 0 && compareVersion(version, '17.0.7.34') < 0)
+        return false;
+    if (Platform.browser.name === Browsers.Firefox && compareVersion(version, '41.0') < 0)
+        return false;
+    if (Platform.browser.name === Browsers.Firefox && compareVersion(version, '58.0') >= 0 && compareVersion(version, '68.11.0') < 0)
+        return false;
+    if (Platform.browser.name === Browsers.Firefox && compareVersion(version, '79.0') >= 0 && compareVersion(version, '81.2.0') < 0)
+        return false;
+    if (Platform.browser.name === Browsers.Firefox && compareVersion(version, '96.0') >= 0 && compareVersion(version, '107.0') < 0)
+        return false;
+    if (Platform.browser.name === Browsers.Opera && compareVersion(version, '14.0') < 0)
+        return false;
+    return !(/(?:fban\/fbios|fb_iab\/fb4a)(?!.+fbav)|;fbav\/[\w.]+;/i.test(Platform.userAgent) || /instagram[\/ ][-\w.]+/i.test(Platform.userAgent) || /micromessenger\/([\w.]+)/i.test(Platform.userAgent) || /musical_ly(?:.+app_?version\/|_)[\w.]+/i.test(Platform.userAgent) || /ultralite app_version\/[\w.]+/i.test(Platform.userAgent));
+}
+function canOpenUniversalURL() {
+    return Platform.os.name === OS.iOS && compareVersion(Platform.os.version, '9.0') >= 0;
+}
+function getURLOpenError(tried) {
+    var triedURLString = '';
+    for (var i = 0; i < tried.length; i++)
+        triedURLString += '\n' + (i + 1) + ': ' + tried[i];
+    if (triedURLString.length > 0)
+        triedURLString = '\n' + triedURLString + '\n';
+    return new URLOpenError('Failed to open any of the provided URLs: ' + triedURLString);
+}
+function openURLViaHref(url, index) {
+    var top = getTopmostWindow();
+    var topDocument = top.document;
+    var a = undefined;
+    try {
+        if (index === 0) {
+            top.location.href = url;
+            return;
+        }
+        a = createHiddenElement('a');
+        if (typeof a === 'undefined')
+            return;
+        a.href = url;
+        topDocument.body.appendChild(a);
+        dispatchClickEvent(a, top);
+        return a;
+    }
+    catch (_) {
+    }
+    finally {
+        if (typeof a !== 'undefined') {
+            try {
+                topDocument.body.removeChild(a);
+            }
+            catch (_) {
+            }
+        }
+    }
+}
+function openURLViaIframe(url) {
+    var top = getTopmostWindow();
+    var topDocument = top.document;
+    var iframe = undefined;
+    try {
+        iframe = createHiddenElement('iframe');
+        if (typeof iframe === 'undefined')
+            return;
+        iframe.src = url;
+        topDocument.body.appendChild(iframe);
+        globalThis.setTimeout(function () {
+            if (typeof iframe !== 'undefined') {
+                try {
+                    topDocument.body.removeChild(iframe);
+                }
+                catch (_) {
+                }
+            }
+        }, 500);
     }
+    catch (_) {
+    }
+    return iframe;
+}
+function isDocumentHidden() {
+    var top = getTopmostWindow();
+    var topDocument = top.document;
+    if (topDocument.visibilityState === 'hidden')
+        return true;
+    if (topDocument.webkitVisibilityState === 'hidden')
+        return true;
+    if (topDocument.mozVisibilityState === 'hidden')
+        return true;
+    if (topDocument.msVisibilityState === 'hidden')
+        return true;
+    if (typeof topDocument.hidden !== 'undefined')
+        return topDocument.hidden;
+    if (typeof topDocument.webkitHidden !== 'undefined')
+        return topDocument.webkitHidden;
+    if (typeof topDocument.mozHidden !== 'undefined')
+        return topDocument.mozHidden;
+    if (typeof topDocument.msHidden !== 'undefined')
+        return topDocument.msHidden;
+    if (typeof topDocument.hasFocus === 'function')
+        return !topDocument.hasFocus();
+    return true;
+}
+function hasFocus(document) {
+    if (typeof document.hasFocus === 'function')
+        return document.hasFocus();
+    return false;
+}
+function focus(target) {
+    try {
+        target.focus({ preventScroll: true });
+    }
+    catch (_) {
+        try {
+            target.focus();
+        }
+        catch (_) {
+        }
+    }
+}
+function restoreFocus() {
+    var top = getTopmostWindow();
+    var topDocument = top.document;
+    focus(top);
+    if (hasFocus(topDocument))
+        return true;
+    if (topDocument.body.tabIndex < 0)
+        topDocument.body.tabIndex = -1;
+    focus(topDocument.body);
+    if (hasFocus(topDocument))
+        return true;
+    var input = undefined;
+    try {
+        input = createHiddenElement('input');
+        if (typeof input === 'undefined')
+            return false;
+        input.type = 'text';
+        input.readOnly = true;
+        topDocument.body.appendChild(input);
+        focus(input);
+        try {
+            input.select();
+        }
+        catch (_) {
+        }
+        if (hasFocus(topDocument))
+            return true;
+    }
+    catch (_) {
+    }
+    finally {
+        if (typeof input !== 'undefined' && input !== null) {
+            try {
+                input.blur();
+            }
+            catch (_) {
+            }
+            try {
+                topDocument.body.removeChild(input);
+            }
+            catch (_) {
+            }
+        }
+    }
+    return hasFocus(topDocument);
+}
+function tryOpenURL(url, index, timeout) {
+    var top = getTopmostWindow();
+    var topDocument = top.document;
+    var eventType = { focus: undefined, blur: undefined, visibilitychange: undefined };
+    var eventTarget = { focus: undefined, blur: undefined, visibilitychange: undefined };
+    if (typeof globalThis.cordova !== 'undefined') {
+        eventTarget = { focus: topDocument, blur: topDocument };
+        eventType = { focus: 'resume', blur: 'pause' };
+    }
+    else if (Platform.os.name === OS.iOS) {
+        if (compareVersion(Platform.os.version, '8.0') >= 0) {
+            eventTarget = { visibilitychange: topDocument };
+            eventType = { visibilitychange: 'visibilitychange' };
+        }
+        else {
+            eventTarget = { focus: top, blur: top };
+            eventType = { focus: 'pageshow', blur: 'pagehide' };
+        }
+    }
+    else {
+        if (EventListenerUtils.useStd) {
+            eventTarget = { focus: top, blur: top, visibilitychange: topDocument };
+            eventType = { focus: 'focus', blur: 'blur', visibilitychange: 'visibilitychange' };
+        }
+        else {
+            eventTarget = { focus: topDocument, blur: topDocument, visibilitychange: topDocument };
+            eventType = { focus: 'focus', blur: 'blur', visibilitychange: 'visibilitychange' };
+        }
+    }
+    var a = undefined;
+    var iframe = undefined;
+    return new Promise(function (resolve, reject) {
+        var timeoutId;
+        var resolved = false;
+        function cleanup() {
+            if (typeof timeoutId !== 'undefined') {
+                clearTimeout(timeoutId);
+                timeoutId = undefined;
+            }
+            try {
+                EventListenerUtils.remove(eventTarget.blur, { type: eventType.blur, callback: onBlur });
+                EventListenerUtils.remove(eventTarget.focus, { type: eventType.focus, callback: onFocus });
+                EventListenerUtils.remove(eventTarget.visibilitychange, { type: eventType.visibilitychange, callback: onVisibilityChange });
+            }
+            catch (_) {
+            }
+            if (typeof a !== 'undefined') {
+                try {
+                    topDocument.body.removeChild(a);
+                }
+                catch (_) {
+                }
+            }
+            if (typeof iframe !== 'undefined') {
+                try {
+                    topDocument.body.removeChild(iframe);
+                }
+                catch (_) {
+                }
+            }
+        }
+        function done(success) {
+            if (resolved)
+                return;
+            resolved = true;
+            try {
+                cleanup();
+                if (success)
+                    resolve();
+                else
+                    reject();
+            }
+            catch (_) {
+                resolve();
+            }
+        }
+        function onBlur() {
+            if (typeof timeoutId !== 'undefined') {
+                clearTimeout(timeoutId);
+                timeoutId = undefined;
+            }
+            EventListenerUtils.remove(eventTarget.blur, { type: eventType.blur, callback: onBlur });
+            EventListenerUtils.add(eventTarget.focus, { type: eventType.focus, callback: onFocus });
+        }
+        function onFocus() {
+            done(true);
+        }
+        function onVisibilityChange() {
+            if (isDocumentHidden())
+                done(true);
+        }
+        timeoutId = globalThis.setTimeout(function () {
+            done(false);
+        }, timeout);
+        EventListenerUtils.add(eventTarget.blur, { type: eventType.blur, callback: onBlur });
+        EventListenerUtils.add(eventTarget.visibilitychange, { type: eventType.visibilitychange, callback: onVisibilityChange });
+        if (!hasFocus(topDocument))
+            restoreFocus();
+        try {
+            if (typeof globalThis.cordova !== 'undefined') {
+                globalThis.open(url, '_system');
+            }
+            else {
+                a = openURLViaHref(url, index);
+                iframe = openURLViaIframe(url);
+            }
+        }
+        catch (_) {
+            done(false);
+        }
+    });
+}
+function open(options) {
+    var os = Platform.os.name;
+    var urls = [];
+    var tried = [];
+    var infos = {};
+    var timeout;
+    if (os === OS.Android) {
+        var option = options[OS.Android] || options['android'];
+        if (typeof option === 'undefined')
+            return Promise.reject(getURLOpenError(tried));
+        timeout = option.timeout;
+        infos.scheme = urlToString(option.scheme);
+        infos.intent = urlToString(option.intent);
+        infos.packageName = option.packageName;
+        infos.fallback = urlToString(option.fallback);
+        infos.appStore = createAppStoreURL(infos.packageName, OS.Android);
+        infos.webStore = createWebStoreURL(infos.packageName, OS.Android);
+        infos.allowAppStore = option.allowAppStore;
+        infos.allowWebStore = option.allowWebStore;
+        if (typeof infos.intent !== 'undefined' && (typeof infos.scheme === 'undefined' || typeof infos.packageName === 'undefined' || typeof infos.fallback === 'undefined')) {
+            var parsed = parseIntentURL(infos.intent);
+            if (typeof parsed.scheme !== 'undefined' && typeof infos.scheme === 'undefined')
+                infos.scheme = parsed.scheme;
+            if (typeof parsed.packageName !== 'undefined' && typeof infos.packageName === 'undefined')
+                infos.packageName = parsed.packageName;
+            if (typeof parsed.fallback !== 'undefined' && typeof infos.fallback === 'undefined')
+                infos.fallback = parsed.fallback;
+        }
+        if (typeof infos.scheme !== 'undefined' && typeof infos.intent === 'undefined')
+            infos.intent = createIntentURL(infos.scheme, infos.packageName, infos.fallback);
+    }
+    else if (os === OS.iOS) {
+        var option = options[OS.iOS] || options['ios'];
+        if (typeof option === 'undefined')
+            return Promise.reject(getURLOpenError(tried));
+        timeout = option.timeout;
+        infos.scheme = urlToString(option.scheme);
+        infos.bundleId = option.bundleId;
+        infos.trackId = option.trackId;
+        infos.universal = urlToString(option.universal);
+        infos.fallback = urlToString(option.fallback);
+        infos.appStore = createAppStoreURL(infos.trackId, OS.iOS);
+        infos.webStore = createWebStoreURL(infos.trackId, OS.iOS);
+        infos.allowAppStore = option.allowAppStore;
+        infos.allowWebStore = option.allowWebStore;
+        if (typeof infos.bundleId !== 'undefined' && typeof infos.trackId === 'undefined')
+            infos.trackId = getTrackId(infos.bundleId);
+    }
+    else if (os === OS.Windows) {
+        var option = options[OS.Windows] || options['windows'];
+        if (typeof option === 'undefined')
+            return Promise.reject(getURLOpenError(tried));
+        timeout = option.timeout;
+        infos.scheme = urlToString(option.scheme);
+        infos.productId = option.productId;
+        infos.fallback = urlToString(option.fallback);
+        infos.appStore = createAppStoreURL(infos.productId, OS.Windows);
+        infos.webStore = createWebStoreURL(infos.productId, OS.Windows);
+        infos.allowAppStore = option.allowAppStore;
+        infos.allowWebStore = option.allowWebStore;
+    }
+    else if (os === OS.MacOS) {
+        var option = options[OS.MacOS] || options['macos'];
+        if (typeof option === 'undefined')
+            return Promise.reject(getURLOpenError(tried));
+        timeout = option.timeout;
+        infos.scheme = urlToString(option.scheme);
+        infos.bundleId = option.bundleId;
+        infos.trackId = option.trackId;
+        infos.fallback = urlToString(option.fallback);
+        infos.appStore = createAppStoreURL(infos.trackId, OS.MacOS);
+        infos.webStore = createWebStoreURL(infos.trackId, OS.MacOS);
+        infos.allowAppStore = option.allowAppStore;
+        infos.allowWebStore = option.allowWebStore;
+        if (typeof infos.bundleId !== 'undefined' && typeof infos.trackId === 'undefined')
+            infos.trackId = getTrackId(infos.bundleId);
+    }
+    pushURL(urls, infos.intent, AppOpenState.Intent, canOpenIntentURL());
+    pushURL(urls, infos.universal, AppOpenState.Universal, canOpenUniversalURL());
+    pushURL(urls, infos.scheme, AppOpenState.Scheme, true);
+    pushURL(urls, infos.fallback, AppOpenState.Fallback, true);
+    pushURL(urls, infos.appStore, AppOpenState.Store, infos.allowAppStore);
+    pushURL(urls, infos.webStore, AppOpenState.Store, infos.allowWebStore);
+    if (typeof timeout === 'undefined')
+        timeout = getDefaultTimeoutByOS(os);
+    return new Promise(function (resolve, reject) {
+        function openURLSequential(index) {
+            if (index === void 0) { index = 0; }
+            if (index >= urls.length)
+                return reject(getURLOpenError(tried));
+            var entry = urls[index];
+            var state = entry[0];
+            var url = entry[1];
+            if (typeof url === 'string') {
+                tried[index] = url;
+                return tryOpenURL(url, index, timeout)
+                    .then(function () {
+                    resolve(state);
+                })
+                    .catch(function () {
+                    openURLSequential(index + 1);
+                });
+            }
+            else {
+                tried[index] = '[function fallback]';
+                url();
+                resolve(state);
+            }
+        }
+        return openURLSequential();
+    });
+}
+function pushURL(urls, url, state, condition) {
+    if (condition === void 0) { condition = false; }
+    if ((typeof url === 'function' || typeof url === 'string') && condition)
+        urls.push([state, url]);
+}
+function isArrayLike(value) {
+    if (value == null || typeof value === 'string')
+        return false;
+    var length = value.length;
+    return typeof length === 'number' && length >= 0 && !(length % 1);
+}
+function joining(values, mapfn, separator) {
+    if (separator === void 0) { separator = ','; }
+    var length = values.length;
+    var result = '';
+    for (var i = 0; i < length; i++) {
+        result = result + mapfn(values[i]);
+        if (i !== length - 1)
+            result = result + separator;
+    }
+    return result;
+}
+function encode(value) {
+    return encodeURIComponent(value)
+        .replace(/[!'()*]/g, function (c) {
+        return '%' + c.charCodeAt(0).toString(16);
+    });
+}
+function urlToString(value) {
+    if (value instanceof URL)
+        return value.toString();
+    return value;
+}
+function stringifiableToString(value) {
+    if (typeof value === 'string')
+        return encode(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return encode(String(value));
+    if (value == null)
+        return '';
+    if (isArrayLike(value))
+        return joining(value, function (v) {
+            return stringifiableToString(v);
+        });
+    if (value instanceof HTMLInputElement) {
+        var type = value.type;
+        if (type === 'checkbox') {
+            return encode(value.checked.toString());
+        }
+        else if (type === 'radio') {
+            if (value.checked)
+                return encode(value.value);
+            else
+                return '';
+        }
+        else if (type === 'file') {
+            var files = value.files;
+            if (files === null)
+                return '';
+            return joining(files, function (file) {
+                return encode(file.name);
+            });
+        }
+        else {
+            return encode(value.value);
+        }
+    }
+    if (value instanceof HTMLSelectElement) {
+        if (value.multiple)
+            return joining(value.selectedOptions, function (option) {
+                return encode(option.value);
+            });
+        return encode(value.value);
+    }
+    if (value instanceof HTMLTextAreaElement)
+        return encode(value.value);
+    if (value instanceof HTMLElement)
+        return encode(value.innerText);
+    if (value instanceof Node)
+        return stringifiableToString(value.textContent);
+    return encode(value.toString());
+}
+function normalize(value) {
+    if (value instanceof HTMLFormElement)
+        return normalize(new FormData(value));
+    if (value instanceof FormData) {
+        var result_1 = {};
+        value.forEach(function (value, key) {
+            var name;
+            if (value instanceof File)
+                name = value.name;
+            else
+                name = value;
+            if (Object.prototype.hasOwnProperty.call(result_1, key)) {
+                var prev = result_1[key];
+                if (Array.isArray(prev))
+                    prev.push(name);
+                else
+                    result_1[key] = [prev, name];
+            }
+            else {
+                result_1[key] = name;
+            }
+        });
+        return normalize(result_1);
+    }
+    var result = {};
+    var keys = Object.keys(value);
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        result[key] = stringifiableToString(value[key]);
+    }
+    if (typeof result.to === 'undefined')
+        result.to = '';
+    if (typeof result.cc === 'undefined')
+        result.cc = '';
+    if (typeof result.bcc === 'undefined')
+        result.bcc = '';
+    if (typeof result.subject === 'undefined')
+        result.subject = '';
+    if (typeof result.body === 'undefined')
+        result.body = '';
+    return result;
+}
+function openMessenger(options, type) {
+    options = normalize(options);
+    return tryOpenURL(type
+        + ':' + options.to
+        + '?cc=' + options.cc
+        + '&bcc=' + options.bcc
+        + '&subject=' + options.subject
+        + '&body=' + options.body, 0, getDefaultTimeoutByOS(Platform.os.name));
+}
+function openMessengerTelephone(options) {
+    return openMessenger(options, 'tel');
+}
+function openMessengerMessage(options) {
+    return openMessenger(options, 'sms');
+}
+function openMessengerMail(options) {
+    return openMessenger(options, 'mailto');
+}
+function setting(type) {
+    var os = Platform.os.name;
+    var version = Platform.os.version;
+    if (os === OS.Unknown)
+        return Promise.reject(getURLOpenError([]));
+    if (os === OS.Android && !canOpenIntentURL())
+        return Promise.reject(getURLOpenError([]));
+    if (os === OS.iOS)
+        return Promise.reject(getURLOpenError([]));
+    if (os === OS.Windows && (version === 'Vista' || version === 'XP' || version === '2000' || version === 'NT 4.0' || version === 'NT 3.11' || version === 'ME' || compareVersion(version, '10') < 0))
+        return Promise.reject(getURLOpenError([]));
+    if (os === OS.MacOS && compareVersion(version, '10.10') < 0)
+        return Promise.reject(getURLOpenError([]));
+    var urls = [];
+    switch (os) {
+        case OS.Android:
+            if (type !== SettingType.General) {
+                if (type === SettingType.Accessibility && compareVersion(version, '1.6') >= 0)
+                    urls.push(SETTING_URL['Android'][SettingType.Accessibility]);
+                else if (type === SettingType.Battery && compareVersion(version, '5.1') >= 0)
+                    urls.push(SETTING_URL['Android'][SettingType.Battery]);
+                else if (type === SettingType.Accounts && compareVersion(version, '1.5') >= 0)
+                    urls.push(SETTING_URL['Android'][SettingType.Accounts]);
+                else if (type === SettingType.Storage && compareVersion(version, '3.0') >= 0)
+                    urls.push(SETTING_URL['Android'][SettingType.Storage]);
+                else
+                    urls.push(SETTING_URL['Android'][type]);
+            }
+            urls.push(SETTING_URL['Android'][SettingType.General]);
+            break;
+        case OS.Windows:
+            urls.push(SETTING_URL['Windows'][type]);
+            break;
+        case OS.MacOS:
+            if (type === SettingType.Appearance && compareVersion(version, '10.14') < 0) {
+                urls.push(SETTING_URL['MacOS'][SettingType.General]);
+                break;
+            }
+            if (compareVersion(version, '13.0') < 0)
+                urls.push(SETTING_URL['MacOS'][type]);
+            else
+                urls.push(SETTING_URL['MacOS13+'][type]);
+            break;
+    }
+    return new Promise(function (resolve, reject) {
+        function openURLSequential(index) {
+            if (index === void 0) { index = 0; }
+            if (index >= urls.length)
+                return reject(getURLOpenError([]));
+            var url = urls[index];
+            return tryOpenURL(url, index, 750)
+                .then(function () {
+                resolve();
+            })
+                .catch(function () {
+                openURLSequential(index + 1);
+            });
+        }
+        return openURLSequential();
+    });
+}
+function file() {
+    return new Promise(function (resolve, reject) {
+        var input = createHiddenElement('input');
+        if (typeof input !== 'undefined') {
+            input.type = 'file';
+            input.multiple = true;
+            input.onchange = function () {
+                var fileList = input.files;
+                var files = [];
+                if (fileList === null)
+                    return resolve(files);
+                for (var i = 0; i < fileList.length; i++)
+                    files.push(fileList[i]);
+                resolve(files);
+            };
+            dispatchClickEvent(input);
+        }
+        reject(new Error());
+    });
+}
+function contact(options) {
+    return new Promise(function (resolve, reject) {
+        if (typeof navigator.contacts === 'undefined' || typeof globalThis.ContactsManager === 'undefined')
+            return reject(new Error());
+        var multiple = false;
+        var contactManager = navigator.contacts;
+        if (typeof options !== 'undefined')
+            multiple = options.multiple;
+        contactManager.getProperties().then(function (properties) {
+            contactManager.select(properties, { multiple: multiple }).then(function (contacts) {
+                resolve(contacts);
+            });
+        });
+    });
+}
+
+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$1 = [];
+
+var currentAppearance = null;
+var appearanceIntervalId = null;
+var Appearance = {
+    get value() {
+        return getAppearance();
+    },
+    onchange: onchange$2,
+    Constants: {
+        Appearances: Appearances
+    },
+    Errors: {}
+};
+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 getAppearance() {
+    if (Platform.browser.name === Browsers.SamsungInternet)
+        return getAppearanceFromEngine();
+    return getAppearanceFromMediaQuery();
+}
+function startPolling() {
+    currentAppearance = getAppearanceFromEngine();
+    appearanceIntervalId = globalThis.setInterval(function () {
+        var appearance = getAppearanceFromEngine();
+        if (appearance !== currentAppearance) {
+            currentAppearance = appearance;
+            notify$1(appearance);
+        }
+    }, 2000);
+}
+function stopPolling() {
+    currentAppearance = null;
+    if (appearanceIntervalId !== null) {
+        clearInterval(appearanceIntervalId);
+        appearanceIntervalId = null;
+    }
+}
+function addListener$1(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$1(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$1(currentAppearance = appearance);
+}
+function notify$1(appearance) {
+    for (var i = 0; i < ENTRIES$1.length; i++) {
+        var entry = ENTRIES$1[i];
+        entry.fn(appearance);
+        if (entry.once)
+            removeEntry$1(entry);
+    }
+}
+function removeEntry$1(entry) {
+    var index = indexOfEntry$1(entry);
+    if (index !== -1)
+        ENTRIES$1.splice(index, 1);
+    if (ENTRIES$1.length === 0) {
+        if (Platform.browser.name === Browsers.SamsungInternet)
+            stopPolling();
+        else
+            removeListener$1(entry.capture);
+    }
+}
+function indexOfEntry$1(entry) {
+    for (var i = 0; i < ENTRIES$1.length; i++)
+        if (ENTRIES$1[i].fn === entry.fn && ENTRIES$1[i].capture === entry.capture)
+            return i;
+    return -1;
+}
+function onchange$2(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;
+    var index = indexOfEntry$1(entry);
+    if (index === -1) {
+        ENTRIES$1.push(entry);
+        if (ENTRIES$1.length === 1) {
+            if (Platform.browser.name === Browsers.SamsungInternet)
+                startPolling();
+            else
+                addListener$1(entry.capture);
+        }
+    }
+    else if (ENTRIES$1[index].once && !entry.once) {
+        ENTRIES$1[index].once = false;
+    }
+    if (typeof entry.signal !== 'undefined') {
+        if (entry.signal.aborted) {
+            removeEntry$1(entry);
+        }
+        else {
+            entry.signal.addEventListener('abort', function onAbort() {
+                if (typeof entry.signal !== 'undefined')
+                    entry.signal.removeEventListener('abort', onAbort);
+                removeEntry$1(entry);
+            });
+        }
+    }
+    return function () {
+        removeEntry$1(entry);
+    };
+}
+
+function isSecureContext() {
+    if (typeof globalThis.isSecureContext !== 'undefined')
+        return globalThis.isSecureContext;
+    var protocol = location.protocol;
+    var hostname = location.hostname;
+    return protocol === 'https:' ||
+        hostname === 'localhost' ||
+        hostname === '127.0.0.1' ||
+        hostname === '[::1]';
+}
+
+var Clipboard = {
+    copy: copy,
+    paste: paste,
+    Constants: {},
+    Errors: {},
+};
+function isObject(item) {
+    return item !== null && typeof item === 'object';
+}
+function isArray(item) {
+    return Array.isArray(item);
+}
+function isSerializable(item) {
+    return isObject(item) || isArray(item);
+}
+function isElement(item) {
+    return isObject(item) && typeof item.innerText !== 'undefined';
+}
+function isSelection(item) {
+    return Object.prototype.toString.call(item) === '[object Selection]';
+}
+function convertToString(item) {
+    if (isElement(item)) {
+        if ('value' in item && typeof item.value === 'string')
+            return item.value;
+        return item.textContent;
+    }
+    if (isSelection(item))
+        return item.toString();
+    if (isSerializable(item)) {
+        try {
+            return JSON.stringify(item);
+        }
+        catch (_) {
+            return '' + item;
+        }
+    }
+    else if (typeof item !== 'string') {
+        return '' + item;
+    }
+    return item;
+}
+function convertToHTML(item) {
+    var html = null;
+    if (isElement(item))
+        html = item.outerHTML;
+    if (isSelection(item) && item.rangeCount > 0) {
+        var div = globalThis.document.createElement('div');
+        for (var i = 0; i < item.rangeCount; i++)
+            div.appendChild(item.getRangeAt(i).cloneContents());
+        html = div.innerHTML;
+    }
+    if (html === null)
+        return;
+    return html;
+}
+function supportsClipboardAPI() {
+    return (isSecureContext() && typeof navigator !== 'undefined' && 'clipboard' in navigator);
+}
+function supportsClipboardWriteAPI() {
+    return supportsClipboardAPI() && ('write' in navigator.clipboard || 'writeText' in navigator.clipboard);
+}
+function supportsClipboardReadAPI() {
+    return supportsClipboardAPI() && ('read' in navigator.clipboard || 'readText' in navigator.clipboard);
+}
+function copy(item) {
+    var text = convertToString(item);
+    var html = convertToHTML(item);
+    if (supportsClipboardWriteAPI()) {
+        return copyViaClipboardAPI(text, html)
+            .then(function (success) {
+            if (success)
+                return true;
+            return copyViaLegacy(text, html);
+        })
+            .catch(function () {
+            return copyViaLegacy(text, html);
+        });
+    }
+    return Promise.resolve(copyViaLegacy(text, html));
+}
+function copyViaClipboardAPI(text, html) {
+    try {
+        if ('ClipboardItem' in window && 'write' in navigator.clipboard) {
+            var items = {};
+            if (typeof html !== 'undefined')
+                items['text/html'] = new Blob([html], { type: 'text/html' });
+            items['text/plain'] = new Blob([text], { type: 'text/plain' });
+            return navigator.clipboard.write([new ClipboardItem(items)])
+                .then(function () {
+                return true;
+            })
+                .catch(function () {
+                return false;
+            });
+        }
+        else if ('writeText' in navigator.clipboard) {
+            return navigator.clipboard.writeText(text)
+                .then(function () {
+                return true;
+            })
+                .catch(function () {
+                return false;
+            });
+        }
+    }
+    catch (_) {
+        return Promise.resolve(false);
+    }
+    return Promise.resolve(false);
+}
+function copyViaSelection(text, html) {
+    if (!globalThis.getSelection || !globalThis.document.createRange)
+        return false;
+    var div = createHiddenElement('div');
+    if (typeof div === 'undefined')
+        return false;
+    div.contentEditable = 'true';
+    div.innerHTML = text;
+    div.style.whiteSpace = 'pre';
+    div.style.userSelect = 'text';
+    div.style.setProperty('-webkit-user-select', 'text');
+    div.style.setProperty('-moz-user-select', 'text');
+    div.style.setProperty('-ms-user-select', 'text');
+    globalThis.document.body.appendChild(div);
+    var selection = globalThis.getSelection();
+    var range = globalThis.document.createRange();
+    var onCopy = function (event) {
+        try {
+            if (event.clipboardData !== null && typeof event.clipboardData.setData === 'function') {
+                event.preventDefault();
+                if (typeof html !== 'undefined')
+                    event.clipboardData.setData('text/html', html);
+                event.clipboardData.setData('text/plain', text);
+            }
+        }
+        catch (_) {
+        }
+    };
+    EventListenerUtils.add(globalThis.document, { type: 'copy', callback: onCopy, options: { once: true, capture: true } });
+    try {
+        if (selection === null) {
+            cleanupSelection(div, selection, onCopy);
+            return false;
+        }
+        selection.removeAllRanges();
+        range.selectNodeContents(div);
+        selection.addRange(range);
+        var success = globalThis.document.execCommand('copy');
+        cleanupSelection(div, selection, onCopy);
+        return success;
+    }
+    catch (_) {
+        cleanupSelection(div, selection, onCopy);
+        return false;
+    }
+}
+function copyViaClipboardData(text, html) {
+    var windowWithClipboardData = window;
+    var clipboardData = windowWithClipboardData.clipboardData;
+    if (typeof clipboardData !== 'undefined' && typeof clipboardData.setData === 'function') {
+        try {
+            if (typeof html !== 'undefined')
+                clipboardData.setData('HTML', html);
+            return clipboardData.setData('Text', text);
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    return false;
+}
+function copyViaLegacy(text, html) {
+    return copyViaSelection(text, html) || copyViaClipboardData(text, html);
+}
+function paste() {
+    if (supportsClipboardReadAPI()) {
+        return pasteViaClipboardAPI()
+            .then(function (text) {
+            if (text !== null)
+                return text;
+            return pasteViaLegacy();
+        })
+            .catch(function () {
+            return pasteViaLegacy();
+        });
+    }
+    return Promise.resolve(pasteViaLegacy());
+}
+function pasteViaClipboardAPI() {
+    try {
+        if ('ClipboardItem' in window && 'read' in navigator.clipboard) {
+            return navigator.clipboard.read()
+                .then(function (items) {
+                if (items.length === 0)
+                    return Promise.resolve(null);
+                var item = items[0];
+                var types = item.types;
+                for (var i = 0; i < types.length; i++) {
+                    if (types[i] === 'text/html') {
+                        return item.getType('text/html')
+                            .then(function (blob) {
+                            return blob.text();
+                        })
+                            .catch(function () {
+                            return null;
+                        });
+                    }
+                }
+                for (var i = 0; i < types.length; i++) {
+                    if (types[i] === 'text/plain') {
+                        return item.getType('text/plain')
+                            .then(function (blob) {
+                            return blob.text();
+                        })
+                            .catch(function () {
+                            return null;
+                        });
+                    }
+                }
+                return Promise.resolve(null);
+            })
+                .catch(function () {
+                return null;
+            });
+        }
+        else if ('readText' in navigator.clipboard) {
+            return navigator.clipboard.readText()
+                .then(function (text) {
+                return text;
+            })
+                .catch(function () {
+                return null;
+            });
+        }
+    }
+    catch (_) {
+        return Promise.resolve(null);
+    }
+    return Promise.resolve(null);
+}
+function pasteViaSelection() {
+    var div = createHiddenElement('div');
+    if (typeof div === 'undefined')
+        return null;
+    div.contentEditable = 'true';
+    globalThis.document.body.appendChild(div);
+    div.focus();
+    var pastedText = null;
+    var onPaste = function (event) {
+        try {
+            if (event.clipboardData !== null && typeof event.clipboardData.getData === 'function') {
+                event.preventDefault();
+                pastedText = event.clipboardData.getData('text/html') || event.clipboardData.getData('text/plain') || null;
+            }
+        }
+        catch (_) {
+        }
+    };
+    EventListenerUtils.add(globalThis.document, { type: 'paste', callback: onPaste, options: { once: true, capture: true } });
+    try {
+        var success = globalThis.document.execCommand('paste');
+        if (!success && !pastedText) {
+            pastedText = div.innerHTML || div.textContent || null;
+        }
+        cleanupPaste(div, onPaste);
+        return pastedText;
+    }
+    catch (_) {
+        cleanupPaste(div, onPaste);
+        return null;
+    }
+}
+function pasteViaClipboardData() {
+    var windowWithClipboardData = window;
+    var clipboardData = windowWithClipboardData.clipboardData;
+    if (typeof clipboardData !== 'undefined' && typeof clipboardData.getData === 'function') {
+        try {
+            return clipboardData.getData('Text') || null;
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    return null;
+}
+function pasteViaLegacy() {
+    return pasteViaSelection() || pasteViaClipboardData() || '';
+}
+function cleanupSelection(span, selection, onCopy) {
+    if (selection !== null)
+        selection.removeAllRanges();
+    globalThis.document.body.removeChild(span);
+    EventListenerUtils.remove(globalThis.document, { type: 'copy', callback: onCopy });
+}
+function cleanupPaste(div, onPaste) {
+    globalThis.document.body.removeChild(div);
+    EventListenerUtils.remove(globalThis.document, { type: 'paste', callback: onPaste });
+}
+
+var ENTRIES = [];
+var FALLBACK_DIMENSION = {
+    innerWidth: -1,
+    innerHeight: -1,
+    outerWidth: -1,
+    outerHeight: -1,
+    scale: 1,
+};
+
+var currentDimension = null;
+var Dimension = {
+    get value() {
+        return getDimension();
+    },
+    onchange: onchange$1,
+    Constants: {},
+    Errors: {},
+};
+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 getDimension() {
+    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 onchange$1(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;
+    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 Fullscreen = {
+    get enabled() {
+        return getEnabled();
+    },
+    get element() {
+        return getElement();
+    },
+    get isFullscreen() {
+        return getIsFullscreen();
+    },
+    request: request,
+    exit: exit,
+    toggle: toggle,
+    onchange: onchange,
+    onerror: onerror,
+    Constants: {},
+    Errors: {},
+};
+var lastIOSVideo = null;
+var eventsBridged = false;
+var API_VARIANTS = {
+    standard: {
+        enabled: 'fullscreenEnabled',
+        element: 'fullscreenElement',
+        request: 'requestFullscreen',
+        exit: 'exitFullscreen',
+        events: { change: 'fullscreenchange', error: 'fullscreenerror' },
+    },
+    webkit: {
+        enabled: 'webkitFullscreenEnabled',
+        element: 'webkitFullscreenElement',
+        request: 'webkitRequestFullscreen',
+        exit: 'webkitExitFullscreen',
+        events: { change: 'webkitfullscreenchange', error: 'webkitfullscreenerror' },
+    },
+    moz: {
+        enabled: 'mozFullScreenEnabled',
+        element: 'mozFullScreenElement',
+        request: 'mozRequestFullScreen',
+        exit: 'mozCancelFullScreen',
+        events: { change: 'mozfullscreenchange', error: 'mozfullscreenerror' },
+    },
+    ms: {
+        enabled: 'msFullscreenEnabled',
+        element: 'msFullscreenElement',
+        request: 'msRequestFullscreen',
+        exit: 'msExitFullscreen',
+        events: { change: 'MSFullscreenChange', error: 'MSFullscreenError' },
+    },
+};
+var api = detectApi();
+function detectApi() {
+    var element = globalThis.document.documentElement;
+    if ('fullscreenEnabled' in globalThis.document || 'exitFullscreen' in globalThis.document) {
+        return API_VARIANTS.standard;
+    }
+    var keys = ['webkit', 'moz', 'ms'];
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var api_1 = API_VARIANTS[key];
+        if (api_1.enabled in globalThis.document || api_1.element in globalThis.document || api_1.exit in globalThis.document) {
+            if (key === 'webkit' && 'webkitRequestFullScreen' in element)
+                api_1.request = 'webkitRequestFullScreen';
+            return api_1;
+        }
+    }
+    if ('webkitCurrentFullScreenElement' in globalThis.document) {
+        var api_2 = {
+            enabled: 'webkitFullscreenEnabled',
+            element: 'webkitCurrentFullScreenElement',
+            request: 'webkitRequestFullscreen',
+            exit: 'webkitExitFullscreen',
+            events: API_VARIANTS.webkit.events,
+        };
+        if ('webkitRequestFullScreen' in element)
+            api_2.request = 'webkitRequestFullScreen';
+        return api_2;
+    }
+    return null;
+}
+function getDefaultTarget() {
+    if (Platform.os.name === OS.iOS) {
+        var video = globalThis.document.querySelector('video');
+        if (video === null)
+            throw new Error();
+        return video;
+    }
+    return globalThis.document.documentElement;
+}
+function bridgeEvents() {
+    if (eventsBridged)
+        return;
+    eventsBridged = true;
+    var dispatching = false;
+    function emit(type) {
+        if (dispatching)
+            return;
+        dispatching = true;
+        if (typeof globalThis.document !== 'undefined')
+            globalThis.document.dispatchEvent(new Event(type, { bubbles: true, cancelable: false }));
+        Promise.resolve().then(function () {
+            dispatching = false;
+        });
+    }
+    function emitChange() {
+        emit('fullscreenchange');
+    }
+    function emitError() {
+        emit('fullscreenerror');
+    }
+    var changeEvents = ['webkitfullscreenchange', 'mozfullscreenchange', 'MSFullscreenChange'];
+    var errorEvents = ['webkitfullscreenerror', 'mozfullscreenerror', 'MSFullscreenError'];
+    for (var i = 0; i < changeEvents.length; i++) {
+        if (typeof globalThis.document !== 'undefined')
+            globalThis.document.addEventListener(changeEvents[i], emitChange, false);
+    }
+    for (var i = 0; i < errorEvents.length; i++) {
+        if (typeof globalThis.document !== 'undefined')
+            globalThis.document.addEventListener(errorEvents[i], emitError, false);
+    }
+    if (Platform.os.name === OS.iOS) {
+        bridgeIOSVideoEvents();
+        if (typeof globalThis.MutationObserver !== 'undefined') {
+            var observer = new MutationObserver(function () {
+                bridgeIOSVideoEvents();
+            });
+            observer.observe(globalThis.document.documentElement, { childList: true, subtree: true });
+        }
+    }
+}
+function bridgeIOSVideoEvents() {
+    if (typeof globalThis.document !== 'undefined') {
+        var videos = globalThis.document.querySelectorAll('video');
+        videos.forEach(function (video) {
+            if (video.__fsBridged__ || !('webkitEnterFullscreen' in video || 'onwebkitbeginfullscreen' in video))
+                return;
+            function emitChange() {
+                globalThis.document.dispatchEvent(new Event('fullscreenchange'));
+            }
+            video.addEventListener('webkitbeginfullscreen', emitChange, false);
+            video.addEventListener('webkitendfullscreen', emitChange, false);
+            video.__fsBridged__ = true;
+        });
+    }
+}
+function getEnabled() {
+    if (api === null) {
+        if (Platform.os.name !== OS.iOS)
+            return false;
+        var videos = globalThis.document.querySelectorAll('video');
+        for (var i = 0; i < videos.length; i++) {
+            var video = videos[i];
+            if (video.webkitSupportsFullscreen || 'webkitEnterFullscreen' in video)
+                return true;
+        }
+        return false;
+    }
+    var enabledValue = globalThis.document[api.enabled];
+    if (typeof enabledValue === 'boolean')
+        return enabledValue;
+    return typeof globalThis.document[api.element] !== 'undefined';
+}
+function getElement() {
+    if (api === null) {
+        if (lastIOSVideo && lastIOSVideo.webkitDisplayingFullscreen)
+            return lastIOSVideo;
+        return null;
+    }
+    var currentElement = globalThis.document[api.element];
+    if (currentElement !== null && typeof currentElement !== 'undefined')
+        return currentElement;
+    return null;
+}
+function getIsFullscreen() {
+    return getElement() !== null;
+}
+function request(target, options) {
+    if (target === void 0) { target = getDefaultTarget(); }
+    return new Promise(function (resolve, reject) {
+        if (api !== null) {
+            var method = target[api.request];
+            if (typeof method === 'function') {
+                try {
+                    var result = method.call(target, options);
+                    if (typeof result !== 'undefined' && typeof result.then === 'function') {
+                        result
+                            .then(function () {
+                            resolve();
+                        })
+                            .catch(function () {
+                            if (Platform.os.name !== OS.iOS) {
+                                reject();
+                                return;
+                            }
+                            fallbackToIOSVideo();
+                        });
+                        return;
+                    }
+                    else {
+                        resolve();
+                        return;
+                    }
+                }
+                catch (error) {
+                    if (Platform.os.name !== OS.iOS) {
+                        reject();
+                        return;
+                    }
+                }
+            }
+        }
+        function fallbackToIOSVideo() {
+            if (Platform.os.name === OS.iOS && target.tagName.toUpperCase() === 'VIDEO') {
+                var video = target;
+                if (video.webkitSupportsFullscreen && typeof video.webkitEnterFullscreen === 'function') {
+                    lastIOSVideo = video;
+                    bridgeIOSVideoEvents();
+                    video.webkitEnterFullscreen();
+                    resolve();
+                    return;
+                }
+            }
+            reject();
+        }
+        fallbackToIOSVideo();
+    });
+}
+function exit() {
+    return new Promise(function (resolve, reject) {
+        if (api !== null) {
+            var method = globalThis.document[api.exit];
+            if (typeof method === 'function') {
+                var result = method.call(globalThis.document);
+                if (typeof result !== 'undefined' && typeof result.then === 'function') {
+                    result
+                        .then(function () {
+                        resolve();
+                    })
+                        .catch(function () {
+                        reject();
+                    });
+                    return;
+                }
+                else {
+                    resolve();
+                    return;
+                }
+            }
+        }
+        if (Platform.os.name === OS.iOS && lastIOSVideo !== null) {
+            if (typeof lastIOSVideo.webkitExitFullscreen === 'function' && lastIOSVideo.webkitDisplayingFullscreen === true) {
+                lastIOSVideo.webkitExitFullscreen();
+                lastIOSVideo = null;
+                resolve();
+                return;
+            }
+            var videos = globalThis.document.querySelectorAll('video');
+            for (var i = 0; i < videos.length; i++) {
+                var video = videos[i];
+                if (typeof video.webkitExitFullscreen === 'function' && video.webkitDisplayingFullscreen === true) {
+                    video.webkitExitFullscreen();
+                    resolve();
+                    return;
+                }
+            }
+        }
+        if (!getElement()) {
+            resolve();
+            return;
+        }
+        reject();
+    });
+}
+function toggle(target, options) {
+    if (getIsFullscreen())
+        return exit();
+    else
+        return request(target, options);
+}
+function onchange(handler) {
+    var listeners = [];
+    function listen(eventType) {
+        function wrapper(event) {
+            handler(event);
+        }
+        if (typeof globalThis.document === 'undefined')
+            return;
+        globalThis.document.addEventListener(eventType, wrapper, false);
+        listeners.push(function () {
+            globalThis.document.removeEventListener(eventType, wrapper, false);
+        });
+    }
+    listen('fullscreenchange');
+    return function () {
+        for (var i = 0; i < listeners.length; i++) {
+            listeners[i]();
+        }
+    };
+}
+function onerror(handler) {
+    var listeners = [];
+    function listen(eventType) {
+        function wrapper(event) {
+            handler(event);
+        }
+        if (typeof globalThis.document === 'undefined')
+            return;
+        globalThis.document.addEventListener(eventType, wrapper, false);
+        listeners.push(function () {
+            globalThis.document.removeEventListener(eventType, wrapper, false);
+        });
+    }
+    listen('fullscreenerror');
+    return function () {
+        for (var i = 0; i < listeners.length; i++) {
+            listeners[i]();
+        }
+    };
+}
+bridgeEvents();
+
+var IS_IE_MOBILE = /iemobile/i.test(Platform.userAgent);
+var IS_WINDOWS_PHONE = /windows phone/i.test(Platform.userAgent);
+
+var metaElement = null;
+var Theme = {
+    get value() {
+        return getThemeColor();
+    },
+    set value(color) {
+        if (typeof color === 'undefined')
+            removeThemeColor();
+        else
+            setThemeColor(color);
+    },
+    Constants: {},
+    Errors: {},
+};
+function getMetaName() {
+    if (IS_IE_MOBILE)
+        return 'msapplication-navbutton-color';
+    if (IS_WINDOWS_PHONE)
+        return 'msapplication-TileColor';
+    return 'theme-color';
+}
+function getMeta() {
+    if (metaElement !== null && metaElement.isConnected)
+        return metaElement;
+    return metaElement = globalThis.document.querySelector("meta[name=\"" + getMetaName() + "\"]");
+}
+function createMeta() {
+    var meta = globalThis.document.createElement('meta');
+    meta.setAttribute('name', getMetaName());
+    globalThis.document.head.prepend(meta);
+    return metaElement = meta;
+}
+function setThemeColor(color) {
+    var meta = getMeta();
+    if (meta === null)
+        meta = createMeta();
+    meta.setAttribute('content', color);
+}
+function getThemeColor() {
+    var meta = getMeta();
+    if (!meta)
+        return undefined;
+    return meta.getAttribute('content') || undefined;
+}
+function removeThemeColor() {
+    var meta = getMeta();
+    if (meta) {
+        meta.remove();
+        metaElement = null;
+    }
+}
+
+(function () {
+    if (typeof globalThis === 'object')
+        return;
+    Object.defineProperty(Object.prototype, '__getGlobalThis__', {
+        get: function () {
+            return this;
+        },
+        configurable: true
+    });
+    try {
+        var global = __getGlobalThis__;
+        Object.defineProperty(global, 'globalThis', {
+            value: global,
+            writable: true,
+            configurable: true
+        });
+    }
+    finally {
+        delete Object.prototype.__getGlobalThis__;
+    }
+}());
+var Native = {
+    Version: packageJSON.version,
+    App: App,
+    Appearance: Appearance,
+    Clipboard: Clipboard,
+    Dimension: Dimension,
+    Fullscreen: Fullscreen,
+    Platform: Platform,
+    Theme: Theme,
 };
 
 module.exports = Native;