web-launch-kit 0.0.2 → 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.2";
+  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";
@@ -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 {
@@ -1733,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);
@@ -1746,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 (_) {
               }
@@ -1818,7 +2393,7 @@
   }
   var LaunchKit = {
       SettingType: exports.SettingType,
-      version: packageJSON$1.version,
+      version: packageJSON$2.version,
       utils: {
           get canOpenIntent() {
               return canOpenIntent();