web-launch-kit 0.0.1 → 0.0.3

package/dist/launch-kit.umd.js

@@ -4,14 +4,14 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LaunchKit = {}));
 })(this, (function (exports) { 'use strict';
 
-  var version$1 = "0.0.1";
+  var version$2 = "0.0.3";
+  var packageJSON$2 = {
+  	version: version$2};
+
+  var version$1 = "0.0.4";
   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;
@@ -300,7 +300,7 @@
   }
   ready = parseFromHighEntropyValues();
   var PlatformKit = {
-      version: packageJSON.version,
+      version: packageJSON$1.version,
       get ready() {
           return ready;
       },
@@ -371,6 +371,665 @@
       }
   };
 
+  var version = "0.0.1";
+  var packageJSON = {
+  	version: version};
+
+  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 = {
+      'focus': ['focus', 'focusin'],
+      'blur': ['blur', 'focusout'],
+      '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 globalThis.document !== 'undefined' && target !== globalThis.document)
+          hosts.push(globalThis.document);
+      if (target !== globalThis)
+          hosts.push(globalThis);
+      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 globalThis.document === 'undefined' || typeof globalThis.document.documentElement === 'undefined')
+          return false;
+      var style = globalThis.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 globalThis.document === 'undefined' || typeof globalThis.document.documentElement === 'undefined')
+          return false;
+      var element = globalThis.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 === globalThis.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];
+      }
+      for (var i = 1; i < VENDORS.length; i++) {
+          for (var j = 0; j < candidates.length; j++) {
+              var name_1 = VENDORS[i] + candidates[j];
+              var hosts = probeHosts(target);
+              for (var k = 0; k < hosts.length; k++) {
+                  if (hasOnProperty(hosts[k], name_1))
+                      return name_1;
+              }
+          }
+      }
+      return type;
+  }
+
+  var SUPPORTED = {
+      once: false,
+      passive: false,
+      capture: false,
+      some: false,
+      all: false,
+  };
+  var NOOP$1 = function () {
+  };
+  function resolveProbeTarget() {
+      if (typeof globalThis.document !== 'undefined' && typeof globalThis.document.createDocumentFragment === 'function') {
+          try {
+              return globalThis.document.createDocumentFragment();
+          }
+          catch (_) {
+          }
+      }
+      if (typeof globalThis.EventTarget === 'function') {
+          try {
+              return new globalThis.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 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 globalThis.pageXOffset === 'number')
+          return globalThis.pageXOffset;
+      if (typeof globalThis.document !== 'undefined' && typeof globalThis.document.documentElement !== 'undefined')
+          return globalThis.document.documentElement.scrollLeft;
+      return 0;
+  }
+  function scrollOffsetY() {
+      if (typeof globalThis.pageYOffset === 'number')
+          return globalThis.pageYOffset;
+      if (typeof globalThis.document !== 'undefined' && typeof globalThis.document.documentElement !== 'undefined')
+          return globalThis.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) {
+      try {
+          Object.defineProperty(event, property, { value: list, configurable: true });
+      }
+      catch (_) {
+          event[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) {
+      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));
+      defineTouchList(event, 'targetTouches', createTouchList(filterByTarget(ACTIVE_TOUCHES, originTarget)));
+      defineTouchList(event, 'changedTouches', createTouchList([touch]));
+  }
+
+  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 LISTENER_STORE = [];
+  var NOOP = function () {
+  };
+  function findListenerRecord(target, type, callback, capture) {
+      for (var i = 0; i < LISTENER_STORE.length; i++) {
+          var record = LISTENER_STORE[i];
+          if (record.target === target && record.type === type && record.callback === callback && record.capture === capture)
+              return record;
+      }
+      return undefined;
+  }
+  function removeListenerRecord(record) {
+      for (var i = 0; i < LISTENER_STORE.length; i++) {
+          if (LISTENER_STORE[i] === record) {
+              LISTENER_STORE.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);
+  }
+  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 = globalThis.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);
+          if (record.passive && !SUPPORTED_LISTENER_OPTIONS.passive)
+              event.preventDefault = passivePreventDefault.bind(event);
+          if (record.resolvedType !== record.type)
+              defineEventProperty(event, 'type', record.type);
+          if (record.touch)
+              synthesizeTouchEvent(event, record.resolvedType);
+          fixKeyboardEvent(event);
+          invokeCallback(record.callback, record.target, event);
+      };
+  }
+  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);
+          }
+          catch (_) {
+          }
+      }
+      record.onAbort = undefined;
+  }
+  function createEventPolyfill(type, init) {
+      try {
+          return new Event(type, init);
+      }
+      catch (_) {
+      }
+      var event = globalThis.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 = globalThis.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.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);
+          if (typeof existing !== 'undefined') {
+              return function () {
+                  releaseListenerRecord(existing);
+              };
+          }
+          if (typeof normalized.signal !== 'undefined' && normalized.signal.aborted)
+              return NOOP;
+          var resolvedType = resolveEventType(target, type);
+          var record = {
+              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;
+          LISTENER_STORE.push(record);
+          if (typeof record.signal !== 'undefined' && typeof record.signal.addEventListener === 'function') {
+              record.onAbort = function () {
+                  releaseListenerRecord(record);
+              };
+              record.signal.addEventListener('abort', record.onAbort, { once: true });
+          }
+          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 createHiddenElement(tagName, focusable) {
       if (focusable === void 0) { focusable = true; }
       var element = globalThis.document.createElement(tagName);
@@ -780,101 +1439,6 @@
       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";
@@ -942,7 +1506,7 @@
   var IOS_DEFAULT_TIMEOUT = 2000;
   var WINDOWS_DEFAULT_TIMEOUT = 750;
   var MACOS_DEFAULT_TIMEOUT = 750;
-  var SETTING_DEFAULT_TIMEOUT = 750;
+  var DEFAULT_TIMEOUT = 750;
   var NAVIGATOR = globalThis.navigator;
   var CLEANUP_INPUT_ELEMENT = null;
   function createTypeGuard(tag) {
@@ -976,7 +1540,7 @@
           case 'macos':
               return MACOS_DEFAULT_TIMEOUT;
           default:
-              return WINDOWS_DEFAULT_TIMEOUT;
+              return DEFAULT_TIMEOUT;
       }
   }
   function isDocumentHidden() {
@@ -1082,7 +1646,7 @@
       return hasFocus(topDocument);
   }
   function stripURL(value) {
-      return typeof value === 'undefined' ? undefined : isURL(value) ? value.toString() : value;
+      return isURL(value) ? value.toString() : value;
   }
   function resolveFocusEventConfig() {
       var top = getTopmostWindow();
@@ -1224,9 +1788,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 +1827,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, onfocus);
+              if (typeof config.focus.target !== 'undefined' && typeof config.focus.type !== 'undefined')
+                  EventKit.add(config.focus.target, config.focus.type, onfocus);
           }
           function onfocus() {
               done(true);
@@ -1275,8 +1844,10 @@
           timeoutId = globalThis.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 {
@@ -1296,6 +1867,8 @@
       var fallback;
       var allowAppStore;
       var allowWebStore;
+      var allowScheme;
+      var assumeAllowedInApp;
       var timeout;
       var intent;
       var packageName;
@@ -1312,8 +1885,10 @@
               scheme = stripURL(option.android.scheme);
               fallback = stripURL(option.android.fallback);
               packageName = option.android.packageName;
+              assumeAllowedInApp = option.android.assumeAllowedInApp === true;
               allowAppStore = option.android.allowAppStore;
               allowWebStore = option.android.allowWebStore;
+              allowScheme = canOpenScheme(assumeAllowedInApp);
               timeout = option.android.timeout;
               if (typeof intent !== 'undefined' && (typeof scheme === 'undefined' || typeof packageName === 'undefined' || typeof fallback === 'undefined')) {
                   var parsed = parseIntentURL(intent);
@@ -1330,12 +1905,12 @@
                   timeout = ANDROID_DEFAULT_TIMEOUT;
               if (typeof intent !== 'undefined' && canOpenIntent())
                   resolved.push(['intent', intent]);
-              if (typeof scheme !== 'undefined')
+              if (typeof scheme !== 'undefined' && allowScheme)
                   resolved.push(['scheme', scheme]);
               if (typeof fallback !== 'undefined')
                   resolved.push(['fallback', fallback]);
               if (typeof packageName !== 'undefined') {
-                  if (allowAppStore)
+                  if (allowAppStore && allowScheme)
                       resolved.push(['store', createAppStoreURL(packageName, os)]);
                   if (allowWebStore)
                       resolved.push(['store', createWebStoreURL(packageName, os)]);
@@ -1349,21 +1924,23 @@
               fallback = stripURL(option.ios.fallback);
               bundleId = option.ios.bundleId;
               trackId = option.ios.trackId;
+              assumeAllowedInApp = option.ios.assumeAllowedInApp === true;
               allowAppStore = option.ios.allowAppStore;
               allowWebStore = option.ios.allowWebStore;
+              allowScheme = canOpenScheme(assumeAllowedInApp);
               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())
+              if (typeof universal !== 'undefined' && canOpenUniversal(assumeAllowedInApp))
                   resolved.push(['universal', universal]);
-              if (typeof scheme !== 'undefined')
+              if (typeof scheme !== 'undefined' && allowScheme)
                   resolved.push(['scheme', scheme]);
               if (typeof fallback !== 'undefined')
                   resolved.push(['fallback', fallback]);
               if (typeof trackId !== 'undefined') {
-                  if (allowAppStore)
+                  if (allowAppStore && allowScheme)
                       resolved.push(['store', createAppStoreURL(trackId, os)]);
                   if (allowWebStore)
                       resolved.push(['store', createWebStoreURL(trackId, os)]);
@@ -1436,10 +2013,41 @@
           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));
+      if (isFullyBlockedInAppBrowser() || isPartnerAppOnly())
+          return false;
+      return !(/(?:fban\/fbios|fb_iab\/fb4a)(?!.+fbav)|;fbav\/[\w.]+;/i.test(PlatformKit.userAgent) || /instagram[\/ ][-\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 canOpenUniversal(assumeAllowedInApp) {
+      if (assumeAllowedInApp === void 0) { assumeAllowedInApp = false; }
+      if (PlatformKit.os.name !== 'ios' || PlatformKit.compareVersion(PlatformKit.os.version, '9.0') < 0)
+          return false;
+      if (isPartnerAppOnly() && !assumeAllowedInApp)
+          return false;
+      var userAgent = PlatformKit.userAgent;
+      var wechat = userAgent.match(/micromessenger\/(\d+(?:\.\d+)*)/i);
+      if (wechat !== null && PlatformKit.compareVersion(wechat[1], '7.0.5') < 0)
+          return false;
+      if (/ qq\/[\d.]+/i.test(userAgent) || /m?qqbrowser\/[\d.]+/i.test(userAgent) || /ucbrowser\/[\d.]+/i.test(userAgent))
+          return false;
+      return !/qzone\/.*_qz_[\d.]+/i.test(userAgent);
+  }
+  function canOpenScheme(assumeAllowedInApp) {
+      if (assumeAllowedInApp === void 0) { assumeAllowedInApp = false; }
+      var os = PlatformKit.os.name;
+      if (os === 'android')
+          return !isFullyBlockedInAppBrowser() && (!isPartnerAppOnly() || assumeAllowedInApp);
+      if (os === 'ios')
+          return !/micromessenger\/[\w.]+/i.test(PlatformKit.userAgent) && (!isPartnerAppOnly() || assumeAllowedInApp);
+      return true;
+  }
+  function isFullyBlockedInAppBrowser() {
+      if (PlatformKit.os.name !== 'android')
+          return false;
+      var userAgent = PlatformKit.userAgent;
+      return /micromessenger\/[\w.]+/i.test(userAgent) || / qq\/[\d.]+/i.test(userAgent) || /qzone\/.*_qz_[\d.]+/i.test(userAgent) || /baiduboxapp\/[\d.]+/i.test(userAgent);
+  }
+  function isPartnerAppOnly() {
+      return /weibo.*weibo__[\d.]+/i.test(PlatformKit.userAgent);
   }
   function canOpenSetting() {
       var os = PlatformKit.os.name;
@@ -1546,6 +2154,18 @@
   function encodeMailBody(value) {
       return escapeURIComponentString(value.replace(/\r\n|\n|\r/g, '\r\n'));
   }
+  function encodeMapValue(value) {
+      if (isArray(value))
+          return value[0] + ',' + value[1];
+      return escapeURIComponentString(value);
+  }
+  function encodeBingRoutePoint(value) {
+      if (typeof value === 'undefined')
+          return '';
+      if (isArray(value))
+          return 'pos.' + value[0] + '_' + value[1];
+      return escapeURIComponentString(value);
+  }
   function toArray(value) {
       return typeof value === 'undefined' ? [] : typeof value === 'string' ? [value] : value;
   }
@@ -1684,10 +2304,12 @@
           }
           else {
               module.onclick = function () {
-                  addEvent(config.focus.target, config.focus.type, onfocus);
-                  addEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+                  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);
                   globalThis.setTimeout(function () {
-                      addEvent(topDocument, 'click', onclick);
+                      EventKit.add(topDocument, 'click', onclick);
                   }, 100);
                   CLEANUP_INPUT_ELEMENT = function () {
                       done(false);
@@ -1697,9 +2319,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 (_) {
               }
@@ -1769,7 +2393,7 @@
   }
   var LaunchKit = {
       SettingType: exports.SettingType,
-      version: packageJSON$1.version,
+      version: packageJSON$2.version,
       utils: {
           get canOpenIntent() {
               return canOpenIntent();
@@ -1792,12 +2416,12 @@
           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) {
+              var tried = [];
               function openURLSequential(index) {
                   if (index === void 0) { index = 0; }
                   if (index >= urls.length)
@@ -1869,6 +2493,112 @@
               url += '?' + joining(params, undefined, '&');
           return openURL(0, url, getDefaultTimeout());
       },
+      map: function (options) {
+          if (options === void 0) { options = {}; }
+          var params = [];
+          var urls = [];
+          var url = '';
+          switch (PlatformKit.os.name) {
+              case 'android':
+                  if (typeof options.coordinate !== 'undefined') {
+                      url = 'geo:' + options.coordinate[0] + ',' + options.coordinate[1];
+                  }
+                  else if (typeof options.query !== 'undefined') {
+                      url = 'geo:0,0';
+                      params.push('q=' + escapeURIComponentString(options.query));
+                  }
+                  else {
+                      url = 'geo:0,0';
+                  }
+                  if (typeof options.zoom !== 'undefined')
+                      params.push('z=' + options.zoom);
+                  if (params.length > 0)
+                      url = url + '?' + joining(params, undefined, '&');
+                  urls.push(url);
+                  break;
+              case 'ios':
+              case 'macos':
+                  if (typeof options.directions !== 'undefined') {
+                      if (typeof options.directions.destination !== 'undefined')
+                          params.push('daddr=' + encodeMapValue(options.directions.destination));
+                      if (typeof options.directions.origin !== 'undefined')
+                          params.push('saddr=' + encodeMapValue(options.directions.origin));
+                  }
+                  else if (typeof options.coordinate !== 'undefined') {
+                      params.push('ll=' + options.coordinate[0] + ',' + options.coordinate[1]);
+                      if (typeof options.label !== 'undefined')
+                          params.push('q=' + escapeURIComponentString(options.label));
+                  }
+                  else if (typeof options.query !== 'undefined') {
+                      params.push('q=' + escapeURIComponentString(options.query));
+                  }
+                  if (typeof options.zoom !== 'undefined')
+                      params.push('z=' + options.zoom);
+                  urls.push('maps://?' + joining(params, undefined, '&'));
+                  break;
+              case 'windows':
+                  if (typeof options.directions !== 'undefined') {
+                      params.push('rtp=' + encodeBingRoutePoint(options.directions.origin) + '~' + encodeBingRoutePoint(options.directions.destination));
+                  }
+                  else if (typeof options.coordinate !== 'undefined') {
+                      params.push('cp=' + options.coordinate[0] + '~' + options.coordinate[1]);
+                      if (typeof options.label !== 'undefined')
+                          params.push('q=' + escapeURIComponentString(options.label));
+                  }
+                  else if (typeof options.query !== 'undefined') {
+                      params.push('where=' + escapeURIComponentString(options.query));
+                  }
+                  if (typeof options.zoom !== 'undefined')
+                      params.push('lvl=' + options.zoom);
+                  urls.push('bingmaps:?' + joining(params, undefined, '&'));
+          }
+          if (typeof options.fallback !== 'undefined') {
+              urls.push(stripURL(options.fallback));
+          }
+          else {
+              var params_1 = ['api=1'];
+              if (typeof options.directions !== 'undefined') {
+                  params_1.push('destination=' + encodeMapValue(options.directions.destination));
+                  if (typeof options.directions.origin !== 'undefined')
+                      params_1.push('origin=' + encodeMapValue(options.directions.origin));
+                  urls.push('https://www.google.com/maps/dir/?' + joining(params_1, undefined, '&'));
+              }
+              else {
+                  if (typeof options.coordinate !== 'undefined')
+                      params_1.push('query=' + options.coordinate[0] + ',' + options.coordinate[1]);
+                  else if (typeof options.query !== 'undefined')
+                      params_1.push('query=' + escapeURIComponentString(options.query));
+                  if (typeof options.zoom !== 'undefined')
+                      params_1.push('zoom=' + options.zoom);
+                  urls.push('https://www.google.com/maps/search/?' + joining(params_1, undefined, '&'));
+              }
+          }
+          return new Promise(function (resolve, reject) {
+              var tried = [];
+              function openURLSequential(index) {
+                  if (index === void 0) { index = 0; }
+                  if (index >= urls.length)
+                      return reject(new Error('Failed to open a map using all available URLs.\n\nAttempted URLs:\n' + joining(tried, undefined, '\n↓\n')));
+                  var url = urls[index];
+                  if (typeof url === 'string') {
+                      tried[index] = url;
+                      return openURL(index, url, getDefaultTimeout())
+                          .then(function () {
+                          resolve();
+                      })
+                          .catch(function () {
+                          openURLSequential(index + 1);
+                      });
+                  }
+                  else {
+                      tried[index] = '[function fallback]';
+                      url();
+                      resolve();
+                  }
+              }
+              return openURLSequential();
+          });
+      },
       filepicker: function (options) {
           if (options === void 0) { options = {}; }
           var module;
@@ -1971,7 +2701,7 @@
                   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)
+                  return openURL(index, urls[index], DEFAULT_TIMEOUT)
                       .then(function () {
                       resolve();
                   })