web-launch-kit 0.0.2 → 0.0.4

package/dist/launch-kit.cjs

@@ -2,24 +2,37 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version$1 = "0.0.2";
-var packageJSON$1 = {
-	version: version$1};
+var version$3 = "0.0.4";
+var packageJSON$3 = {
+	version: version$3};
 
-var version = "0.0.4";
-var packageJSON = {
-	version: version};
+var version$2 = "0.0.5";
+var packageJSON$2 = {
+	version: version$2};
 
-var NAVIGATOR$1 = globalThis.navigator;
-var USER_AGENT = typeof NAVIGATOR$1 !== 'undefined' ? NAVIGATOR$1.userAgent : '';
-var USER_AGENT_DATA = typeof NAVIGATOR$1 !== 'undefined' ? NAVIGATOR$1.userAgentData : undefined;
+function getGlobal$3() {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    return {};
+}
+var GLOBAL$5 = getGlobal$3();
+var NAVIGATOR$1 = GLOBAL$5.navigator;
+var USER_AGENT = typeof NAVIGATOR$1 !== 'undefined' && NAVIGATOR$1 !== null && typeof NAVIGATOR$1.userAgent === 'string' ? NAVIGATOR$1.userAgent : '';
+var USER_AGENT_DATA = typeof NAVIGATOR$1 !== 'undefined' && NAVIGATOR$1 !== null ? NAVIGATOR$1.userAgentData : undefined;
 var OS_RESOLVER_MAP = [
-    [/windows nt (6\.[23]); arm/i, 'windows', resolveWindowsVersion],
-    [/windows (?:phone|mobile|iot)(?: os)?[\/ ]?([\d.]*( se)?)/i, 'windows', resolveWindowsVersion],
-    [/windows[\/ ](1[01]|2000|3\.1|7|8(\.1)?|9[58]|me|server 20\d\d( r2)?|vista|xp)/i, 'windows', resolveWindowsVersion],
+    [/windows nt (6\.[23]); arm/i, 'windows', 'RT'],
+    [/windows (?:phone|mobile|iot)(?: os)?[\/ ]?([\d.]*( se)?)/i, 'windows'],
+    [/win 9x 4\.90/i, 'windows', 'ME'],
+    [/windows[\/ ](1[01]|2000|3\.1|7|8(\.1)?|9[58]|me|server 20\d\d( r2)?|vista|xp)/i, 'windows'],
     [/windows nt ?([\d.)]*)(?!.+xbox)/i, 'windows', resolveWindowsVersion],
     [/\bwin(?=3| ?9|n)(?:nt| 9x )?([\d.;]*)/i, 'windows', resolveWindowsVersion],
-    [/windows ce\/?([\d.]*)/i, 'windows', resolveWindowsVersion],
+    [/windows ce\/?([\d.]*)/i, 'windows'],
     [/[adehimnop]{4,7}\b(?:.*os (\w+) like mac|; opera)/i, 'ios', resolveUnderscoreVersion],
     [/(?:ios;fbsv|ios(?=.+ip(?:ad|hone))|ip(?:ad|hone)(?: |.+i(?:pad)?)os)[\/ ]([\w.]+)/i, 'ios', resolveUnderscoreVersion],
     [/cfnetwork\/.+darwin/i, 'ios', resolveUnderscoreVersion],
@@ -48,13 +61,14 @@ var BROWSER_RESOLVER_MAP = [
     [/samsungbrowser\/([\w.]+)/i, 'samsung'],
     [/headlesschrome(?:\/([\w.]+)| )/i, 'chrome'],
     [/wv\).+chrome\/([\w.]+).+edgw\//i, 'edge'],
-    [/ wv\).+(chrome)\/([\w.]+)/i, 'chrome'],
+    [/ wv\).+chrome\/([\w.]+)/i, 'chrome'],
     [/chrome\/([\w.]+) mobile/i, 'chrome'],
     [/chrome\/v?([\w.]+)/i, 'chrome'],
     [/version\/([\w.,]+) .*mobile(?:\/\w+ | ?)safari/i, 'safari'],
     [/iphone .*mobile(?:\/\w+ | ?)safari/i, 'safari'],
     [/version\/([\w.,]+) .*safari/i, 'safari'],
     [/webkit.+?(?:mobile ?safari|safari)(\/[\w.]+)/i, 'safari', '1'],
+    [/(?:iphone|ipad|ipod).+applewebkit(?!.*safari)/i, 'safari'],
     [/(?:mobile|tablet);.*firefox\/([\w.-]+)/i, 'firefox'],
     [/mobile vr; rv:([\w.]+)\).+firefox/i, 'firefox'],
     [/firefox\/([\w.]+)/i, 'firefox'],
@@ -71,6 +85,18 @@ var ENGINE_RESOLVER_MAP = [
     [/tasman[\/ ]\(?([\w.]+)/i, 'tasman'],
     [/rv:([\w.]{1,9})\b.+gecko/i, 'gecko']
 ];
+var IN_APP_BROWSER_RESOLVER_MAP = [
+    [/kakaotalk/i, 'kakaotalk'],
+    [/\bline\/[\d.]/i, 'line'],
+    [/instagram/i, 'instagram'],
+    [/\bfban\/|\bfbav\/|fb_iab/i, 'facebook'],
+    [/naver\(inapp/i, 'naver'],
+    [/daumapps/i, 'daum'],
+    [/\bband\/[\d.]/i, 'band'],
+    [/micromessenger/i, 'wechat'],
+    [/twitter for|twitterandroid/i, 'twitter'],
+    [/musical_ly|bytedancewebview|\btiktok/i, 'tiktok'],
+];
 var HIGH_ENTROPY_BRAND_NAME_MAP = {
     'Google Chrome': 'Chrome',
     'Microsoft Edge': 'Edge',
@@ -93,19 +119,18 @@ function resolveWindowsVersion(string) {
         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];
+        '3.51': 'NT 3.51',
+        '4.0': 'NT 4.0',
+        '5.0': '2000',
+        '5.1': 'XP',
+        '5.2': 'XP',
+        '6.0': 'Vista',
+        '6.1': '7',
+        '6.2': '8',
+        '6.3': '8.1',
+        '6.4': '10',
+        '10.0': '10'
+    }[string.replace(/[^\d.]/g, '')];
     if (typeof mapped !== 'undefined')
         return mapped;
     return string;
@@ -124,6 +149,28 @@ function resolveVersion(string, resolver) {
         return '';
     return string;
 }
+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 parseOS() {
     var name = 'unknown';
     var version = '';
@@ -136,7 +183,7 @@ function parseOS() {
             break;
         }
     }
-    if (name === 'ios' && PlatformKit.compareVersion(version, '18.6') === 0) {
+    if (name === 'ios' && compareVersion(version, '18.6') === 0) {
         var execs = /\) Version\/([\d.]+)/.exec(currentUserAgent);
         if (execs !== null) {
             var major = parseInt(execs[1].split('.')[0], 10);
@@ -149,7 +196,7 @@ function parseOS() {
             name = parsedFromHighEntropyValuesOSName;
         if (typeof parsedFromHighEntropyValuesOSVersion !== 'undefined')
             version = parsedFromHighEntropyValuesOSVersion;
-        if (name === 'macos' && typeof globalThis.navigator.standalone !== 'undefined' && typeof globalThis.navigator.maxTouchPoints !== 'undefined' && globalThis.navigator.maxTouchPoints > 2)
+        if (name === 'macos' && typeof NAVIGATOR$1 !== 'undefined' && NAVIGATOR$1 !== null && typeof NAVIGATOR$1.standalone !== 'undefined' && typeof NAVIGATOR$1.maxTouchPoints === 'number' && NAVIGATOR$1.maxTouchPoints > 2)
             name = 'ios';
     }
     return {
@@ -201,6 +248,39 @@ function parseEngine() {
         version: version
     };
 }
+function parseInAppBrowser() {
+    for (var i = 0; i < IN_APP_BROWSER_RESOLVER_MAP.length; i++) {
+        if (IN_APP_BROWSER_RESOLVER_MAP[i][0].test(currentUserAgent))
+            return IN_APP_BROWSER_RESOLVER_MAP[i][1];
+    }
+    return null;
+}
+function parseWebview() {
+    if (/; ?wv\)/i.test(currentUserAgent))
+        return true;
+    if (/\bversion\/[\d.]+ chrome\//i.test(currentUserAgent))
+        return true;
+    if (/\belectron\//i.test(currentUserAgent))
+        return true;
+    if (/(?:iphone|ipad|ipod)/i.test(currentUserAgent) && /applewebkit/i.test(currentUserAgent) && /safari/i.test(currentUserAgent) === false)
+        return true;
+    return parseInAppBrowser() !== null;
+}
+function parseDevice() {
+    if (currentUserAgent === USER_AGENT && parsedFromHighEntropyValuesDevice !== null)
+        return parsedFromHighEntropyValuesDevice;
+    var osName = getParsedCache().os.name;
+    if (osName === 'ios') {
+        if (/ipad/i.test(currentUserAgent) || /macintosh/i.test(currentUserAgent))
+            return 'tablet';
+        return 'mobile';
+    }
+    if (osName === 'android')
+        return /\bmobile\b/i.test(currentUserAgent) ? 'mobile' : 'tablet';
+    if (osName === 'windows' || osName === 'macos')
+        return 'desktop';
+    return 'unknown';
+}
 function getParsedCache() {
     if (parsedCache !== null && parsedCache.userAgent === currentUserAgent)
         return parsedCache;
@@ -228,11 +308,31 @@ function normalizeBrand(entry) {
         return { brand: entry, version: '' };
     return { brand: entry.brand, version: entry.version };
 }
+function resolvedThenable() {
+    if (typeof Promise === 'function')
+        return Promise.resolve();
+    var thenable = {
+        then: function (onFulfilled) {
+            if (typeof onFulfilled === 'function')
+                onFulfilled(undefined);
+            return thenable;
+        },
+        catch: function () {
+            return thenable;
+        },
+        finally: function (onFinally) {
+            if (typeof onFinally === 'function')
+                onFinally();
+            return thenable;
+        },
+    };
+    return thenable;
+}
 function parseFromHighEntropyValues() {
     if (typeof USER_AGENT_DATA === 'undefined' || typeof USER_AGENT_DATA.getHighEntropyValues === 'undefined')
-        return Promise.resolve();
+        return resolvedThenable();
     return USER_AGENT_DATA
-        .getHighEntropyValues(['brands', 'fullVersionList', 'mobile', 'model', 'platform', 'platformVersion', 'architecture', 'formFactors', 'bitness', 'uaFullVersion', 'wow64'])
+        .getHighEntropyValues(['brands', 'fullVersionList', 'mobile', 'platform', 'platformVersion', 'formFactors'])
         .then(function (result) {
         try {
             var brands = result.fullVersionList || result.brands || [];
@@ -285,12 +385,26 @@ function parseFromHighEntropyValues() {
                 else if (/macos|macintel/i.test(platform))
                     parsedFromHighEntropyValuesOSName = 'macos';
             }
-            if (result.mobile === true)
+            var formFactors = result.formFactors;
+            if (typeof formFactors !== 'undefined' && formFactors !== null && typeof formFactors.length === 'number') {
+                for (var i = 0; i < formFactors.length; i++) {
+                    var formFactor = String(formFactors[i]).toLowerCase();
+                    if (formFactor === 'tablet')
+                        parsedFromHighEntropyValuesDevice = 'tablet';
+                    else if (formFactor === 'mobile')
+                        parsedFromHighEntropyValuesDevice = 'mobile';
+                    else if (formFactor === 'desktop')
+                        parsedFromHighEntropyValuesDevice = 'desktop';
+                }
+            }
+            if (parsedFromHighEntropyValuesDevice === null && result.mobile === true)
                 parsedFromHighEntropyValuesDevice = 'mobile';
-            parsedCache = null;
         }
         catch (_) {
         }
+        finally {
+            parsedCache = null;
+        }
     })
         .catch(function () {
         parsedCache = null;
@@ -298,15 +412,29 @@ function parseFromHighEntropyValues() {
 }
 ready = parseFromHighEntropyValues();
 var PlatformKit = {
-    version: packageJSON.version,
+    version: packageJSON$2.version,
     get ready() {
         return ready;
     },
+    whenReady: function (callback) {
+        if (typeof callback !== 'function')
+            return;
+        ready.then(function () {
+            callback();
+        });
+    },
     set userAgent(userAgent) {
         if (currentUserAgent === userAgent)
             return;
         currentUserAgent = userAgent;
         invalidateCache();
+        ready = userAgent === USER_AGENT ? parseFromHighEntropyValues() : resolvedThenable();
+    },
+    reset: function () {
+        if (currentUserAgent === USER_AGENT)
+            return;
+        currentUserAgent = USER_AGENT;
+        invalidateCache();
         ready = parseFromHighEntropyValues();
     },
     get userAgent() {
@@ -322,56 +450,799 @@ var PlatformKit = {
         return getParsedCache().engine;
     },
     get device() {
-        if (currentUserAgent === USER_AGENT && parsedFromHighEntropyValuesDevice !== null)
-            return parsedFromHighEntropyValuesDevice;
-        var osName = getParsedCache().os.name;
-        if (osName === 'ios' || osName === 'android')
-            return 'mobile';
-        if (osName === 'windows' || osName === 'macos')
-            return 'desktop';
-        return 'unknown';
+        return parseDevice();
     },
     get webview() {
-        return /; ?wv|applewebkit(?!.*safari)/i.test(currentUserAgent);
+        return parseWebview();
+    },
+    get inAppBrowser() {
+        return parseInAppBrowser();
     },
     get node() {
-        return typeof globalThis.process !== 'undefined' && typeof globalThis.process.versions !== 'undefined' && typeof globalThis.process.versions.node !== 'undefined';
+        var nodeProcess = GLOBAL$5.process;
+        return typeof nodeProcess !== 'undefined' && nodeProcess !== null && typeof nodeProcess.versions !== 'undefined' && nodeProcess.versions !== null && typeof nodeProcess.versions.node !== 'undefined';
     },
     get standalone() {
         var osName = getParsedCache().os.name;
         if (osName === 'ios')
-            return globalThis.navigator.standalone === true;
-        if (typeof globalThis.matchMedia === 'undefined')
+            return typeof NAVIGATOR$1 !== 'undefined' && NAVIGATOR$1 !== null && NAVIGATOR$1.standalone === true;
+        if (typeof GLOBAL$5.matchMedia !== 'function')
             return false;
-        return globalThis.matchMedia('(display-mode: standalone)').matches;
+        try {
+            return GLOBAL$5.matchMedia('(display-mode: standalone)').matches === true;
+        }
+        catch (_) {
+            return false;
+        }
     },
     compareVersion: function (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);
+        return compareVersion(lhs, rhs);
+    }
+};
+
+function getGlobal$2() {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    return {};
+}
+
+var version$1 = "0.0.1";
+var packageJSON$1 = {
+	version: version$1};
+
+var GLOBAL$3 = getGlobal$2();
+var VENDORS = ['', 'webkit', 'moz', 'ms', 'MS', 'o', 'O'];
+// https://cordova.apache.org/docs/en/latest/cordova/events/events.html
+var CORDOVA_DOCUMENT_EVENTS = ['deviceready', 'pause', 'resume', 'backbutton', 'menubutton', 'searchbutton', 'startcallbutton', 'endcallbutton', 'volumedownbutton', 'volumeupbutton', 'activated', 'cordovacallbackerror'];
+// iOS `<video>` fullscreen events have no `on` attribute but are valid on any element exposing `webkitEnterFullscreen` — they must pass through untouched.
+var IOS_VIDEO_FULLSCREEN_EVENTS = ['webkitbeginfullscreen', 'webkitendfullscreen', 'webkitpresentationmodechanged'];
+var TYPE_ALIAS_MAP = {
+    'wheel': ['wheel', 'mousewheel', 'DOMMouseScroll'],
+    'fullscreenchange': ['fullscreenchange', 'webkitfullscreenchange', 'mozfullscreenchange', 'MSFullscreenChange', 'msfullscreenchange'],
+    'fullscreenerror': ['fullscreenerror', 'webkitfullscreenerror', 'mozfullscreenerror', 'MSFullscreenError', 'msfullscreenerror'],
+    'pointerdown': ['pointerdown', 'MSPointerDown'],
+    'pointermove': ['pointermove', 'MSPointerMove'],
+    'pointerup': ['pointerup', 'MSPointerUp'],
+    'pointercancel': ['pointercancel', 'MSPointerCancel'],
+    'pointerover': ['pointerover', 'MSPointerOver'],
+    'pointerout': ['pointerout', 'MSPointerOut'],
+    'pointerenter': ['pointerenter', 'MSPointerEnter', 'mouseenter'],
+    'pointerleave': ['pointerleave', 'MSPointerLeave', 'mouseleave'],
+    'gotpointercapture': ['gotpointercapture', 'MSGotPointerCapture'],
+    'lostpointercapture': ['lostpointercapture', 'MSLostPointerCapture'],
+    'pointerlockchange': ['pointerlockchange', 'webkitpointerlockchange', 'mozpointerlockchange', 'mspointerlockchange'],
+    'pointerlockerror': ['pointerlockerror', 'webkitpointerlockerror', 'mozpointerlockerror', 'mspointerlockerror'],
+    'touchstart': ['touchstart', 'pointerdown', 'MSPointerDown'],
+    'touchmove': ['touchmove', 'pointermove', 'MSPointerMove'],
+    'touchend': ['touchend', 'pointerup', 'MSPointerUp'],
+    'touchcancel': ['touchcancel', 'pointercancel', 'MSPointerCancel'],
+    'transitionrun': ['transitionrun', 'webkitTransitionRun'],
+    'transitionstart': ['transitionstart', 'webkitTransitionStart'],
+    'transitionend': ['transitionend', 'webkitTransitionEnd', 'oTransitionEnd', 'otransitionend', 'MSTransitionEnd'],
+    'animationstart': ['animationstart', 'webkitAnimationStart', 'oanimationstart', 'MSAnimationStart'],
+    'animationiteration': ['animationiteration', 'webkitAnimationIteration', 'oanimationiteration', 'MSAnimationIteration'],
+    'animationend': ['animationend', 'webkitAnimationEnd', 'oanimationend', 'MSAnimationEnd'],
+    'visibilitychange': ['visibilitychange', 'webkitvisibilitychange', 'mozvisibilitychange', 'msvisibilitychange'],
+};
+var FULLSCREEN_REQUEST_MAP = {
+    '': ['requestFullscreen'],
+    'webkit': ['webkitRequestFullscreen', 'webkitRequestFullScreen'],
+    'moz': ['mozRequestFullScreen', 'mozRequestFullscreen'],
+    'ms': ['msRequestFullscreen'],
+    'MS': ['msRequestFullscreen'],
+};
+function asRecord(value) {
+    return value;
+}
+function hasOnProperty(host, name) {
+    if (typeof host === 'undefined' || host === null)
+        return false;
+    if (typeof asRecord(host)['on' + name] !== 'undefined')
+        return true;
+    var lower = name.toLowerCase();
+    return lower !== name && typeof asRecord(host)['on' + lower] !== 'undefined';
+}
+function probeHosts(target) {
+    var hosts = [target];
+    if (typeof GLOBAL$3.document !== 'undefined' && target !== GLOBAL$3.document)
+        hosts.push(GLOBAL$3.document);
+    if (target !== GLOBAL$3)
+        hosts.push(GLOBAL$3);
+    return hosts;
+}
+function extractVendorPrefix(name) {
+    for (var i = 1; i < VENDORS.length; i++) {
+        if (name.indexOf(VENDORS[i]) === 0)
+            return VENDORS[i];
+    }
+    return '';
+}
+function testStyleSupport(name, styleProperty) {
+    if (typeof GLOBAL$3.document === 'undefined' || typeof GLOBAL$3.document.documentElement === 'undefined')
+        return false;
+    var style = GLOBAL$3.document.documentElement.style;
+    if (typeof style === 'undefined' || style === null)
+        return false;
+    var prefix = extractVendorPrefix(name);
+    var property;
+    if (prefix === '')
+        property = styleProperty;
+    else
+        property = prefix + styleProperty.charAt(0).toUpperCase() + styleProperty.slice(1);
+    return typeof asRecord(style)[property] !== 'undefined';
+}
+function testFullscreenSupport(name) {
+    if (typeof GLOBAL$3.document === 'undefined' || typeof GLOBAL$3.document.documentElement === 'undefined')
+        return false;
+    var element = GLOBAL$3.document.documentElement;
+    var methods = FULLSCREEN_REQUEST_MAP[extractVendorPrefix(name)];
+    if (typeof methods === 'undefined')
+        return false;
+    for (var i = 0; i < methods.length; i++) {
+        if (typeof asRecord(element)[methods[i]] === 'function')
+            return true;
+    }
+    return false;
+}
+function isEventTypeSupported(target, name) {
+    var hosts = probeHosts(target);
+    for (var i = 0; i < hosts.length; i++) {
+        if (hasOnProperty(hosts[i], name))
+            return true;
+    }
+    var lower = name.toLowerCase();
+    if (lower.indexOf('transition') > -1)
+        return testStyleSupport(name, 'transition');
+    if (lower.indexOf('animation') > -1)
+        return testStyleSupport(name, 'animation');
+    if (lower.indexOf('fullscreen') > -1)
+        return testFullscreenSupport(name);
+    return false;
+}
+function resolveEventType(target, type) {
+    if (target === GLOBAL$3.document && CORDOVA_DOCUMENT_EVENTS.indexOf(type) > -1)
+        return type;
+    if (typeof asRecord(target)['webkitEnterFullscreen'] === 'function' && IOS_VIDEO_FULLSCREEN_EVENTS.indexOf(type) > -1)
+        return type;
+    var candidates = typeof TYPE_ALIAS_MAP[type] !== 'undefined' ? TYPE_ALIAS_MAP[type] : [type];
+    for (var i = 0; i < candidates.length; i++) {
+        if (isEventTypeSupported(target, candidates[i]))
+            return candidates[i];
+    }
+    var hosts = probeHosts(target);
+    for (var i = 1; i < VENDORS.length; i++) {
+        for (var j = 0; j < candidates.length; j++) {
+            var name_1 = VENDORS[i] + candidates[j];
+            for (var k = 0; k < hosts.length; k++) {
+                if (hasOnProperty(hosts[k], name_1))
+                    return name_1;
+            }
+        }
+    }
+    return type;
+}
+
+var GLOBAL$2 = getGlobal$2();
+var SUPPORTED = {
+    once: false,
+    passive: false,
+    capture: false,
+    some: false,
+    all: false,
+};
+var NOOP$1 = function () {
+};
+function resolveProbeTarget() {
+    if (typeof GLOBAL$2.document !== 'undefined' && typeof GLOBAL$2.document.createDocumentFragment === 'function') {
+        try {
+            return GLOBAL$2.document.createDocumentFragment();
+        }
+        catch (_) {
+        }
+    }
+    if (typeof GLOBAL$2.EventTarget === 'function') {
+        try {
+            return new GLOBAL$2.EventTarget();
+        }
+        catch (_) {
+        }
+    }
+    return undefined;
+}
+(function detectSupportedListenerOptions() {
+    var probe = resolveProbeTarget();
+    if (typeof probe === 'undefined' || typeof probe.addEventListener !== 'function')
+        return;
+    var options = {};
+    try {
+        Object.defineProperty(options, 'once', {
+            get: function () {
+                SUPPORTED.once = true;
+                return false;
+            },
+        });
+        Object.defineProperty(options, 'passive', {
+            get: function () {
+                SUPPORTED.passive = true;
+                return false;
+            },
+        });
+        Object.defineProperty(options, 'capture', {
+            get: function () {
+                SUPPORTED.capture = true;
+                return false;
+            },
+        });
+        probe.addEventListener('test', NOOP$1, options);
+        probe.removeEventListener('test', NOOP$1, options);
+    }
+    catch (_) {
+    }
+    SUPPORTED.some = SUPPORTED.once || SUPPORTED.passive || SUPPORTED.capture;
+    SUPPORTED.all = SUPPORTED.once && SUPPORTED.passive && SUPPORTED.capture;
+})();
+var SUPPORTED_LISTENER_OPTIONS = SUPPORTED;
+function normalizeListenerOptions(options) {
+    if (typeof options === 'boolean')
+        return { capture: options, once: false, passive: false, signal: undefined };
+    if (typeof options === 'object' && options !== null) {
+        return {
+            capture: options.capture === true,
+            once: options.once === true,
+            passive: options.passive === true,
+            signal: options.signal,
+        };
+    }
+    return {
+        capture: Boolean(options),
+        once: false,
+        passive: false,
+        signal: undefined
+    };
+}
+function toNativeListenerOptions(normalized) {
+    if (SUPPORTED.passive)
+        return {
+            capture: normalized.capture,
+            passive: normalized.passive
+        };
+    if (SUPPORTED.capture)
+        return {
+            capture: normalized.capture
+        };
+    return normalized.capture;
+}
+
+var GLOBAL$1$1 = getGlobal$2();
+var TOUCH_TYPES = ['touchstart', 'touchmove', 'touchend', 'touchcancel'];
+var POINTER_PHASE_MAP = {
+    'pointerdown': 'start',
+    'MSPointerDown': 'start',
+    'pointermove': 'move',
+    'MSPointerMove': 'move',
+    'pointerup': 'end',
+    'MSPointerUp': 'end',
+    'pointercancel': 'cancel',
+    'MSPointerCancel': 'cancel',
+};
+var ACTIVE_TOUCHES = [];
+function isTouchEventType(type) {
+    return TOUCH_TYPES.indexOf(type) > -1;
+}
+function isPointerEventType(type) {
+    return typeof POINTER_PHASE_MAP[type] !== 'undefined';
+}
+function createTouchList(touches) {
+    var list = touches.slice();
+    list.item = function (index) {
+        if (index >= 0 && index < list.length)
+            return list[index];
+        return null;
+    };
+    return list;
+}
+function findTouchIndex(identifier) {
+    for (var i = 0; i < ACTIVE_TOUCHES.length; i++) {
+        if (ACTIVE_TOUCHES[i].identifier === identifier)
+            return i;
+    }
+    return -1;
+}
+function scrollOffsetX() {
+    if (typeof GLOBAL$1$1.pageXOffset === 'number')
+        return GLOBAL$1$1.pageXOffset;
+    if (typeof GLOBAL$1$1.document !== 'undefined' && typeof GLOBAL$1$1.document.documentElement !== 'undefined')
+        return GLOBAL$1$1.document.documentElement.scrollLeft;
+    return 0;
+}
+function scrollOffsetY() {
+    if (typeof GLOBAL$1$1.pageYOffset === 'number')
+        return GLOBAL$1$1.pageYOffset;
+    if (typeof GLOBAL$1$1.document !== 'undefined' && typeof GLOBAL$1$1.document.documentElement !== 'undefined')
+        return GLOBAL$1$1.document.documentElement.scrollTop;
+    return 0;
+}
+function createSyntheticTouch(event, target) {
+    var clientX = typeof event.clientX === 'number' ? event.clientX : 0;
+    var clientY = typeof event.clientY === 'number' ? event.clientY : 0;
+    return {
+        identifier: typeof event.pointerId === 'number' ? event.pointerId : 0,
+        target: target,
+        screenX: typeof event.screenX === 'number' ? event.screenX : 0,
+        screenY: typeof event.screenY === 'number' ? event.screenY : 0,
+        clientX: clientX,
+        clientY: clientY,
+        pageX: typeof event.pageX === 'number' ? event.pageX : clientX + scrollOffsetX(),
+        pageY: typeof event.pageY === 'number' ? event.pageY : clientY + scrollOffsetY(),
+        radiusX: typeof event.width === 'number' ? event.width / 2 : 0,
+        radiusY: typeof event.height === 'number' ? event.height / 2 : 0,
+        rotationAngle: typeof event.rotation === 'number' ? event.rotation : 0,
+        force: typeof event.pressure === 'number' ? event.pressure : 0,
+    };
+}
+function defineTouchList(event, property, list, patches) {
+    var holder = event;
+    var had = false;
+    try {
+        had = Object.prototype.hasOwnProperty.call(event, property);
+    }
+    catch (_) {
+    }
+    patches.push({ property: property, had: had, previous: had ? holder[property] : undefined });
+    try {
+        Object.defineProperty(event, property, { value: list, configurable: true });
+    }
+    catch (_) {
+        holder[property] = list;
+    }
+}
+function filterByTarget(touches, target) {
+    var filtered = [];
+    for (var i = 0; i < touches.length; i++) {
+        if (touches[i].target === target)
+            filtered.push(touches[i]);
+    }
+    return filtered;
+}
+function synthesizeTouchEvent(event, resolvedType, patches) {
+    var phase = POINTER_PHASE_MAP[resolvedType];
+    if (typeof phase === 'undefined')
+        return;
+    var pointerEvent = event;
+    var eventTarget = event.target;
+    var index = findTouchIndex(typeof pointerEvent.pointerId === 'number' ? pointerEvent.pointerId : 0);
+    var originTarget = index > -1 ? ACTIVE_TOUCHES[index].target : eventTarget;
+    var touch = createSyntheticTouch(pointerEvent, originTarget);
+    if (phase === 'start' || phase === 'move') {
+        if (index > -1)
+            ACTIVE_TOUCHES[index] = touch;
+        else
+            ACTIVE_TOUCHES.push(touch);
+    }
+    else {
+        if (index > -1)
+            ACTIVE_TOUCHES.splice(index, 1);
+    }
+    defineTouchList(event, 'touches', createTouchList(ACTIVE_TOUCHES), patches);
+    defineTouchList(event, 'targetTouches', createTouchList(filterByTarget(ACTIVE_TOUCHES, originTarget)), patches);
+    defineTouchList(event, 'changedTouches', createTouchList([touch]), patches);
+}
+
+var KEY_CODE_MAP = {
+    8: 'Backspace',
+    9: 'Tab',
+    12: 'Numpad5',
+    13: 'Enter',
+    16: 'ShiftLeft',
+    17: 'ControlLeft',
+    18: 'AltLeft',
+    19: 'Pause',
+    20: 'CapsLock',
+    27: 'Escape',
+    32: 'Space',
+    33: 'PageUp',
+    34: 'PageDown',
+    35: 'End',
+    36: 'Home',
+    37: 'ArrowLeft',
+    38: 'ArrowUp',
+    39: 'ArrowRight',
+    40: 'ArrowDown',
+    45: 'Insert',
+    46: 'Delete',
+    48: 'Digit0',
+    49: 'Digit1',
+    50: 'Digit2',
+    51: 'Digit3',
+    52: 'Digit4',
+    53: 'Digit5',
+    54: 'Digit6',
+    55: 'Digit7',
+    56: 'Digit8',
+    57: 'Digit9',
+    65: 'KeyA',
+    66: 'KeyB',
+    67: 'KeyC',
+    68: 'KeyD',
+    69: 'KeyE',
+    70: 'KeyF',
+    71: 'KeyG',
+    72: 'KeyH',
+    73: 'KeyI',
+    74: 'KeyJ',
+    75: 'KeyK',
+    76: 'KeyL',
+    77: 'KeyM',
+    78: 'KeyN',
+    79: 'KeyO',
+    80: 'KeyP',
+    81: 'KeyQ',
+    82: 'KeyR',
+    83: 'KeyS',
+    84: 'KeyT',
+    85: 'KeyU',
+    86: 'KeyV',
+    87: 'KeyW',
+    88: 'KeyX',
+    89: 'KeyY',
+    90: 'KeyZ',
+    91: 'MetaLeft',
+    92: 'MetaRight',
+    93: 'ContextMenu',
+    96: 'Numpad0',
+    97: 'Numpad1',
+    98: 'Numpad2',
+    99: 'Numpad3',
+    100: 'Numpad4',
+    101: 'Numpad5',
+    102: 'Numpad6',
+    103: 'Numpad7',
+    104: 'Numpad8',
+    105: 'Numpad9',
+    106: 'NumpadMultiply',
+    107: 'NumpadAdd',
+    109: 'NumpadSubtract',
+    110: 'NumpadDecimal',
+    111: 'NumpadDivide',
+    112: 'F1',
+    113: 'F2',
+    114: 'F3',
+    115: 'F4',
+    116: 'F5',
+    117: 'F6',
+    118: 'F7',
+    119: 'F8',
+    120: 'F9',
+    121: 'F10',
+    122: 'F11',
+    123: 'F12',
+    144: 'NumLock',
+    145: 'ScrollLock',
+    186: 'Semicolon',
+    187: 'Equal',
+    188: 'Comma',
+    189: 'Minus',
+    190: 'Period',
+    191: 'Slash',
+    192: 'Backquote',
+    219: 'BracketLeft',
+    220: 'Backslash',
+    221: 'BracketRight',
+    222: 'Quote',
+    226: 'IntlBackslash',
+};
+
+var GLOBAL$4 = getGlobal$2();
+var LISTENER_STORE = [];
+var NOOP = function () {
+};
+// Records live on the target itself, so they are collected with it and lookups only scan
+// that target's own listeners. Targets that reject the expando fall back to LISTENER_STORE.
+var STORE_KEY = '__webEventKitListeners__';
+function resolveBucket(target, create) {
+    var holder = target;
+    try {
+        var existing = holder[STORE_KEY];
+        if (typeof existing !== 'undefined' && existing !== null)
+            return existing;
+        if (!create)
+            return LISTENER_STORE;
+        var bucket = [];
+        try {
+            Object.defineProperty(target, STORE_KEY, { value: bucket, configurable: true, enumerable: false, writable: true });
+        }
+        catch (_) {
+            holder[STORE_KEY] = bucket;
+        }
+        if (holder[STORE_KEY] !== bucket)
+            return LISTENER_STORE;
+        return bucket;
+    }
+    catch (_) {
+        return LISTENER_STORE;
+    }
+}
+function findListenerRecord(target, type, callback, capture) {
+    var bucket = resolveBucket(target, false);
+    for (var i = 0; i < bucket.length; i++) {
+        var record = bucket[i];
+        if (record.target === target && record.type === type && record.callback === callback && record.capture === capture)
+            return record;
+    }
+    return undefined;
+}
+function removeListenerRecord(record) {
+    var bucket = record.bucket;
+    for (var i = 0; i < bucket.length; i++) {
+        if (bucket[i] === record) {
+            bucket.splice(i, 1);
+            return;
+        }
+    }
+}
+function preventDefaultPolyfill() {
+    this.returnValue = false;
+}
+function stopPropagationPolyfill() {
+    this.cancelBubble = true;
+}
+function passivePreventDefault() {
+    // Per spec, preventDefault() inside a passive listener does nothing.
+}
+function invokeCallback(callback, target, event) {
+    if (typeof callback === 'function')
+        return callback.call(target, event);
+    if (typeof callback === 'object' && callback !== null && typeof callback.handleEvent === 'function')
+        return callback.handleEvent(event);
+}
+// The same Event object is handed to every listener, so any property this kit overrides has
+// to be put back before the next one runs — otherwise a `pointerdown` listener would observe
+// the `touchstart` type and synthetic touches written by a listener registered before it.
+function patchEventProperty(event, property, value, patches) {
+    var holder = event;
+    var had = false;
+    try {
+        had = Object.prototype.hasOwnProperty.call(event, property);
+    }
+    catch (_) {
+    }
+    patches.push({ property: property, had: had, previous: had ? holder[property] : undefined });
+    defineEventProperty(event, property, value);
+}
+function restoreEventProperties(event, patches) {
+    var holder = event;
+    for (var i = patches.length - 1; i >= 0; i--) {
+        var patch = patches[i];
+        try {
+            if (patch.had)
+                defineEventProperty(event, patch.property, patch.previous);
             else
-                b = 0;
-            if (a > b)
-                return 1;
-            if (a < b)
-                return -1;
+                delete holder[patch.property];
+        }
+        catch (_) {
         }
-        return 0;
     }
+    patches.length = 0;
+}
+function defineEventProperty(event, property, value) {
+    try {
+        Object.defineProperty(event, property, { value: value, configurable: true });
+    }
+    catch (_) {
+        try {
+            event[property] = value;
+        }
+        catch (__) {
+        }
+    }
+}
+function fixLegacyEvent(event, target) {
+    if (typeof event.currentTarget === 'undefined' || event.currentTarget === null)
+        defineEventProperty(event, 'currentTarget', target);
+    if ((typeof event.target === 'undefined' || event.target === null) && typeof event.srcElement !== 'undefined')
+        defineEventProperty(event, 'target', event.srcElement);
+    if (typeof event.preventDefault !== 'function')
+        event.preventDefault = preventDefaultPolyfill.bind(event);
+    if (typeof event.stopPropagation !== 'function')
+        event.stopPropagation = stopPropagationPolyfill.bind(event);
+}
+function fixKeyboardEvent(event) {
+    if (typeof event.keyCode === 'number' && typeof event.code === 'undefined') {
+        var code = KEY_CODE_MAP[event.keyCode];
+        if (typeof code === 'string')
+            defineEventProperty(event, 'code', code);
+    }
+}
+function createDispatcher(record) {
+    return function (event) {
+        if (typeof event === 'undefined')
+            event = GLOBAL$4.event; // IE: implicit global event object
+        if (typeof event === 'undefined' || event === null)
+            return;
+        if (record.released)
+            return;
+        fixLegacyEvent(event, record.target);
+        if (record.once)
+            releaseListenerRecord(record);
+        var patches = [];
+        if (record.passive && !SUPPORTED_LISTENER_OPTIONS.passive)
+            patchEventProperty(event, 'preventDefault', passivePreventDefault.bind(event), patches);
+        if (record.resolvedType !== record.type)
+            patchEventProperty(event, 'type', record.type, patches);
+        if (record.touch)
+            synthesizeTouchEvent(event, record.resolvedType, patches);
+        fixKeyboardEvent(event);
+        try {
+            invokeCallback(record.callback, record.target, event);
+        }
+        finally {
+            restoreEventProperties(event, patches);
+        }
+    };
+}
+function attachNativeListener(record) {
+    var target = record.target;
+    if (typeof target.addEventListener === 'function') {
+        target.addEventListener(record.resolvedType, record.wrapper, toNativeListenerOptions(record));
+        return true;
+    }
+    if (typeof target.attachEvent === 'function') {
+        target.attachEvent('on' + record.resolvedType, record.wrapper);
+        return true;
+    }
+    return false;
+}
+function detachNativeListener(record) {
+    var target = record.target;
+    if (typeof target.removeEventListener === 'function')
+        return target.removeEventListener(record.resolvedType, record.wrapper, toNativeListenerOptions(record));
+    if (typeof target.detachEvent === 'function')
+        return target.detachEvent('on' + record.resolvedType, record.wrapper);
+}
+function releaseListenerRecord(record) {
+    if (record.released)
+        return;
+    record.released = true;
+    removeListenerRecord(record);
+    try {
+        detachNativeListener(record);
+    }
+    catch (_) {
+    }
+    if (typeof record.signal !== 'undefined' && typeof record.onAbort === 'function' && typeof record.signal.removeEventListener === 'function') {
+        try {
+            record.signal.removeEventListener('abort', record.onAbort, false);
+        }
+        catch (_) {
+        }
+    }
+    record.onAbort = undefined;
+}
+function createEventPolyfill(type, init) {
+    try {
+        return new Event(type, init);
+    }
+    catch (_) {
+    }
+    var event = GLOBAL$4.document.createEvent('Event');
+    event.initEvent(type, typeof init !== 'undefined' && init.bubbles === true, typeof init !== 'undefined' && init.cancelable === true);
+    return event;
+}
+function createCustomEventPolyfill(type, init) {
+    try {
+        return new CustomEvent(type, init);
+    }
+    catch (_) {
+    }
+    var event = GLOBAL$4.document.createEvent('CustomEvent');
+    event.initCustomEvent(type, typeof init !== 'undefined' && init.bubbles === true, typeof init !== 'undefined' && init.cancelable === true, typeof init !== 'undefined' && typeof init.detail !== 'undefined' ? init.detail : null);
+    return event;
+}
+var EventKit = {
+    version: packageJSON$1.version,
+    utils: {
+        get supportedOptions() {
+            return {
+                once: SUPPORTED_LISTENER_OPTIONS.once,
+                passive: SUPPORTED_LISTENER_OPTIONS.passive,
+                capture: SUPPORTED_LISTENER_OPTIONS.capture,
+                some: SUPPORTED_LISTENER_OPTIONS.some,
+                all: SUPPORTED_LISTENER_OPTIONS.all,
+            };
+        },
+        resolveType: resolveEventType,
+        createEvent: createEventPolyfill,
+        createCustomEvent: createCustomEventPolyfill,
+    },
+    add: function (target, type, callback, options) {
+        if (typeof target === 'undefined' || target === null)
+            return NOOP;
+        if (typeof type !== 'string' || type.length === 0)
+            return NOOP;
+        if (typeof callback !== 'function' && (typeof callback !== 'object' || callback === null))
+            return NOOP;
+        var normalized = normalizeListenerOptions(options);
+        var existing = findListenerRecord(target, type, callback, normalized.capture);
+        // Native `addEventListener` ignores a duplicate registration, so hand back a releaser
+        // that does nothing rather than one that would detach the first caller's listener.
+        if (typeof existing !== 'undefined')
+            return NOOP;
+        if (typeof normalized.signal !== 'undefined' && normalized.signal.aborted)
+            return NOOP;
+        var resolvedType = resolveEventType(target, type);
+        var bucket = resolveBucket(target, true);
+        var record = {
+            bucket: bucket,
+            target: target,
+            type: type,
+            callback: callback,
+            wrapper: NOOP,
+            resolvedType: resolvedType,
+            capture: normalized.capture,
+            once: normalized.once,
+            passive: normalized.passive,
+            signal: normalized.signal,
+            onAbort: undefined,
+            touch: isTouchEventType(type) && isPointerEventType(resolvedType),
+            released: false,
+        };
+        record.wrapper = createDispatcher(record);
+        if (!attachNativeListener(record))
+            return NOOP;
+        bucket.push(record);
+        if (typeof record.signal !== 'undefined' && typeof record.signal.addEventListener === 'function') {
+            record.onAbort = function () {
+                releaseListenerRecord(record);
+            };
+            // Engines without listener-options coerce `{once: true}` to capture, which would then
+            // fail to match on removal; releaseListenerRecord detaches this anyway.
+            record.signal.addEventListener('abort', record.onAbort, false);
+        }
+        return function () {
+            releaseListenerRecord(record);
+        };
+    },
+    remove: function (target, type, callback, options) {
+        if (typeof target === 'undefined' || target === null)
+            return;
+        if (typeof type !== 'string' || type.length === 0)
+            return;
+        if (typeof callback !== 'function' && (typeof callback !== 'object' || callback === null))
+            return;
+        var normalized = normalizeListenerOptions(options);
+        var record = findListenerRecord(target, type, callback, normalized.capture);
+        if (typeof record !== 'undefined')
+            return releaseListenerRecord(record);
+        var resolvedType = resolveEventType(target, type);
+        if (typeof target.removeEventListener === 'function')
+            return target.removeEventListener(resolvedType, callback, toNativeListenerOptions(normalized));
+        if (typeof target.detachEvent === 'function' && typeof callback === 'function')
+            return target.detachEvent('on' + resolvedType, callback);
+    },
 };
 
+function getGlobal$1() {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    return {};
+}
+
 function createHiddenElement(tagName, focusable) {
     if (focusable === void 0) { focusable = true; }
-    var element = globalThis.document.createElement(tagName);
+    var document = getGlobal$1().document;
+    var element = document.createElement(tagName);
     if (typeof element.width !== 'undefined')
         element.width = '0';
     if (typeof element.height !== 'undefined')
@@ -422,116 +1293,301 @@ function createHiddenElement(tagName, focusable) {
     return element;
 }
 
-var RTL_LANGUAGES = ['ae', 'ar', 'arc', 'bcc', 'bqi', 'ckb', 'dv', 'fa', 'glk', 'he', 'iw', 'ku', 'mzn', 'nqo', 'pnb', 'ps', 'sd', 'ug', 'ur', 'yi'];
-function normalizeLocale(locale) {
-    if (locale === null || typeof locale === 'undefined')
-        return locale;
-    if (locale.length === 0)
+var version = "0.0.5";
+var packageJSON = {
+	version: version};
+
+var RTL_LANGUAGES = ['ae', 'ar', 'arc', 'bcc', 'bqi', 'ckb', 'dv', 'fa', 'glk', 'he', 'iw', 'ji', 'ku', 'mzn', 'nqo', 'pnb', 'ps', 'sd', 'ug', 'ur', 'yi'];
+var RTL_SCRIPTS = ['Adlm', 'Arab', 'Aran', 'Hebr', 'Mand', 'Mend', 'Nkoo', 'Rohg', 'Samr', 'Syrc', 'Thaa', 'Yezi'];
+var LANGUAGE_PATTERN = /^[A-Za-z]{2,8}$/;
+var SCRIPT_PATTERN = /^[A-Za-z]{4}$/;
+var REGION_PATTERN = /^(?:[A-Za-z]{2}|[0-9]{3})$/;
+var VARIANT_PATTERN = /^(?:[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})$/;
+var SINGLETON_PATTERN = /^[A-Za-z0-9]$/;
+var EXTENSION_PATTERN = /^[A-Za-z0-9]{1,8}$/;
+function getGlobal() {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    return {};
+}
+function freeze(values) {
+    return typeof Object.freeze === 'function' ? Object.freeze(values) : values;
+}
+function contains(values, value) {
+    for (var i = 0; i < values.length; i++) {
+        if (values[i] === value)
+            return true;
+    }
+    return false;
+}
+function getIntlLocaleConstructor() {
+    if (typeof Intl === 'undefined')
+        return undefined;
+    var constructor = Intl.Locale;
+    return typeof constructor === 'function' ? constructor : undefined;
+}
+function parseTag(raw) {
+    if (raw === null || typeof raw !== 'string')
+        return null;
+    var value = raw.replace(/_/g, '-');
+    if (value.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)
+    if (value === 'C' || value.toLowerCase() === 'posix')
+        value = 'en-US';
+    var dot = value.indexOf('.');
+    if (dot !== -1)
+        value = value.slice(0, dot);
+    var at = value.indexOf('@');
+    if (at !== -1)
+        value = value.slice(0, at);
+    if (value.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('-');
+    var segments = value.split('-');
+    if (LANGUAGE_PATTERN.test(segments[0]) === false)
+        return null;
+    var language = segments[0].toLowerCase();
+    var index = 1;
+    var script = null;
+    if (index < segments.length && SCRIPT_PATTERN.test(segments[index])) {
+        script = segments[index].charAt(0).toUpperCase() + segments[index].slice(1).toLowerCase();
+        index++;
+    }
+    var region = null;
+    if (index < segments.length && REGION_PATTERN.test(segments[index])) {
+        region = segments[index].toUpperCase();
+        index++;
+    }
+    var variants = [];
+    while (index < segments.length && VARIANT_PATTERN.test(segments[index])) {
+        variants.push(segments[index].toLowerCase());
+        index++;
+    }
+    var extensions = [];
+    while (index < segments.length) {
+        var singleton = segments[index];
+        if (SINGLETON_PATTERN.test(singleton) === false)
+            return null;
+        var isPrivateUse = singleton.toLowerCase() === 'x';
+        var parts = [singleton.toLowerCase()];
+        index++;
+        while (index < segments.length) {
+            var segment = segments[index];
+            if (EXTENSION_PATTERN.test(segment) === false)
+                return null;
+            if (segment.length === 1 && isPrivateUse === false)
+                break;
+            parts.push(segment.toLowerCase());
+            index++;
+        }
+        if (parts.length < 2)
+            return null;
+        extensions.push(parts.join('-'));
+    }
+    var base = [language];
+    if (script !== null)
+        base.push(script);
+    if (region !== null)
+        base.push(region);
+    for (var i = 0; i < variants.length; i++)
+        base.push(variants[i]);
+    var baseName = base.join('-');
+    return {
+        tag: extensions.length === 0 ? baseName : baseName + '-' + extensions.join('-'),
+        baseName: baseName,
+        language: language,
+        script: script,
+        region: region,
+        variants: freeze(variants),
+        extensions: freeze(extensions),
+    };
+}
+function isRTL(subtags) {
+    if (subtags.script !== null)
+        return contains(RTL_SCRIPTS, subtags.script);
+    return contains(RTL_LANGUAGES, subtags.language);
+}
+function expandTag(tag) {
+    var parsed = parseTag(tag);
+    if (parsed === null)
+        return freeze([]);
+    var segments = parsed.baseName.split('-');
+    var chain = [];
+    for (var i = segments.length; i > 0; i--)
+        chain.push(segments.slice(0, i).join('-'));
+    return freeze(chain);
+}
+function toLookupKey(tag) {
+    var parsed = parseTag(tag);
+    return (parsed === null ? tag : parsed.baseName).toLowerCase();
+}
+function lookupTag(supported, preferred, fallback) {
+    if (supported === null || typeof supported === 'undefined' || typeof supported.length !== 'number')
+        return fallback;
+    var keys = [];
+    for (var i = 0; i < supported.length; i++)
+        keys.push(toLookupKey(supported[i]));
+    for (var i = 0; i < preferred.length; i++) {
+        var chain = expandTag(preferred[i]);
+        for (var j = 0; j < chain.length; j++) {
+            var candidate = chain[j].toLowerCase();
+            var prefix = candidate + '-';
+            for (var k = 0; k < keys.length; k++) {
+                if (keys[k] === candidate)
+                    return supported[k];
+            }
+            for (var k = 0; k < keys.length; k++) {
+                if (keys[k].indexOf(prefix) === 0)
+                    return supported[k];
+            }
+        }
+    }
+    return fallback;
+}
+function resolveDirection(primary) {
+    if (primary === null)
+        return false;
+    var IntlLocale = getIntlLocaleConstructor();
+    if (typeof IntlLocale !== 'undefined') {
+        try {
+            var intlLocale = new IntlLocale(primary.tag);
+            if (typeof intlLocale.getTextInfo === 'function')
+                return intlLocale.getTextInfo().direction === 'rtl';
+            if (typeof intlLocale.textInfo !== 'undefined')
+                return intlLocale.textInfo.direction === 'rtl';
+        }
+        catch (_) {
+        }
+    }
+    return isRTL(primary);
 }
+var subtags = null;
 var language = null;
-var languages = [];
+var languages = freeze([]);
+var fallbacks = freeze([]);
 var timezone = null;
 var offset = 0;
-var isRTLResolved = null;
-function addLanguages(langs) {
-    for (var i = 0; i < langs.length; i++)
-        addLanguage(langs[i]);
-}
-function addLanguage(lang) {
-    lang = normalizeLocale(lang);
-    if (typeof lang === 'string' && languages.indexOf(lang) === -1) {
-        if (language === null)
-            language = lang;
-        languages.push(lang);
+var rtl = false;
+function resolveLanguages(candidates) {
+    var resolved = [];
+    var primary = null;
+    for (var i = 0; i < candidates.length; i++) {
+        var parsed = parseTag(candidates[i]);
+        if (parsed === null)
+            continue;
+        if (contains(resolved, parsed.baseName))
+            continue;
+        if (primary === null)
+            primary = parsed;
+        resolved.push(parsed.baseName);
+    }
+    subtags = primary;
+    language = primary === null ? null : primary.baseName;
+    languages = freeze(resolved);
+    fallbacks = primary === null ? freeze([]) : expandTag(primary.baseName);
+    rtl = resolveDirection(primary);
+}
+function collectEnvironmentLanguages() {
+    var candidates = [];
+    var navigatorLike = getGlobal().navigator;
+    if (typeof navigatorLike !== 'undefined' && navigatorLike !== null) {
+        if (typeof navigatorLike.languages !== 'undefined' && navigatorLike.languages !== null) {
+            for (var i = 0; i < navigatorLike.languages.length; i++)
+                candidates.push(navigatorLike.languages[i]);
+        }
+        candidates.push(navigatorLike.language);
+        candidates.push(navigatorLike.userLanguage);
+        candidates.push(navigatorLike.browserLanguage);
+        candidates.push(navigatorLike.systemLanguage);
+    }
+    if (typeof Intl !== 'undefined') {
+        try {
+            candidates.push(Intl.DateTimeFormat().resolvedOptions().locale);
+        }
+        catch (_) {
+        }
     }
+    return candidates;
 }
+var ENVIRONMENT_LANGUAGES = collectEnvironmentLanguages();
+resolveLanguages(ENVIRONMENT_LANGUAGES);
 if (typeof Intl !== 'undefined') {
-    try {
-        addLanguage(Intl.DateTimeFormat().resolvedOptions().locale);
-    }
-    catch (_) {
-    }
     try {
         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 {
     offset = new Date().getTimezoneOffset() * -1;
 }
 catch (_) {
 }
-if (typeof language === 'string') {
-    if (typeof Intl !== 'undefined' && typeof Intl.Locale !== 'undefined') {
-        try {
-            var intlLocale = new Intl.Locale(language);
-            if (typeof intlLocale.getTextInfo === 'function')
-                isRTLResolved = intlLocale.getTextInfo().direction === 'rtl';
-            else if (typeof intlLocale.textInfo !== 'undefined')
-                isRTLResolved = intlLocale.textInfo.direction === 'rtl';
-        }
-        catch (_) {
-        }
-    }
-    if (typeof isRTLResolved !== 'boolean') {
-        var matched = /^([A-Za-z]{1,8})(?:[-_][A-Za-z0-9]{1,8})*$/.exec(language);
-        if (matched !== null) {
-            var lang = matched[1].toLowerCase();
-            for (var i = 0; i < RTL_LANGUAGES.length; i++) {
-                if (RTL_LANGUAGES[i] === lang) {
-                    isRTLResolved = true;
-                    break;
-                }
-            }
-        }
-    }
-}
 var LocaleKit = {
-    languages: languages};
+    version: packageJSON.version,
+    get language() {
+        return language;
+    },
+    get languages() {
+        return languages;
+    },
+    set languages(value) {
+        resolveLanguages(typeof value === 'string' ? [value] : value);
+    },
+    get subtags() {
+        return subtags;
+    },
+    get fallbacks() {
+        return fallbacks;
+    },
+    get timezone() {
+        return timezone;
+    },
+    get offset() {
+        return offset;
+    },
+    get rtl() {
+        return rtl;
+    },
+    reset: function () {
+        resolveLanguages(ENVIRONMENT_LANGUAGES);
+    },
+    parse: function (tag) {
+        return parseTag(tag);
+    },
+    expand: function (tag) {
+        return expandTag(tag);
+    },
+    lookup: function (supported, fallback) {
+        return lookupTag(supported, languages, typeof fallback === 'undefined' ? null : fallback);
+    },
+};
+if (typeof Object.freeze === 'function')
+    Object.freeze(LocaleKit);
 
+var GLOBAL$1 = getGlobal$1();
+var CACHE_PREFIX = 'web-launch-kit:';
 var TRACK_ID = 'track-id';
-var BUNDLE_ID = 'bundle-id';
+var PRODUCT_ID = 'product-id';
 var TRACK_ID_CACHE_TTL = 1000 * 60 * 60;
+function toCacheKey(mode, query) {
+    return CACHE_PREFIX + mode + ':' + query;
+}
 var idCache = (function () {
     var supportsLocalStorage;
     try {
-        if (typeof globalThis.localStorage === 'undefined') {
+        if (typeof GLOBAL$1.localStorage === 'undefined' || GLOBAL$1.localStorage === null) {
             supportsLocalStorage = false;
         }
         else {
             var key = '__id_cache_test__';
-            globalThis.localStorage.setItem(key, '');
-            globalThis.localStorage.removeItem(key);
+            GLOBAL$1.localStorage.setItem(key, '');
+            GLOBAL$1.localStorage.removeItem(key);
             supportsLocalStorage = true;
         }
     }
@@ -542,7 +1598,7 @@ var idCache = (function () {
         return {
             get: function (mode, query) {
                 try {
-                    var item = globalThis.localStorage.getItem(mode + ':' + query);
+                    var item = GLOBAL$1.localStorage.getItem(toCacheKey(mode, query));
                     if (item == null)
                         return undefined;
                     var split = item.split('|');
@@ -550,7 +1606,7 @@ var idCache = (function () {
                         return undefined;
                     var expiry = +split[0];
                     if (isNotANumber(expiry) || expiry < getNow()) {
-                        globalThis.localStorage.removeItem(mode + ':' + query);
+                        GLOBAL$1.localStorage.removeItem(toCacheKey(mode, query));
                         return undefined;
                     }
                     return split[1];
@@ -561,7 +1617,7 @@ var idCache = (function () {
             },
             set: function (mode, query, id) {
                 try {
-                    globalThis.localStorage.setItem(mode + ':' + query, getNow() + TRACK_ID_CACHE_TTL + '|' + id);
+                    GLOBAL$1.localStorage.setItem(toCacheKey(mode, query), getNow() + TRACK_ID_CACHE_TTL + '|' + id);
                 }
                 catch (_) {
                     return;
@@ -569,11 +1625,11 @@ var idCache = (function () {
             }
         };
     }
-    if (typeof globalThis.Map !== 'undefined') {
-        var cache_1 = new Map();
+    if (typeof GLOBAL$1.Map !== 'undefined') {
+        var cache_1 = new GLOBAL$1.Map();
         return {
             get: function (mode, query) {
-                var item = cache_1.get(mode + ':' + query);
+                var item = cache_1.get(toCacheKey(mode, query));
                 if (typeof item === 'undefined')
                     return undefined;
                 var split = item.split('|');
@@ -581,20 +1637,20 @@ var idCache = (function () {
                     return undefined;
                 var expiry = +split[0];
                 if (isNotANumber(expiry) || expiry < getNow()) {
-                    cache_1.delete(mode + ':' + query);
+                    cache_1.delete(toCacheKey(mode, query));
                     return undefined;
                 }
                 return split[1];
             },
             set: function (mode, query, id) {
-                cache_1.set(mode + ':' + query, getNow() + TRACK_ID_CACHE_TTL + '|' + id);
+                cache_1.set(toCacheKey(mode, query), getNow() + TRACK_ID_CACHE_TTL + '|' + id);
             },
         };
     }
     var cache = Object.create(null);
     return {
         get: function (mode, query) {
-            var item = cache[mode + ':' + query];
+            var item = cache[toCacheKey(mode, query)];
             if (typeof item === 'undefined')
                 return undefined;
             var split = item.split('|');
@@ -603,17 +1659,17 @@ var idCache = (function () {
             var expiry = +split[0];
             if (isNotANumber(expiry) || expiry < getNow()) {
                 try {
-                    delete cache[mode + ':' + query];
+                    delete cache[toCacheKey(mode, query)];
                 }
                 catch (_) {
-                    cache[mode + ':' + query] = undefined;
+                    cache[toCacheKey(mode, query)] = undefined;
                 }
                 return undefined;
             }
             return split[1];
         },
         set: function (mode, query, id) {
-            cache[mode + ':' + query] = getNow() + TRACK_ID_CACHE_TTL + '|' + id;
+            cache[toCacheKey(mode, query)] = getNow() + TRACK_ID_CACHE_TTL + '|' + id;
         }
     };
 })();
@@ -627,8 +1683,8 @@ function getNow() {
 }
 function requestGet(url, async) {
     if (async === void 0) { async = false; }
-    if (typeof globalThis.fetch === 'function' && async) {
-        return globalThis.fetch(url)
+    if (typeof GLOBAL$1.fetch === 'function' && async) {
+        return GLOBAL$1.fetch(url)
             .then(function (response) {
             return response.json();
         })
@@ -671,10 +1727,10 @@ function resolveGetProductIdURL(packageFamilyName) {
         if (locale === candidate)
             break;
     }
-    return 'https://displaycatalog.md.mp.microsoft.com/v7.0/products/lookup?value=' + globalThis.encodeURIComponent(packageFamilyName) + '&market=' + globalThis.encodeURIComponent(country) + '&languages=' + globalThis.encodeURIComponent(locale) + '&alternateId=PackageFamilyName';
+    return 'https://displaycatalog.md.mp.microsoft.com/v7.0/products/lookup?value=' + encodeURIComponent(packageFamilyName) + '&market=' + encodeURIComponent(country) + '&languages=' + encodeURIComponent(locale) + '&alternateId=PackageFamilyName';
 }
 function resolveGetTrackIdURL(bundleId) {
-    return 'https://itunes.apple.com/lookup?bundleId=' + globalThis.encodeURIComponent(bundleId);
+    return 'https://itunes.apple.com/lookup?bundleId=' + encodeURIComponent(bundleId);
 }
 function parseGetProductIdResponse(response) {
     if (typeof response === 'undefined')
@@ -700,14 +1756,14 @@ function parseGetTrackIdResponse(response) {
     return '' + result.trackId;
 }
 function getProductId(packageFamilyName) {
-    var cache = idCache.get(BUNDLE_ID, packageFamilyName);
+    var cache = idCache.get(PRODUCT_ID, packageFamilyName);
     if (typeof cache !== 'undefined')
         return cache;
     try {
         var productId = parseGetProductIdResponse(requestGet(resolveGetProductIdURL(packageFamilyName)));
         if (typeof productId === 'undefined')
             return undefined;
-        idCache.set(BUNDLE_ID, packageFamilyName, productId);
+        idCache.set(PRODUCT_ID, packageFamilyName, productId);
         return productId;
     }
     catch (_) {
@@ -730,7 +1786,7 @@ function getTrackId(bundleId) {
     }
 }
 function getProductIdAsync(packageFamilyName) {
-    var cache = idCache.get(BUNDLE_ID, packageFamilyName);
+    var cache = idCache.get(PRODUCT_ID, packageFamilyName);
     if (typeof cache !== 'undefined')
         return Promise.resolve(cache);
     try {
@@ -739,7 +1795,7 @@ function getProductIdAsync(packageFamilyName) {
             .then(function (productId) {
             if (typeof productId === 'undefined')
                 return undefined;
-            idCache.set(BUNDLE_ID, packageFamilyName, productId);
+            idCache.set(PRODUCT_ID, packageFamilyName, productId);
             return productId;
         });
     }
@@ -767,110 +1823,16 @@ function getTrackIdAsync(bundleId) {
 }
 
 function getTopmostWindow() {
+    var globalLike = getGlobal$1();
     try {
-        if (globalThis.top !== null && globalThis.top !== globalThis.window) {
-            void globalThis.top.location.href;
-            return globalThis.top;
+        if (typeof globalLike.top !== 'undefined' && globalLike.top !== null && globalLike.top !== globalLike.window) {
+            void globalLike.top.location.href;
+            return globalLike.top;
         }
     }
     catch (_) {
     }
-    return globalThis;
-}
-
-var IE_WRAPPER_STORE = [];
-var VENDORS = ['', 'webkit', 'moz', 'ms', 'MS', 'o', 'O'];
-var LEGACY_TYPE_MAP = {
-    'focus': ['focus', 'focusin'],
-    'blur': ['blur', 'focusout'],
-};
-function resolveVendor(target, type) {
-    var types;
-    var legacy = LEGACY_TYPE_MAP[type];
-    if (typeof legacy !== 'undefined')
-        types = legacy;
-    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 type;
-}
-function findIEWrapper(target, type, callback) {
-    for (var i = 0; i < IE_WRAPPER_STORE.length; i++) {
-        var wrapper = IE_WRAPPER_STORE[i];
-        if (wrapper.target === target && wrapper.type === type && wrapper.callback === callback)
-            return wrapper.wrapper;
-    }
-    return undefined;
-}
-function setIEWrapper(target, type, callback, wrapper) {
-    IE_WRAPPER_STORE.push({ target: target, type: type, callback: callback, wrapper: wrapper });
-}
-function removeIEWrapper(target, type, callback) {
-    for (var i = 0; i < IE_WRAPPER_STORE.length; i++) {
-        var wrapper = IE_WRAPPER_STORE[i];
-        if (wrapper.target === target && wrapper.type === type && wrapper.callback === callback) {
-            IE_WRAPPER_STORE.splice(i, 1);
-            return wrapper.wrapper;
-        }
-    }
-    return undefined;
-}
-function preventDefaultPolyfill() {
-    this.returnValue = false;
-}
-function stopPropagationPolyfill() {
-    this.cancelBubble = true;
-}
-function addEvent(target, type, callback) {
-    if (typeof target === 'undefined' || typeof type === 'undefined')
-        return;
-    type = resolveVendor(target, type);
-    if (typeof target.addEventListener === 'function') {
-        return target.addEventListener(type, callback);
-    }
-    if (typeof target.attachEvent === 'function') {
-        var existing = findIEWrapper(target, type, callback);
-        if (typeof existing === 'function')
-            return;
-        var wrapper = function (event) {
-            if (typeof event === 'undefined')
-                event = globalThis.event;
-            if (typeof event === 'undefined')
-                return;
-            try {
-                Object.defineProperty(event, 'currentTarget', { value: target, configurable: true });
-            }
-            catch (_) {
-            }
-            if (typeof event.preventDefault !== 'function')
-                event.preventDefault = preventDefaultPolyfill.bind(event);
-            if (typeof event.stopPropagation !== 'function')
-                event.stopPropagation = stopPropagationPolyfill.bind(event);
-            callback.call(target, event);
-        };
-        setIEWrapper(target, type, callback, wrapper);
-        return target.attachEvent('on' + type, wrapper);
-    }
-}
-function removeEvent(target, type, callback) {
-    if (typeof target === 'undefined' || typeof type === 'undefined')
-        return;
-    type = resolveVendor(target, type);
-    if (typeof target.removeEventListener === 'function') {
-        return target.removeEventListener(type, callback);
-    }
-    if (typeof target.detachEvent === 'function') {
-        var wrapper = removeIEWrapper(target, type, callback);
-        if (typeof wrapper === 'function')
-            target.detachEvent('on' + type, wrapper);
-        return;
-    }
+    return globalLike;
 }
 
 exports.SettingType = void 0;
@@ -941,7 +1903,8 @@ var IOS_DEFAULT_TIMEOUT = 2000;
 var WINDOWS_DEFAULT_TIMEOUT = 750;
 var MACOS_DEFAULT_TIMEOUT = 750;
 var DEFAULT_TIMEOUT = 750;
-var NAVIGATOR = globalThis.navigator;
+var GLOBAL = getGlobal$1();
+var NAVIGATOR = GLOBAL.navigator;
 var CLEANUP_INPUT_ELEMENT = null;
 function createTypeGuard(tag) {
     return function (value) {
@@ -1001,7 +1964,7 @@ function isDocumentHidden() {
     return true;
 }
 function dispatchClickEvent(element, view) {
-    if (view === void 0) { view = globalThis; }
+    if (view === void 0) { view = GLOBAL; }
     var fake;
     try {
         fake = new MouseEvent('click', {
@@ -1011,7 +1974,7 @@ function dispatchClickEvent(element, view) {
         });
     }
     catch (_) {
-        fake = globalThis.document.createEvent('MouseEvents');
+        fake = GLOBAL.document.createEvent('MouseEvents');
         fake.initMouseEvent('click', true, true, view, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
     }
     element.dispatchEvent(fake);
@@ -1039,11 +2002,14 @@ function restoreFocus() {
     focus(top);
     if (hasFocus(topDocument))
         return true;
-    if (topDocument.body.tabIndex < 0)
-        topDocument.body.tabIndex = -1;
+    var hadBodyTabIndex = topDocument.body.hasAttribute('tabindex');
+    if (!hadBodyTabIndex)
+        topDocument.body.setAttribute('tabindex', '-1');
     focus(topDocument.body);
     if (hasFocus(topDocument))
         return true;
+    if (!hadBodyTabIndex)
+        topDocument.body.removeAttribute('tabindex');
     var input = undefined;
     try {
         input = createHiddenElement('input');
@@ -1085,7 +2051,7 @@ function stripURL(value) {
 function resolveFocusEventConfig() {
     var top = getTopmostWindow();
     var topDocument = top.document;
-    if (typeof globalThis.cordova !== 'undefined') {
+    if (typeof GLOBAL.cordova !== 'undefined') {
         return {
             focus: {
                 target: topDocument,
@@ -1123,7 +2089,7 @@ function resolveFocusEventConfig() {
             };
         }
     }
-    else if (typeof globalThis.document.addEventListener === 'function') {
+    else if (typeof GLOBAL.document.addEventListener === 'function') {
         return {
             focus: {
                 target: top,
@@ -1163,12 +2129,12 @@ function openURL(tried, url, timeout) {
     var anchor = undefined;
     var iframe = undefined;
     function open() {
-        if (typeof globalThis.cordova !== 'undefined') {
-            if (typeof globalThis.cordova.InAppBrowser !== 'undefined') {
-                globalThis.cordova.InAppBrowser.open(url, '_system');
+        if (typeof GLOBAL.cordova !== 'undefined' && GLOBAL.cordova !== null) {
+            if (typeof GLOBAL.cordova.InAppBrowser !== 'undefined') {
+                GLOBAL.cordova.InAppBrowser.open(url, '_system');
             }
-            else {
-                globalThis.open(url, '_system');
+            else if (typeof GLOBAL.open === 'function') {
+                GLOBAL.open(url, '_system');
             }
             return;
         }
@@ -1198,7 +2164,7 @@ function openURL(tried, url, timeout) {
             iframe = createHiddenElement('iframe');
             iframe.src = url;
             topDocument.body.appendChild(iframe);
-            globalThis.setTimeout(function () {
+            setTimeout(function () {
                 if (typeof iframe !== 'undefined') {
                     try {
                         topDocument.body.removeChild(iframe);
@@ -1222,9 +2188,12 @@ function openURL(tried, url, timeout) {
                 timeoutId = undefined;
             }
             try {
-                removeEvent(config.blur.target, config.blur.type, onblur);
-                removeEvent(config.focus.target, config.focus.type, onfocus);
-                removeEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+                if (typeof config.blur.target !== 'undefined' && typeof config.blur.type !== 'undefined')
+                    EventKit.remove(config.blur.target, config.blur.type, onblur);
+                if (typeof config.focus.target !== 'undefined' && typeof config.focus.type !== 'undefined')
+                    EventKit.remove(config.focus.target, config.focus.type, onfocus);
+                if (typeof config.visibilitychange.target !== 'undefined' && typeof config.visibilitychange.type !== 'undefined')
+                    EventKit.remove(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
             }
             catch (_) {
             }
@@ -1258,8 +2227,10 @@ function openURL(tried, url, timeout) {
                 clearTimeout(timeoutId);
                 timeoutId = undefined;
             }
-            removeEvent(config.blur.target, config.blur.type, onblur);
-            addEvent(config.focus.target, config.focus.type, onfocus);
+            if (typeof config.blur.target !== 'undefined' && typeof config.blur.type !== 'undefined')
+                EventKit.remove(config.blur.target, config.blur.type, onblur);
+            if (typeof config.focus.target !== 'undefined' && typeof config.focus.type !== 'undefined')
+                EventKit.add(config.focus.target, config.focus.type, onfocus);
         }
         function onfocus() {
             done(true);
@@ -1270,11 +2241,13 @@ function openURL(tried, url, timeout) {
             else
                 onfocus();
         }
-        timeoutId = globalThis.setTimeout(function () {
+        timeoutId = setTimeout(function () {
             done(false);
         }, timeout);
-        addEvent(config.blur.target, config.blur.type, onblur);
-        addEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+        if (typeof config.blur.target !== 'undefined' && typeof config.blur.type !== 'undefined')
+            EventKit.add(config.blur.target, config.blur.type, onblur);
+        if (typeof config.visibilitychange.target !== 'undefined' && typeof config.visibilitychange.type !== 'undefined')
+            EventKit.add(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
         if (!hasFocus(topDocument))
             restoreFocus();
         try {
@@ -1476,13 +2449,22 @@ function isFullyBlockedInAppBrowser() {
 function isPartnerAppOnly() {
     return /weibo.*weibo__[\d.]+/i.test(PlatformKit.userAgent);
 }
+function canOpenWindowsSetting(version) {
+    if (version.length === 0)
+        return false;
+    if (/^\d/.test(version) === false)
+        return false;
+    if (version === '95' || version === '98' || version === '2000')
+        return false;
+    return PlatformKit.compareVersion(version, '10') >= 0;
+}
 function canOpenSetting() {
     var os = PlatformKit.os.name;
     var version = PlatformKit.os.version;
     return !(os === 'unknown'
         || (os === 'android' && !canOpenIntent())
         || os === 'ios'
-        || (os === 'windows' && (version === 'Vista' || version === 'XP' || version === '2000' || version === 'NT 4.0' || version === 'NT 3.11' || version === 'ME' || PlatformKit.compareVersion(version, '10') < 0))
+        || (os === 'windows' && !canOpenWindowsSetting(version))
         || (os === 'macos' && PlatformKit.compareVersion(version, '10.10') < 0));
 }
 function parseIntentURL(intent) {
@@ -1511,7 +2493,7 @@ function parseIntentURL(intent) {
     if (typeof extras['S.browser_fallback_url'] !== 'undefined') {
         var fallback = extras['S.browser_fallback_url'];
         try {
-            fallback = globalThis.decodeURIComponent(fallback);
+            fallback = decodeURIComponent(fallback);
         }
         catch (_) {
         }
@@ -1531,9 +2513,9 @@ function createIntentURL(scheme, packageName, fallback) {
     if (typeof packageName !== 'undefined')
         intent += 'package=' + packageName + ';';
     if (typeof fallback !== 'undefined' && typeof fallback === 'string')
-        intent += 'S.browser_fallback_url=' + globalThis.encodeURIComponent(fallback) + ';';
+        intent += 'S.browser_fallback_url=' + encodeURIComponent(fallback) + ';';
     else if (typeof packageName !== 'undefined')
-        intent += 'S.browser_fallback_url=' + globalThis.encodeURIComponent(createAppStoreURL(packageName, 'android')) + ';';
+        intent += 'S.browser_fallback_url=' + encodeURIComponent(createAppStoreURL(packageName, 'android')) + ';';
     return intent + 'end';
 }
 function createAppStoreURL(id, os) {
@@ -1565,7 +2547,7 @@ function createWebStoreURL(id, os) {
     }
 }
 function escapeURIComponentString(value) {
-    return globalThis.encodeURIComponent(value)
+    return encodeURIComponent(value)
         .replace(/[!'()*]/g, function (char) {
         return '%' + char.charCodeAt(0).toString(16);
     });
@@ -1634,10 +2616,10 @@ function isUserActivationActive() {
     return typeof NAVIGATOR !== 'undefined' && typeof NAVIGATOR.userActivation !== 'undefined' && NAVIGATOR.userActivation.isActive;
 }
 function canShowDirectoryPicker() {
-    return typeof globalThis.showDirectoryPicker === 'function';
+    return typeof GLOBAL.showDirectoryPicker === 'function';
 }
 function canShowOpenFilePicker() {
-    return typeof globalThis.showOpenFilePicker === 'function';
+    return typeof GLOBAL.showOpenFilePicker === 'function';
 }
 function isFileSystemFileHandle(handle) {
     return handle.kind === 'file';
@@ -1705,7 +2687,7 @@ function resolveFile(module) {
             resolve(fileListToArray(module.files));
         }
         function onfocus() {
-            globalThis.setTimeout(function () {
+            setTimeout(function () {
                 if (module.value.length > 0)
                     done(true);
                 else
@@ -1731,10 +2713,12 @@ function resolveFile(module) {
         }
         else {
             module.onclick = function () {
-                addEvent(config.focus.target, config.focus.type, onfocus);
-                addEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
-                globalThis.setTimeout(function () {
-                    addEvent(topDocument, 'click', onclick);
+                if (typeof config.focus.target !== 'undefined' && typeof config.focus.type !== 'undefined')
+                    EventKit.add(config.focus.target, config.focus.type, onfocus);
+                if (typeof config.visibilitychange.target !== 'undefined' && typeof config.visibilitychange.type !== 'undefined')
+                    EventKit.add(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+                setTimeout(function () {
+                    EventKit.add(topDocument, 'click', onclick);
                 }, 100);
                 CLEANUP_INPUT_ELEMENT = function () {
                     done(false);
@@ -1744,9 +2728,11 @@ function resolveFile(module) {
         function cleanup() {
             CLEANUP_INPUT_ELEMENT = null;
             try {
-                removeEvent(config.focus.target, config.focus.type, onfocus);
-                removeEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
-                removeEvent(topDocument, 'click', onclick);
+                if (typeof config.focus.target !== 'undefined' && typeof config.focus.type !== 'undefined')
+                    EventKit.remove(config.focus.target, config.focus.type, onfocus);
+                if (typeof config.visibilitychange.target !== 'undefined' && typeof config.visibilitychange.type !== 'undefined')
+                    EventKit.remove(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+                EventKit.remove(topDocument, 'click', onclick);
             }
             catch (_) {
             }
@@ -1816,7 +2802,7 @@ function walk(directory, basePath) {
 }
 var LaunchKit = {
     SettingType: exports.SettingType,
-    version: packageJSON$1.version,
+    version: packageJSON$3.version,
     utils: {
         get canOpenIntent() {
             return canOpenIntent();
@@ -1864,7 +2850,12 @@ var LaunchKit = {
                 }
                 else {
                     tried[index] = '[function fallback]';
-                    url();
+                    try {
+                        url();
+                    }
+                    catch (_) {
+                        return openURLSequential(index + 1);
+                    }
                     resolve(by);
                 }
             }
@@ -2037,7 +3028,7 @@ var LaunchKit = {
                     option.id = options.id;
                 if (typeof options.startIn !== 'undefined')
                     option.startIn = options.startIn;
-                module = globalThis.showDirectoryPicker(option);
+                module = GLOBAL.showDirectoryPicker(option);
             }
             else {
                 var input = createHiddenElement('input');
@@ -2075,7 +3066,7 @@ var LaunchKit = {
                         }
                     }
                 }
-                module = globalThis.showOpenFilePicker(option);
+                module = GLOBAL.showOpenFilePicker(option);
             }
             else {
                 var input = createHiddenElement('input');