what-input 5.2.11 → 6.0.0

package/dist/what-input.js

@@ -1,517 +1,301 @@
 /**
  * what-input - A global utility for tracking the current input method (mouse, keyboard or touch).
- * @version v5.2.11
+ * @version v6.0.0
  * @link https://github.com/ten1seven/what-input
  * @license MIT
  */
-(function webpackUniversalModuleDefinition(root, factory) {
-	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory();
-	else if(typeof define === 'function' && define.amd)
-		define("whatInput", [], factory);
-	else if(typeof exports === 'object')
-		exports["whatInput"] = factory();
-	else
-		root["whatInput"] = factory();
-})(this, function() {
-return /******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId])
-/******/ 			return installedModules[moduleId].exports;
-
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			exports: {},
-/******/ 			id: moduleId,
-/******/ 			loaded: false
-/******/ 		};
-
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-
-/******/ 		// Flag the module as loaded
-/******/ 		module.loaded = true;
-
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-
-
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(0);
-/******/ })
-/************************************************************************/
-/******/ ([
-/* 0 */
-/***/ (function(module, exports) {
-
-	'use strict';
-
-	module.exports = function () {
-	  /*
-	   * bail out if there is no document or window
-	   * (i.e. in a node/non-DOM environment)
-	   *
-	   * Return a stubbed API instead
-	   */
-	  if (typeof document === 'undefined' || typeof window === 'undefined') {
-	    return {
-	      // always return "initial" because no interaction will ever be detected
-	      ask: function ask() {
-	        return 'initial';
-	      },
-
-	      // always return null
-	      element: function element() {
-	        return null;
-	      },
-
-	      // no-op
-	      ignoreKeys: function ignoreKeys() {},
-
-	      // no-op
-	      specificKeys: function specificKeys() {},
-
-	      // no-op
-	      registerOnChange: function registerOnChange() {},
-
-	      // no-op
-	      unRegisterOnChange: function unRegisterOnChange() {}
-	    };
-	  }
-
-	  /*
-	   * variables
-	   */
-
-	  // cache document.documentElement
-	  var docElem = document.documentElement;
-
-	  // currently focused dom element
-	  var currentElement = null;
-
-	  // last used input type
-	  var currentInput = 'initial';
-
-	  // last used input intent
-	  var currentIntent = currentInput;
-
-	  // UNIX timestamp of current event
-	  var currentTimestamp = Date.now();
-
-	  // check for a `data-whatpersist` attribute on either the `html` or `body` elements, defaults to `true`
-	  var shouldPersist = 'false';
-
-	  // form input types
-	  var formInputs = ['button', 'input', 'select', 'textarea'];
-
-	  // empty array for holding callback functions
-	  var functionList = [];
-
-	  // list of modifier keys commonly used with the mouse and
-	  // can be safely ignored to prevent false keyboard detection
-	  var ignoreMap = [16, // shift
-	  17, // control
-	  18, // alt
-	  91, // Windows key / left Apple cmd
-	  93 // Windows menu / right Apple cmd
-	  ];
-
-	  var specificMap = [];
-
-	  // mapping of events to input types
-	  var inputMap = {
-	    keydown: 'keyboard',
-	    keyup: 'keyboard',
-	    mousedown: 'mouse',
-	    mousemove: 'mouse',
-	    MSPointerDown: 'pointer',
-	    MSPointerMove: 'pointer',
-	    pointerdown: 'pointer',
-	    pointermove: 'pointer',
-	    touchstart: 'touch',
-	    touchend: 'touch'
-
-	    // boolean: true if the page is being scrolled
-	  };var isScrolling = false;
-
-	  // store current mouse position
-	  var mousePos = {
-	    x: null,
-	    y: null
-
-	    // map of IE 10 pointer events
-	  };var pointerMap = {
-	    2: 'touch',
-	    3: 'touch', // treat pen like touch
-	    4: 'mouse'
-
-	    // check support for passive event listeners
-	  };var supportsPassive = false;
-
-	  try {
-	    var opts = Object.defineProperty({}, 'passive', {
-	      get: function get() {
-	        supportsPassive = true;
-	      }
-	    });
-
-	    window.addEventListener('test', null, opts);
-	  } catch (e) {}
-	  // fail silently
-
-
-	  /*
-	   * set up
-	   */
-
-	  var setUp = function setUp() {
-	    // add correct mouse wheel event mapping to `inputMap`
-	    inputMap[detectWheel()] = 'mouse';
-
-	    addListeners();
-	  };
-
-	  /*
-	   * events
-	   */
-
-	  var addListeners = function addListeners() {
-	    // `pointermove`, `MSPointerMove`, `mousemove` and mouse wheel event binding
-	    // can only demonstrate potential, but not actual, interaction
-	    // and are treated separately
-	    var options = supportsPassive ? { passive: true, capture: true } : true;
-
-	    document.addEventListener('DOMContentLoaded', setPersist, true);
-
-	    // pointer events (mouse, pen, touch)
-	    if (window.PointerEvent) {
-	      window.addEventListener('pointerdown', setInput, true);
-	      window.addEventListener('pointermove', setIntent, true);
-	    } else if (window.MSPointerEvent) {
-	      window.addEventListener('MSPointerDown', setInput, true);
-	      window.addEventListener('MSPointerMove', setIntent, true);
-	    } else {
-	      // mouse events
-	      window.addEventListener('mousedown', setInput, true);
-	      window.addEventListener('mousemove', setIntent, true);
-
-	      // touch events
-	      if ('ontouchstart' in window) {
-	        window.addEventListener('touchstart', setInput, options);
-	        window.addEventListener('touchend', setInput, true);
-	      }
-	    }
-
-	    // mouse wheel
-	    window.addEventListener(detectWheel(), setIntent, options);
-
-	    // keyboard events
-	    window.addEventListener('keydown', setInput, true);
-	    window.addEventListener('keyup', setInput, true);
-
-	    // focus events
-	    window.addEventListener('focusin', setElement, true);
-	    window.addEventListener('focusout', clearElement, true);
-	  };
-
-	  // checks if input persistence should happen and
-	  // get saved state from session storage if true (defaults to `false`)
-	  var setPersist = function setPersist() {
-	    shouldPersist = !(docElem.getAttribute('data-whatpersist') || document.body.getAttribute('data-whatpersist') === 'false');
-
-	    if (shouldPersist) {
-	      // check for session variables and use if available
-	      try {
-	        if (window.sessionStorage.getItem('what-input')) {
-	          currentInput = window.sessionStorage.getItem('what-input');
-	        }
-
-	        if (window.sessionStorage.getItem('what-intent')) {
-	          currentIntent = window.sessionStorage.getItem('what-intent');
-	        }
-	      } catch (e) {
-	        // fail silently
-	      }
-	    }
-
-	    // always run these so at least `initial` state is set
-	    doUpdate('input');
-	    doUpdate('intent');
-	  };
-
-	  // checks conditions before updating new input
-	  var setInput = function setInput(event) {
-	    var eventKey = event.which;
-	    var value = inputMap[event.type];
-
-	    if (value === 'pointer') {
-	      value = pointerType(event);
-	    }
-
-	    var ignoreMatch = !specificMap.length && ignoreMap.indexOf(eventKey) === -1;
-
-	    var specificMatch = specificMap.length && specificMap.indexOf(eventKey) !== -1;
-
-	    var shouldUpdate = value === 'keyboard' && eventKey && (ignoreMatch || specificMatch) || value === 'mouse' || value === 'touch';
-
-	    // prevent touch detection from being overridden by event execution order
-	    if (validateTouch(value)) {
-	      shouldUpdate = false;
-	    }
-
-	    if (shouldUpdate && currentInput !== value) {
-	      currentInput = value;
-
-	      persistInput('input', currentInput);
-	      doUpdate('input');
-	    }
-
-	    if (shouldUpdate && currentIntent !== value) {
-	      // preserve intent for keyboard interaction with form fields
-	      var activeElem = document.activeElement;
-	      var notFormInput = activeElem && activeElem.nodeName && (formInputs.indexOf(activeElem.nodeName.toLowerCase()) === -1 || activeElem.nodeName.toLowerCase() === 'button' && !checkClosest(activeElem, 'form'));
-
-	      if (notFormInput) {
-	        currentIntent = value;
-
-	        persistInput('intent', currentIntent);
-	        doUpdate('intent');
-	      }
-	    }
-	  };
-
-	  // updates the doc and `inputTypes` array with new input
-	  var doUpdate = function doUpdate(which) {
-	    docElem.setAttribute('data-what' + which, which === 'input' ? currentInput : currentIntent);
-
-	    fireFunctions(which);
-	  };
-
-	  // updates input intent for `mousemove` and `pointermove`
-	  var setIntent = function setIntent(event) {
-	    var value = inputMap[event.type];
-
-	    if (value === 'pointer') {
-	      value = pointerType(event);
-	    }
-
-	    // test to see if `mousemove` happened relative to the screen to detect scrolling versus mousemove
-	    detectScrolling(event);
-
-	    // only execute if scrolling isn't happening
-	    if ((!isScrolling && !validateTouch(value) || isScrolling && event.type === 'wheel' || event.type === 'mousewheel' || event.type === 'DOMMouseScroll') && currentIntent !== value) {
-	      currentIntent = value;
-
-	      persistInput('intent', currentIntent);
-	      doUpdate('intent');
-	    }
-	  };
-
-	  var setElement = function setElement(event) {
-	    if (!event.target.nodeName) {
-	      // If nodeName is undefined, clear the element
-	      // This can happen if click inside an <svg> element.
-	      clearElement();
-	      return;
-	    }
-
-	    currentElement = event.target.nodeName.toLowerCase();
-	    docElem.setAttribute('data-whatelement', currentElement);
-
-	    if (event.target.classList && event.target.classList.length) {
-	      docElem.setAttribute('data-whatclasses', event.target.classList.toString().replace(' ', ','));
-	    }
-	  };
-
-	  var clearElement = function clearElement() {
-	    currentElement = null;
-
-	    docElem.removeAttribute('data-whatelement');
-	    docElem.removeAttribute('data-whatclasses');
-	  };
-
-	  var persistInput = function persistInput(which, value) {
-	    if (shouldPersist) {
-	      try {
-	        window.sessionStorage.setItem('what-' + which, value);
-	      } catch (e) {
-	        // fail silently
-	      }
-	    }
-	  };
-
-	  /*
-	   * utilities
-	   */
-
-	  var pointerType = function pointerType(event) {
-	    if (typeof event.pointerType === 'number') {
-	      return pointerMap[event.pointerType];
-	    } else {
-	      // treat pen like touch
-	      return event.pointerType === 'pen' ? 'touch' : event.pointerType;
-	    }
-	  };
-
-	  // prevent touch detection from being overridden by event execution order
-	  var validateTouch = function validateTouch(value) {
-	    var timestamp = Date.now();
-
-	    var touchIsValid = value === 'mouse' && currentInput === 'touch' && timestamp - currentTimestamp < 200;
-
-	    currentTimestamp = timestamp;
-
-	    return touchIsValid;
-	  };
-
-	  // detect version of mouse wheel event to use
-	  // via https://developer.mozilla.org/en-US/docs/Web/API/Element/wheel_event
-	  var detectWheel = function detectWheel() {
-	    var wheelType = null;
-
-	    // Modern browsers support "wheel"
-	    if ('onwheel' in document.createElement('div')) {
-	      wheelType = 'wheel';
-	    } else {
-	      // Webkit and IE support at least "mousewheel"
-	      // or assume that remaining browsers are older Firefox
-	      wheelType = document.onmousewheel !== undefined ? 'mousewheel' : 'DOMMouseScroll';
-	    }
-
-	    return wheelType;
-	  };
-
-	  // runs callback functions
-	  var fireFunctions = function fireFunctions(type) {
-	    for (var i = 0, len = functionList.length; i < len; i++) {
-	      if (functionList[i].type === type) {
-	        functionList[i].fn.call(undefined, type === 'input' ? currentInput : currentIntent);
-	      }
-	    }
-	  };
-
-	  // finds matching element in an object
-	  var objPos = function objPos(match) {
-	    for (var i = 0, len = functionList.length; i < len; i++) {
-	      if (functionList[i].fn === match) {
-	        return i;
-	      }
-	    }
-	  };
-
-	  var detectScrolling = function detectScrolling(event) {
-	    if (mousePos.x !== event.screenX || mousePos.y !== event.screenY) {
-	      isScrolling = false;
-
-	      mousePos.x = event.screenX;
-	      mousePos.y = event.screenY;
-	    } else {
-	      isScrolling = true;
-	    }
-	  };
-
-	  // manual version of `closest()`
-	  var checkClosest = function checkClosest(elem, tag) {
-	    var ElementPrototype = window.Element.prototype;
-
-	    if (!ElementPrototype.matches) {
-	      ElementPrototype.matches = ElementPrototype.msMatchesSelector || ElementPrototype.webkitMatchesSelector;
-	    }
-
-	    if (!ElementPrototype.closest) {
-	      do {
-	        if (elem.matches(tag)) {
-	          return elem;
-	        }
-
-	        elem = elem.parentElement || elem.parentNode;
-	      } while (elem !== null && elem.nodeType === 1);
-
-	      return null;
-	    } else {
-	      return elem.closest(tag);
-	    }
-	  };
-
-	  /*
-	   * init
-	   */
-
-	  // don't start script unless browser cuts the mustard
-	  // (also passes if polyfills are used)
-	  if ('addEventListener' in window && Array.prototype.indexOf) {
-	    setUp();
-	  }
-
-	  /*
-	   * api
-	   */
-
-	  return {
-	    // returns string: the current input type
-	    // opt: 'intent'|'input'
-	    // 'input' (default): returns the same value as the `data-whatinput` attribute
-	    // 'intent': includes `data-whatintent` value if it's different than `data-whatinput`
-	    ask: function ask(opt) {
-	      return opt === 'intent' ? currentIntent : currentInput;
-	    },
-
-	    // returns string: the currently focused element or null
-	    element: function element() {
-	      return currentElement;
-	    },
-
-	    // overwrites ignored keys with provided array
-	    ignoreKeys: function ignoreKeys(arr) {
-	      ignoreMap = arr;
-	    },
-
-	    // overwrites specific char keys to update on
-	    specificKeys: function specificKeys(arr) {
-	      specificMap = arr;
-	    },
-
-	    // attach functions to input and intent "events"
-	    // funct: function to fire on change
-	    // eventType: 'input'|'intent'
-	    registerOnChange: function registerOnChange(fn, eventType) {
-	      functionList.push({
-	        fn: fn,
-	        type: eventType || 'input'
-	      });
-	    },
-
-	    unRegisterOnChange: function unRegisterOnChange(fn) {
-	      var position = objPos(fn);
-
-	      if (position || position === 0) {
-	        functionList.splice(position, 1);
-	      }
-	    },
-
-	    clearStorage: function clearStorage() {
-	      window.sessionStorage.clear();
-	    }
-	  };
-	}();
-
-/***/ })
-/******/ ])
-});
-;
+;(function (root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object') {
+    module.exports = factory()
+  } else if (typeof define === 'function' && define.amd) {
+    define('whatInput', [], factory)
+  } else {
+    root.whatInput = factory()
+  }
+})(
+  typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : this,
+  function () {
+    var __whatInput
+"use strict";
+(() => {
+  // src/what-input.ts
+  var ATTRIBUTE_PREFIX = "data-what";
+  var STORAGE_KEYS = {
+    input: "what-input",
+    intent: "what-intent"
+  };
+  var INPUT_METHODS = /* @__PURE__ */ new Set([
+    "initial",
+    "mouse",
+    "keyboard",
+    "touch"
+  ]);
+  var POINTER_TYPES = {
+    mouse: "mouse",
+    pen: "touch",
+    touch: "touch"
+  };
+  var DEFAULT_IGNORED_KEYS = [
+    "Shift",
+    "Control",
+    "Alt",
+    "Meta",
+    // Windows key / Apple command
+    "ContextMenu"
+    // Windows menu key
+  ];
+  var TEXT_ENTRY_ELEMENTS = /* @__PURE__ */ new Set(["input", "select", "textarea"]);
+  var TOGGLE_INPUT_TYPES = /* @__PURE__ */ new Set(["checkbox", "radio"]);
+  var FREEZE_SELECTOR = "[data-whatfreeze]";
+  var HINT_QUERIES = {
+    touch: "(pointer: coarse)",
+    mouse: "(pointer: fine)"
+  };
+  var hasDom = () => typeof window !== "undefined" && typeof document !== "undefined";
+  var isInputMethod = (value) => typeof value === "string" && INPUT_METHODS.has(value);
+  var deepActiveElement = () => {
+    let element = document.activeElement;
+    while (element?.shadowRoot?.activeElement) {
+      element = element.shadowRoot.activeElement;
+    }
+    return element;
+  };
+  var isTextEntry = (element) => {
+    if (!element) return false;
+    const tag = element.localName;
+    if (tag === "input") return !TOGGLE_INPUT_TYPES.has(element.type);
+    if (TEXT_ENTRY_ELEMENTS.has(tag)) return true;
+    if (tag === "button" && element.closest("form") !== null) return true;
+    if (element.isContentEditable === true) return true;
+    if (element.closest(FREEZE_SELECTOR) !== null) return true;
+    return element.constructor.formAssociated === true;
+  };
+  var hintQueries = () => typeof window.matchMedia === "function" ? Object.values(HINT_QUERIES).map((query) => window.matchMedia(query)) : [];
+  var readHint = () => {
+    if (typeof window.matchMedia !== "function") return "unknown";
+    for (const [hint, query] of Object.entries(HINT_QUERIES)) {
+      if (window.matchMedia(query).matches) return hint;
+    }
+    return "unknown";
+  };
+  var eventTarget = (event) => {
+    const target = event.composedPath()[0] ?? event.target;
+    return target instanceof Element ? target : null;
+  };
+  var WhatInput = class extends EventTarget {
+    #state = {
+      input: "initial",
+      intent: "initial",
+      hint: "unknown"
+    };
+    #element = null;
+    #persist = false;
+    #ignoredKeys = DEFAULT_IGNORED_KEYS;
+    #specificKeys = [];
+    #callbacks = {
+      input: /* @__PURE__ */ new Set(),
+      intent: /* @__PURE__ */ new Set(),
+      hint: /* @__PURE__ */ new Set()
+    };
+    #controller = null;
+    #lastPointerPosition = { x: NaN, y: NaN };
+    constructor() {
+      super();
+      if (hasDom()) this.#start();
+    }
+    ask(strategy = "input") {
+      return this.#state[strategy];
+    }
+    /** The tag name of the currently focused element, or `null`. */
+    element() {
+      return this.#element;
+    }
+    /**
+     * Replaces the list of keys that are ignored (do not switch to `keyboard`)
+     * when pressed. Defaults to the modifier keys.
+     */
+    ignoreKeys(keys) {
+      this.#ignoredKeys = [...keys];
+    }
+    /**
+     * Replaces the list of keys that are the *only* keys that switch to
+     * `keyboard`. When set, this overrides `ignoreKeys()`. Pass an empty array
+     * to restore the `ignoreKeys()` behavior.
+     */
+    specificKeys(keys) {
+      this.#specificKeys = [...keys];
+    }
+    registerOnChange(callback, strategy = "input") {
+      this.#callbacks[strategy].add(callback);
+    }
+    /** Removes a callback added with `registerOnChange()`. */
+    unRegisterOnChange(callback) {
+      for (const callbacks of Object.values(this.#callbacks)) {
+        callbacks.delete(callback);
+      }
+    }
+    /** Removes the persisted input and intent from session storage. */
+    clearStorage() {
+      try {
+        for (const key of Object.values(STORAGE_KEYS)) {
+          window.sessionStorage.removeItem(key);
+        }
+      } catch {
+      }
+    }
+    /**
+     * Stops listening, removes the `data-what*` attributes from `<html>` and
+     * drops every registered callback. Useful for tests and app teardown.
+     */
+    destroy() {
+      this.#controller?.abort();
+      this.#controller = null;
+      for (const callbacks of Object.values(this.#callbacks)) {
+        callbacks.clear();
+      }
+      if (!hasDom()) return;
+      const html = document.documentElement;
+      for (const name of ["input", "intent", "hint", "element", "classes"]) {
+        html.removeAttribute(ATTRIBUTE_PREFIX + name);
+      }
+    }
+    /*
+     * set up
+     */
+    #start() {
+      const controller = new AbortController();
+      const { signal } = controller;
+      this.#controller = controller;
+      const options = { capture: true, passive: true, signal };
+      window.addEventListener("pointerdown", this.#onPointerDown, options);
+      window.addEventListener("keydown", this.#onKey, options);
+      window.addEventListener("keyup", this.#onKey, options);
+      window.addEventListener("pointermove", this.#onPointerMove, options);
+      window.addEventListener("wheel", this.#onWheel, options);
+      window.addEventListener("focusin", this.#onFocusIn, options);
+      window.addEventListener("focusout", this.#onFocusOut, options);
+      for (const query of hintQueries()) {
+        query.addEventListener("change", this.#onHintChange, { signal });
+      }
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", this.#init, { once: true, signal });
+      } else {
+        this.#init();
+      }
+    }
+    /** Restores persisted state (if allowed) and publishes the initial state. */
+    #init = () => {
+      const { documentElement, body } = document;
+      this.#persist = documentElement.dataset.whatpersist !== "false" && body?.dataset.whatpersist !== "false";
+      if (this.#persist) {
+        for (const strategy of ["input", "intent"]) {
+          const stored = this.#restore(strategy);
+          if (stored && this.#state[strategy] === "initial") {
+            this.#state[strategy] = stored;
+          }
+        }
+      }
+      this.#state.hint = readHint();
+      this.#publish("input");
+      this.#publish("intent");
+      this.#publish("hint");
+    };
+    /*
+     * events
+     */
+    #onPointerDown = (event) => {
+      const value = POINTER_TYPES[event.pointerType];
+      if (!value) return;
+      this.#set("input", value);
+      this.#set("intent", value);
+    };
+    #onPointerMove = (event) => {
+      const value = POINTER_TYPES[event.pointerType];
+      if (!value) return;
+      const { x, y } = this.#lastPointerPosition;
+      this.#lastPointerPosition = { x: event.screenX, y: event.screenY };
+      if (event.screenX === x && event.screenY === y) return;
+      this.#set("intent", value);
+    };
+    #onWheel = () => {
+      this.#set("intent", "mouse");
+    };
+    #onHintChange = () => {
+      this.#set("hint", readHint());
+    };
+    #onKey = (event) => {
+      if (!this.#isCountedKey(event)) return;
+      this.#set("input", "keyboard");
+      if (!isTextEntry(deepActiveElement())) {
+        this.#set("intent", "keyboard");
+      }
+    };
+    #onFocusIn = (event) => {
+      const target = eventTarget(event);
+      if (!target) {
+        this.#onFocusOut();
+        return;
+      }
+      const html = document.documentElement;
+      this.#element = target.localName;
+      html.setAttribute(ATTRIBUTE_PREFIX + "element", this.#element);
+      if (target.classList.length) {
+        html.setAttribute(ATTRIBUTE_PREFIX + "classes", Array.from(target.classList).join(","));
+      } else {
+        html.removeAttribute(ATTRIBUTE_PREFIX + "classes");
+      }
+    };
+    #onFocusOut = () => {
+      const html = document.documentElement;
+      this.#element = null;
+      html.removeAttribute(ATTRIBUTE_PREFIX + "element");
+      html.removeAttribute(ATTRIBUTE_PREFIX + "classes");
+    };
+    /*
+     * state
+     */
+    #isCountedKey(event) {
+      const matches = (key) => typeof key === "number" ? key === event.keyCode : key === event.key || key === event.code;
+      return this.#specificKeys.length ? this.#specificKeys.some(matches) : !this.#ignoredKeys.some(matches);
+    }
+    #set(channel, value) {
+      if (this.#state[channel] === value) return;
+      this.#state[channel] = value;
+      this.#store(channel, value);
+      this.#publish(channel);
+    }
+    /** Writes the attribute, runs the callbacks and dispatches the event. */
+    #publish(channel) {
+      const value = this.#state[channel];
+      document.documentElement.setAttribute(ATTRIBUTE_PREFIX + channel, value);
+      for (const callback of this.#callbacks[channel]) {
+        ;
+        callback(value);
+      }
+      this.dispatchEvent(new CustomEvent(channel, { detail: value }));
+    }
+    #store(channel, value) {
+      if (channel === "hint" || !this.#persist) return;
+      try {
+        window.sessionStorage.setItem(STORAGE_KEYS[channel], value);
+      } catch {
+      }
+    }
+    #restore(strategy) {
+      try {
+        const value = window.sessionStorage.getItem(STORAGE_KEYS[strategy]);
+        return isInputMethod(value) ? value : null;
+      } catch {
+        return null;
+      }
+    }
+  };
+  var whatInput = new WhatInput();
+  var what_input_default = whatInput;
+
+  // scripts/umd-entry.ts
+  __whatInput = what_input_default;
+})();
+return __whatInput
+  },
+)