web-launch-kit 0.0.1

package/dist/launch-kit.umd.js

@@ -0,0 +1,1992 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LaunchKit = {}));
+})(this, (function (exports) { 'use strict';
+
+  var version$1 = "0.0.1";
+  var packageJSON$1 = {
+  	version: version$1};
+
+  var version = "0.0.4";
+  var packageJSON = {
+  	version: version};
+
+  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;
+  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 ?([\d.)]*)(?!.+xbox)/i, 'windows', resolveWindowsVersion],
+      [/\bwin(?=3| ?9|n)(?:nt| 9x )?([\d.;]*)/i, 'windows', resolveWindowsVersion],
+      [/windows ce\/?([\d.]*)/i, 'windows', resolveWindowsVersion],
+      [/[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],
+      [/mac os x ?([\w. ]*)/i, 'macos', resolveUnderscoreVersion],
+      [/(?:macintosh|mac_powerpc\b)(?!.+(haiku|morphos))/i, 'macos', resolveUnderscoreVersion],
+      [/droid ([\w.]+)\b.+(android[- ]x86)/i, 'android'],
+      [/android\w*[-\/.; ]?([\d.]*)/i, 'android'],
+  ];
+  var BROWSER_RESOLVER_MAP = [
+      [/\b(?:crmo|crios)\/([\w.]+)/i, 'chrome'],
+      [/webview.+edge\/([\w.]+)/i, 'edge'],
+      [/edg(?:e|ios|a)?\/([\w.]+)/i, 'edge'],
+      [/opera mini\/([-\w.]+)/i, 'opera'],
+      [/opera [mobileta]{3,6}\b.+version\/([-\w.]+)/i, 'opera'],
+      [/opera(?:.+version\/|[\/ ]+)([\w.]+)/i, 'opera'],
+      [/opios[\/ ]+([\w.]+)/i, 'opera'],
+      [/\bop(?:rg)?x\/([\w.]+)/i, 'opera'],
+      [/\bopr\/([\w.]+)/i, 'opera'],
+      [/iemobile(?:browser|boat|jet)[\/ ]?([\d.]*)/i, 'ie'],
+      [/(?:ms|\()ie ([\w.]+)/i, 'ie'],
+      [/trident.+rv[: ]([\w.]{1,9})\b.+like gecko/i, 'ie'],
+      [/\bfocus\/([\w.]+)/i, 'firefox'],
+      [/\bopt\/([\w.]+)/i, 'opera'],
+      [/coast\/([\w.]+)/i, 'opera'],
+      [/fxios\/([\w.-]+)/i, 'firefox'],
+      [/samsungbrowser\/([\w.]+)/i, 'samsung'],
+      [/headlesschrome(?:\/([\w.]+)| )/i, 'chrome'],
+      [/wv\).+chrome\/([\w.]+).+edgw\//i, 'edge'],
+      [/ 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'],
+      [/(?:mobile|tablet);.*firefox\/([\w.-]+)/i, 'firefox'],
+      [/mobile vr; rv:([\w.]+)\).+firefox/i, 'firefox'],
+      [/firefox\/([\w.]+)/i, 'firefox'],
+  ];
+  var ENGINE_RESOLVER_MAP = [
+      [/windows.+ edge\/([\w.]+)/i, 'edgeHtml'],
+      [/arkweb\/([\w.]+)/i, 'arkWeb'],
+      [/webkit\/537\.36.+chrome\/(?!27)([\w.]+)/i, 'blink'],
+      [/presto\/([\w.]+)/i, 'presto'],
+      [/webkit\/([\w.]+)/i, 'webKit'],
+      [/trident\/([\w.]+)/i, 'trident'],
+      [/netfront\/([\w.]+)/i, 'netFront'],
+      [/khtml[\/ ]\(?([\w.]+)/i, 'khtml'],
+      [/tasman[\/ ]\(?([\w.]+)/i, 'tasman'],
+      [/rv:([\w.]{1,9})\b.+gecko/i, 'gecko']
+  ];
+  var HIGH_ENTROPY_BRAND_NAME_MAP = {
+      'Google Chrome': 'Chrome',
+      'Microsoft Edge': 'Edge',
+      'Microsoft Edge WebView2': 'Edge WebView2',
+      'Android WebView': 'Chrome WebView',
+      'HeadlessChrome': 'Chrome Headless',
+      'OperaMobile': 'Opera Mobi',
+  };
+  var currentUserAgent = USER_AGENT;
+  var parsedCache = null;
+  var parsedFromHighEntropyValuesOSName = undefined;
+  var parsedFromHighEntropyValuesOSVersion = undefined;
+  var parsedFromHighEntropyValuesBrowserName = undefined;
+  var parsedFromHighEntropyValuesBrowserVersion = undefined;
+  var parsedFromHighEntropyValuesEngineVersion = undefined;
+  var parsedFromHighEntropyValuesDevice = null;
+  var ready;
+  function resolveWindowsVersion(string) {
+      if (typeof string === 'undefined')
+          return '';
+      var mapped = {
+          '4.90': 'ME',
+          'NT3.51': 'NT 3.11',
+          'NT4.0': 'NT 4.0',
+          'NT 5.0': '2000',
+          'NT 5.1': 'XP',
+          'NT 5.2': 'XP',
+          'NT 6.0': 'Vista',
+          'NT 6.1': '7',
+          'NT 6.2': '8',
+          'NT 6.3': '8.1',
+          'NT 6.4': '10',
+          'NT 10.0': '10',
+          'ARM': 'RT'
+      }[string];
+      if (typeof mapped !== 'undefined')
+          return mapped;
+      return string;
+  }
+  function resolveUnderscoreVersion(string) {
+      if (typeof string === 'undefined')
+          return '';
+      return string.replace(/_/g, '.');
+  }
+  function resolveVersion(string, resolver) {
+      if (typeof resolver === 'function')
+          return resolver(string);
+      if (typeof resolver === 'string')
+          return resolver;
+      if (typeof string === 'undefined')
+          return '';
+      return string;
+  }
+  function parseOS() {
+      var name = 'unknown';
+      var version = '';
+      for (var i = 0; i < OS_RESOLVER_MAP.length; i++) {
+          var map = OS_RESOLVER_MAP[i];
+          var matched = currentUserAgent.match(map[0]);
+          if (matched !== null) {
+              name = map[1];
+              version = resolveVersion(matched[1], map[2]);
+              break;
+          }
+      }
+      if (name === 'ios' && PlatformKit.compareVersion(version, '18.6') === 0) {
+          var execs = /\) Version\/([\d.]+)/.exec(currentUserAgent);
+          if (execs !== null) {
+              var major = parseInt(execs[1].split('.')[0], 10);
+              if (major >= 26)
+                  version = execs[1];
+          }
+      }
+      if (currentUserAgent === USER_AGENT) {
+          if (typeof parsedFromHighEntropyValuesOSName !== 'undefined')
+              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)
+              name = 'ios';
+      }
+      return {
+          name: name,
+          version: version
+      };
+  }
+  function parseBrowser() {
+      var name = 'unknown';
+      var version = '';
+      for (var i = 0; i < BROWSER_RESOLVER_MAP.length; i++) {
+          var map = BROWSER_RESOLVER_MAP[i];
+          var matched = currentUserAgent.match(map[0]);
+          if (matched !== null) {
+              name = map[1];
+              version = resolveVersion(matched[1], map[2]);
+              break;
+          }
+      }
+      if (currentUserAgent === USER_AGENT) {
+          if (typeof parsedFromHighEntropyValuesBrowserName !== 'undefined')
+              name = parsedFromHighEntropyValuesBrowserName;
+          if (typeof parsedFromHighEntropyValuesBrowserVersion !== 'undefined')
+              version = parsedFromHighEntropyValuesBrowserVersion;
+      }
+      return {
+          name: name,
+          version: version
+      };
+  }
+  function parseEngine() {
+      var name = 'unknown';
+      var version = '';
+      for (var i = 0; i < ENGINE_RESOLVER_MAP.length; i++) {
+          var map = ENGINE_RESOLVER_MAP[i];
+          var matched = currentUserAgent.match(map[0]);
+          if (matched !== null) {
+              name = map[1];
+              version = resolveVersion(matched[1], map[2]);
+              break;
+          }
+      }
+      if (currentUserAgent === USER_AGENT) {
+          if (typeof parsedFromHighEntropyValuesEngineVersion !== 'undefined')
+              version = parsedFromHighEntropyValuesEngineVersion;
+      }
+      return {
+          name: name,
+          version: version
+      };
+  }
+  function getParsedCache() {
+      if (parsedCache !== null && parsedCache.userAgent === currentUserAgent)
+          return parsedCache;
+      parsedCache = {
+          userAgent: currentUserAgent,
+          os: parseOS(),
+          browser: parseBrowser(),
+          engine: parseEngine(),
+      };
+      return parsedCache;
+  }
+  function invalidateCache() {
+      parsedCache = null;
+      parsedFromHighEntropyValuesOSName = undefined;
+      parsedFromHighEntropyValuesOSVersion = undefined;
+      parsedFromHighEntropyValuesBrowserName = undefined;
+      parsedFromHighEntropyValuesBrowserVersion = undefined;
+      parsedFromHighEntropyValuesEngineVersion = undefined;
+      parsedFromHighEntropyValuesDevice = null;
+  }
+  function normalizeBrand(entry) {
+      if (entry === null || typeof entry === 'undefined')
+          return { brand: '', version: '' };
+      if (typeof entry === 'string')
+          return { brand: entry, version: '' };
+      return { brand: entry.brand, version: entry.version };
+  }
+  function parseFromHighEntropyValues() {
+      if (typeof USER_AGENT_DATA === 'undefined' || typeof USER_AGENT_DATA.getHighEntropyValues === 'undefined')
+          return Promise.resolve();
+      return USER_AGENT_DATA
+          .getHighEntropyValues(['brands', 'fullVersionList', 'mobile', 'model', 'platform', 'platformVersion', 'architecture', 'formFactors', 'bitness', 'uaFullVersion', 'wow64'])
+          .then(function (result) {
+          try {
+              var brands = result.fullVersionList || result.brands || [];
+              var platformVersion = result.platformVersion;
+              var platform = result.platform;
+              var browserName = getParsedCache().browser.name;
+              var prevBrandName = null;
+              for (var i = 0; i < brands.length; i++) {
+                  var brand = normalizeBrand(brands[i]);
+                  var brandVersion = brand.version;
+                  var brandName = brand.brand;
+                  if (/not.a.brand/i.test(brandName))
+                      continue;
+                  if (prevBrandName === null || (/Chrom/.test(prevBrandName) && brandName !== 'Chromium') || (prevBrandName === 'Edge' && /WebView2/.test(brandName))) {
+                      brandName = HIGH_ENTROPY_BRAND_NAME_MAP[brandName] || brandName;
+                      prevBrandName = browserName;
+                      if (prevBrandName === null || /Chrom/.test(prevBrandName) || !/Chrom/.test(brandName)) {
+                          browserName = brandName;
+                          if (browserName === 'Chrome' || browserName === 'Chrome WebView' || browserName === 'Chrome Headless')
+                              parsedFromHighEntropyValuesBrowserName = 'chrome';
+                          else if (browserName === 'Edge' || browserName === 'Edge WebView2')
+                              parsedFromHighEntropyValuesBrowserName = 'edge';
+                          else if (browserName === 'Opera Mobi')
+                              parsedFromHighEntropyValuesBrowserName = 'opera';
+                          parsedFromHighEntropyValuesBrowserVersion = brandVersion;
+                      }
+                      prevBrandName = brandName;
+                  }
+                  if (brandName === 'Chromium')
+                      parsedFromHighEntropyValuesEngineVersion = brandVersion;
+              }
+              if (typeof platformVersion === 'string') {
+                  if (getParsedCache().os.name === 'windows') {
+                      if (parseInt(platformVersion.split('.')[0], 10) >= 13)
+                          parsedFromHighEntropyValuesOSVersion = '11';
+                      else
+                          parsedFromHighEntropyValuesOSVersion = '10';
+                  }
+                  else {
+                      parsedFromHighEntropyValuesOSVersion = platformVersion;
+                  }
+              }
+              if (typeof platform === 'string') {
+                  if (/android/i.test(platform))
+                      parsedFromHighEntropyValuesOSName = 'android';
+                  else if (/ios|iphone|ipad/i.test(platform))
+                      parsedFromHighEntropyValuesOSName = 'ios';
+                  else if (/windows|win32/i.test(platform))
+                      parsedFromHighEntropyValuesOSName = 'windows';
+                  else if (/macos|macintel/i.test(platform))
+                      parsedFromHighEntropyValuesOSName = 'macos';
+              }
+              if (result.mobile === true)
+                  parsedFromHighEntropyValuesDevice = 'mobile';
+              parsedCache = null;
+          }
+          catch (_) {
+          }
+      })
+          .catch(function () {
+          parsedCache = null;
+      });
+  }
+  ready = parseFromHighEntropyValues();
+  var PlatformKit = {
+      version: packageJSON.version,
+      get ready() {
+          return ready;
+      },
+      set userAgent(userAgent) {
+          if (currentUserAgent === userAgent)
+              return;
+          currentUserAgent = userAgent;
+          invalidateCache();
+          ready = parseFromHighEntropyValues();
+      },
+      get userAgent() {
+          return currentUserAgent;
+      },
+      get os() {
+          return getParsedCache().os;
+      },
+      get browser() {
+          return getParsedCache().browser;
+      },
+      get engine() {
+          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';
+      },
+      get webview() {
+          return /; ?wv|applewebkit(?!.*safari)/i.test(currentUserAgent);
+      },
+      get node() {
+          return typeof globalThis.process !== 'undefined' && typeof globalThis.process.versions !== 'undefined' && typeof globalThis.process.versions.node !== 'undefined';
+      },
+      get standalone() {
+          var osName = getParsedCache().os.name;
+          if (osName === 'ios')
+              return globalThis.navigator.standalone === true;
+          if (typeof globalThis.matchMedia === 'undefined')
+              return false;
+          return globalThis.matchMedia('(display-mode: standalone)').matches;
+      },
+      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);
+              else
+                  b = 0;
+              if (a > b)
+                  return 1;
+              if (a < b)
+                  return -1;
+          }
+          return 0;
+      }
+  };
+
+  function createHiddenElement(tagName, focusable) {
+      if (focusable === void 0) { focusable = true; }
+      var element = globalThis.document.createElement(tagName);
+      if (typeof element.width !== 'undefined')
+          element.width = '0';
+      if (typeof element.height !== 'undefined')
+          element.height = '0';
+      if (typeof element.border !== 'undefined')
+          element.border = '0';
+      if (typeof element.frameBorder !== 'undefined')
+          element.frameBorder = '0';
+      if (typeof element.scrolling !== 'undefined')
+          element.scrolling = 'no';
+      if (typeof element.cellPadding !== 'undefined')
+          element.cellPadding = '0';
+      if (typeof element.cellSpacing !== 'undefined')
+          element.cellSpacing = '0';
+      if (typeof element.frame !== 'undefined')
+          element.frame = 'void';
+      if (typeof element.rules !== 'undefined')
+          element.rules = 'none';
+      if (typeof element.noWrap !== 'undefined')
+          element.noWrap = true;
+      element.tabIndex = -1;
+      element.setAttribute('role', 'presentation');
+      if (focusable) {
+          element.setAttribute('aria-hidden', 'false');
+          element.style.width = '1px';
+          element.style.height = '1px';
+      }
+      else {
+          element.setAttribute('aria-hidden', 'true');
+          element.style.width = '0';
+          element.style.height = '0';
+          element.style.zIndex = '-9999';
+          element.style.display = 'none';
+          element.style.visibility = 'hidden';
+          element.style.pointerEvents = 'none';
+      }
+      element.style.position = 'absolute';
+      element.style.top = '0';
+      element.style.left = '0';
+      element.style.padding = '0';
+      element.style.margin = '0';
+      element.style.border = 'none';
+      element.style.outline = 'hidden';
+      element.style.clip = 'rect(1px, 1px, 1px, 1px)';
+      element.style.clipPath = 'inset(50%)';
+      element.style.overflow = 'hidden';
+      element.style.whiteSpace = 'nowrap';
+      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)
+          return null;
+      locale = locale.replace(/_/g, '-');
+      if (locale === 'C' || locale.toLowerCase() === 'posix')
+          return 'en-US';
+      if (locale.indexOf('.') !== -1)
+          return normalizeLocale(locale.split('.')[0]);
+      if (locale.indexOf('@') !== -1)
+          return normalizeLocale(locale.split('@')[0]);
+      var parts = locale.split('-');
+      if (parts.length === 0)
+          return null;
+      parts[0] = parts[0].toLowerCase();
+      if (parts.length > 1 && parts[1].length === 2)
+          parts[1] = parts[1].toUpperCase();
+      if (parts.length > 2 && parts[1].length === 4)
+          parts[1] = parts[1].charAt(0).toUpperCase() + parts[1].slice(1).toLowerCase();
+      return parts.join('-');
+  }
+  var language = null;
+  var languages = [];
+  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);
+      }
+  }
+  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};
+
+  var TRACK_ID = 'track-id';
+  var BUNDLE_ID = 'bundle-id';
+  var TRACK_ID_CACHE_TTL = 1000 * 60 * 60;
+  var idCache = (function () {
+      var supportsLocalStorage;
+      try {
+          if (typeof globalThis.localStorage === 'undefined') {
+              supportsLocalStorage = false;
+          }
+          else {
+              var key = '__id_cache_test__';
+              globalThis.localStorage.setItem(key, '');
+              globalThis.localStorage.removeItem(key);
+              supportsLocalStorage = true;
+          }
+      }
+      catch (_) {
+          supportsLocalStorage = false;
+      }
+      if (supportsLocalStorage) {
+          return {
+              get: function (mode, query) {
+                  try {
+                      var item = globalThis.localStorage.getItem(mode + ':' + query);
+                      if (item == null)
+                          return undefined;
+                      var split = item.split('|');
+                      if (split.length !== 2)
+                          return undefined;
+                      var expiry = +split[0];
+                      if (isNotANumber(expiry) || expiry < getNow()) {
+                          globalThis.localStorage.removeItem(mode + ':' + query);
+                          return undefined;
+                      }
+                      return split[1];
+                  }
+                  catch (_) {
+                      return undefined;
+                  }
+              },
+              set: function (mode, query, id) {
+                  try {
+                      globalThis.localStorage.setItem(mode + ':' + query, getNow() + TRACK_ID_CACHE_TTL + '|' + id);
+                  }
+                  catch (_) {
+                      return;
+                  }
+              }
+          };
+      }
+      if (typeof globalThis.Map !== 'undefined') {
+          var cache_1 = new Map();
+          return {
+              get: function (mode, query) {
+                  var item = cache_1.get(mode + ':' + query);
+                  if (typeof item === 'undefined')
+                      return undefined;
+                  var split = item.split('|');
+                  if (split.length !== 2)
+                      return undefined;
+                  var expiry = +split[0];
+                  if (isNotANumber(expiry) || expiry < getNow()) {
+                      cache_1.delete(mode + ':' + query);
+                      return undefined;
+                  }
+                  return split[1];
+              },
+              set: function (mode, query, id) {
+                  cache_1.set(mode + ':' + query, getNow() + TRACK_ID_CACHE_TTL + '|' + id);
+              },
+          };
+      }
+      var cache = Object.create(null);
+      return {
+          get: function (mode, query) {
+              var item = cache[mode + ':' + query];
+              if (typeof item === 'undefined')
+                  return undefined;
+              var split = item.split('|');
+              if (split.length !== 2)
+                  return undefined;
+              var expiry = +split[0];
+              if (isNotANumber(expiry) || expiry < getNow()) {
+                  try {
+                      delete cache[mode + ':' + query];
+                  }
+                  catch (_) {
+                      cache[mode + ':' + query] = undefined;
+                  }
+                  return undefined;
+              }
+              return split[1];
+          },
+          set: function (mode, query, id) {
+              cache[mode + ':' + query] = getNow() + TRACK_ID_CACHE_TTL + '|' + id;
+          }
+      };
+  })();
+  function isNotANumber(value) {
+      return value !== value;
+  }
+  function getNow() {
+      if (typeof Date.now !== 'undefined')
+          return Date.now();
+      return (new Date).getTime();
+  }
+  function requestGet(url, async) {
+      if (async === void 0) { async = false; }
+      if (typeof globalThis.fetch === 'function' && async) {
+          return globalThis.fetch(url)
+              .then(function (response) {
+              return response.json();
+          })
+              .catch(function (_) {
+              return undefined;
+          });
+      }
+      else {
+          try {
+              var xhr = new XMLHttpRequest();
+              xhr.open('GET', url, async);
+              xhr.send();
+              var status_1 = xhr.status;
+              if (status_1 >= 200 && status_1 < 300)
+                  return JSON.parse(xhr.response);
+              return undefined;
+          }
+          catch (_) {
+              return undefined;
+          }
+      }
+  }
+  function resolveGetProductIdURL(packageFamilyName) {
+      var locales = LocaleKit.languages;
+      var locale = 'en-US';
+      var country = 'US';
+      for (var i = 0; i < locales.length; i++) {
+          var candidate = locales[i];
+          if (candidate.indexOf('-') === -1)
+              continue;
+          var subtags = candidate.split('-');
+          for (var j = 1; j < subtags.length; j++) {
+              var subtag = subtags[j];
+              if (/^[A-Za-z]{2}$/.test(subtag) || /^\d{3}$/.test(subtag)) {
+                  locale = candidate;
+                  country = subtag;
+                  break;
+              }
+          }
+          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';
+  }
+  function resolveGetTrackIdURL(bundleId) {
+      return 'https://itunes.apple.com/lookup?bundleId=' + globalThis.encodeURIComponent(bundleId);
+  }
+  function parseGetProductIdResponse(response) {
+      if (typeof response === 'undefined')
+          return undefined;
+      var product = undefined;
+      if (typeof response.Products !== 'undefined')
+          product = response.Products[0];
+      else if (typeof response.Product !== 'undefined')
+          product = response.Product;
+      if (typeof product === 'undefined' || product === null)
+          return undefined;
+      return product.ProductId;
+  }
+  function parseGetTrackIdResponse(response) {
+      if (typeof response === 'undefined' || typeof response.results === 'undefined')
+          return undefined;
+      var results = response.results;
+      if (results.length === 0)
+          return undefined;
+      var result = results[0];
+      if (typeof result === 'undefined')
+          return undefined;
+      return '' + result.trackId;
+  }
+  function getProductId(packageFamilyName) {
+      var cache = idCache.get(BUNDLE_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);
+          return productId;
+      }
+      catch (_) {
+          return undefined;
+      }
+  }
+  function getTrackId(bundleId) {
+      var cache = idCache.get(TRACK_ID, bundleId);
+      if (typeof cache !== 'undefined')
+          return cache;
+      try {
+          var trackId = parseGetTrackIdResponse(requestGet(resolveGetTrackIdURL(bundleId)));
+          if (typeof trackId === 'undefined')
+              return undefined;
+          idCache.set(TRACK_ID, bundleId, trackId);
+          return trackId;
+      }
+      catch (_) {
+          return undefined;
+      }
+  }
+  function getProductIdAsync(packageFamilyName) {
+      var cache = idCache.get(BUNDLE_ID, packageFamilyName);
+      if (typeof cache !== 'undefined')
+          return Promise.resolve(cache);
+      try {
+          return requestGet(resolveGetProductIdURL(packageFamilyName), true)
+              .then(parseGetProductIdResponse)
+              .then(function (productId) {
+              if (typeof productId === 'undefined')
+                  return undefined;
+              idCache.set(BUNDLE_ID, packageFamilyName, productId);
+              return productId;
+          });
+      }
+      catch (_) {
+          return Promise.resolve(undefined);
+      }
+  }
+  function getTrackIdAsync(bundleId) {
+      var cache = idCache.get(TRACK_ID, bundleId);
+      if (typeof cache !== 'undefined')
+          return Promise.resolve(cache);
+      try {
+          return requestGet(resolveGetTrackIdURL(bundleId), true)
+              .then(parseGetTrackIdResponse)
+              .then(function (trackId) {
+              if (typeof trackId === 'undefined')
+                  return undefined;
+              idCache.set(TRACK_ID, bundleId, trackId);
+              return trackId;
+          });
+      }
+      catch (_) {
+          return Promise.resolve(undefined);
+      }
+  }
+
+  function getTopmostWindow() {
+      try {
+          if (globalThis.top !== null && globalThis.top !== globalThis.window) {
+              void globalThis.top.location.href;
+              return globalThis.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;
+      }
+  }
+
+  exports.SettingType = void 0;
+  (function (SettingType) {
+      SettingType["General"] = "general";
+      SettingType["Network"] = "network";
+      SettingType["Display"] = "display";
+      SettingType["Appearance"] = "appearance";
+      SettingType["Accessibility"] = "accessibility";
+      SettingType["Battery"] = "battery";
+      SettingType["Datetime"] = "datetime";
+      SettingType["Language"] = "language";
+      SettingType["Accounts"] = "accounts";
+      SettingType["Storage"] = "storage";
+  })(exports.SettingType || (exports.SettingType = {}));
+  var SETTING_URL = {
+      android: {
+          general: 'intent:#Intent;action=android.settings.SETTINGS;end',
+          network: 'intent:#Intent;action=android.settings.WIFI_SETTINGS;end',
+          display: 'intent:#Intent;action=android.settings.DISPLAY_SETTINGS;end',
+          appearance: 'intent:#Intent;action=android.settings.DISPLAY_SETTINGS;end',
+          accessibility: 'intent:#Intent;action=android.settings.ACCESSIBILITY_SETTINGS;end',
+          battery: 'intent:#Intent;action=android.settings.BATTERY_SAVER_SETTINGS;end',
+          datetime: 'intent:#Intent;action=android.settings.DATE_SETTINGS;end',
+          language: 'intent:#Intent;action=android.settings.LOCALE_SETTINGS;end',
+          accounts: 'intent:#Intent;action=android.settings.SYNC_SETTINGS;end',
+          storage: 'intent:#Intent;action=android.settings.INTERNAL_STORAGE_SETTINGS;end',
+      },
+      windows: {
+          general: 'ms-settings:system',
+          network: 'ms-settings:network',
+          display: 'ms-settings:display',
+          appearance: 'ms-settings:colors',
+          accessibility: 'ms-settings:easeofaccess',
+          battery: 'ms-settings:batterysaver',
+          datetime: 'ms-settings:dateandtime',
+          language: 'ms-settings:regionlanguage',
+          accounts: 'ms-settings:emailandaccounts',
+          storage: 'ms-settings:storagesense',
+      },
+      macos: {
+          general: 'x-apple.systempreferences:',
+          network: 'x-apple.systempreferences:com.apple.preference.network',
+          display: 'x-apple.systempreferences:com.apple.preference.displays',
+          appearance: 'x-apple.systempreferences:com.apple.preference.general',
+          accessibility: 'x-apple.systempreferences:com.apple.preference.universalaccess',
+          battery: 'x-apple.systempreferences:com.apple.preference.energysaver',
+          datetime: 'x-apple.systempreferences:com.apple.preference.datetime',
+          language: 'x-apple.systempreferences:com.apple.Localization',
+          accounts: 'x-apple.systempreferences:com.apple.preferences.internetaccounts',
+          storage: 'x-apple.systempreferences:',
+      },
+      macos13: {
+          general: 'x-apple.systempreferences:com.apple.General-Settings.extension',
+          network: 'x-apple.systempreferences:com.apple.Network-Settings.extension',
+          display: 'x-apple.systempreferences:com.apple.Displays-Settings.extension',
+          appearance: 'x-apple.systempreferences:com.apple.Appearance-Settings.extension',
+          accessibility: 'x-apple.systempreferences:com.apple.Accessibility-Settings.extension',
+          battery: 'x-apple.systempreferences:com.apple.Battery-Settings.extension',
+          datetime: 'x-apple.systempreferences:com.apple.Date-Time-Settings.extension',
+          language: 'x-apple.systempreferences:com.apple.Localization-Settings.extension',
+          accounts: 'x-apple.systempreferences:com.apple.Internet-Accounts-Settings.extension',
+          storage: 'x-apple.systempreferences:com.apple.settings.Storage',
+      }
+  };
+  var ANDROID_DEFAULT_TIMEOUT = 1000;
+  var IOS_DEFAULT_TIMEOUT = 2000;
+  var WINDOWS_DEFAULT_TIMEOUT = 750;
+  var MACOS_DEFAULT_TIMEOUT = 750;
+  var SETTING_DEFAULT_TIMEOUT = 750;
+  var NAVIGATOR = globalThis.navigator;
+  var CLEANUP_INPUT_ELEMENT = null;
+  function createTypeGuard(tag) {
+      return function (value) {
+          return Object.prototype.toString.call(value) === '[object ' + tag + ']';
+      };
+  }
+  var isURL = createTypeGuard('URL');
+  var isDOMException = createTypeGuard('DOMException');
+  var isArray = createTypeGuard('Array');
+  var isPromise = createTypeGuard('Promise');
+  var isHTMLInputElement = createTypeGuard('HTMLInputElement');
+  function isHTMLInputElementLike(value) {
+      if (isHTMLInputElement(value))
+          return true;
+      var maybe = value;
+      return typeof maybe === 'object'
+          && maybe !== null
+          && maybe.nodeType === 1
+          && typeof maybe.tagName === 'string'
+          && maybe.tagName.toUpperCase() === 'INPUT';
+  }
+  function getDefaultTimeout() {
+      switch (PlatformKit.os.name) {
+          case 'android':
+              return ANDROID_DEFAULT_TIMEOUT;
+          case 'ios':
+              return IOS_DEFAULT_TIMEOUT;
+          case 'windows':
+              return WINDOWS_DEFAULT_TIMEOUT;
+          case 'macos':
+              return MACOS_DEFAULT_TIMEOUT;
+          default:
+              return WINDOWS_DEFAULT_TIMEOUT;
+      }
+  }
+  function isDocumentHidden() {
+      var top = getTopmostWindow();
+      var topDocument = top.document;
+      if (topDocument.visibilityState === 'hidden')
+          return true;
+      if (topDocument.webkitVisibilityState === 'hidden')
+          return true;
+      if (topDocument.mozVisibilityState === 'hidden')
+          return true;
+      if (topDocument.msVisibilityState === 'hidden')
+          return true;
+      if (typeof topDocument.hidden !== 'undefined')
+          return topDocument.hidden;
+      if (typeof topDocument.webkitHidden !== 'undefined')
+          return topDocument.webkitHidden;
+      if (typeof topDocument.mozHidden !== 'undefined')
+          return topDocument.mozHidden;
+      if (typeof topDocument.msHidden !== 'undefined')
+          return topDocument.msHidden;
+      if (typeof topDocument.hasFocus === 'function')
+          return !topDocument.hasFocus();
+      return true;
+  }
+  function dispatchClickEvent(element, view) {
+      if (view === void 0) { view = globalThis; }
+      var fake;
+      try {
+          fake = new MouseEvent('click', {
+              bubbles: true,
+              cancelable: true,
+              view: view
+          });
+      }
+      catch (_) {
+          fake = globalThis.document.createEvent('MouseEvents');
+          fake.initMouseEvent('click', true, true, view, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+      }
+      element.dispatchEvent(fake);
+  }
+  function hasFocus(document) {
+      if (typeof document.hasFocus === 'function')
+          return document.hasFocus();
+      return false;
+  }
+  function focus(target) {
+      try {
+          target.focus({ preventScroll: true });
+      }
+      catch (_) {
+          try {
+              target.focus();
+          }
+          catch (_) {
+          }
+      }
+  }
+  function restoreFocus() {
+      var top = getTopmostWindow();
+      var topDocument = top.document;
+      focus(top);
+      if (hasFocus(topDocument))
+          return true;
+      if (topDocument.body.tabIndex < 0)
+          topDocument.body.tabIndex = -1;
+      focus(topDocument.body);
+      if (hasFocus(topDocument))
+          return true;
+      var input = undefined;
+      try {
+          input = createHiddenElement('input');
+          if (typeof input === 'undefined')
+              return false;
+          input.type = 'text';
+          input.readOnly = true;
+          topDocument.body.appendChild(input);
+          focus(input);
+          try {
+              input.select();
+          }
+          catch (_) {
+          }
+          if (hasFocus(topDocument))
+              return true;
+      }
+      catch (_) {
+      }
+      finally {
+          if (typeof input !== 'undefined' && input !== null) {
+              try {
+                  input.blur();
+              }
+              catch (_) {
+              }
+              try {
+                  topDocument.body.removeChild(input);
+              }
+              catch (_) {
+              }
+          }
+      }
+      return hasFocus(topDocument);
+  }
+  function stripURL(value) {
+      return typeof value === 'undefined' ? undefined : isURL(value) ? value.toString() : value;
+  }
+  function resolveFocusEventConfig() {
+      var top = getTopmostWindow();
+      var topDocument = top.document;
+      if (typeof globalThis.cordova !== 'undefined') {
+          return {
+              focus: {
+                  target: topDocument,
+                  type: 'resume',
+              },
+              blur: {
+                  target: topDocument,
+                  type: 'pause',
+              },
+              visibilitychange: {}
+          };
+      }
+      else if (PlatformKit.os.name === 'ios') {
+          if (PlatformKit.compareVersion(PlatformKit.os.version, '8.0') >= 0) {
+              return {
+                  focus: {},
+                  blur: {},
+                  visibilitychange: {
+                      target: topDocument,
+                      type: 'visibilitychange',
+                  }
+              };
+          }
+          else {
+              return {
+                  focus: {
+                      target: top,
+                      type: 'pageshow',
+                  },
+                  blur: {
+                      target: top,
+                      type: 'pagehide',
+                  },
+                  visibilitychange: {}
+              };
+          }
+      }
+      else if (typeof globalThis.document.addEventListener === 'function') {
+          return {
+              focus: {
+                  target: top,
+                  type: 'focus',
+              },
+              blur: {
+                  target: top,
+                  type: 'blur',
+              },
+              visibilitychange: {
+                  target: topDocument,
+                  type: 'visibilitychange',
+              }
+          };
+      }
+      else {
+          return {
+              focus: {
+                  target: topDocument,
+                  type: 'focus',
+              },
+              blur: {
+                  target: topDocument,
+                  type: 'blur',
+              },
+              visibilitychange: {
+                  target: topDocument,
+                  type: 'visibilitychange',
+              }
+          };
+      }
+  }
+  function openURL(tried, url, timeout) {
+      var config = resolveFocusEventConfig();
+      var top = getTopmostWindow();
+      var topDocument = top.document;
+      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');
+              }
+              else {
+                  globalThis.open(url, '_system');
+              }
+              return;
+          }
+          if (isUserActivationActive() || tried === 0) {
+              top.location.href = url;
+          }
+          else {
+              try {
+                  anchor = createHiddenElement('a');
+                  anchor.href = url;
+                  topDocument.body.appendChild(anchor);
+                  dispatchClickEvent(anchor, top);
+              }
+              catch (_) {
+              }
+              finally {
+                  if (typeof anchor !== 'undefined') {
+                      try {
+                          topDocument.body.removeChild(anchor);
+                      }
+                      catch (_) {
+                      }
+                  }
+              }
+          }
+          try {
+              iframe = createHiddenElement('iframe');
+              iframe.src = url;
+              topDocument.body.appendChild(iframe);
+              globalThis.setTimeout(function () {
+                  if (typeof iframe !== 'undefined') {
+                      try {
+                          topDocument.body.removeChild(iframe);
+                      }
+                      catch (_) {
+                      }
+                  }
+              }, 500);
+              return;
+          }
+          catch (_) {
+          }
+      }
+      return new Promise(function (resolve, reject) {
+          debugger;
+          var timeoutId;
+          var resolved = false;
+          function cleanup() {
+              if (typeof timeoutId !== 'undefined') {
+                  clearTimeout(timeoutId);
+                  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);
+              }
+              catch (_) {
+              }
+              if (typeof anchor !== 'undefined') {
+                  try {
+                      topDocument.body.removeChild(anchor);
+                  }
+                  catch (_) {
+                  }
+              }
+              if (typeof iframe !== 'undefined') {
+                  try {
+                      topDocument.body.removeChild(iframe);
+                  }
+                  catch (_) {
+                  }
+              }
+          }
+          function done(success) {
+              if (resolved)
+                  return;
+              resolved = true;
+              cleanup();
+              if (success)
+                  resolve();
+              else
+                  reject();
+          }
+          function onblur() {
+              if (typeof timeoutId !== 'undefined') {
+                  clearTimeout(timeoutId);
+                  timeoutId = undefined;
+              }
+              removeEvent(config.blur.target, config.blur.type, onblur);
+              addEvent(config.focus.target, config.focus.type, onfocus);
+          }
+          function onfocus() {
+              done(true);
+          }
+          function onvisibilitychange() {
+              if (isDocumentHidden())
+                  onblur();
+              else
+                  onfocus();
+          }
+          timeoutId = globalThis.setTimeout(function () {
+              done(false);
+          }, timeout);
+          addEvent(config.blur.target, config.blur.type, onblur);
+          addEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+          if (!hasFocus(topDocument))
+              restoreFocus();
+          try {
+              open();
+          }
+          catch (_) {
+              done(false);
+          }
+      });
+  }
+  function resolveOptions(option) {
+      var resolved = [];
+      var os = PlatformKit.os.name;
+      if (os === 'unknown')
+          throw new Error('Cannot resolve app open options: unsupported or undetected OS. (userAgent: "' + PlatformKit.userAgent + '")');
+      var scheme;
+      var fallback;
+      var allowAppStore;
+      var allowWebStore;
+      var timeout;
+      var intent;
+      var packageName;
+      var bundleId;
+      var trackId;
+      var universal;
+      var packageFamilyName;
+      var productId;
+      switch (os) {
+          case 'android':
+              if (typeof option.android === 'undefined')
+                  return [[], 0];
+              intent = stripURL(option.android.intent);
+              scheme = stripURL(option.android.scheme);
+              fallback = stripURL(option.android.fallback);
+              packageName = option.android.packageName;
+              allowAppStore = option.android.allowAppStore;
+              allowWebStore = option.android.allowWebStore;
+              timeout = option.android.timeout;
+              if (typeof intent !== 'undefined' && (typeof scheme === 'undefined' || typeof packageName === 'undefined' || typeof fallback === 'undefined')) {
+                  var parsed = parseIntentURL(intent);
+                  if (typeof parsed.scheme !== 'undefined' && typeof scheme === 'undefined')
+                      scheme = parsed.scheme;
+                  if (typeof parsed.packageName !== 'undefined' && typeof packageName === 'undefined')
+                      packageName = parsed.packageName;
+                  if (typeof parsed.fallback !== 'undefined' && typeof fallback === 'undefined')
+                      fallback = parsed.fallback;
+              }
+              if (typeof scheme !== 'undefined' && typeof intent === 'undefined')
+                  intent = createIntentURL(scheme, packageName, fallback);
+              if (typeof timeout === 'undefined')
+                  timeout = ANDROID_DEFAULT_TIMEOUT;
+              if (typeof intent !== 'undefined' && canOpenIntent())
+                  resolved.push(['intent', intent]);
+              if (typeof scheme !== 'undefined')
+                  resolved.push(['scheme', scheme]);
+              if (typeof fallback !== 'undefined')
+                  resolved.push(['fallback', fallback]);
+              if (typeof packageName !== 'undefined') {
+                  if (allowAppStore)
+                      resolved.push(['store', createAppStoreURL(packageName, os)]);
+                  if (allowWebStore)
+                      resolved.push(['store', createWebStoreURL(packageName, os)]);
+              }
+              return [resolved, timeout];
+          case 'ios':
+              if (typeof option.ios === 'undefined')
+                  return [[], 0];
+              universal = stripURL(option.ios.universal);
+              scheme = stripURL(option.ios.scheme);
+              fallback = stripURL(option.ios.fallback);
+              bundleId = option.ios.bundleId;
+              trackId = option.ios.trackId;
+              allowAppStore = option.ios.allowAppStore;
+              allowWebStore = option.ios.allowWebStore;
+              timeout = option.ios.timeout;
+              if (typeof bundleId !== 'undefined' && typeof trackId === 'undefined')
+                  trackId = getTrackId(bundleId);
+              if (typeof timeout === 'undefined')
+                  timeout = IOS_DEFAULT_TIMEOUT;
+              if (typeof universal !== 'undefined' && canOpenUniversal())
+                  resolved.push(['universal', universal]);
+              if (typeof scheme !== 'undefined')
+                  resolved.push(['scheme', scheme]);
+              if (typeof fallback !== 'undefined')
+                  resolved.push(['fallback', fallback]);
+              if (typeof trackId !== 'undefined') {
+                  if (allowAppStore)
+                      resolved.push(['store', createAppStoreURL(trackId, os)]);
+                  if (allowWebStore)
+                      resolved.push(['store', createWebStoreURL(trackId, os)]);
+              }
+              return [resolved, timeout];
+          case 'windows':
+              if (typeof option.windows === 'undefined')
+                  return [[], 0];
+              scheme = stripURL(option.windows.scheme);
+              fallback = stripURL(option.windows.fallback);
+              packageFamilyName = option.windows.packageFamilyName;
+              productId = option.windows.productId;
+              allowAppStore = option.windows.allowAppStore;
+              allowWebStore = option.windows.allowWebStore;
+              timeout = option.windows.timeout;
+              if (typeof packageFamilyName !== 'undefined' && typeof productId === 'undefined')
+                  productId = getProductId(packageFamilyName);
+              if (typeof timeout === 'undefined')
+                  timeout = WINDOWS_DEFAULT_TIMEOUT;
+              if (typeof scheme !== 'undefined')
+                  resolved.push(['scheme', scheme]);
+              if (typeof fallback !== 'undefined')
+                  resolved.push(['fallback', fallback]);
+              if (typeof productId !== 'undefined') {
+                  if (allowAppStore)
+                      resolved.push(['store', createAppStoreURL(productId, os)]);
+                  if (allowWebStore)
+                      resolved.push(['store', createWebStoreURL(productId, os)]);
+              }
+              return [resolved, timeout];
+          case 'macos':
+              if (typeof option.macos === 'undefined')
+                  return [[], 0];
+              scheme = stripURL(option.macos.scheme);
+              fallback = stripURL(option.macos.fallback);
+              bundleId = option.macos.bundleId;
+              trackId = option.macos.trackId;
+              allowAppStore = option.macos.allowAppStore;
+              allowWebStore = option.macos.allowWebStore;
+              timeout = option.macos.timeout;
+              if (typeof bundleId !== 'undefined' && typeof trackId === 'undefined')
+                  trackId = getTrackId(bundleId);
+              if (typeof timeout === 'undefined')
+                  timeout = MACOS_DEFAULT_TIMEOUT;
+              if (typeof scheme !== 'undefined')
+                  resolved.push(['scheme', scheme]);
+              if (typeof fallback !== 'undefined')
+                  resolved.push(['fallback', fallback]);
+              if (typeof trackId !== 'undefined') {
+                  if (allowAppStore)
+                      resolved.push(['store', createAppStoreURL(trackId, os)]);
+                  if (allowWebStore)
+                      resolved.push(['store', createWebStoreURL(trackId, os)]);
+              }
+              return [resolved, timeout];
+      }
+  }
+  function canOpenIntent() {
+      if (PlatformKit.os.name !== 'android')
+          return false;
+      var browser = PlatformKit.browser.name;
+      var version = PlatformKit.browser.version;
+      if (browser === 'firefox' && PlatformKit.compareVersion(version, '41.0') < 0)
+          return false;
+      if (browser === 'firefox' && PlatformKit.compareVersion(version, '59.0') >= 0 && PlatformKit.compareVersion(version, '68.11.0') < 0)
+          return false;
+      if (browser === 'firefox' && PlatformKit.compareVersion(version, '80.0') >= 0 && PlatformKit.compareVersion(version, '82.0') < 0)
+          return false;
+      if (browser === 'firefox' && PlatformKit.compareVersion(version, '96.0') >= 0 && PlatformKit.compareVersion(version, '107.0') < 0)
+          return false;
+      if (browser === 'opera' && PlatformKit.compareVersion(version, '14.0') < 0)
+          return false;
+      return !(/(?:fban\/fbios|fb_iab\/fb4a)(?!.+fbav)|;fbav\/[\w.]+;/i.test(PlatformKit.userAgent) || /instagram[\/ ][-\w.]+/i.test(PlatformKit.userAgent) || /micromessenger\/([\w.]+)/i.test(PlatformKit.userAgent) || /musical_ly(?:.+app_?version\/|_)[\w.]+/i.test(PlatformKit.userAgent) || /ultralite app_version\/[\w.]+/i.test(PlatformKit.userAgent));
+  }
+  function canOpenUniversal() {
+      return PlatformKit.os.name === 'ios' && PlatformKit.compareVersion(PlatformKit.os.version, '9.0') >= 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 === 'macos' && PlatformKit.compareVersion(version, '10.10') < 0));
+  }
+  function parseIntentURL(intent) {
+      var parsed = {};
+      var split = intent.split('#Intent;');
+      if (split.length !== 2)
+          return parsed;
+      var host = split[0].replace(/^intent:\/\//i, '');
+      var parameterString = split[1].replace(/;?end\s*$/i, '');
+      var parameters = parameterString.split(';');
+      var extras = {};
+      for (var i = 0; i < parameters.length; i++) {
+          var part = parameters[i];
+          var index = part.indexOf('=');
+          if (index !== -1)
+              extras[part.substring(0, index)] = part.substring(index + 1);
+      }
+      if (typeof extras['scheme'] !== 'undefined') {
+          if (host.length > 0)
+              parsed.scheme = extras['scheme'] + '://' + host;
+          else
+              parsed.scheme = extras['scheme'] + '://';
+      }
+      if (typeof extras['package'] !== 'undefined')
+          parsed.packageName = extras['package'];
+      if (typeof extras['S.browser_fallback_url'] !== 'undefined') {
+          var fallback = extras['S.browser_fallback_url'];
+          try {
+              fallback = globalThis.decodeURIComponent(fallback);
+          }
+          catch (_) {
+          }
+          if (/^https?:\/\//i.test(fallback))
+              parsed.fallback = fallback;
+      }
+      return parsed;
+  }
+  function createIntentURL(scheme, packageName, fallback) {
+      var split = scheme.split('://');
+      var prefix = split[0];
+      var suffix = split[1];
+      var intent = 'intent://';
+      if (typeof suffix !== 'undefined')
+          intent += suffix;
+      intent += '#Intent;scheme=' + prefix + ';' + 'action=android.intent.action.VIEW;category=android.intent.category.BROWSABLE;';
+      if (typeof packageName !== 'undefined')
+          intent += 'package=' + packageName + ';';
+      if (typeof fallback !== 'undefined' && typeof fallback === 'string')
+          intent += 'S.browser_fallback_url=' + globalThis.encodeURIComponent(fallback) + ';';
+      else if (typeof packageName !== 'undefined')
+          intent += 'S.browser_fallback_url=' + globalThis.encodeURIComponent(createAppStoreURL(packageName, 'android')) + ';';
+      return intent + 'end';
+  }
+  function createAppStoreURL(id, os) {
+      switch (os) {
+          case 'android':
+              return 'market://details?id=' + id;
+          case 'ios':
+              return 'itms-apps://itunes.apple.com/app/id' + id + '?mt=8';
+          case 'windows':
+              return 'ms-windows-store://pdp/?ProductId=' + id;
+          case 'macos':
+              return 'macappstore://itunes.apple.com/app/id' + id + '?mt=12';
+          default:
+              return os;
+      }
+  }
+  function createWebStoreURL(id, os) {
+      switch (os) {
+          case 'android':
+              return 'https://play.google.com/store/apps/details?id=' + id;
+          case 'ios':
+              return 'https://itunes.apple.com/app/id' + id + '?mt=8';
+          case 'windows':
+              return 'https://apps.microsoft.com/detail/' + id;
+          case 'macos':
+              return 'https://apps.apple.com/app/id' + id + '?mt=12';
+          default:
+              return os;
+      }
+  }
+  function escapeURIComponentString(value) {
+      return globalThis.encodeURIComponent(value)
+          .replace(/[!'()*]/g, function (char) {
+          return '%' + char.charCodeAt(0).toString(16);
+      });
+  }
+  function sanitizeSMSRecipient(value) {
+      return value.replace(/[^\d+\-.]/g, '');
+  }
+  function escapeURIComponentMailAddressString(value) {
+      return escapeURIComponentString(value)
+          .replace(/%40/g, '@')
+          .replace(/%2C/gi, ',');
+  }
+  function encodeMailBody(value) {
+      return escapeURIComponentString(value.replace(/\r\n|\n|\r/g, '\r\n'));
+  }
+  function toArray(value) {
+      return typeof value === 'undefined' ? [] : typeof value === 'string' ? [value] : value;
+  }
+  function joining(values, mapfn, separator) {
+      if (mapfn === void 0) { mapfn = undefined; }
+      if (separator === void 0) { separator = ','; }
+      var length = values.length;
+      var result = '';
+      for (var i = 0; i < length; i++) {
+          if (i !== 0)
+              result += separator;
+          if (typeof mapfn !== 'undefined')
+              result += mapfn(values[i]);
+          else
+              result += values[i];
+      }
+      return result;
+  }
+  function tokenize(string) {
+      if (string === '')
+          return [];
+      return string
+          .split(/\s*[,，]\s*/)
+          .filter(function (string) {
+          return string !== '';
+      });
+  }
+  function flatten(arrays) {
+      var result = [];
+      for (var i = 0; i < arrays.length; i++) {
+          var sub = arrays[i];
+          for (var j = 0; j < sub.length; j++) {
+              result.push(sub[j]);
+          }
+      }
+      return result;
+  }
+  function isUserActivationActive() {
+      return typeof NAVIGATOR !== 'undefined' && typeof NAVIGATOR.userActivation !== 'undefined' && NAVIGATOR.userActivation.isActive;
+  }
+  function canShowDirectoryPicker() {
+      return typeof globalThis.showDirectoryPicker === 'function';
+  }
+  function canShowOpenFilePicker() {
+      return typeof globalThis.showOpenFilePicker === 'function';
+  }
+  function isFileSystemFileHandle(handle) {
+      return handle.kind === 'file';
+  }
+  function isFileSystemDirectoryHandle(handle) {
+      return handle.kind === 'directory';
+  }
+  function fileListToArray(fileList) {
+      var files = [];
+      if (fileList === null)
+          return files;
+      for (var i = 0; i < fileList.length; i++) {
+          var file = fileList[i];
+          files.push(file);
+      }
+      return files;
+  }
+  function setWebkitRelativePath(file, path) {
+      if (path === void 0) { path = file.webkitRelativePath; }
+      Object.defineProperty(file, 'webkitRelativePath', {
+          value: path,
+          writable: false,
+          configurable: true,
+          enumerable: true,
+      });
+      return file;
+  }
+  function resolveFile(module) {
+      var top = getTopmostWindow();
+      var topDocument = top.document;
+      var config = resolveFocusEventConfig();
+      function resolveFileSystemHandle(module, resolve, reject) {
+          module
+              .then(function (result) {
+              if (isArray(result)) {
+                  var handles = [];
+                  for (var i = 0; i < result.length; i++)
+                      handles[i] = result[i].getFile();
+                  return Promise
+                      .all(handles)
+                      .then(resolve)
+                      .catch(reject);
+              }
+              else if (isFileSystemDirectoryHandle(result)) {
+                  return walk(result, result.name)
+                      .then(resolve)
+                      .catch(reject);
+              }
+          })
+              .catch(function (error) {
+              if (isDOMException(error) && error.name === 'AbortError')
+                  return resolve([]);
+              reject(error);
+          });
+      }
+      function resolveInput(module, resolve) {
+          var resolved = false;
+          function done(success) {
+              if (resolved)
+                  return;
+              resolved = true;
+              cleanup();
+              if (!success)
+                  return resolve([]);
+              resolve(fileListToArray(module.files));
+          }
+          function onfocus() {
+              globalThis.setTimeout(function () {
+                  if (module.value.length > 0)
+                      done(true);
+                  else
+                      done(false);
+              }, 1000);
+          }
+          function onvisibilitychange() {
+              if (!isDocumentHidden())
+                  onfocus();
+          }
+          function onclick() {
+              done(false);
+          }
+          module.onchange = function () {
+              done(true);
+          };
+          if (CLEANUP_INPUT_ELEMENT !== null)
+              CLEANUP_INPUT_ELEMENT();
+          if (typeof module.oncancel !== 'undefined') {
+              module.oncancel = function () {
+                  done(false);
+              };
+          }
+          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);
+                  }, 100);
+                  CLEANUP_INPUT_ELEMENT = function () {
+                      done(false);
+                  };
+              };
+          }
+          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);
+              }
+              catch (_) {
+              }
+          }
+          dispatchClickEvent(module);
+      }
+      return new Promise(function (resolve, reject) {
+          if (isPromise(module))
+              return resolveFileSystemHandle(module, resolve, reject);
+          else if (isHTMLInputElementLike(module))
+              return resolveInput(module, resolve);
+          else
+              reject(new TypeError('resolveFile expects an HTMLInputElement or a file-system handle Promise, but received: ' + Object.prototype.toString.call(module)));
+      });
+  }
+  function walk(directory, basePath) {
+      if (basePath === void 0) { basePath = ''; }
+      return new Promise(function (resolve, reject) {
+          var iterator = directory.values();
+          var handles = [];
+          function collectNext() {
+              iterator
+                  .next()
+                  .then(function (result) {
+                  if (result.done) {
+                      processHandles();
+                      return;
+                  }
+                  handles.push(result.value);
+                  collectNext();
+              })
+                  .catch(reject);
+          }
+          function processHandles() {
+              var promises = [];
+              var _loop_1 = function (i) {
+                  var handle = handles[i];
+                  var name_1 = handle.name;
+                  var path;
+                  if (basePath === '')
+                      path = name_1;
+                  else
+                      path = basePath + '/' + name_1;
+                  if (isFileSystemFileHandle(handle)) {
+                      var filePromise = handle
+                          .getFile()
+                          .then(function (file) {
+                          return [setWebkitRelativePath(file, path)];
+                      });
+                      promises.push(filePromise);
+                  }
+                  else if (isFileSystemDirectoryHandle(handle)) {
+                      promises.push(walk(handle, path));
+                  }
+              };
+              for (var i = 0; i < handles.length; i++) {
+                  _loop_1(i);
+              }
+              Promise
+                  .all(promises)
+                  .then(flatten)
+                  .then(resolve)
+                  .catch(reject);
+          }
+          collectNext();
+      });
+  }
+  var LaunchKit = {
+      SettingType: exports.SettingType,
+      version: packageJSON$1.version,
+      utils: {
+          get canOpenIntent() {
+              return canOpenIntent();
+          },
+          get canOpenUniversal() {
+              return canOpenUniversal();
+          },
+          get canOpenSetting() {
+              return canOpenSetting();
+          },
+          getTrackId: getTrackIdAsync,
+          getProductId: getProductIdAsync,
+      },
+      app: function (options) {
+          if (options === void 0) { options = {}; }
+          var resolved;
+          try {
+              resolved = resolveOptions(options);
+          }
+          catch (error) {
+              return Promise.reject(error);
+          }
+          var tried = [];
+          var urls = resolved[0];
+          var timeout = resolved[1];
+          if (urls.length === 0)
+              return Promise.reject(new Error('No openable URL candidates were resolved for the current OS ("' + PlatformKit.os.name + '"). Provide at least one of: scheme, intent, universal, fallback, or store id for this platform.'));
+          return new Promise(function (resolve, reject) {
+              function openURLSequential(index) {
+                  if (index === void 0) { index = 0; }
+                  if (index >= urls.length)
+                      return reject(new Error('Failed to open the application using all available URLs.\n\n' + 'Attempted URLs:\n' + joining(tried, undefined, '\n↓\n')));
+                  var entry = urls[index];
+                  var by = entry[0];
+                  var url = entry[1];
+                  if (typeof url === 'string') {
+                      tried[index] = url;
+                      return openURL(index, url, timeout)
+                          .then(function () {
+                          resolve(by);
+                      })
+                          .catch(function () {
+                          openURLSequential(index + 1);
+                      });
+                  }
+                  else {
+                      tried[index] = '[function fallback]';
+                      url();
+                      resolve(by);
+                  }
+              }
+              return openURLSequential();
+          });
+      },
+      telephone: function (options) {
+          if (options === void 0) { options = {}; }
+          var url = 'tel:';
+          if (typeof options.to !== 'undefined')
+              url += options.to.replace(/[^\d+*#]/g, '');
+          return openURL(0, url, getDefaultTimeout());
+      },
+      message: function (options) {
+          if (options === void 0) { options = {}; }
+          var to = toArray(options.to);
+          var url = 'sms:';
+          if (to.length > 0)
+              url += joining(to, sanitizeSMSRecipient);
+          if (typeof options.body !== 'undefined') {
+              if (PlatformKit.os.name !== 'ios')
+                  url += '?';
+              else if (PlatformKit.compareVersion(PlatformKit.os.version, '8.0') >= 0)
+                  url += '&';
+              else
+                  url += ';';
+              url += 'body=' + escapeURIComponentString(options.body);
+          }
+          return openURL(0, url, getDefaultTimeout());
+      },
+      mail: function (options) {
+          if (options === void 0) { options = {}; }
+          var params = [];
+          var to = toArray(options.to);
+          var cc = toArray(options.cc);
+          var bcc = toArray(options.bcc);
+          var url = 'mailto:';
+          if (to.length > 0)
+              url += joining(to, escapeURIComponentMailAddressString);
+          if (cc.length > 0)
+              params.push('cc=' + joining(cc, escapeURIComponentMailAddressString));
+          if (bcc.length > 0)
+              params.push('bcc=' + joining(bcc, escapeURIComponentMailAddressString));
+          if (typeof options.subject === 'string')
+              params.push('subject=' + escapeURIComponentString(options.subject));
+          if (typeof options.body === 'string')
+              params.push('body=' + encodeMailBody(options.body));
+          if (params.length > 0)
+              url += '?' + joining(params, undefined, '&');
+          return openURL(0, url, getDefaultTimeout());
+      },
+      filepicker: function (options) {
+          if (options === void 0) { options = {}; }
+          var module;
+          var accepts = [];
+          if (isArray(options.accept))
+              accepts = options.accept;
+          else if (typeof options.accept === 'string')
+              accepts = tokenize(options.accept);
+          if (options.directory) {
+              if (canShowDirectoryPicker()) {
+                  var option = { mode: 'read' };
+                  if (typeof options.id !== 'undefined')
+                      option.id = options.id;
+                  if (typeof options.startIn !== 'undefined')
+                      option.startIn = options.startIn;
+                  module = globalThis.showDirectoryPicker(option);
+              }
+              else {
+                  var input = createHiddenElement('input');
+                  input.type = 'file';
+                  input.webkitdirectory = true;
+                  input.accept = accepts.join(',');
+                  module = input;
+              }
+          }
+          else {
+              if (canShowOpenFilePicker()) {
+                  var option = {};
+                  if (typeof options.id !== 'undefined')
+                      option.id = options.id;
+                  if (typeof options.startIn !== 'undefined')
+                      option.startIn = options.startIn;
+                  if (typeof options.multiple !== 'undefined')
+                      option.multiple = options.multiple;
+                  if (accepts.length > 0) {
+                      var acceptObject = {};
+                      option.excludeAcceptAllOption = true;
+                      option.types = [{
+                              description: '',
+                              accept: acceptObject,
+                          }];
+                      for (var i = 0; i < accepts.length; i++) {
+                          var accept = accepts[i];
+                          if (accept.startsWith('.')) {
+                              if (typeof acceptObject['application/octet-stream'] === 'undefined')
+                                  acceptObject['application/octet-stream'] = [];
+                              acceptObject['application/octet-stream'].push(accept);
+                          }
+                          else if (accept.includes('/')) {
+                              acceptObject[accept] = [];
+                          }
+                      }
+                  }
+                  module = globalThis.showOpenFilePicker(option);
+              }
+              else {
+                  var input = createHiddenElement('input');
+                  input.type = 'file';
+                  input.accept = accepts.join(',');
+                  if (typeof options.multiple !== 'undefined')
+                      input.multiple = options.multiple;
+                  module = input;
+              }
+          }
+          return resolveFile(module);
+      },
+      setting: function (type) {
+          if (type === void 0) { type = exports.SettingType.General; }
+          var os = PlatformKit.os.name;
+          var version = PlatformKit.os.version;
+          var urls = [];
+          if (!canOpenSetting())
+              return Promise.reject(new Error('Opening system settings is not supported on this platform. (userAgent: "' + PlatformKit.userAgent + '")'));
+          switch (os) {
+              case 'android':
+                  if ((type === 'accessibility' && PlatformKit.compareVersion(version, '2.0') < 0)
+                      || (type === 'battery' && PlatformKit.compareVersion(version, '5.1') < 0)
+                      || (type === 'accounts' && PlatformKit.compareVersion(version, '1.5') < 0)
+                      || (type === 'storage' && PlatformKit.compareVersion(version, '1.5') < 0)
+                      || type === 'general') {
+                      urls.push(SETTING_URL.android.general);
+                      break;
+                  }
+                  urls.push(SETTING_URL.android[type]);
+                  urls.push(SETTING_URL.android.general);
+                  break;
+              case 'windows':
+                  urls.push(SETTING_URL.windows[type]);
+                  break;
+              case 'macos':
+                  if (type === 'appearance' && PlatformKit.compareVersion(version, '10.14') < 0)
+                      urls.push(SETTING_URL.macos.general);
+                  else if (PlatformKit.compareVersion(version, '13.0') < 0)
+                      urls.push(SETTING_URL.macos[type]);
+                  else
+                      urls.push(SETTING_URL.macos13[type]);
+          }
+          return new Promise(function (resolve, reject) {
+              function openURLSequential(index) {
+                  if (index === void 0) { index = 0; }
+                  if (index >= urls.length)
+                      return reject(new Error('Failed to open the "' + type + '" settings pane using all available URLs.\n\nAttempted URLs:\n' + joining(urls, undefined, '\n↓\n')));
+                  return openURL(index, urls[index], SETTING_DEFAULT_TIMEOUT)
+                      .then(function () {
+                      resolve();
+                  })
+                      .catch(function () {
+                      openURLSequential(index + 1);
+                  });
+              }
+              return openURLSequential();
+          });
+      },
+  };
+
+  exports.default = LaunchKit;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=launch-kit.umd.js.map