web-launch-kit 0.0.2 → 0.0.3

package/dist/launch-kit.cjs

@@ -2,14 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-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;
@@ -298,7 +298,7 @@ function parseFromHighEntropyValues() {
 }
 ready = parseFromHighEntropyValues();
 var PlatformKit = {
-    version: packageJSON.version,
+    version: packageJSON$1.version,
     get ready() {
         return ready;
     },
@@ -369,6 +369,665 @@ var PlatformKit = {
     }
 };
 
+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);
@@ -778,101 +1437,6 @@ function getTopmostWindow() {
     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";
@@ -1222,9 +1786,12 @@ function openURL(tried, url, timeout) {
                 timeoutId = undefined;
             }
             try {
-                removeEvent(config.blur.target, config.blur.type, onblur);
-                removeEvent(config.focus.target, config.focus.type, onfocus);
-                removeEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+                if (typeof config.blur.target !== 'undefined' && typeof config.blur.type !== 'undefined')
+                    EventKit.remove(config.blur.target, config.blur.type, onblur);
+                if (typeof config.focus.target !== 'undefined' && typeof config.focus.type !== 'undefined')
+                    EventKit.remove(config.focus.target, config.focus.type, onfocus);
+                if (typeof config.visibilitychange.target !== 'undefined' && typeof config.visibilitychange.type !== 'undefined')
+                    EventKit.remove(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
             }
             catch (_) {
             }
@@ -1258,8 +1825,10 @@ function openURL(tried, url, timeout) {
                 clearTimeout(timeoutId);
                 timeoutId = undefined;
             }
-            removeEvent(config.blur.target, config.blur.type, onblur);
-            addEvent(config.focus.target, config.focus.type, onfocus);
+            if (typeof config.blur.target !== 'undefined' && typeof config.blur.type !== 'undefined')
+                EventKit.remove(config.blur.target, config.blur.type, 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);
@@ -1273,8 +1842,10 @@ function openURL(tried, url, timeout) {
         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 {
@@ -1731,10 +2302,12 @@ function resolveFile(module) {
         }
         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);
@@ -1744,9 +2317,11 @@ function resolveFile(module) {
         function cleanup() {
             CLEANUP_INPUT_ELEMENT = null;
             try {
-                removeEvent(config.focus.target, config.focus.type, onfocus);
-                removeEvent(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
-                removeEvent(topDocument, 'click', onclick);
+                if (typeof config.focus.target !== 'undefined' && typeof config.focus.type !== 'undefined')
+                    EventKit.remove(config.focus.target, config.focus.type, onfocus);
+                if (typeof config.visibilitychange.target !== 'undefined' && typeof config.visibilitychange.type !== 'undefined')
+                    EventKit.remove(config.visibilitychange.target, config.visibilitychange.type, onvisibilitychange);
+                EventKit.remove(topDocument, 'click', onclick);
             }
             catch (_) {
             }
@@ -1816,7 +2391,7 @@ function walk(directory, basePath) {
 }
 var LaunchKit = {
     SettingType: exports.SettingType,
-    version: packageJSON$1.version,
+    version: packageJSON$2.version,
     utils: {
         get canOpenIntent() {
             return canOpenIntent();