web-launch-kit 0.0.2 → 0.0.4

package/dist/launch-kit.umd.js

@@ -4,24 +4,37 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LaunchKit = {}));
 })(this, (function (exports) { 'use strict';
 
-  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],
@@ -50,13 +63,14 @@
       [/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'],
@@ -73,6 +87,18 @@
       [/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',
@@ -95,19 +121,18 @@
           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;
@@ -126,6 +151,28 @@
           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 = '';
@@ -138,7 +185,7 @@
               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);
@@ -151,7 +198,7 @@
               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 {
@@ -203,6 +250,39 @@
           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;
@@ -230,11 +310,31 @@
           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 || [];
@@ -287,12 +387,26 @@
                   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;
@@ -300,15 +414,29 @@
   }
   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() {
@@ -324,56 +452,799 @@
           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')
@@ -424,116 +1295,301 @@
       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;
           }
       }
@@ -544,7 +1600,7 @@
           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('|');
@@ -552,7 +1608,7 @@
                           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];
@@ -563,7 +1619,7 @@
               },
               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;
@@ -571,11 +1627,11 @@
               }
           };
       }
-      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('|');
@@ -583,20 +1639,20 @@
                       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('|');
@@ -605,17 +1661,17 @@
               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;
           }
       };
   })();
@@ -629,8 +1685,8 @@
   }
   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();
           })
@@ -673,10 +1729,10 @@
           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')
@@ -702,14 +1758,14 @@
       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 (_) {
@@ -732,7 +1788,7 @@
       }
   }
   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 {
@@ -741,7 +1797,7 @@
               .then(function (productId) {
               if (typeof productId === 'undefined')
                   return undefined;
-              idCache.set(BUNDLE_ID, packageFamilyName, productId);
+              idCache.set(PRODUCT_ID, packageFamilyName, productId);
               return productId;
           });
       }
@@ -769,110 +1825,16 @@
   }
 
   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;
@@ -943,7 +1905,8 @@
   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) {
@@ -1003,7 +1966,7 @@
       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', {
@@ -1013,7 +1976,7 @@
           });
       }
       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);
@@ -1041,11 +2004,14 @@
       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');
@@ -1087,7 +2053,7 @@
   function resolveFocusEventConfig() {
       var top = getTopmostWindow();
       var topDocument = top.document;
-      if (typeof globalThis.cordova !== 'undefined') {
+      if (typeof GLOBAL.cordova !== 'undefined') {
           return {
               focus: {
                   target: topDocument,
@@ -1125,7 +2091,7 @@
               };
           }
       }
-      else if (typeof globalThis.document.addEventListener === 'function') {
+      else if (typeof GLOBAL.document.addEventListener === 'function') {
           return {
               focus: {
                   target: top,
@@ -1165,12 +2131,12 @@
       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;
           }
@@ -1200,7 +2166,7 @@
               iframe = createHiddenElement('iframe');
               iframe.src = url;
               topDocument.body.appendChild(iframe);
-              globalThis.setTimeout(function () {
+              setTimeout(function () {
                   if (typeof iframe !== 'undefined') {
                       try {
                           topDocument.body.removeChild(iframe);
@@ -1224,9 +2190,12 @@
                   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 (_) {
               }
@@ -1260,8 +2229,10 @@
                   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);
@@ -1272,11 +2243,13 @@
               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 {
@@ -1478,13 +2451,22 @@
   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) {
@@ -1513,7 +2495,7 @@
       if (typeof extras['S.browser_fallback_url'] !== 'undefined') {
           var fallback = extras['S.browser_fallback_url'];
           try {
-              fallback = globalThis.decodeURIComponent(fallback);
+              fallback = decodeURIComponent(fallback);
           }
           catch (_) {
           }
@@ -1533,9 +2515,9 @@
       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) {
@@ -1567,7 +2549,7 @@
       }
   }
   function escapeURIComponentString(value) {
-      return globalThis.encodeURIComponent(value)
+      return encodeURIComponent(value)
           .replace(/[!'()*]/g, function (char) {
           return '%' + char.charCodeAt(0).toString(16);
       });
@@ -1636,10 +2618,10 @@
       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';
@@ -1707,7 +2689,7 @@
               resolve(fileListToArray(module.files));
           }
           function onfocus() {
-              globalThis.setTimeout(function () {
+              setTimeout(function () {
                   if (module.value.length > 0)
                       done(true);
                   else
@@ -1733,10 +2715,12 @@
           }
           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);
@@ -1746,9 +2730,11 @@
           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 (_) {
               }
@@ -1818,7 +2804,7 @@
   }
   var LaunchKit = {
       SettingType: exports.SettingType,
-      version: packageJSON$1.version,
+      version: packageJSON$3.version,
       utils: {
           get canOpenIntent() {
               return canOpenIntent();
@@ -1866,7 +2852,12 @@
                   }
                   else {
                       tried[index] = '[function fallback]';
-                      url();
+                      try {
+                          url();
+                      }
+                      catch (_) {
+                          return openURLSequential(index + 1);
+                      }
                       resolve(by);
                   }
               }
@@ -2039,7 +3030,7 @@
                       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');
@@ -2077,7 +3068,7 @@
                           }
                       }
                   }
-                  module = globalThis.showOpenFilePicker(option);
+                  module = GLOBAL.showOpenFilePicker(option);
               }
               else {
                   var input = createHiddenElement('input');