tinykeys 3.1.0 → 4.0.0

package/README.md

@@ -1,6 +1,6 @@
 # `tinykeys`
 
-> A tiny (~650 B) & modern library for keybindings.
+> A tiny (~1KB) & modern library for keybindings.
 > [See Demo](https://jamiebuilds.github.io/tinykeys/)
 
 ## Install
@@ -162,6 +162,13 @@ valid value to
 "Meta+Shift+D"
 ```
 
+Modifiers can be made optional by wrapping them with `[brackets]`
+
+```js
+"[Shift]+?"
+"Control+[Shift]+D"
+```
+
 There is also a special `$mod` modifier that makes it easy to support cross
 platform keybindings:
 
@@ -173,8 +180,8 @@ platform keybindings:
 "$mod+Shift+D" // Meta/Control+Shift+D
 ```
 
-Alternatively, you can use parenthesis to use case-sensitive regular expressions
-to match multiple keys.
+You can also use parenthesis to use case-insensitive regular expressions to
+match multiple keys (Note: This does not work for modifiers).
 
 ```js
 "$mod+([0-9])" // $mod+0, $mod+1, $mod+2, etc...
@@ -201,6 +208,72 @@ Each press can optionally be prefixed with modifier keys:
 
 Each press in the sequence must be pressed within 1000ms of the last.
 
+#### Keybinding Priorities
+
+It should rarely come up, but the order of your keybindings matters. So if you
+were to create two keybindings that would match the same event, only the first
+will fire.
+
+This mainly comes up when you create bindings for both `KeyboardEvent#key` and
+`KeyboardEvent#code` in order to support more keyboard layouts:
+
+```js
+tinykeys(window, {
+  "$mod+b": () => console.log("make bold"),
+  "$mod+KeyB": () => console.log("also bold"),
+})
+```
+
+> In this case, if the user holds `$mod` and types `b (KeyB)` it will only
+> trigger `$mod+B` and log `"make bold"`
+
+This can also come up when you have sequences that overlap with other
+keybindings.
+
+<!-- prettier-ignore -->
+```js
+tinykeys(window, {
+  "g a": () => console.log("goto archive"),
+  "a": () => console.log("archive item"),
+})
+```
+
+> In this case, if the user types `g a` it will only log `"goto archive"`
+
+However, you can also break later keybindings by declaring earlier keybindings
+that will always win:
+
+<!-- prettier-ignore -->
+```js
+tinykeys(window, {
+  "g": () => console.log("show goto indicator"),
+  "g a": () => console.log("goto archive"),
+})
+```
+
+> In this case, if the user types `g a` it will only log `"show goto indicator"`
+> (after the first `g`)
+
+#### Keybinding Sequence Conflicts
+
+In some circumstances, overlapping keybindings can cause "conflicts" where a
+keybinding has been completely typed, but there is another keybinding declared
+earlier that might still match.
+
+```js
+tinykeys(window, {
+  "a b c": () => console.log("abc"),
+  "a b": () => console.log("ab"),
+})
+```
+
+> In this case, if the user types `a b` it will not trigger either keybinding,
+> but it will print this warning to the console:
+>
+> ```
+> warning: tinykeys: Conflict found, "a b" did not fire, waiting for: ["a b c"]
+> ```
+
 ### Display the keyboard sequence
 
 You can use the `parseKeybinding` method to get a structured representation of a
@@ -256,3 +329,10 @@ Keybinding sequences will wait this long between key presses before cancelling
 
 > **Note:** Setting this value too low (i.e. `300`) will be too fast for many of
 > your users.
+
+### `options.ignore`
+
+Add a filter for which keyboard events should be ignored.
+
+By default, tinykeys will ignore keyboard events from `[contenteditable]`,
+`input`, `textarea`, and `select` unless they are the `event.currentTarget`.

package/dist/tinykeys.cjs

@@ -0,0 +1,205 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/tinykeys.ts
+/**
+* These are the modifier keys that change the meaning of keybindings.
+*
+* Note: Ignoring "AltGraph" because it is covered by the others.
+*/
+let KEYBINDING_MODIFIER_KEYS = [
+	"Shift",
+	"Meta",
+	"Alt",
+	"Control"
+];
+/**
+* Keybinding sequences should timeout if individual key presses are more than
+* 1s apart by default.
+*/
+let DEFAULT_TIMEOUT = 1e3;
+/**
+* Keybinding sequences should bind to this event by default.
+*/
+let DEFAULT_EVENT = "keydown";
+/**
+* Platform detection code.
+* @see https://github.com/jamiebuilds/tinykeys/issues/184
+*/
+let PLATFORM = typeof navigator === "object" ? navigator.platform : "";
+/**
+* An alias for creating platform-specific keybinding aliases.
+*/
+let MOD = /Mac|iPod|iPhone|iPad/.test(PLATFORM) ? "Meta" : "Control";
+/**
+* Meaning of `AltGraph`, from MDN:
+* - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed
+* - Mac: ⌥ Option key pressed
+* - Linux: Level 3 Shift key (or Level 5 Shift key) pressed
+* - Android: Not supported
+* @see https://github.com/jamiebuilds/tinykeys/issues/185
+*/
+let ALT_GRAPH_ALIASES = PLATFORM === "Win32" ? ["Control", "Alt"] : ["Alt"];
+/**
+* Ensure and stop any event that isn't a full keyboard event.
+* Autocomplete option navigation and selection would fire an Event,
+* instead of the expected KeyboardEvent
+*/
+function isKeyboardEvent(event) {
+	return !!(event.key && event.code && event.getModifierState);
+}
+/**
+* Ignores keyboard events from contenteditable and form elements unless they
+* are the current target.
+*/
+function defaultKeybindingsHandlerIgnore(event) {
+	let target = event.target;
+	return event.repeat || event.isComposing || target !== event.currentTarget && target.matches("[contenteditable],input,select,textarea");
+}
+/**
+* There's a bug in Chrome that causes event.getModifierState not to exist on
+* KeyboardEvent's for F1/F2/etc keys.
+*/
+function getModifierState(event, mod) {
+	return typeof event.getModifierState === "function" ? event.getModifierState(mod) || ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState("AltGraph") : false;
+}
+/**
+* Parses a keybinding string into its parts.
+*
+* ```
+* grammar    = `<sequence>`
+* <sequence> = `<press> <press> <press> ...`
+* <press>    = `<key>` or `<mods>+<key>`
+* <mods>     = `<mod>+<mod>+...`
+* <mod>      = `<modifier>` (required) or `[<modifier>]` (optional)
+* <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)
+* <key>      = `(<regex>)` -> `/^(?:<regex>)$/iy` (case-insensitive)
+* ```
+*/
+function parseKeybinding(str) {
+	return str.trim().split(" ").map((press) => {
+		let parts = press.split(/(?<=\w|\])\+/);
+		let last = parts.pop();
+		let regex = last.match(/^\((.+)\)$/);
+		let key = regex ? new RegExp(`^(?:${regex[1]})$`, "iv") : last;
+		let requiredModifiers = [];
+		let optionalModifiers = [];
+		for (const part of parts) {
+			let optional = part.match(/^\[(.*)\]$/);
+			let mod = optional?.[1] ?? part;
+			mod = mod === "$mod" ? MOD : mod;
+			if (optional) optionalModifiers.push(mod);
+			else requiredModifiers.push(mod);
+		}
+		return [
+			requiredModifiers,
+			optionalModifiers,
+			key
+		];
+	});
+}
+/**
+* This tells us if a single keyboard event matches a single keybinding press.
+*/
+function matchKeybindingPress(event, [requiredModifiers, optionalModifiers, key]) {
+	const hasAltGraph = requiredModifiers.includes("AltGraph");
+	return !((key instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) : key.toUpperCase() !== event.key.toUpperCase() && key !== event.code) || requiredModifiers.find((mod) => {
+		return !getModifierState(event, mod);
+	}) || KEYBINDING_MODIFIER_KEYS.find((mod) => {
+		return !requiredModifiers.includes(mod) && !optionalModifiers.includes(mod) && key !== mod && getModifierState(event, mod) && !(hasAltGraph && ALT_GRAPH_ALIASES.includes(mod));
+	}));
+}
+/**
+* Creates an event listener for handling keybindings.
+*
+* @example
+* ```js
+* import { createKeybindingsHandler } from "../src/keybindings"
+*
+* let handler = createKeybindingsHandler({
+* 	"Shift+d": () => {
+* 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+* 	},
+* 	"y e e t": () => {
+* 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+* 	},
+* 	"$mod+d": () => {
+* 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+* 	},
+* })
+*
+* window.addEventListener("keydown", handler)
+* ```
+*/
+function createKeybindingsHandler(keybindingsMap, options = {}) {
+	let timeout = options.timeout ?? DEFAULT_TIMEOUT;
+	let ignore = options.ignore ?? defaultKeybindingsHandlerIgnore;
+	let keybindings = Object.keys(keybindingsMap).map((input) => {
+		return [
+			input,
+			parseKeybinding(input),
+			keybindingsMap[input]
+		];
+	});
+	let pending = /* @__PURE__ */ new Map();
+	let timer = null;
+	return (event) => {
+		if (!isKeyboardEvent(event) || ignore(event)) return;
+		let conflicts = [];
+		for (let [input, sequence, handler] of keybindings) {
+			let prev = pending.get(input);
+			let [current, ...rest] = prev ? prev : sequence;
+			if (!matchKeybindingPress(event, current)) {
+				if (!getModifierState(event, event.key)) pending.delete(input);
+			} else if (rest.length > 0) {
+				pending.set(input, rest);
+				conflicts.push(input);
+			} else {
+				pending.delete(input);
+				if (conflicts.length) console.warn(`tinykeys: Conflict found, "${input}" did not fire, waiting for:`, conflicts);
+				else {
+					handler(event);
+					break;
+				}
+			}
+		}
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => pending.clear(), timeout);
+	};
+}
+/**
+* Subscribes to keybindings.
+*
+* Returns an unsubscribe method.
+*
+* @example
+* ```js
+* import { tinykeys } from "../src/tinykeys"
+*
+* tinykeys(window, {
+* 	"Shift+d": () => {
+* 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+* 	},
+* 	"y e e t": () => {
+* 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+* 	},
+* 	"$mod+d": () => {
+* 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+* 	},
+* })
+* ```
+*/
+function tinykeys(target, keybindingMap, options = {}) {
+	let event = options.event ?? DEFAULT_EVENT;
+	let onKeyEvent = createKeybindingsHandler(keybindingMap, options);
+	target.addEventListener(event, onKeyEvent, options.capture);
+	return () => {
+		target.removeEventListener(event, onKeyEvent, options.capture);
+	};
+}
+//#endregion
+exports.createKeybindingsHandler = createKeybindingsHandler;
+exports.defaultKeybindingsHandlerIgnore = defaultKeybindingsHandlerIgnore;
+exports.matchKeybindingPress = matchKeybindingPress;
+exports.parseKeybinding = parseKeybinding;
+exports.tinykeys = tinykeys;
+
+//# sourceMappingURL=tinykeys.cjs.map

package/dist/tinykeys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tinykeys.cjs","names":[],"sources":["../src/tinykeys.ts"],"sourcesContent":["/**\n * A single press of a keybinding sequence.\n */\nexport type KeybindingPress = readonly [\n\trequiredModifiers: ReadonlyArray<string>,\n\toptionalModifiers: ReadonlyArray<string>,\n\tkey: string | RegExp,\n]\n\n/**\n * Keyboard event callback fired when keybinding is triggered.\n */\nexport type KeybindingHandler = (event: KeyboardEvent) => void\n\n/**\n * A map of keybinding strings to event handlers.\n */\nexport type KeybindingsMap = Record<string, KeybindingHandler>\n\n/**\n * Predicate that returns true if a keyboard event should be ignored.\n */\nexport type KeybindingFilter = (event: KeyboardEvent) => boolean\n\nexport interface KeybindingHandlerOptions {\n\t/**\n\t * Keybinding sequences will wait this long between key presses before\n\t * cancelling (default: 1000).\n\t *\n\t * **Note:** Setting this value too low (i.e. `300`) will be too fast for many\n\t * of your users.\n\t */\n\ttimeout?: number\n\n\t/**\n\t * Customize the behavior of which keyboard events will be ignored/skipped.\n\t *\n\t * By default this uses the behavior of {@link defaultKeybindingsHandlerIgnore}.\n\t *\n\t * @example Allow all events\n\t * ```tsx\n\t * tinykeys(window, {...}, {\n\t *   ignore: () => false\n\t * })\n\t * ```\n\t *\n\t * @example Extend the default ignore\n\t * ```tsx\n\t * tinykeys(window, {...}, {\n\t *   ignore: event => {\n\t *     return (\n\t *       // Also ignore events inside a dialog\n\t *       event.target.closest(\"dialog\") != null &&\n\t *       defaultKeybindingsHandlerIgnore(event)\n\t *     );\n\t *   }\n\t * })\n\t * ```\n\t */\n\tignore?: KeybindingFilter\n}\n\n/**\n * Options to configure the behavior of keybindings.\n */\nexport interface KeybindingOptions extends KeybindingHandlerOptions {\n\t/**\n\t * Key presses will listen to this event (default: \"keydown\").\n\t */\n\tevent?: \"keydown\" | \"keyup\"\n\n\t/**\n\t * Key presses will use a capture listener (default: false)\n\t */\n\tcapture?: boolean\n}\n\n/**\n * These are the modifier keys that change the meaning of keybindings.\n *\n * Note: Ignoring \"AltGraph\" because it is covered by the others.\n */\nlet KEYBINDING_MODIFIER_KEYS = [\"Shift\", \"Meta\", \"Alt\", \"Control\"]\n\n/**\n * Keybinding sequences should timeout if individual key presses are more than\n * 1s apart by default.\n */\nlet DEFAULT_TIMEOUT = 1000\n\n/**\n * Keybinding sequences should bind to this event by default.\n */\nlet DEFAULT_EVENT = \"keydown\" as const\n\n/**\n * Platform detection code.\n * @see https://github.com/jamiebuilds/tinykeys/issues/184\n */\nlet PLATFORM = typeof navigator === \"object\" ? navigator.platform : \"\"\nlet APPLE_DEVICE = /Mac|iPod|iPhone|iPad/.test(PLATFORM)\n\n/**\n * An alias for creating platform-specific keybinding aliases.\n */\nlet MOD = APPLE_DEVICE ? \"Meta\" : \"Control\"\n\n/**\n * Meaning of `AltGraph`, from MDN:\n * - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed\n * - Mac: ⌥ Option key pressed\n * - Linux: Level 3 Shift key (or Level 5 Shift key) pressed\n * - Android: Not supported\n * @see https://github.com/jamiebuilds/tinykeys/issues/185\n */\nlet ALT_GRAPH_ALIASES = PLATFORM === \"Win32\" ? [\"Control\", \"Alt\"] : [\"Alt\"]\n\n/**\n * Ensure and stop any event that isn't a full keyboard event.\n * Autocomplete option navigation and selection would fire an Event,\n * instead of the expected KeyboardEvent\n */\nfunction isKeyboardEvent(\n\tevent: Partial<KeyboardEvent>,\n): event is KeyboardEvent {\n\treturn !!(event.key && event.code && event.getModifierState)\n}\n\n/**\n * Ignores keyboard events from contenteditable and form elements unless they\n * are the current target.\n */\nexport function defaultKeybindingsHandlerIgnore(event: KeyboardEvent) {\n\tlet target = event.target as HTMLElement\n\treturn (\n\t\t// Always ignore repeated keyboard events\n\t\tevent.repeat ||\n\t\t// Always ignore keyboard events during composition input\n\t\tevent.isComposing ||\n\t\t// Always allow the current target\n\t\t(target !== event.currentTarget &&\n\t\t\t// Ignore contenteditable and form elements\n\t\t\ttarget.matches(\"[contenteditable],input,select,textarea\"))\n\t)\n}\n\n/**\n * There's a bug in Chrome that causes event.getModifierState not to exist on\n * KeyboardEvent's for F1/F2/etc keys.\n */\nfunction getModifierState(event: KeyboardEvent, mod: string) {\n\treturn typeof event.getModifierState === \"function\"\n\t\t? event.getModifierState(mod) ||\n\t\t\t\t(ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState(\"AltGraph\"))\n\t\t: false\n}\n\n/**\n * Parses a keybinding string into its parts.\n *\n * ```\n * grammar    = `<sequence>`\n * <sequence> = `<press> <press> <press> ...`\n * <press>    = `<key>` or `<mods>+<key>`\n * <mods>     = `<mod>+<mod>+...`\n * <mod>      = `<modifier>` (required) or `[<modifier>]` (optional)\n * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)\n * <key>      = `(<regex>)` -> `/^(?:<regex>)$/iy` (case-insensitive)\n * ```\n */\nexport function parseKeybinding(str: string): KeybindingPress[] {\n\treturn str\n\t\t.trim()\n\t\t.split(\" \")\n\t\t.map(press => {\n\t\t\tlet parts = press.split(/(?<=\\w|\\])\\+/)\n\n\t\t\tlet last: string | RegExp = parts.pop() as string\n\t\t\tlet regex = last.match(/^\\((.+)\\)$/)\n\t\t\tlet key = regex ? new RegExp(`^(?:${regex[1]})$`, \"iv\") : last\n\n\t\t\tlet requiredModifiers: string[] = []\n\t\t\tlet optionalModifiers: string[] = []\n\n\t\t\tfor (const part of parts) {\n\t\t\t\tlet optional = part.match(/^\\[(.*)\\]$/)\n\t\t\t\tlet mod = optional?.[1] ?? part\n\t\t\t\tmod = mod === \"$mod\" ? MOD : mod\n\t\t\t\tif (optional) {\n\t\t\t\t\toptionalModifiers.push(mod)\n\t\t\t\t} else {\n\t\t\t\t\trequiredModifiers.push(mod)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn [requiredModifiers, optionalModifiers, key]\n\t\t})\n}\n\n/**\n * This tells us if a single keyboard event matches a single keybinding press.\n */\nexport function matchKeybindingPress(\n\tevent: KeyboardEvent,\n\t[requiredModifiers, optionalModifiers, key]: KeybindingPress,\n): boolean {\n\tconst hasAltGraph = requiredModifiers.includes(\"AltGraph\")\n\t// prettier-ignore\n\treturn !(\n\t\t// Allow either the `event.key` or the `event.code`\n\t\t// MDN event.key: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n\t\t// MDN event.code: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code\n\t\t(\n\t\t\tkey instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) :\n\t\t\t(key.toUpperCase() !== event.key.toUpperCase() &&\n\t\t\tkey !== event.code)\n\t\t) ||\n\n\t\t// Ensure all required modifiers in the keybinding are pressed.\n\t\trequiredModifiers.find(mod => {\n\t\t\treturn !getModifierState(event, mod)\n\t\t}) ||\n\n\t\t// KEYBINDING_MODIFIER_KEYS (Shift/Control/etc) change the meaning of a\n\t\t// keybinding. So if they are pressed but aren't part of the current\n\t\t// keybinding press, then we don't have a match.\n\t\tKEYBINDING_MODIFIER_KEYS.find(mod => {\n\t\t\treturn (\n\t\t\t\t!requiredModifiers.includes(mod) &&\n\t\t\t\t!optionalModifiers.includes(mod) &&\n\t\t\t\tkey !== mod &&\n\t\t\t\tgetModifierState(event, mod) &&\n\t\t\t\t// When AltGraph is required, its alias modifiers (e.g. Alt, Control)\n\t\t\t\t// being active is expected — don't treat them as unexpected modifiers.\n\t\t\t\t!(hasAltGraph && ALT_GRAPH_ALIASES.includes(mod))\n\t\t\t);\n\t\t})\n\t)\n}\n\n/**\n * Creates an event listener for handling keybindings.\n *\n * @example\n * ```js\n * import { createKeybindingsHandler } from \"../src/keybindings\"\n *\n * let handler = createKeybindingsHandler({\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n *\n * window.addEventListener(\"keydown\", handler)\n * ```\n */\nexport function createKeybindingsHandler(\n\tkeybindingsMap: KeybindingsMap,\n\toptions: KeybindingHandlerOptions = {},\n): EventListener {\n\tlet timeout = options.timeout ?? DEFAULT_TIMEOUT\n\tlet ignore = options.ignore ?? defaultKeybindingsHandlerIgnore\n\n\tlet keybindings = Object.keys(keybindingsMap).map(input => {\n\t\treturn [input, parseKeybinding(input), keybindingsMap[input]] as const\n\t})\n\n\tlet pending = new Map<string, KeybindingPress[]>()\n\tlet timer: number | null = null\n\n\treturn event => {\n\t\tif (!isKeyboardEvent(event) || ignore(event)) {\n\t\t\treturn\n\t\t}\n\n\t\tlet conflicts: Array<string> = []\n\t\tfor (let [input, sequence, handler] of keybindings) {\n\t\t\tlet prev = pending.get(input)\n\t\t\tlet expected = prev ? prev : sequence\n\t\t\tlet [current, ...rest] = expected\n\n\t\t\tlet matches = matchKeybindingPress(event, current)\n\n\t\t\tif (!matches) {\n\t\t\t\t// Modifier keydown events shouldn't break sequences\n\t\t\t\t// Note: This works because:\n\t\t\t\t// - non-modifiers will always return false\n\t\t\t\t// - if the current keypress is a modifier then it will return true when we check its state\n\t\t\t\t// MDN: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState\n\t\t\t\tif (!getModifierState(event, event.key)) {\n\t\t\t\t\tpending.delete(input)\n\t\t\t\t}\n\t\t\t} else if (rest.length > 0) {\n\t\t\t\tpending.set(input, rest)\n\t\t\t\tconflicts.push(input)\n\t\t\t} else {\n\t\t\t\tpending.delete(input)\n\t\t\t\tif (conflicts.length) {\n\t\t\t\t\tconsole.warn(\n\t\t\t\t\t\t`tinykeys: Conflict found, \"${input}\" did not fire, waiting for:`,\n\t\t\t\t\t\tconflicts,\n\t\t\t\t\t)\n\t\t\t\t} else {\n\t\t\t\t\thandler(event)\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (timer) {\n\t\t\tclearTimeout(timer)\n\t\t}\n\n\t\ttimer = setTimeout(() => pending.clear(), timeout)\n\t}\n}\n\n/**\n * Subscribes to keybindings.\n *\n * Returns an unsubscribe method.\n *\n * @example\n * ```js\n * import { tinykeys } from \"../src/tinykeys\"\n *\n * tinykeys(window, {\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n * ```\n */\nexport function tinykeys(\n\ttarget: Window | HTMLElement,\n\tkeybindingMap: KeybindingsMap,\n\toptions: KeybindingOptions = {},\n): () => void {\n\tlet event = options.event ?? DEFAULT_EVENT\n\tlet onKeyEvent = createKeybindingsHandler(keybindingMap, options)\n\ttarget.addEventListener(event, onKeyEvent, options.capture)\n\treturn () => {\n\t\ttarget.removeEventListener(event, onKeyEvent, options.capture)\n\t}\n}\n"],"mappings":"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"}

package/dist/tinykeys.d.cts

@@ -0,0 +1,138 @@
+//#region src/tinykeys.d.ts
+/**
+ * A single press of a keybinding sequence.
+ */
+type KeybindingPress = readonly [requiredModifiers: ReadonlyArray<string>, optionalModifiers: ReadonlyArray<string>, key: string | RegExp];
+/**
+ * Keyboard event callback fired when keybinding is triggered.
+ */
+type KeybindingHandler = (event: KeyboardEvent) => void;
+/**
+ * A map of keybinding strings to event handlers.
+ */
+type KeybindingsMap = Record<string, KeybindingHandler>;
+/**
+ * Predicate that returns true if a keyboard event should be ignored.
+ */
+type KeybindingFilter = (event: KeyboardEvent) => boolean;
+interface KeybindingHandlerOptions {
+  /**
+   * Keybinding sequences will wait this long between key presses before
+   * cancelling (default: 1000).
+   *
+   * **Note:** Setting this value too low (i.e. `300`) will be too fast for many
+   * of your users.
+   */
+  timeout?: number;
+  /**
+   * Customize the behavior of which keyboard events will be ignored/skipped.
+   *
+   * By default this uses the behavior of {@link defaultKeybindingsHandlerIgnore}.
+   *
+   * @example Allow all events
+   * ```tsx
+   * tinykeys(window, {...}, {
+   *   ignore: () => false
+   * })
+   * ```
+   *
+   * @example Extend the default ignore
+   * ```tsx
+   * tinykeys(window, {...}, {
+   *   ignore: event => {
+   *     return (
+   *       // Also ignore events inside a dialog
+   *       event.target.closest("dialog") != null &&
+   *       defaultKeybindingsHandlerIgnore(event)
+   *     );
+   *   }
+   * })
+   * ```
+   */
+  ignore?: KeybindingFilter;
+}
+/**
+ * Options to configure the behavior of keybindings.
+ */
+interface KeybindingOptions extends KeybindingHandlerOptions {
+  /**
+   * Key presses will listen to this event (default: "keydown").
+   */
+  event?: "keydown" | "keyup";
+  /**
+   * Key presses will use a capture listener (default: false)
+   */
+  capture?: boolean;
+}
+/**
+ * Ignores keyboard events from contenteditable and form elements unless they
+ * are the current target.
+ */
+declare function defaultKeybindingsHandlerIgnore(event: KeyboardEvent): boolean;
+/**
+ * Parses a keybinding string into its parts.
+ *
+ * ```
+ * grammar    = `<sequence>`
+ * <sequence> = `<press> <press> <press> ...`
+ * <press>    = `<key>` or `<mods>+<key>`
+ * <mods>     = `<mod>+<mod>+...`
+ * <mod>      = `<modifier>` (required) or `[<modifier>]` (optional)
+ * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)
+ * <key>      = `(<regex>)` -> `/^(?:<regex>)$/iy` (case-insensitive)
+ * ```
+ */
+declare function parseKeybinding(str: string): KeybindingPress[];
+/**
+ * This tells us if a single keyboard event matches a single keybinding press.
+ */
+declare function matchKeybindingPress(event: KeyboardEvent, [requiredModifiers, optionalModifiers, key]: KeybindingPress): boolean;
+/**
+ * Creates an event listener for handling keybindings.
+ *
+ * @example
+ * ```js
+ * import { createKeybindingsHandler } from "../src/keybindings"
+ *
+ * let handler = createKeybindingsHandler({
+ * 	"Shift+d": () => {
+ * 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+ * 	},
+ * 	"y e e t": () => {
+ * 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+ * 	},
+ * 	"$mod+d": () => {
+ * 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+ * 	},
+ * })
+ *
+ * window.addEventListener("keydown", handler)
+ * ```
+ */
+declare function createKeybindingsHandler(keybindingsMap: KeybindingsMap, options?: KeybindingHandlerOptions): EventListener;
+/**
+ * Subscribes to keybindings.
+ *
+ * Returns an unsubscribe method.
+ *
+ * @example
+ * ```js
+ * import { tinykeys } from "../src/tinykeys"
+ *
+ * tinykeys(window, {
+ * 	"Shift+d": () => {
+ * 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+ * 	},
+ * 	"y e e t": () => {
+ * 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+ * 	},
+ * 	"$mod+d": () => {
+ * 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+ * 	},
+ * })
+ * ```
+ */
+declare function tinykeys(target: Window | HTMLElement, keybindingMap: KeybindingsMap, options?: KeybindingOptions): () => void;
+//#endregion
+export { KeybindingFilter, KeybindingHandler, KeybindingHandlerOptions, KeybindingOptions, KeybindingPress, KeybindingsMap, createKeybindingsHandler, defaultKeybindingsHandlerIgnore, matchKeybindingPress, parseKeybinding, tinykeys };
+//# sourceMappingURL=tinykeys.d.cts.map

package/dist/tinykeys.d.mts

@@ -0,0 +1,138 @@
+//#region src/tinykeys.d.ts
+/**
+ * A single press of a keybinding sequence.
+ */
+type KeybindingPress = readonly [requiredModifiers: ReadonlyArray<string>, optionalModifiers: ReadonlyArray<string>, key: string | RegExp];
+/**
+ * Keyboard event callback fired when keybinding is triggered.
+ */
+type KeybindingHandler = (event: KeyboardEvent) => void;
+/**
+ * A map of keybinding strings to event handlers.
+ */
+type KeybindingsMap = Record<string, KeybindingHandler>;
+/**
+ * Predicate that returns true if a keyboard event should be ignored.
+ */
+type KeybindingFilter = (event: KeyboardEvent) => boolean;
+interface KeybindingHandlerOptions {
+  /**
+   * Keybinding sequences will wait this long between key presses before
+   * cancelling (default: 1000).
+   *
+   * **Note:** Setting this value too low (i.e. `300`) will be too fast for many
+   * of your users.
+   */
+  timeout?: number;
+  /**
+   * Customize the behavior of which keyboard events will be ignored/skipped.
+   *
+   * By default this uses the behavior of {@link defaultKeybindingsHandlerIgnore}.
+   *
+   * @example Allow all events
+   * ```tsx
+   * tinykeys(window, {...}, {
+   *   ignore: () => false
+   * })
+   * ```
+   *
+   * @example Extend the default ignore
+   * ```tsx
+   * tinykeys(window, {...}, {
+   *   ignore: event => {
+   *     return (
+   *       // Also ignore events inside a dialog
+   *       event.target.closest("dialog") != null &&
+   *       defaultKeybindingsHandlerIgnore(event)
+   *     );
+   *   }
+   * })
+   * ```
+   */
+  ignore?: KeybindingFilter;
+}
+/**
+ * Options to configure the behavior of keybindings.
+ */
+interface KeybindingOptions extends KeybindingHandlerOptions {
+  /**
+   * Key presses will listen to this event (default: "keydown").
+   */
+  event?: "keydown" | "keyup";
+  /**
+   * Key presses will use a capture listener (default: false)
+   */
+  capture?: boolean;
+}
+/**
+ * Ignores keyboard events from contenteditable and form elements unless they
+ * are the current target.
+ */
+declare function defaultKeybindingsHandlerIgnore(event: KeyboardEvent): boolean;
+/**
+ * Parses a keybinding string into its parts.
+ *
+ * ```
+ * grammar    = `<sequence>`
+ * <sequence> = `<press> <press> <press> ...`
+ * <press>    = `<key>` or `<mods>+<key>`
+ * <mods>     = `<mod>+<mod>+...`
+ * <mod>      = `<modifier>` (required) or `[<modifier>]` (optional)
+ * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)
+ * <key>      = `(<regex>)` -> `/^(?:<regex>)$/iy` (case-insensitive)
+ * ```
+ */
+declare function parseKeybinding(str: string): KeybindingPress[];
+/**
+ * This tells us if a single keyboard event matches a single keybinding press.
+ */
+declare function matchKeybindingPress(event: KeyboardEvent, [requiredModifiers, optionalModifiers, key]: KeybindingPress): boolean;
+/**
+ * Creates an event listener for handling keybindings.
+ *
+ * @example
+ * ```js
+ * import { createKeybindingsHandler } from "../src/keybindings"
+ *
+ * let handler = createKeybindingsHandler({
+ * 	"Shift+d": () => {
+ * 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+ * 	},
+ * 	"y e e t": () => {
+ * 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+ * 	},
+ * 	"$mod+d": () => {
+ * 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+ * 	},
+ * })
+ *
+ * window.addEventListener("keydown", handler)
+ * ```
+ */
+declare function createKeybindingsHandler(keybindingsMap: KeybindingsMap, options?: KeybindingHandlerOptions): EventListener;
+/**
+ * Subscribes to keybindings.
+ *
+ * Returns an unsubscribe method.
+ *
+ * @example
+ * ```js
+ * import { tinykeys } from "../src/tinykeys"
+ *
+ * tinykeys(window, {
+ * 	"Shift+d": () => {
+ * 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+ * 	},
+ * 	"y e e t": () => {
+ * 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+ * 	},
+ * 	"$mod+d": () => {
+ * 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+ * 	},
+ * })
+ * ```
+ */
+declare function tinykeys(target: Window | HTMLElement, keybindingMap: KeybindingsMap, options?: KeybindingOptions): () => void;
+//#endregion
+export { KeybindingFilter, KeybindingHandler, KeybindingHandlerOptions, KeybindingOptions, KeybindingPress, KeybindingsMap, createKeybindingsHandler, defaultKeybindingsHandlerIgnore, matchKeybindingPress, parseKeybinding, tinykeys };
+//# sourceMappingURL=tinykeys.d.mts.map

package/dist/tinykeys.mjs

@@ -0,0 +1,200 @@
+//#region src/tinykeys.ts
+/**
+* These are the modifier keys that change the meaning of keybindings.
+*
+* Note: Ignoring "AltGraph" because it is covered by the others.
+*/
+let KEYBINDING_MODIFIER_KEYS = [
+	"Shift",
+	"Meta",
+	"Alt",
+	"Control"
+];
+/**
+* Keybinding sequences should timeout if individual key presses are more than
+* 1s apart by default.
+*/
+let DEFAULT_TIMEOUT = 1e3;
+/**
+* Keybinding sequences should bind to this event by default.
+*/
+let DEFAULT_EVENT = "keydown";
+/**
+* Platform detection code.
+* @see https://github.com/jamiebuilds/tinykeys/issues/184
+*/
+let PLATFORM = typeof navigator === "object" ? navigator.platform : "";
+/**
+* An alias for creating platform-specific keybinding aliases.
+*/
+let MOD = /Mac|iPod|iPhone|iPad/.test(PLATFORM) ? "Meta" : "Control";
+/**
+* Meaning of `AltGraph`, from MDN:
+* - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed
+* - Mac: ⌥ Option key pressed
+* - Linux: Level 3 Shift key (or Level 5 Shift key) pressed
+* - Android: Not supported
+* @see https://github.com/jamiebuilds/tinykeys/issues/185
+*/
+let ALT_GRAPH_ALIASES = PLATFORM === "Win32" ? ["Control", "Alt"] : ["Alt"];
+/**
+* Ensure and stop any event that isn't a full keyboard event.
+* Autocomplete option navigation and selection would fire an Event,
+* instead of the expected KeyboardEvent
+*/
+function isKeyboardEvent(event) {
+	return !!(event.key && event.code && event.getModifierState);
+}
+/**
+* Ignores keyboard events from contenteditable and form elements unless they
+* are the current target.
+*/
+function defaultKeybindingsHandlerIgnore(event) {
+	let target = event.target;
+	return event.repeat || event.isComposing || target !== event.currentTarget && target.matches("[contenteditable],input,select,textarea");
+}
+/**
+* There's a bug in Chrome that causes event.getModifierState not to exist on
+* KeyboardEvent's for F1/F2/etc keys.
+*/
+function getModifierState(event, mod) {
+	return typeof event.getModifierState === "function" ? event.getModifierState(mod) || ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState("AltGraph") : false;
+}
+/**
+* Parses a keybinding string into its parts.
+*
+* ```
+* grammar    = `<sequence>`
+* <sequence> = `<press> <press> <press> ...`
+* <press>    = `<key>` or `<mods>+<key>`
+* <mods>     = `<mod>+<mod>+...`
+* <mod>      = `<modifier>` (required) or `[<modifier>]` (optional)
+* <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)
+* <key>      = `(<regex>)` -> `/^(?:<regex>)$/iy` (case-insensitive)
+* ```
+*/
+function parseKeybinding(str) {
+	return str.trim().split(" ").map((press) => {
+		let parts = press.split(/(?<=\w|\])\+/);
+		let last = parts.pop();
+		let regex = last.match(/^\((.+)\)$/);
+		let key = regex ? new RegExp(`^(?:${regex[1]})$`, "iv") : last;
+		let requiredModifiers = [];
+		let optionalModifiers = [];
+		for (const part of parts) {
+			let optional = part.match(/^\[(.*)\]$/);
+			let mod = optional?.[1] ?? part;
+			mod = mod === "$mod" ? MOD : mod;
+			if (optional) optionalModifiers.push(mod);
+			else requiredModifiers.push(mod);
+		}
+		return [
+			requiredModifiers,
+			optionalModifiers,
+			key
+		];
+	});
+}
+/**
+* This tells us if a single keyboard event matches a single keybinding press.
+*/
+function matchKeybindingPress(event, [requiredModifiers, optionalModifiers, key]) {
+	const hasAltGraph = requiredModifiers.includes("AltGraph");
+	return !((key instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) : key.toUpperCase() !== event.key.toUpperCase() && key !== event.code) || requiredModifiers.find((mod) => {
+		return !getModifierState(event, mod);
+	}) || KEYBINDING_MODIFIER_KEYS.find((mod) => {
+		return !requiredModifiers.includes(mod) && !optionalModifiers.includes(mod) && key !== mod && getModifierState(event, mod) && !(hasAltGraph && ALT_GRAPH_ALIASES.includes(mod));
+	}));
+}
+/**
+* Creates an event listener for handling keybindings.
+*
+* @example
+* ```js
+* import { createKeybindingsHandler } from "../src/keybindings"
+*
+* let handler = createKeybindingsHandler({
+* 	"Shift+d": () => {
+* 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+* 	},
+* 	"y e e t": () => {
+* 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+* 	},
+* 	"$mod+d": () => {
+* 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+* 	},
+* })
+*
+* window.addEventListener("keydown", handler)
+* ```
+*/
+function createKeybindingsHandler(keybindingsMap, options = {}) {
+	let timeout = options.timeout ?? DEFAULT_TIMEOUT;
+	let ignore = options.ignore ?? defaultKeybindingsHandlerIgnore;
+	let keybindings = Object.keys(keybindingsMap).map((input) => {
+		return [
+			input,
+			parseKeybinding(input),
+			keybindingsMap[input]
+		];
+	});
+	let pending = /* @__PURE__ */ new Map();
+	let timer = null;
+	return (event) => {
+		if (!isKeyboardEvent(event) || ignore(event)) return;
+		let conflicts = [];
+		for (let [input, sequence, handler] of keybindings) {
+			let prev = pending.get(input);
+			let [current, ...rest] = prev ? prev : sequence;
+			if (!matchKeybindingPress(event, current)) {
+				if (!getModifierState(event, event.key)) pending.delete(input);
+			} else if (rest.length > 0) {
+				pending.set(input, rest);
+				conflicts.push(input);
+			} else {
+				pending.delete(input);
+				if (conflicts.length) console.warn(`tinykeys: Conflict found, "${input}" did not fire, waiting for:`, conflicts);
+				else {
+					handler(event);
+					break;
+				}
+			}
+		}
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => pending.clear(), timeout);
+	};
+}
+/**
+* Subscribes to keybindings.
+*
+* Returns an unsubscribe method.
+*
+* @example
+* ```js
+* import { tinykeys } from "../src/tinykeys"
+*
+* tinykeys(window, {
+* 	"Shift+d": () => {
+* 		alert("The 'Shift' and 'd' keys were pressed at the same time")
+* 	},
+* 	"y e e t": () => {
+* 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
+* 	},
+* 	"$mod+d": () => {
+* 		alert("Either 'Control+d' or 'Meta+d' were pressed")
+* 	},
+* })
+* ```
+*/
+function tinykeys(target, keybindingMap, options = {}) {
+	let event = options.event ?? DEFAULT_EVENT;
+	let onKeyEvent = createKeybindingsHandler(keybindingMap, options);
+	target.addEventListener(event, onKeyEvent, options.capture);
+	return () => {
+		target.removeEventListener(event, onKeyEvent, options.capture);
+	};
+}
+//#endregion
+export { createKeybindingsHandler, defaultKeybindingsHandlerIgnore, matchKeybindingPress, parseKeybinding, tinykeys };
+
+//# sourceMappingURL=tinykeys.mjs.map

package/dist/tinykeys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tinykeys.mjs","names":[],"sources":["../src/tinykeys.ts"],"sourcesContent":["/**\n * A single press of a keybinding sequence.\n */\nexport type KeybindingPress = readonly [\n\trequiredModifiers: ReadonlyArray<string>,\n\toptionalModifiers: ReadonlyArray<string>,\n\tkey: string | RegExp,\n]\n\n/**\n * Keyboard event callback fired when keybinding is triggered.\n */\nexport type KeybindingHandler = (event: KeyboardEvent) => void\n\n/**\n * A map of keybinding strings to event handlers.\n */\nexport type KeybindingsMap = Record<string, KeybindingHandler>\n\n/**\n * Predicate that returns true if a keyboard event should be ignored.\n */\nexport type KeybindingFilter = (event: KeyboardEvent) => boolean\n\nexport interface KeybindingHandlerOptions {\n\t/**\n\t * Keybinding sequences will wait this long between key presses before\n\t * cancelling (default: 1000).\n\t *\n\t * **Note:** Setting this value too low (i.e. `300`) will be too fast for many\n\t * of your users.\n\t */\n\ttimeout?: number\n\n\t/**\n\t * Customize the behavior of which keyboard events will be ignored/skipped.\n\t *\n\t * By default this uses the behavior of {@link defaultKeybindingsHandlerIgnore}.\n\t *\n\t * @example Allow all events\n\t * ```tsx\n\t * tinykeys(window, {...}, {\n\t *   ignore: () => false\n\t * })\n\t * ```\n\t *\n\t * @example Extend the default ignore\n\t * ```tsx\n\t * tinykeys(window, {...}, {\n\t *   ignore: event => {\n\t *     return (\n\t *       // Also ignore events inside a dialog\n\t *       event.target.closest(\"dialog\") != null &&\n\t *       defaultKeybindingsHandlerIgnore(event)\n\t *     );\n\t *   }\n\t * })\n\t * ```\n\t */\n\tignore?: KeybindingFilter\n}\n\n/**\n * Options to configure the behavior of keybindings.\n */\nexport interface KeybindingOptions extends KeybindingHandlerOptions {\n\t/**\n\t * Key presses will listen to this event (default: \"keydown\").\n\t */\n\tevent?: \"keydown\" | \"keyup\"\n\n\t/**\n\t * Key presses will use a capture listener (default: false)\n\t */\n\tcapture?: boolean\n}\n\n/**\n * These are the modifier keys that change the meaning of keybindings.\n *\n * Note: Ignoring \"AltGraph\" because it is covered by the others.\n */\nlet KEYBINDING_MODIFIER_KEYS = [\"Shift\", \"Meta\", \"Alt\", \"Control\"]\n\n/**\n * Keybinding sequences should timeout if individual key presses are more than\n * 1s apart by default.\n */\nlet DEFAULT_TIMEOUT = 1000\n\n/**\n * Keybinding sequences should bind to this event by default.\n */\nlet DEFAULT_EVENT = \"keydown\" as const\n\n/**\n * Platform detection code.\n * @see https://github.com/jamiebuilds/tinykeys/issues/184\n */\nlet PLATFORM = typeof navigator === \"object\" ? navigator.platform : \"\"\nlet APPLE_DEVICE = /Mac|iPod|iPhone|iPad/.test(PLATFORM)\n\n/**\n * An alias for creating platform-specific keybinding aliases.\n */\nlet MOD = APPLE_DEVICE ? \"Meta\" : \"Control\"\n\n/**\n * Meaning of `AltGraph`, from MDN:\n * - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed\n * - Mac: ⌥ Option key pressed\n * - Linux: Level 3 Shift key (or Level 5 Shift key) pressed\n * - Android: Not supported\n * @see https://github.com/jamiebuilds/tinykeys/issues/185\n */\nlet ALT_GRAPH_ALIASES = PLATFORM === \"Win32\" ? [\"Control\", \"Alt\"] : [\"Alt\"]\n\n/**\n * Ensure and stop any event that isn't a full keyboard event.\n * Autocomplete option navigation and selection would fire an Event,\n * instead of the expected KeyboardEvent\n */\nfunction isKeyboardEvent(\n\tevent: Partial<KeyboardEvent>,\n): event is KeyboardEvent {\n\treturn !!(event.key && event.code && event.getModifierState)\n}\n\n/**\n * Ignores keyboard events from contenteditable and form elements unless they\n * are the current target.\n */\nexport function defaultKeybindingsHandlerIgnore(event: KeyboardEvent) {\n\tlet target = event.target as HTMLElement\n\treturn (\n\t\t// Always ignore repeated keyboard events\n\t\tevent.repeat ||\n\t\t// Always ignore keyboard events during composition input\n\t\tevent.isComposing ||\n\t\t// Always allow the current target\n\t\t(target !== event.currentTarget &&\n\t\t\t// Ignore contenteditable and form elements\n\t\t\ttarget.matches(\"[contenteditable],input,select,textarea\"))\n\t)\n}\n\n/**\n * There's a bug in Chrome that causes event.getModifierState not to exist on\n * KeyboardEvent's for F1/F2/etc keys.\n */\nfunction getModifierState(event: KeyboardEvent, mod: string) {\n\treturn typeof event.getModifierState === \"function\"\n\t\t? event.getModifierState(mod) ||\n\t\t\t\t(ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState(\"AltGraph\"))\n\t\t: false\n}\n\n/**\n * Parses a keybinding string into its parts.\n *\n * ```\n * grammar    = `<sequence>`\n * <sequence> = `<press> <press> <press> ...`\n * <press>    = `<key>` or `<mods>+<key>`\n * <mods>     = `<mod>+<mod>+...`\n * <mod>      = `<modifier>` (required) or `[<modifier>]` (optional)\n * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)\n * <key>      = `(<regex>)` -> `/^(?:<regex>)$/iy` (case-insensitive)\n * ```\n */\nexport function parseKeybinding(str: string): KeybindingPress[] {\n\treturn str\n\t\t.trim()\n\t\t.split(\" \")\n\t\t.map(press => {\n\t\t\tlet parts = press.split(/(?<=\\w|\\])\\+/)\n\n\t\t\tlet last: string | RegExp = parts.pop() as string\n\t\t\tlet regex = last.match(/^\\((.+)\\)$/)\n\t\t\tlet key = regex ? new RegExp(`^(?:${regex[1]})$`, \"iv\") : last\n\n\t\t\tlet requiredModifiers: string[] = []\n\t\t\tlet optionalModifiers: string[] = []\n\n\t\t\tfor (const part of parts) {\n\t\t\t\tlet optional = part.match(/^\\[(.*)\\]$/)\n\t\t\t\tlet mod = optional?.[1] ?? part\n\t\t\t\tmod = mod === \"$mod\" ? MOD : mod\n\t\t\t\tif (optional) {\n\t\t\t\t\toptionalModifiers.push(mod)\n\t\t\t\t} else {\n\t\t\t\t\trequiredModifiers.push(mod)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn [requiredModifiers, optionalModifiers, key]\n\t\t})\n}\n\n/**\n * This tells us if a single keyboard event matches a single keybinding press.\n */\nexport function matchKeybindingPress(\n\tevent: KeyboardEvent,\n\t[requiredModifiers, optionalModifiers, key]: KeybindingPress,\n): boolean {\n\tconst hasAltGraph = requiredModifiers.includes(\"AltGraph\")\n\t// prettier-ignore\n\treturn !(\n\t\t// Allow either the `event.key` or the `event.code`\n\t\t// MDN event.key: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n\t\t// MDN event.code: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code\n\t\t(\n\t\t\tkey instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) :\n\t\t\t(key.toUpperCase() !== event.key.toUpperCase() &&\n\t\t\tkey !== event.code)\n\t\t) ||\n\n\t\t// Ensure all required modifiers in the keybinding are pressed.\n\t\trequiredModifiers.find(mod => {\n\t\t\treturn !getModifierState(event, mod)\n\t\t}) ||\n\n\t\t// KEYBINDING_MODIFIER_KEYS (Shift/Control/etc) change the meaning of a\n\t\t// keybinding. So if they are pressed but aren't part of the current\n\t\t// keybinding press, then we don't have a match.\n\t\tKEYBINDING_MODIFIER_KEYS.find(mod => {\n\t\t\treturn (\n\t\t\t\t!requiredModifiers.includes(mod) &&\n\t\t\t\t!optionalModifiers.includes(mod) &&\n\t\t\t\tkey !== mod &&\n\t\t\t\tgetModifierState(event, mod) &&\n\t\t\t\t// When AltGraph is required, its alias modifiers (e.g. Alt, Control)\n\t\t\t\t// being active is expected — don't treat them as unexpected modifiers.\n\t\t\t\t!(hasAltGraph && ALT_GRAPH_ALIASES.includes(mod))\n\t\t\t);\n\t\t})\n\t)\n}\n\n/**\n * Creates an event listener for handling keybindings.\n *\n * @example\n * ```js\n * import { createKeybindingsHandler } from \"../src/keybindings\"\n *\n * let handler = createKeybindingsHandler({\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n *\n * window.addEventListener(\"keydown\", handler)\n * ```\n */\nexport function createKeybindingsHandler(\n\tkeybindingsMap: KeybindingsMap,\n\toptions: KeybindingHandlerOptions = {},\n): EventListener {\n\tlet timeout = options.timeout ?? DEFAULT_TIMEOUT\n\tlet ignore = options.ignore ?? defaultKeybindingsHandlerIgnore\n\n\tlet keybindings = Object.keys(keybindingsMap).map(input => {\n\t\treturn [input, parseKeybinding(input), keybindingsMap[input]] as const\n\t})\n\n\tlet pending = new Map<string, KeybindingPress[]>()\n\tlet timer: number | null = null\n\n\treturn event => {\n\t\tif (!isKeyboardEvent(event) || ignore(event)) {\n\t\t\treturn\n\t\t}\n\n\t\tlet conflicts: Array<string> = []\n\t\tfor (let [input, sequence, handler] of keybindings) {\n\t\t\tlet prev = pending.get(input)\n\t\t\tlet expected = prev ? prev : sequence\n\t\t\tlet [current, ...rest] = expected\n\n\t\t\tlet matches = matchKeybindingPress(event, current)\n\n\t\t\tif (!matches) {\n\t\t\t\t// Modifier keydown events shouldn't break sequences\n\t\t\t\t// Note: This works because:\n\t\t\t\t// - non-modifiers will always return false\n\t\t\t\t// - if the current keypress is a modifier then it will return true when we check its state\n\t\t\t\t// MDN: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState\n\t\t\t\tif (!getModifierState(event, event.key)) {\n\t\t\t\t\tpending.delete(input)\n\t\t\t\t}\n\t\t\t} else if (rest.length > 0) {\n\t\t\t\tpending.set(input, rest)\n\t\t\t\tconflicts.push(input)\n\t\t\t} else {\n\t\t\t\tpending.delete(input)\n\t\t\t\tif (conflicts.length) {\n\t\t\t\t\tconsole.warn(\n\t\t\t\t\t\t`tinykeys: Conflict found, \"${input}\" did not fire, waiting for:`,\n\t\t\t\t\t\tconflicts,\n\t\t\t\t\t)\n\t\t\t\t} else {\n\t\t\t\t\thandler(event)\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (timer) {\n\t\t\tclearTimeout(timer)\n\t\t}\n\n\t\ttimer = setTimeout(() => pending.clear(), timeout)\n\t}\n}\n\n/**\n * Subscribes to keybindings.\n *\n * Returns an unsubscribe method.\n *\n * @example\n * ```js\n * import { tinykeys } from \"../src/tinykeys\"\n *\n * tinykeys(window, {\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n * ```\n */\nexport function tinykeys(\n\ttarget: Window | HTMLElement,\n\tkeybindingMap: KeybindingsMap,\n\toptions: KeybindingOptions = {},\n): () => void {\n\tlet event = options.event ?? DEFAULT_EVENT\n\tlet onKeyEvent = createKeybindingsHandler(keybindingMap, options)\n\ttarget.addEventListener(event, onKeyEvent, options.capture)\n\treturn () => {\n\t\ttarget.removeEventListener(event, onKeyEvent, options.capture)\n\t}\n}\n"],"mappings":"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"}

package/dist/tinykeys.umd.js

@@ -1,2 +1,2 @@
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e||self).tinykeys={})}(this,function(e){var t=["Shift","Meta","Alt","Control"],n="object"==typeof navigator?navigator.platform:"",i=/Mac|iPod|iPhone|iPad/.test(n),o=i?"Meta":"Control",r="Win32"===n?["Control","Alt"]:i?["Alt"]:[];function a(e,t){return"function"==typeof e.getModifierState&&(e.getModifierState(t)||r.includes(t)&&e.getModifierState("AltGraph"))}function u(e){return e.trim().split(" ").map(function(e){var t=e.split(/\b\+/),n=t.pop(),i=n.match(/^\((.+)\)$/);return i&&(n=new RegExp("^(?:"+i[1]+")$","iv")),[t=t.map(function(e){return"$mod"===e?o:e}),n]})}function f(e,n){var i=n[0],o=n[1];return!((o instanceof RegExp?!o.test(e.key)&&!o.test(e.code):o.toUpperCase()!==e.key.toUpperCase()&&o!==e.code)||i.find(function(t){return!a(e,t)})||t.find(function(t){return!i.includes(t)&&o!==t&&a(e,t)}))}function c(e,t){var n;void 0===t&&(t={});var i=null!=(n=t.timeout)?n:1e3,o=Object.keys(e).map(function(t){return[u(t),e[t]]}),r=new Map,c=null;return function(e){e instanceof KeyboardEvent&&(o.forEach(function(t){var n=t[0],i=t[1],o=r.get(n)||n;f(e,o[0])?o.length>1?r.set(n,o.slice(1)):(r.delete(n),i(e)):a(e,e.key)||r.delete(n)}),c&&clearTimeout(c),c=setTimeout(r.clear.bind(r),i))}}e.createKeybindingsHandler=c,e.matchKeyBindingPress=f,e.parseKeybinding=u,e.tinykeys=function(e,t,n){var i=void 0===n?{}:n,o=i.event,r=void 0===o?"keydown":o,a=i.capture,u=c(t,{timeout:i.timeout});return e.addEventListener(r,u,a),function(){e.removeEventListener(r,u,a)}}});
-//# sourceMappingURL=tinykeys.umd.js.map
+(function(e,t){typeof exports==`object`&&typeof module<`u`?t(exports):typeof define==`function`&&define.amd?define([`exports`],t):(e=typeof globalThis<`u`?globalThis:e||self,t(e.tinykeys={}))})(this,function(e){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});let t=[`Shift`,`Meta`,`Alt`,`Control`],n=typeof navigator==`object`?navigator.platform:``,r=/Mac|iPod|iPhone|iPad/.test(n)?`Meta`:`Control`,i=n===`Win32`?[`Control`,`Alt`]:[`Alt`];function a(e){return!!(e.key&&e.code&&e.getModifierState)}function o(e){let t=e.target;return e.repeat||e.isComposing||t!==e.currentTarget&&t.matches(`[contenteditable],input,select,textarea`)}function s(e,t){return typeof e.getModifierState==`function`?e.getModifierState(t)||i.includes(t)&&e.getModifierState(`AltGraph`):!1}function c(e){return e.trim().split(` `).map(e=>{let t=e.split(/(?<=\w|\])\+/),n=t.pop(),i=n.match(/^\((.+)\)$/),a=i?RegExp(`^(?:${i[1]})$`,`iv`):n,o=[],s=[];for(let e of t){let t=e.match(/^\[(.*)\]$/),n=t?.[1]??e;n=n===`$mod`?r:n,t?s.push(n):o.push(n)}return[o,s,a]})}function l(e,[n,r,a]){let o=n.includes(`AltGraph`);return!((a instanceof RegExp?!(a.test(e.key)||a.test(e.code)):a.toUpperCase()!==e.key.toUpperCase()&&a!==e.code)||n.find(t=>!s(e,t))||t.find(t=>!n.includes(t)&&!r.includes(t)&&a!==t&&s(e,t)&&!(o&&i.includes(t))))}function u(e,t={}){let n=t.timeout??1e3,r=t.ignore??o,i=Object.keys(e).map(t=>[t,c(t),e[t]]),u=new Map,d=null;return e=>{if(!a(e)||r(e))return;let t=[];for(let[n,r,a]of i){let[i,...o]=u.get(n)||r;if(!l(e,i))s(e,e.key)||u.delete(n);else if(o.length>0)u.set(n,o),t.push(n);else if(u.delete(n),t.length)console.warn(`tinykeys: Conflict found, "${n}" did not fire, waiting for:`,t);else{a(e);break}}d&&clearTimeout(d),d=setTimeout(()=>u.clear(),n)}}function d(e,t,n={}){let r=n.event??`keydown`,i=u(t,n);return e.addEventListener(r,i,n.capture),()=>{e.removeEventListener(r,i,n.capture)}}e.createKeybindingsHandler=u,e.defaultKeybindingsHandlerIgnore=o,e.matchKeybindingPress=l,e.parseKeybinding=c,e.tinykeys=d});
+//# sourceMappingURL=tinykeys.umd.js.map

package/dist/tinykeys.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"tinykeys.umd.js","sources":["../src/tinykeys.ts"],"sourcesContent":["/**\n * A single press of a keybinding sequence\n */\nexport type KeyBindingPress = [mods: string[], key: string | RegExp]\n\n/**\n * A map of keybinding strings to event handlers.\n */\nexport interface KeyBindingMap {\n\t[keybinding: string]: (event: KeyboardEvent) => void\n}\n\nexport interface KeyBindingHandlerOptions {\n\t/**\n\t * Keybinding sequences will wait this long between key presses before\n\t * cancelling (default: 1000).\n\t *\n\t * **Note:** Setting this value too low (i.e. `300`) will be too fast for many\n\t * of your users.\n\t */\n\ttimeout?: number\n}\n\n/**\n * Options to configure the behavior of keybindings.\n */\nexport interface KeyBindingOptions extends KeyBindingHandlerOptions {\n\t/**\n\t * Key presses will listen to this event (default: \"keydown\").\n\t */\n\tevent?: \"keydown\" | \"keyup\"\n\n\t/**\n\t * Key presses will use a capture listener (default: false)\n\t */\n\tcapture?: boolean\n}\n\n/**\n * These are the modifier keys that change the meaning of keybindings.\n *\n * Note: Ignoring \"AltGraph\" because it is covered by the others.\n */\nlet KEYBINDING_MODIFIER_KEYS = [\"Shift\", \"Meta\", \"Alt\", \"Control\"]\n\n/**\n * Keybinding sequences should timeout if individual key presses are more than\n * 1s apart by default.\n */\nlet DEFAULT_TIMEOUT = 1000\n\n/**\n * Keybinding sequences should bind to this event by default.\n */\nlet DEFAULT_EVENT = \"keydown\" as const\n\n/**\n * Platform detection code.\n * @see https://github.com/jamiebuilds/tinykeys/issues/184\n */\nlet PLATFORM = typeof navigator === \"object\" ? navigator.platform : \"\"\nlet APPLE_DEVICE = /Mac|iPod|iPhone|iPad/.test(PLATFORM)\n\n/**\n * An alias for creating platform-specific keybinding aliases.\n */\nlet MOD = APPLE_DEVICE ? \"Meta\" : \"Control\"\n\n/**\n * Meaning of `AltGraph`, from MDN:\n * - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed\n * - Mac: ⌥ Option key pressed\n * - Linux: Level 3 Shift key (or Level 5 Shift key) pressed\n * - Android: Not supported\n * @see https://github.com/jamiebuilds/tinykeys/issues/185\n */\nlet ALT_GRAPH_ALIASES =\n\tPLATFORM === \"Win32\" ? [\"Control\", \"Alt\"] : APPLE_DEVICE ? [\"Alt\"] : []\n\n/**\n * There's a bug in Chrome that causes event.getModifierState not to exist on\n * KeyboardEvent's for F1/F2/etc keys.\n */\nfunction getModifierState(event: KeyboardEvent, mod: string) {\n\treturn typeof event.getModifierState === \"function\"\n\t\t? event.getModifierState(mod) ||\n\t\t\t\t(ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState(\"AltGraph\"))\n\t\t: false\n}\n\n/**\n * Parses a \"Key Binding String\" into its parts\n *\n * grammar    = `<sequence>`\n * <sequence> = `<press> <press> <press> ...`\n * <press>    = `<key>` or `<mods>+<key>`\n * <mods>     = `<mod>+<mod>+...`\n * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)\n * <key>      = `(<regex>)` -> `/^(?:<regex>)$/` (case-sensitive)\n */\nexport function parseKeybinding(str: string): KeyBindingPress[] {\n\treturn str\n\t\t.trim()\n\t\t.split(\" \")\n\t\t.map(press => {\n\t\t\tlet mods = press.split(/\\b\\+/)\n\t\t\tlet key: string | RegExp = mods.pop() as string\n\t\t\tlet match = key.match(/^\\((.+)\\)$/)\n\t\t\tif (match) {\n\t\t\t\tkey = new RegExp(`^(?:${match[1]})$`, \"iv\")\n\t\t\t}\n\t\t\tmods = mods.map(mod => (mod === \"$mod\" ? MOD : mod))\n\t\t\treturn [mods, key]\n\t\t})\n}\n\n/**\n * This tells us if a single keyboard event matches a single keybinding press.\n */\nexport function matchKeyBindingPress(\n\tevent: KeyboardEvent,\n\t[mods, key]: KeyBindingPress,\n): boolean {\n\t// prettier-ignore\n\treturn !(\n\t\t// Allow either the `event.key` or the `event.code`\n\t\t// MDN event.key: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n\t\t// MDN event.code: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code\n\t\t(\n\t\t\tkey instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) :\n\t\t\t(key.toUpperCase() !== event.key.toUpperCase() &&\n\t\t\tkey !== event.code)\n\t\t) ||\n\n\t\t// Ensure all the modifiers in the keybinding are pressed.\n\t\tmods.find(mod => {\n\t\t\treturn !getModifierState(event, mod)\n\t\t}) ||\n\n\t\t// KEYBINDING_MODIFIER_KEYS (Shift/Control/etc) change the meaning of a\n\t\t// keybinding. So if they are pressed but aren't part of the current\n\t\t// keybinding press, then we don't have a match.\n\t\tKEYBINDING_MODIFIER_KEYS.find(mod => {\n\t\t\treturn !mods.includes(mod) && key !== mod && getModifierState(event, mod)\n\t\t})\n\t)\n}\n\n/**\n * Creates an event listener for handling keybindings.\n *\n * @example\n * ```js\n * import { createKeybindingsHandler } from \"../src/keybindings\"\n *\n * let handler = createKeybindingsHandler({\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n *\n * window.addEvenListener(\"keydown\", handler)\n * ```\n */\nexport function createKeybindingsHandler(\n\tkeyBindingMap: KeyBindingMap,\n\toptions: KeyBindingHandlerOptions = {},\n): EventListener {\n\tlet timeout = options.timeout ?? DEFAULT_TIMEOUT\n\n\tlet keyBindings = Object.keys(keyBindingMap).map(key => {\n\t\treturn [parseKeybinding(key), keyBindingMap[key]] as const\n\t})\n\n\tlet possibleMatches = new Map<KeyBindingPress[], KeyBindingPress[]>()\n\tlet timer: number | null = null\n\n\treturn event => {\n\t\t// Ensure and stop any event that isn't a full keyboard event.\n\t\t// Autocomplete option navigation and selection would fire a instanceof Event,\n\t\t// instead of the expected KeyboardEvent\n\t\tif (!(event instanceof KeyboardEvent)) {\n\t\t\treturn\n\t\t}\n\n\t\tkeyBindings.forEach(keyBinding => {\n\t\t\tlet sequence = keyBinding[0]\n\t\t\tlet callback = keyBinding[1]\n\n\t\t\tlet prev = possibleMatches.get(sequence)\n\t\t\tlet remainingExpectedPresses = prev ? prev : sequence\n\t\t\tlet currentExpectedPress = remainingExpectedPresses[0]\n\n\t\t\tlet matches = matchKeyBindingPress(event, currentExpectedPress)\n\n\t\t\tif (!matches) {\n\t\t\t\t// Modifier keydown events shouldn't break sequences\n\t\t\t\t// Note: This works because:\n\t\t\t\t// - non-modifiers will always return false\n\t\t\t\t// - if the current keypress is a modifier then it will return true when we check its state\n\t\t\t\t// MDN: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState\n\t\t\t\tif (!getModifierState(event, event.key)) {\n\t\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\t}\n\t\t\t} else if (remainingExpectedPresses.length > 1) {\n\t\t\t\tpossibleMatches.set(sequence, remainingExpectedPresses.slice(1))\n\t\t\t} else {\n\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\tcallback(event)\n\t\t\t}\n\t\t})\n\n\t\tif (timer) {\n\t\t\tclearTimeout(timer)\n\t\t}\n\n\t\ttimer = setTimeout(possibleMatches.clear.bind(possibleMatches), timeout)\n\t}\n}\n\n/**\n * Subscribes to keybindings.\n *\n * Returns an unsubscribe method.\n *\n * @example\n * ```js\n * import { tinykeys } from \"../src/tinykeys\"\n *\n * tinykeys(window, {\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n * ```\n */\nexport function tinykeys(\n\ttarget: Window | HTMLElement,\n\tkeyBindingMap: KeyBindingMap,\n\t{ event = DEFAULT_EVENT, capture, timeout }: KeyBindingOptions = {},\n): () => void {\n\tlet onKeyEvent = createKeybindingsHandler(keyBindingMap, { timeout })\n\ttarget.addEventListener(event, onKeyEvent, capture)\n\treturn () => {\n\t\ttarget.removeEventListener(event, onKeyEvent, capture)\n\t}\n}\n"],"names":["KEYBINDING_MODIFIER_KEYS","PLATFORM","navigator","platform","APPLE_DEVICE","test","MOD","ALT_GRAPH_ALIASES","getModifierState","event","mod","includes","parseKeybinding","str","trim","split","map","press","mods","key","pop","match","RegExp","matchKeyBindingPress","_ref","code","toUpperCase","find","createKeybindingsHandler","keyBindingMap","options","timeout","_options$timeout","keyBindings","Object","keys","possibleMatches","Map","timer","KeyboardEvent","forEach","keyBinding","sequence","callback","remainingExpectedPresses","get","length","set","slice","clearTimeout","setTimeout","clear","bind","target","_temp","_ref2$event","_ref2","capture","onKeyEvent","addEventListener","removeEventListener"],"mappings":"kOA2CA,IAAIA,EAA2B,CAAC,QAAS,OAAQ,MAAO,WAiBpDC,EAAgC,iBAAdC,UAAyBA,UAAUC,SAAW,GAChEC,EAAe,uBAAuBC,KAAKJ,GAK3CK,EAAMF,EAAe,OAAS,UAU9BG,EACU,UAAbN,EAAuB,CAAC,UAAW,OAASG,EAAe,CAAC,OAAS,GAMtE,SAASI,EAAiBC,EAAsBC,GAC/C,MAAyC,mBAA3BD,EAAMD,mBACjBC,EAAMD,iBAAiBE,IACtBH,EAAkBI,SAASD,IAAQD,EAAMD,iBAAiB,sBAc/CI,EAAgBC,GAC/B,OAAOA,EACLC,OACAC,MAAM,KACNC,IAAI,SAAAC,GACJ,IAAIC,EAAOD,EAAMF,MAAM,QACnBI,EAAuBD,EAAKE,MAC5BC,EAAQF,EAAIE,MAAM,cAKtB,OAJIA,IACHF,EAAM,IAAIG,cAAcD,EAAM,QAAQ,OAGhC,CADPH,EAAOA,EAAKF,IAAI,SAAAN,SAAgB,SAARA,EAAiBJ,EAAMI,IACjCS,cAODI,EACfd,EAAoBe,OACnBN,EAAIM,KAAEL,EAAGK,KAGV,SAKEL,aAAeG,QAAWH,EAAId,KAAKI,EAAMU,OAAQA,EAAId,KAAKI,EAAMgB,MAC/DN,EAAIO,gBAAkBjB,EAAMU,IAAIO,eACjCP,IAAQV,EAAMgB,OAIfP,EAAKS,KAAK,SAAAjB,GACT,OAAQF,EAAiBC,EAAOC,MAMjCV,EAAyB2B,KAAK,SAAAjB,GAC7B,OAAQQ,EAAKP,SAASD,IAAQS,IAAQT,GAAOF,EAAiBC,EAAOC,eA2BxDkB,EACfC,EACAC,kBAAAA,IAAAA,EAAoC,IAEpC,IAAIC,SAAOC,EAAGF,EAAQC,SAAOC,EA7HR,IA+HjBC,EAAcC,OAAOC,KAAKN,GAAeb,IAAI,SAAAG,GAChD,MAAO,CAACP,EAAgBO,GAAMU,EAAcV,MAGzCiB,EAAkB,IAAIC,IACtBC,EAAuB,KAE3B,gBAAO7B,GAIAA,aAAiB8B,gBAIvBN,EAAYO,QAAQ,SAAAC,GACnB,IAAIC,EAAWD,EAAW,GACtBE,EAAWF,EAAW,GAGtBG,EADOR,EAAgBS,IAAIH,IACcA,EAG/BnB,EAAqBd,EAFRmC,EAAyB,IAazCA,EAAyBE,OAAS,EAC5CV,EAAgBW,IAAIL,EAAUE,EAAyBI,MAAM,KAE7DZ,SAAuBM,GACvBC,EAASlC,IAPJD,EAAiBC,EAAOA,EAAMU,MAClCiB,SAAuBM,KAUtBJ,GACHW,aAAaX,GAGdA,EAAQY,WAAWd,EAAgBe,MAAMC,KAAKhB,GAAkBL,mGA2BjEsB,EACAxB,EAA4ByB,oBACqC,GAAEA,EAAAC,EAAAC,EAAjE/C,MAAAA,WAAK8C,EArMY,UAqMIA,EAAEE,EAAOD,EAAPC,QAErBC,EAAa9B,EAAyBC,EAAe,CAAEE,QAFlByB,EAAPzB,UAIlC,OADAsB,EAAOM,iBAAiBlD,EAAOiD,EAAYD,cAE1CJ,EAAOO,oBAAoBnD,EAAOiD,EAAYD"}
+{"version":3,"file":"tinykeys.umd.js","names":[],"sources":["../src/tinykeys.ts"],"sourcesContent":["/**\n * A single press of a keybinding sequence.\n */\nexport type KeybindingPress = readonly [\n\trequiredModifiers: ReadonlyArray<string>,\n\toptionalModifiers: ReadonlyArray<string>,\n\tkey: string | RegExp,\n]\n\n/**\n * Keyboard event callback fired when keybinding is triggered.\n */\nexport type KeybindingHandler = (event: KeyboardEvent) => void\n\n/**\n * A map of keybinding strings to event handlers.\n */\nexport type KeybindingsMap = Record<string, KeybindingHandler>\n\n/**\n * Predicate that returns true if a keyboard event should be ignored.\n */\nexport type KeybindingFilter = (event: KeyboardEvent) => boolean\n\nexport interface KeybindingHandlerOptions {\n\t/**\n\t * Keybinding sequences will wait this long between key presses before\n\t * cancelling (default: 1000).\n\t *\n\t * **Note:** Setting this value too low (i.e. `300`) will be too fast for many\n\t * of your users.\n\t */\n\ttimeout?: number\n\n\t/**\n\t * Customize the behavior of which keyboard events will be ignored/skipped.\n\t *\n\t * By default this uses the behavior of {@link defaultKeybindingsHandlerIgnore}.\n\t *\n\t * @example Allow all events\n\t * ```tsx\n\t * tinykeys(window, {...}, {\n\t *   ignore: () => false\n\t * })\n\t * ```\n\t *\n\t * @example Extend the default ignore\n\t * ```tsx\n\t * tinykeys(window, {...}, {\n\t *   ignore: event => {\n\t *     return (\n\t *       // Also ignore events inside a dialog\n\t *       event.target.closest(\"dialog\") != null &&\n\t *       defaultKeybindingsHandlerIgnore(event)\n\t *     );\n\t *   }\n\t * })\n\t * ```\n\t */\n\tignore?: KeybindingFilter\n}\n\n/**\n * Options to configure the behavior of keybindings.\n */\nexport interface KeybindingOptions extends KeybindingHandlerOptions {\n\t/**\n\t * Key presses will listen to this event (default: \"keydown\").\n\t */\n\tevent?: \"keydown\" | \"keyup\"\n\n\t/**\n\t * Key presses will use a capture listener (default: false)\n\t */\n\tcapture?: boolean\n}\n\n/**\n * These are the modifier keys that change the meaning of keybindings.\n *\n * Note: Ignoring \"AltGraph\" because it is covered by the others.\n */\nlet KEYBINDING_MODIFIER_KEYS = [\"Shift\", \"Meta\", \"Alt\", \"Control\"]\n\n/**\n * Keybinding sequences should timeout if individual key presses are more than\n * 1s apart by default.\n */\nlet DEFAULT_TIMEOUT = 1000\n\n/**\n * Keybinding sequences should bind to this event by default.\n */\nlet DEFAULT_EVENT = \"keydown\" as const\n\n/**\n * Platform detection code.\n * @see https://github.com/jamiebuilds/tinykeys/issues/184\n */\nlet PLATFORM = typeof navigator === \"object\" ? navigator.platform : \"\"\nlet APPLE_DEVICE = /Mac|iPod|iPhone|iPad/.test(PLATFORM)\n\n/**\n * An alias for creating platform-specific keybinding aliases.\n */\nlet MOD = APPLE_DEVICE ? \"Meta\" : \"Control\"\n\n/**\n * Meaning of `AltGraph`, from MDN:\n * - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed\n * - Mac: ⌥ Option key pressed\n * - Linux: Level 3 Shift key (or Level 5 Shift key) pressed\n * - Android: Not supported\n * @see https://github.com/jamiebuilds/tinykeys/issues/185\n */\nlet ALT_GRAPH_ALIASES = PLATFORM === \"Win32\" ? [\"Control\", \"Alt\"] : [\"Alt\"]\n\n/**\n * Ensure and stop any event that isn't a full keyboard event.\n * Autocomplete option navigation and selection would fire an Event,\n * instead of the expected KeyboardEvent\n */\nfunction isKeyboardEvent(\n\tevent: Partial<KeyboardEvent>,\n): event is KeyboardEvent {\n\treturn !!(event.key && event.code && event.getModifierState)\n}\n\n/**\n * Ignores keyboard events from contenteditable and form elements unless they\n * are the current target.\n */\nexport function defaultKeybindingsHandlerIgnore(event: KeyboardEvent) {\n\tlet target = event.target as HTMLElement\n\treturn (\n\t\t// Always ignore repeated keyboard events\n\t\tevent.repeat ||\n\t\t// Always ignore keyboard events during composition input\n\t\tevent.isComposing ||\n\t\t// Always allow the current target\n\t\t(target !== event.currentTarget &&\n\t\t\t// Ignore contenteditable and form elements\n\t\t\ttarget.matches(\"[contenteditable],input,select,textarea\"))\n\t)\n}\n\n/**\n * There's a bug in Chrome that causes event.getModifierState not to exist on\n * KeyboardEvent's for F1/F2/etc keys.\n */\nfunction getModifierState(event: KeyboardEvent, mod: string) {\n\treturn typeof event.getModifierState === \"function\"\n\t\t? event.getModifierState(mod) ||\n\t\t\t\t(ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState(\"AltGraph\"))\n\t\t: false\n}\n\n/**\n * Parses a keybinding string into its parts.\n *\n * ```\n * grammar    = `<sequence>`\n * <sequence> = `<press> <press> <press> ...`\n * <press>    = `<key>` or `<mods>+<key>`\n * <mods>     = `<mod>+<mod>+...`\n * <mod>      = `<modifier>` (required) or `[<modifier>]` (optional)\n * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)\n * <key>      = `(<regex>)` -> `/^(?:<regex>)$/iy` (case-insensitive)\n * ```\n */\nexport function parseKeybinding(str: string): KeybindingPress[] {\n\treturn str\n\t\t.trim()\n\t\t.split(\" \")\n\t\t.map(press => {\n\t\t\tlet parts = press.split(/(?<=\\w|\\])\\+/)\n\n\t\t\tlet last: string | RegExp = parts.pop() as string\n\t\t\tlet regex = last.match(/^\\((.+)\\)$/)\n\t\t\tlet key = regex ? new RegExp(`^(?:${regex[1]})$`, \"iv\") : last\n\n\t\t\tlet requiredModifiers: string[] = []\n\t\t\tlet optionalModifiers: string[] = []\n\n\t\t\tfor (const part of parts) {\n\t\t\t\tlet optional = part.match(/^\\[(.*)\\]$/)\n\t\t\t\tlet mod = optional?.[1] ?? part\n\t\t\t\tmod = mod === \"$mod\" ? MOD : mod\n\t\t\t\tif (optional) {\n\t\t\t\t\toptionalModifiers.push(mod)\n\t\t\t\t} else {\n\t\t\t\t\trequiredModifiers.push(mod)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn [requiredModifiers, optionalModifiers, key]\n\t\t})\n}\n\n/**\n * This tells us if a single keyboard event matches a single keybinding press.\n */\nexport function matchKeybindingPress(\n\tevent: KeyboardEvent,\n\t[requiredModifiers, optionalModifiers, key]: KeybindingPress,\n): boolean {\n\tconst hasAltGraph = requiredModifiers.includes(\"AltGraph\")\n\t// prettier-ignore\n\treturn !(\n\t\t// Allow either the `event.key` or the `event.code`\n\t\t// MDN event.key: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n\t\t// MDN event.code: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code\n\t\t(\n\t\t\tkey instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) :\n\t\t\t(key.toUpperCase() !== event.key.toUpperCase() &&\n\t\t\tkey !== event.code)\n\t\t) ||\n\n\t\t// Ensure all required modifiers in the keybinding are pressed.\n\t\trequiredModifiers.find(mod => {\n\t\t\treturn !getModifierState(event, mod)\n\t\t}) ||\n\n\t\t// KEYBINDING_MODIFIER_KEYS (Shift/Control/etc) change the meaning of a\n\t\t// keybinding. So if they are pressed but aren't part of the current\n\t\t// keybinding press, then we don't have a match.\n\t\tKEYBINDING_MODIFIER_KEYS.find(mod => {\n\t\t\treturn (\n\t\t\t\t!requiredModifiers.includes(mod) &&\n\t\t\t\t!optionalModifiers.includes(mod) &&\n\t\t\t\tkey !== mod &&\n\t\t\t\tgetModifierState(event, mod) &&\n\t\t\t\t// When AltGraph is required, its alias modifiers (e.g. Alt, Control)\n\t\t\t\t// being active is expected — don't treat them as unexpected modifiers.\n\t\t\t\t!(hasAltGraph && ALT_GRAPH_ALIASES.includes(mod))\n\t\t\t);\n\t\t})\n\t)\n}\n\n/**\n * Creates an event listener for handling keybindings.\n *\n * @example\n * ```js\n * import { createKeybindingsHandler } from \"../src/keybindings\"\n *\n * let handler = createKeybindingsHandler({\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n *\n * window.addEventListener(\"keydown\", handler)\n * ```\n */\nexport function createKeybindingsHandler(\n\tkeybindingsMap: KeybindingsMap,\n\toptions: KeybindingHandlerOptions = {},\n): EventListener {\n\tlet timeout = options.timeout ?? DEFAULT_TIMEOUT\n\tlet ignore = options.ignore ?? defaultKeybindingsHandlerIgnore\n\n\tlet keybindings = Object.keys(keybindingsMap).map(input => {\n\t\treturn [input, parseKeybinding(input), keybindingsMap[input]] as const\n\t})\n\n\tlet pending = new Map<string, KeybindingPress[]>()\n\tlet timer: number | null = null\n\n\treturn event => {\n\t\tif (!isKeyboardEvent(event) || ignore(event)) {\n\t\t\treturn\n\t\t}\n\n\t\tlet conflicts: Array<string> = []\n\t\tfor (let [input, sequence, handler] of keybindings) {\n\t\t\tlet prev = pending.get(input)\n\t\t\tlet expected = prev ? prev : sequence\n\t\t\tlet [current, ...rest] = expected\n\n\t\t\tlet matches = matchKeybindingPress(event, current)\n\n\t\t\tif (!matches) {\n\t\t\t\t// Modifier keydown events shouldn't break sequences\n\t\t\t\t// Note: This works because:\n\t\t\t\t// - non-modifiers will always return false\n\t\t\t\t// - if the current keypress is a modifier then it will return true when we check its state\n\t\t\t\t// MDN: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState\n\t\t\t\tif (!getModifierState(event, event.key)) {\n\t\t\t\t\tpending.delete(input)\n\t\t\t\t}\n\t\t\t} else if (rest.length > 0) {\n\t\t\t\tpending.set(input, rest)\n\t\t\t\tconflicts.push(input)\n\t\t\t} else {\n\t\t\t\tpending.delete(input)\n\t\t\t\tif (conflicts.length) {\n\t\t\t\t\tconsole.warn(\n\t\t\t\t\t\t`tinykeys: Conflict found, \"${input}\" did not fire, waiting for:`,\n\t\t\t\t\t\tconflicts,\n\t\t\t\t\t)\n\t\t\t\t} else {\n\t\t\t\t\thandler(event)\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (timer) {\n\t\t\tclearTimeout(timer)\n\t\t}\n\n\t\ttimer = setTimeout(() => pending.clear(), timeout)\n\t}\n}\n\n/**\n * Subscribes to keybindings.\n *\n * Returns an unsubscribe method.\n *\n * @example\n * ```js\n * import { tinykeys } from \"../src/tinykeys\"\n *\n * tinykeys(window, {\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n * ```\n */\nexport function tinykeys(\n\ttarget: Window | HTMLElement,\n\tkeybindingMap: KeybindingsMap,\n\toptions: KeybindingOptions = {},\n): () => void {\n\tlet event = options.event ?? DEFAULT_EVENT\n\tlet onKeyEvent = createKeybindingsHandler(keybindingMap, options)\n\ttarget.addEventListener(event, onKeyEvent, options.capture)\n\treturn () => {\n\t\ttarget.removeEventListener(event, onKeyEvent, options.capture)\n\t}\n}\n"],"mappings":"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"}

package/package.json

@@ -1,25 +1,35 @@
 {
   "name": "tinykeys",
-  "version": "3.1.0",
-  "description": "A tiny (~650 B) & modern library for keybindings.",
+  "version": "4.0.0",
+  "description": "A tiny (~1KB) & modern library for keybindings.",
   "author": "Jamie Kyle <me@thejameskyle.com>",
   "license": "MIT",
   "repository": "jamiebuilds/tinykeys",
+  "type": "module",
+  "sideEffects": false,
   "source": "src/tinykeys.ts",
-  "main": "dist/tinykeys.js",
-  "module": "dist/tinykeys.module.js",
+  "main": "dist/tinykeys.cjs",
+  "module": "dist/tinykeys.mjs",
   "unpkg": "dist/tinykeys.umd.js",
-  "types": "dist/tinykeys.d.ts",
+  "types": "dist/tinykeys.d.mts",
   "files": [
     "dist"
   ],
   "exports": {
     ".": {
-      "types": "./dist/tinykeys.d.ts",
-      "import": "./dist/tinykeys.module.js",
-      "require": "./dist/tinykeys.js"
+      "import": {
+        "types": "./dist/tinykeys.d.mts",
+        "default": "./dist/tinykeys.mjs"
+      },
+      "require": {
+        "types": "./dist/tinykeys.d.cts",
+        "default": "./dist/tinykeys.cjs"
+      }
     }
   },
+  "engines": {
+    "node": ">=22"
+  },
   "keywords": [
     "key",
     "keys",
@@ -40,48 +50,45 @@
     "shortcuts"
   ],
   "scripts": {
-    "format": "prettier --write '**'",
+    "format": "prettier --write .",
     "check": "npm run -s check:types && npm run -s lint && npm run -s check:format",
     "check:types": "tsc --noEmit",
-    "check:lint": "eslint '**'",
-    "check:format": "prettier --check '**'",
-    "test": "TS_NODE_PROJECT=./tsconfig.test.json nyc --reporter=lcov --reporter=text-summary ava",
-    "build": "rm -rf dist && microbundle --inline none",
-    "build:example": "rm -rf example-dist && parcel build example/index.html -d example-dist --public-url ./",
-    "start": "rm -rf example-dist && parcel example/index.html -d example-dist",
+    "check:lint": "eslint .",
+    "check:format": "prettier --check .",
+    "build": "tsdown",
+    "build:example": "vite build ./example --base ./",
+    "test": "vitest",
+    "start": "vite example --base ./",
     "precommit": "lint-staged",
     "prepublishOnly": "npm run -s build"
   },
   "devDependencies": {
-    "@types/canvas-confetti": "^1.6.4",
-    "@typescript-eslint/eslint-plugin": "^4.0.0",
-    "@typescript-eslint/parser": "^3.7.1",
-    "ava": "^3.11.0",
-    "canvas-confetti": "^1.9.3",
-    "eslint": "^7.5.0",
-    "eslint-plugin-ava": "^12.0.0",
-    "husky": "^6.0.0",
-    "lint-staged": "^11.0.0",
-    "microbundle": "^0.13.0",
-    "nyc": "^15.1.0",
-    "parcel": "^1.12.4",
-    "prettier": "^2.0.5",
-    "ts-node": "^9.0.0",
-    "typescript": "^4.0.2"
+    "@arethetypeswrong/core": "^0.18.2",
+    "@eslint/js": "^10.0.1",
+    "@types/canvas-confetti": "^1.9.0",
+    "@vitest/browser-playwright": "^4.1.6",
+    "canvas-confetti": "^1.9.4",
+    "eslint": "^10.4.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.5",
+    "prettier": "^3.8.3",
+    "prettier-plugin-tailwindcss": "^0.8.0",
+    "publint": "^0.3.21",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.4",
+    "vite": "^8.0.13",
+    "vitest": "^4.1.6"
+  },
+  "overrides": {
+    "@arethetypeswrong/core": {
+      "fflate": "0.8.2"
+    }
   },
   "lint-staged": {
     "*": [
       "prettier --write",
       "git add"
     ]
-  },
-  "ava": {
-    "extensions": [
-      "ts",
-      "tsx"
-    ],
-    "require": [
-      "ts-node/register"
-    ]
   }
 }

package/dist/tinykeys.d.ts

@@ -1,94 +0,0 @@
-/**
- * A single press of a keybinding sequence
- */
-export declare type KeyBindingPress = [mods: string[], key: string | RegExp];
-/**
- * A map of keybinding strings to event handlers.
- */
-export interface KeyBindingMap {
-    [keybinding: string]: (event: KeyboardEvent) => void;
-}
-export interface KeyBindingHandlerOptions {
-    /**
-     * Keybinding sequences will wait this long between key presses before
-     * cancelling (default: 1000).
-     *
-     * **Note:** Setting this value too low (i.e. `300`) will be too fast for many
-     * of your users.
-     */
-    timeout?: number;
-}
-/**
- * Options to configure the behavior of keybindings.
- */
-export interface KeyBindingOptions extends KeyBindingHandlerOptions {
-    /**
-     * Key presses will listen to this event (default: "keydown").
-     */
-    event?: "keydown" | "keyup";
-    /**
-     * Key presses will use a capture listener (default: false)
-     */
-    capture?: boolean;
-}
-/**
- * Parses a "Key Binding String" into its parts
- *
- * grammar    = `<sequence>`
- * <sequence> = `<press> <press> <press> ...`
- * <press>    = `<key>` or `<mods>+<key>`
- * <mods>     = `<mod>+<mod>+...`
- * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)
- * <key>      = `(<regex>)` -> `/^(?:<regex>)$/` (case-sensitive)
- */
-export declare function parseKeybinding(str: string): KeyBindingPress[];
-/**
- * This tells us if a single keyboard event matches a single keybinding press.
- */
-export declare function matchKeyBindingPress(event: KeyboardEvent, [mods, key]: KeyBindingPress): boolean;
-/**
- * Creates an event listener for handling keybindings.
- *
- * @example
- * ```js
- * import { createKeybindingsHandler } from "../src/keybindings"
- *
- * let handler = createKeybindingsHandler({
- * 	"Shift+d": () => {
- * 		alert("The 'Shift' and 'd' keys were pressed at the same time")
- * 	},
- * 	"y e e t": () => {
- * 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
- * 	},
- * 	"$mod+d": () => {
- * 		alert("Either 'Control+d' or 'Meta+d' were pressed")
- * 	},
- * })
- *
- * window.addEvenListener("keydown", handler)
- * ```
- */
-export declare function createKeybindingsHandler(keyBindingMap: KeyBindingMap, options?: KeyBindingHandlerOptions): EventListener;
-/**
- * Subscribes to keybindings.
- *
- * Returns an unsubscribe method.
- *
- * @example
- * ```js
- * import { tinykeys } from "../src/tinykeys"
- *
- * tinykeys(window, {
- * 	"Shift+d": () => {
- * 		alert("The 'Shift' and 'd' keys were pressed at the same time")
- * 	},
- * 	"y e e t": () => {
- * 		alert("The keys 'y', 'e', 'e', and 't' were pressed in order")
- * 	},
- * 	"$mod+d": () => {
- * 		alert("Either 'Control+d' or 'Meta+d' were pressed")
- * 	},
- * })
- * ```
- */
-export declare function tinykeys(target: Window | HTMLElement, keyBindingMap: KeyBindingMap, { event, capture, timeout }?: KeyBindingOptions): () => void;

package/dist/tinykeys.js

@@ -1,2 +0,0 @@
-var e=["Shift","Meta","Alt","Control"],t="object"==typeof navigator?navigator.platform:"",n=/Mac|iPod|iPhone|iPad/.test(t),i=n?"Meta":"Control",r="Win32"===t?["Control","Alt"]:n?["Alt"]:[];function o(e,t){return"function"==typeof e.getModifierState&&(e.getModifierState(t)||r.includes(t)&&e.getModifierState("AltGraph"))}function a(e){return e.trim().split(" ").map(function(e){var t=e.split(/\b\+/),n=t.pop(),r=n.match(/^\((.+)\)$/);return r&&(n=new RegExp("^(?:"+r[1]+")$","iv")),[t=t.map(function(e){return"$mod"===e?i:e}),n]})}function u(t,n){var i=n[0],r=n[1];return!((r instanceof RegExp?!r.test(t.key)&&!r.test(t.code):r.toUpperCase()!==t.key.toUpperCase()&&r!==t.code)||i.find(function(e){return!o(t,e)})||e.find(function(e){return!i.includes(e)&&r!==e&&o(t,e)}))}function c(e,t){var n;void 0===t&&(t={});var i=null!=(n=t.timeout)?n:1e3,r=Object.keys(e).map(function(t){return[a(t),e[t]]}),c=new Map,d=null;return function(e){e instanceof KeyboardEvent&&(r.forEach(function(t){var n=t[0],i=t[1],r=c.get(n)||n;u(e,r[0])?r.length>1?c.set(n,r.slice(1)):(c.delete(n),i(e)):o(e,e.key)||c.delete(n)}),d&&clearTimeout(d),d=setTimeout(c.clear.bind(c),i))}}exports.createKeybindingsHandler=c,exports.matchKeyBindingPress=u,exports.parseKeybinding=a,exports.tinykeys=function(e,t,n){var i=void 0===n?{}:n,r=i.event,o=void 0===r?"keydown":r,a=i.capture,u=c(t,{timeout:i.timeout});return e.addEventListener(o,u,a),function(){e.removeEventListener(o,u,a)}};
-//# sourceMappingURL=tinykeys.js.map

package/dist/tinykeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tinykeys.js","sources":["../src/tinykeys.ts"],"sourcesContent":["/**\n * A single press of a keybinding sequence\n */\nexport type KeyBindingPress = [mods: string[], key: string | RegExp]\n\n/**\n * A map of keybinding strings to event handlers.\n */\nexport interface KeyBindingMap {\n\t[keybinding: string]: (event: KeyboardEvent) => void\n}\n\nexport interface KeyBindingHandlerOptions {\n\t/**\n\t * Keybinding sequences will wait this long between key presses before\n\t * cancelling (default: 1000).\n\t *\n\t * **Note:** Setting this value too low (i.e. `300`) will be too fast for many\n\t * of your users.\n\t */\n\ttimeout?: number\n}\n\n/**\n * Options to configure the behavior of keybindings.\n */\nexport interface KeyBindingOptions extends KeyBindingHandlerOptions {\n\t/**\n\t * Key presses will listen to this event (default: \"keydown\").\n\t */\n\tevent?: \"keydown\" | \"keyup\"\n\n\t/**\n\t * Key presses will use a capture listener (default: false)\n\t */\n\tcapture?: boolean\n}\n\n/**\n * These are the modifier keys that change the meaning of keybindings.\n *\n * Note: Ignoring \"AltGraph\" because it is covered by the others.\n */\nlet KEYBINDING_MODIFIER_KEYS = [\"Shift\", \"Meta\", \"Alt\", \"Control\"]\n\n/**\n * Keybinding sequences should timeout if individual key presses are more than\n * 1s apart by default.\n */\nlet DEFAULT_TIMEOUT = 1000\n\n/**\n * Keybinding sequences should bind to this event by default.\n */\nlet DEFAULT_EVENT = \"keydown\" as const\n\n/**\n * Platform detection code.\n * @see https://github.com/jamiebuilds/tinykeys/issues/184\n */\nlet PLATFORM = typeof navigator === \"object\" ? navigator.platform : \"\"\nlet APPLE_DEVICE = /Mac|iPod|iPhone|iPad/.test(PLATFORM)\n\n/**\n * An alias for creating platform-specific keybinding aliases.\n */\nlet MOD = APPLE_DEVICE ? \"Meta\" : \"Control\"\n\n/**\n * Meaning of `AltGraph`, from MDN:\n * - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed\n * - Mac: ⌥ Option key pressed\n * - Linux: Level 3 Shift key (or Level 5 Shift key) pressed\n * - Android: Not supported\n * @see https://github.com/jamiebuilds/tinykeys/issues/185\n */\nlet ALT_GRAPH_ALIASES =\n\tPLATFORM === \"Win32\" ? [\"Control\", \"Alt\"] : APPLE_DEVICE ? [\"Alt\"] : []\n\n/**\n * There's a bug in Chrome that causes event.getModifierState not to exist on\n * KeyboardEvent's for F1/F2/etc keys.\n */\nfunction getModifierState(event: KeyboardEvent, mod: string) {\n\treturn typeof event.getModifierState === \"function\"\n\t\t? event.getModifierState(mod) ||\n\t\t\t\t(ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState(\"AltGraph\"))\n\t\t: false\n}\n\n/**\n * Parses a \"Key Binding String\" into its parts\n *\n * grammar    = `<sequence>`\n * <sequence> = `<press> <press> <press> ...`\n * <press>    = `<key>` or `<mods>+<key>`\n * <mods>     = `<mod>+<mod>+...`\n * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)\n * <key>      = `(<regex>)` -> `/^(?:<regex>)$/` (case-sensitive)\n */\nexport function parseKeybinding(str: string): KeyBindingPress[] {\n\treturn str\n\t\t.trim()\n\t\t.split(\" \")\n\t\t.map(press => {\n\t\t\tlet mods = press.split(/\\b\\+/)\n\t\t\tlet key: string | RegExp = mods.pop() as string\n\t\t\tlet match = key.match(/^\\((.+)\\)$/)\n\t\t\tif (match) {\n\t\t\t\tkey = new RegExp(`^(?:${match[1]})$`, \"iv\")\n\t\t\t}\n\t\t\tmods = mods.map(mod => (mod === \"$mod\" ? MOD : mod))\n\t\t\treturn [mods, key]\n\t\t})\n}\n\n/**\n * This tells us if a single keyboard event matches a single keybinding press.\n */\nexport function matchKeyBindingPress(\n\tevent: KeyboardEvent,\n\t[mods, key]: KeyBindingPress,\n): boolean {\n\t// prettier-ignore\n\treturn !(\n\t\t// Allow either the `event.key` or the `event.code`\n\t\t// MDN event.key: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n\t\t// MDN event.code: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code\n\t\t(\n\t\t\tkey instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) :\n\t\t\t(key.toUpperCase() !== event.key.toUpperCase() &&\n\t\t\tkey !== event.code)\n\t\t) ||\n\n\t\t// Ensure all the modifiers in the keybinding are pressed.\n\t\tmods.find(mod => {\n\t\t\treturn !getModifierState(event, mod)\n\t\t}) ||\n\n\t\t// KEYBINDING_MODIFIER_KEYS (Shift/Control/etc) change the meaning of a\n\t\t// keybinding. So if they are pressed but aren't part of the current\n\t\t// keybinding press, then we don't have a match.\n\t\tKEYBINDING_MODIFIER_KEYS.find(mod => {\n\t\t\treturn !mods.includes(mod) && key !== mod && getModifierState(event, mod)\n\t\t})\n\t)\n}\n\n/**\n * Creates an event listener for handling keybindings.\n *\n * @example\n * ```js\n * import { createKeybindingsHandler } from \"../src/keybindings\"\n *\n * let handler = createKeybindingsHandler({\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n *\n * window.addEvenListener(\"keydown\", handler)\n * ```\n */\nexport function createKeybindingsHandler(\n\tkeyBindingMap: KeyBindingMap,\n\toptions: KeyBindingHandlerOptions = {},\n): EventListener {\n\tlet timeout = options.timeout ?? DEFAULT_TIMEOUT\n\n\tlet keyBindings = Object.keys(keyBindingMap).map(key => {\n\t\treturn [parseKeybinding(key), keyBindingMap[key]] as const\n\t})\n\n\tlet possibleMatches = new Map<KeyBindingPress[], KeyBindingPress[]>()\n\tlet timer: number | null = null\n\n\treturn event => {\n\t\t// Ensure and stop any event that isn't a full keyboard event.\n\t\t// Autocomplete option navigation and selection would fire a instanceof Event,\n\t\t// instead of the expected KeyboardEvent\n\t\tif (!(event instanceof KeyboardEvent)) {\n\t\t\treturn\n\t\t}\n\n\t\tkeyBindings.forEach(keyBinding => {\n\t\t\tlet sequence = keyBinding[0]\n\t\t\tlet callback = keyBinding[1]\n\n\t\t\tlet prev = possibleMatches.get(sequence)\n\t\t\tlet remainingExpectedPresses = prev ? prev : sequence\n\t\t\tlet currentExpectedPress = remainingExpectedPresses[0]\n\n\t\t\tlet matches = matchKeyBindingPress(event, currentExpectedPress)\n\n\t\t\tif (!matches) {\n\t\t\t\t// Modifier keydown events shouldn't break sequences\n\t\t\t\t// Note: This works because:\n\t\t\t\t// - non-modifiers will always return false\n\t\t\t\t// - if the current keypress is a modifier then it will return true when we check its state\n\t\t\t\t// MDN: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState\n\t\t\t\tif (!getModifierState(event, event.key)) {\n\t\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\t}\n\t\t\t} else if (remainingExpectedPresses.length > 1) {\n\t\t\t\tpossibleMatches.set(sequence, remainingExpectedPresses.slice(1))\n\t\t\t} else {\n\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\tcallback(event)\n\t\t\t}\n\t\t})\n\n\t\tif (timer) {\n\t\t\tclearTimeout(timer)\n\t\t}\n\n\t\ttimer = setTimeout(possibleMatches.clear.bind(possibleMatches), timeout)\n\t}\n}\n\n/**\n * Subscribes to keybindings.\n *\n * Returns an unsubscribe method.\n *\n * @example\n * ```js\n * import { tinykeys } from \"../src/tinykeys\"\n *\n * tinykeys(window, {\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n * ```\n */\nexport function tinykeys(\n\ttarget: Window | HTMLElement,\n\tkeyBindingMap: KeyBindingMap,\n\t{ event = DEFAULT_EVENT, capture, timeout }: KeyBindingOptions = {},\n): () => void {\n\tlet onKeyEvent = createKeybindingsHandler(keyBindingMap, { timeout })\n\ttarget.addEventListener(event, onKeyEvent, capture)\n\treturn () => {\n\t\ttarget.removeEventListener(event, onKeyEvent, capture)\n\t}\n}\n"],"names":["KEYBINDING_MODIFIER_KEYS","PLATFORM","navigator","platform","APPLE_DEVICE","test","MOD","ALT_GRAPH_ALIASES","getModifierState","event","mod","includes","parseKeybinding","str","trim","split","map","press","mods","key","pop","match","RegExp","matchKeyBindingPress","_ref","code","toUpperCase","find","createKeybindingsHandler","keyBindingMap","options","timeout","_options$timeout","keyBindings","Object","keys","possibleMatches","Map","timer","KeyboardEvent","forEach","keyBinding","sequence","callback","remainingExpectedPresses","get","length","set","slice","clearTimeout","setTimeout","clear","bind","target","_temp","_ref2$event","_ref2","capture","onKeyEvent","addEventListener","removeEventListener"],"mappings":"AA2CA,IAAIA,EAA2B,CAAC,QAAS,OAAQ,MAAO,WAiBpDC,EAAgC,iBAAdC,UAAyBA,UAAUC,SAAW,GAChEC,EAAe,uBAAuBC,KAAKJ,GAK3CK,EAAMF,EAAe,OAAS,UAU9BG,EACU,UAAbN,EAAuB,CAAC,UAAW,OAASG,EAAe,CAAC,OAAS,GAMtE,SAASI,EAAiBC,EAAsBC,GAC/C,MAAyC,mBAA3BD,EAAMD,mBACjBC,EAAMD,iBAAiBE,IACtBH,EAAkBI,SAASD,IAAQD,EAAMD,iBAAiB,sBAc/CI,EAAgBC,GAC/B,OAAOA,EACLC,OACAC,MAAM,KACNC,IAAI,SAAAC,GACJ,IAAIC,EAAOD,EAAMF,MAAM,QACnBI,EAAuBD,EAAKE,MAC5BC,EAAQF,EAAIE,MAAM,cAKtB,OAJIA,IACHF,EAAM,IAAIG,cAAcD,EAAM,QAAQ,OAGhC,CADPH,EAAOA,EAAKF,IAAI,SAAAN,SAAgB,SAARA,EAAiBJ,EAAMI,IACjCS,cAODI,EACfd,EAAoBe,OACnBN,EAAIM,KAAEL,EAAGK,KAGV,SAKEL,aAAeG,QAAWH,EAAId,KAAKI,EAAMU,OAAQA,EAAId,KAAKI,EAAMgB,MAC/DN,EAAIO,gBAAkBjB,EAAMU,IAAIO,eACjCP,IAAQV,EAAMgB,OAIfP,EAAKS,KAAK,SAAAjB,GACT,OAAQF,EAAiBC,EAAOC,MAMjCV,EAAyB2B,KAAK,SAAAjB,GAC7B,OAAQQ,EAAKP,SAASD,IAAQS,IAAQT,GAAOF,EAAiBC,EAAOC,eA2BxDkB,EACfC,EACAC,kBAAAA,IAAAA,EAAoC,IAEpC,IAAIC,SAAOC,EAAGF,EAAQC,SAAOC,EA7HR,IA+HjBC,EAAcC,OAAOC,KAAKN,GAAeb,IAAI,SAAAG,GAChD,MAAO,CAACP,EAAgBO,GAAMU,EAAcV,MAGzCiB,EAAkB,IAAIC,IACtBC,EAAuB,KAE3B,gBAAO7B,GAIAA,aAAiB8B,gBAIvBN,EAAYO,QAAQ,SAAAC,GACnB,IAAIC,EAAWD,EAAW,GACtBE,EAAWF,EAAW,GAGtBG,EADOR,EAAgBS,IAAIH,IACcA,EAG/BnB,EAAqBd,EAFRmC,EAAyB,IAazCA,EAAyBE,OAAS,EAC5CV,EAAgBW,IAAIL,EAAUE,EAAyBI,MAAM,KAE7DZ,SAAuBM,GACvBC,EAASlC,IAPJD,EAAiBC,EAAOA,EAAMU,MAClCiB,SAAuBM,KAUtBJ,GACHW,aAAaX,GAGdA,EAAQY,WAAWd,EAAgBe,MAAMC,KAAKhB,GAAkBL,2HA2BjEsB,EACAxB,EAA4ByB,oBACqC,GAAEA,EAAAC,EAAAC,EAAjE/C,MAAAA,WAAK8C,EArMY,UAqMIA,EAAEE,EAAOD,EAAPC,QAErBC,EAAa9B,EAAyBC,EAAe,CAAEE,QAFlByB,EAAPzB,UAIlC,OADAsB,EAAOM,iBAAiBlD,EAAOiD,EAAYD,cAE1CJ,EAAOO,oBAAoBnD,EAAOiD,EAAYD"}

package/dist/tinykeys.modern.js

@@ -1,2 +0,0 @@
-let e=["Shift","Meta","Alt","Control"],t="object"==typeof navigator?navigator.platform:"",n=/Mac|iPod|iPhone|iPad/.test(t),o=n?"Meta":"Control",i="Win32"===t?["Control","Alt"]:n?["Alt"]:[];function r(e,t){return"function"==typeof e.getModifierState&&(e.getModifierState(t)||i.includes(t)&&e.getModifierState("AltGraph"))}function a(e){return e.trim().split(" ").map(e=>{let t=e.split(/\b\+/),n=t.pop(),i=n.match(/^\((.+)\)$/);return i&&(n=new RegExp(`^(?:${i[1]})$`,"iv")),t=t.map(e=>"$mod"===e?o:e),[t,n]})}function l(t,[n,o]){return!((o instanceof RegExp?!o.test(t.key)&&!o.test(t.code):o.toUpperCase()!==t.key.toUpperCase()&&o!==t.code)||n.find(e=>!r(t,e))||e.find(e=>!n.includes(e)&&o!==e&&r(t,e)))}function u(e,t={}){var n;let o=null!=(n=t.timeout)?n:1e3,i=Object.keys(e).map(t=>[a(t),e[t]]),u=new Map,c=null;return e=>{e instanceof KeyboardEvent&&(i.forEach(t=>{let n=t[0],o=t[1],i=u.get(n)||n;l(e,i[0])?i.length>1?u.set(n,i.slice(1)):(u.delete(n),o(e)):r(e,e.key)||u.delete(n)}),c&&clearTimeout(c),c=setTimeout(u.clear.bind(u),o))}}function c(e,t,{event:n="keydown",capture:o,timeout:i}={}){let r=u(t,{timeout:i});return e.addEventListener(n,r,o),()=>{e.removeEventListener(n,r,o)}}export{u as createKeybindingsHandler,l as matchKeyBindingPress,a as parseKeybinding,c as tinykeys};
-//# sourceMappingURL=tinykeys.modern.js.map

package/dist/tinykeys.modern.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tinykeys.modern.js","sources":["../src/tinykeys.ts"],"sourcesContent":["/**\n * A single press of a keybinding sequence\n */\nexport type KeyBindingPress = [mods: string[], key: string | RegExp]\n\n/**\n * A map of keybinding strings to event handlers.\n */\nexport interface KeyBindingMap {\n\t[keybinding: string]: (event: KeyboardEvent) => void\n}\n\nexport interface KeyBindingHandlerOptions {\n\t/**\n\t * Keybinding sequences will wait this long between key presses before\n\t * cancelling (default: 1000).\n\t *\n\t * **Note:** Setting this value too low (i.e. `300`) will be too fast for many\n\t * of your users.\n\t */\n\ttimeout?: number\n}\n\n/**\n * Options to configure the behavior of keybindings.\n */\nexport interface KeyBindingOptions extends KeyBindingHandlerOptions {\n\t/**\n\t * Key presses will listen to this event (default: \"keydown\").\n\t */\n\tevent?: \"keydown\" | \"keyup\"\n\n\t/**\n\t * Key presses will use a capture listener (default: false)\n\t */\n\tcapture?: boolean\n}\n\n/**\n * These are the modifier keys that change the meaning of keybindings.\n *\n * Note: Ignoring \"AltGraph\" because it is covered by the others.\n */\nlet KEYBINDING_MODIFIER_KEYS = [\"Shift\", \"Meta\", \"Alt\", \"Control\"]\n\n/**\n * Keybinding sequences should timeout if individual key presses are more than\n * 1s apart by default.\n */\nlet DEFAULT_TIMEOUT = 1000\n\n/**\n * Keybinding sequences should bind to this event by default.\n */\nlet DEFAULT_EVENT = \"keydown\" as const\n\n/**\n * Platform detection code.\n * @see https://github.com/jamiebuilds/tinykeys/issues/184\n */\nlet PLATFORM = typeof navigator === \"object\" ? navigator.platform : \"\"\nlet APPLE_DEVICE = /Mac|iPod|iPhone|iPad/.test(PLATFORM)\n\n/**\n * An alias for creating platform-specific keybinding aliases.\n */\nlet MOD = APPLE_DEVICE ? \"Meta\" : \"Control\"\n\n/**\n * Meaning of `AltGraph`, from MDN:\n * - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed\n * - Mac: ⌥ Option key pressed\n * - Linux: Level 3 Shift key (or Level 5 Shift key) pressed\n * - Android: Not supported\n * @see https://github.com/jamiebuilds/tinykeys/issues/185\n */\nlet ALT_GRAPH_ALIASES =\n\tPLATFORM === \"Win32\" ? [\"Control\", \"Alt\"] : APPLE_DEVICE ? [\"Alt\"] : []\n\n/**\n * There's a bug in Chrome that causes event.getModifierState not to exist on\n * KeyboardEvent's for F1/F2/etc keys.\n */\nfunction getModifierState(event: KeyboardEvent, mod: string) {\n\treturn typeof event.getModifierState === \"function\"\n\t\t? event.getModifierState(mod) ||\n\t\t\t\t(ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState(\"AltGraph\"))\n\t\t: false\n}\n\n/**\n * Parses a \"Key Binding String\" into its parts\n *\n * grammar    = `<sequence>`\n * <sequence> = `<press> <press> <press> ...`\n * <press>    = `<key>` or `<mods>+<key>`\n * <mods>     = `<mod>+<mod>+...`\n * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)\n * <key>      = `(<regex>)` -> `/^(?:<regex>)$/` (case-sensitive)\n */\nexport function parseKeybinding(str: string): KeyBindingPress[] {\n\treturn str\n\t\t.trim()\n\t\t.split(\" \")\n\t\t.map(press => {\n\t\t\tlet mods = press.split(/\\b\\+/)\n\t\t\tlet key: string | RegExp = mods.pop() as string\n\t\t\tlet match = key.match(/^\\((.+)\\)$/)\n\t\t\tif (match) {\n\t\t\t\tkey = new RegExp(`^(?:${match[1]})$`, \"iv\")\n\t\t\t}\n\t\t\tmods = mods.map(mod => (mod === \"$mod\" ? MOD : mod))\n\t\t\treturn [mods, key]\n\t\t})\n}\n\n/**\n * This tells us if a single keyboard event matches a single keybinding press.\n */\nexport function matchKeyBindingPress(\n\tevent: KeyboardEvent,\n\t[mods, key]: KeyBindingPress,\n): boolean {\n\t// prettier-ignore\n\treturn !(\n\t\t// Allow either the `event.key` or the `event.code`\n\t\t// MDN event.key: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n\t\t// MDN event.code: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code\n\t\t(\n\t\t\tkey instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) :\n\t\t\t(key.toUpperCase() !== event.key.toUpperCase() &&\n\t\t\tkey !== event.code)\n\t\t) ||\n\n\t\t// Ensure all the modifiers in the keybinding are pressed.\n\t\tmods.find(mod => {\n\t\t\treturn !getModifierState(event, mod)\n\t\t}) ||\n\n\t\t// KEYBINDING_MODIFIER_KEYS (Shift/Control/etc) change the meaning of a\n\t\t// keybinding. So if they are pressed but aren't part of the current\n\t\t// keybinding press, then we don't have a match.\n\t\tKEYBINDING_MODIFIER_KEYS.find(mod => {\n\t\t\treturn !mods.includes(mod) && key !== mod && getModifierState(event, mod)\n\t\t})\n\t)\n}\n\n/**\n * Creates an event listener for handling keybindings.\n *\n * @example\n * ```js\n * import { createKeybindingsHandler } from \"../src/keybindings\"\n *\n * let handler = createKeybindingsHandler({\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n *\n * window.addEvenListener(\"keydown\", handler)\n * ```\n */\nexport function createKeybindingsHandler(\n\tkeyBindingMap: KeyBindingMap,\n\toptions: KeyBindingHandlerOptions = {},\n): EventListener {\n\tlet timeout = options.timeout ?? DEFAULT_TIMEOUT\n\n\tlet keyBindings = Object.keys(keyBindingMap).map(key => {\n\t\treturn [parseKeybinding(key), keyBindingMap[key]] as const\n\t})\n\n\tlet possibleMatches = new Map<KeyBindingPress[], KeyBindingPress[]>()\n\tlet timer: number | null = null\n\n\treturn event => {\n\t\t// Ensure and stop any event that isn't a full keyboard event.\n\t\t// Autocomplete option navigation and selection would fire a instanceof Event,\n\t\t// instead of the expected KeyboardEvent\n\t\tif (!(event instanceof KeyboardEvent)) {\n\t\t\treturn\n\t\t}\n\n\t\tkeyBindings.forEach(keyBinding => {\n\t\t\tlet sequence = keyBinding[0]\n\t\t\tlet callback = keyBinding[1]\n\n\t\t\tlet prev = possibleMatches.get(sequence)\n\t\t\tlet remainingExpectedPresses = prev ? prev : sequence\n\t\t\tlet currentExpectedPress = remainingExpectedPresses[0]\n\n\t\t\tlet matches = matchKeyBindingPress(event, currentExpectedPress)\n\n\t\t\tif (!matches) {\n\t\t\t\t// Modifier keydown events shouldn't break sequences\n\t\t\t\t// Note: This works because:\n\t\t\t\t// - non-modifiers will always return false\n\t\t\t\t// - if the current keypress is a modifier then it will return true when we check its state\n\t\t\t\t// MDN: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState\n\t\t\t\tif (!getModifierState(event, event.key)) {\n\t\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\t}\n\t\t\t} else if (remainingExpectedPresses.length > 1) {\n\t\t\t\tpossibleMatches.set(sequence, remainingExpectedPresses.slice(1))\n\t\t\t} else {\n\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\tcallback(event)\n\t\t\t}\n\t\t})\n\n\t\tif (timer) {\n\t\t\tclearTimeout(timer)\n\t\t}\n\n\t\ttimer = setTimeout(possibleMatches.clear.bind(possibleMatches), timeout)\n\t}\n}\n\n/**\n * Subscribes to keybindings.\n *\n * Returns an unsubscribe method.\n *\n * @example\n * ```js\n * import { tinykeys } from \"../src/tinykeys\"\n *\n * tinykeys(window, {\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n * ```\n */\nexport function tinykeys(\n\ttarget: Window | HTMLElement,\n\tkeyBindingMap: KeyBindingMap,\n\t{ event = DEFAULT_EVENT, capture, timeout }: KeyBindingOptions = {},\n): () => void {\n\tlet onKeyEvent = createKeybindingsHandler(keyBindingMap, { timeout })\n\ttarget.addEventListener(event, onKeyEvent, capture)\n\treturn () => {\n\t\ttarget.removeEventListener(event, onKeyEvent, capture)\n\t}\n}\n"],"names":["KEYBINDING_MODIFIER_KEYS","PLATFORM","navigator","platform","APPLE_DEVICE","test","MOD","ALT_GRAPH_ALIASES","getModifierState","event","mod","includes","parseKeybinding","str","trim","split","map","press","mods","key","pop","match","RegExp","matchKeyBindingPress","code","toUpperCase","find","createKeybindingsHandler","keyBindingMap","options","timeout","_options$timeout","keyBindings","Object","keys","possibleMatches","Map","timer","KeyboardEvent","forEach","keyBinding","sequence","callback","remainingExpectedPresses","get","length","set","slice","delete","clearTimeout","setTimeout","clear","bind","tinykeys","target","capture","onKeyEvent","addEventListener","removeEventListener"],"mappings":"AA2CA,IAAIA,EAA2B,CAAC,QAAS,OAAQ,MAAO,WAiBpDC,EAAgC,iBAAdC,UAAyBA,UAAUC,SAAW,GAChEC,EAAe,uBAAuBC,KAAKJ,GAK3CK,EAAMF,EAAe,OAAS,UAU9BG,EACU,UAAbN,EAAuB,CAAC,UAAW,OAASG,EAAe,CAAC,OAAS,GAMtE,SAASI,EAAiBC,EAAsBC,GAC/C,MAAyC,mBAA3BD,EAAMD,mBACjBC,EAAMD,iBAAiBE,IACtBH,EAAkBI,SAASD,IAAQD,EAAMD,iBAAiB,sBAc/CI,EAAgBC,GAC/B,OAAOA,EACLC,OACAC,MAAM,KACNC,IAAIC,IACJ,IAAIC,EAAOD,EAAMF,MAAM,QACnBI,EAAuBD,EAAKE,MAC5BC,EAAQF,EAAIE,MAAM,cAKtB,OAJIA,IACHF,EAAM,IAAIG,OAAO,OAAOD,EAAM,OAAQ,OAEvCH,EAAOA,EAAKF,IAAIN,GAAgB,SAARA,EAAiBJ,EAAMI,GACxC,CAACQ,EAAMC,cAODI,EACfd,GACCS,EAAMC,IAGP,SAKEA,aAAeG,QAAWH,EAAId,KAAKI,EAAMU,OAAQA,EAAId,KAAKI,EAAMe,MAC/DL,EAAIM,gBAAkBhB,EAAMU,IAAIM,eACjCN,IAAQV,EAAMe,OAIfN,EAAKQ,KAAKhB,IACDF,EAAiBC,EAAOC,KAMjCV,EAAyB0B,KAAKhB,IACrBQ,EAAKP,SAASD,IAAQS,IAAQT,GAAOF,EAAiBC,EAAOC,cA2BxDiB,EACfC,EACAC,EAAoC,UAEpC,IAAIC,SAAOC,EAAGF,EAAQC,SAAOC,EA7HR,IA+HjBC,EAAcC,OAAOC,KAAKN,GAAeZ,IAAIG,GACzC,CAACP,EAAgBO,GAAMS,EAAcT,KAGzCgB,EAAkB,IAAIC,IACtBC,EAAuB,KAE3B,OAAO5B,IAIAA,aAAiB6B,gBAIvBN,EAAYO,QAAQC,IACnB,IAAIC,EAAWD,EAAW,GACtBE,EAAWF,EAAW,GAGtBG,EADOR,EAAgBS,IAAIH,IACcA,EAG/BlB,EAAqBd,EAFRkC,EAAyB,IAazCA,EAAyBE,OAAS,EAC5CV,EAAgBW,IAAIL,EAAUE,EAAyBI,MAAM,KAE7DZ,EAAgBa,OAAOP,GACvBC,EAASjC,IAPJD,EAAiBC,EAAOA,EAAMU,MAClCgB,EAAgBa,OAAOP,KAUtBJ,GACHY,aAAaZ,GAGdA,EAAQa,WAAWf,EAAgBgB,MAAMC,KAAKjB,GAAkBL,cA0BlDuB,EACfC,EACA1B,GACAnB,MAAEA,EArMiB,UAqMI8C,QAAEA,EAAOzB,QAAEA,GAA+B,IAEjE,IAAI0B,EAAa7B,EAAyBC,EAAe,CAAEE,QAAAA,IAE3D,OADAwB,EAAOG,iBAAiBhD,EAAO+C,EAAYD,GACpC,KACND,EAAOI,oBAAoBjD,EAAO+C,EAAYD"}

package/dist/tinykeys.module.js

@@ -1,2 +0,0 @@
-var t=["Shift","Meta","Alt","Control"],e="object"==typeof navigator?navigator.platform:"",n=/Mac|iPod|iPhone|iPad/.test(e),o=n?"Meta":"Control",i="Win32"===e?["Control","Alt"]:n?["Alt"]:[];function r(t,e){return"function"==typeof t.getModifierState&&(t.getModifierState(e)||i.includes(e)&&t.getModifierState("AltGraph"))}function a(t){return t.trim().split(" ").map(function(t){var e=t.split(/\b\+/),n=e.pop(),i=n.match(/^\((.+)\)$/);return i&&(n=new RegExp("^(?:"+i[1]+")$","iv")),[e=e.map(function(t){return"$mod"===t?o:t}),n]})}function u(e,n){var o=n[0],i=n[1];return!((i instanceof RegExp?!i.test(e.key)&&!i.test(e.code):i.toUpperCase()!==e.key.toUpperCase()&&i!==e.code)||o.find(function(t){return!r(e,t)})||t.find(function(t){return!o.includes(t)&&i!==t&&r(e,t)}))}function c(t,e){var n;void 0===e&&(e={});var o=null!=(n=e.timeout)?n:1e3,i=Object.keys(t).map(function(e){return[a(e),t[e]]}),c=new Map,f=null;return function(t){t instanceof KeyboardEvent&&(i.forEach(function(e){var n=e[0],o=e[1],i=c.get(n)||n;u(t,i[0])?i.length>1?c.set(n,i.slice(1)):(c.delete(n),o(t)):r(t,t.key)||c.delete(n)}),f&&clearTimeout(f),f=setTimeout(c.clear.bind(c),o))}}function f(t,e,n){var o=void 0===n?{}:n,i=o.event,r=void 0===i?"keydown":i,a=o.capture,u=c(e,{timeout:o.timeout});return t.addEventListener(r,u,a),function(){t.removeEventListener(r,u,a)}}export{c as createKeybindingsHandler,u as matchKeyBindingPress,a as parseKeybinding,f as tinykeys};
-//# sourceMappingURL=tinykeys.module.js.map

package/dist/tinykeys.module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tinykeys.module.js","sources":["../src/tinykeys.ts"],"sourcesContent":["/**\n * A single press of a keybinding sequence\n */\nexport type KeyBindingPress = [mods: string[], key: string | RegExp]\n\n/**\n * A map of keybinding strings to event handlers.\n */\nexport interface KeyBindingMap {\n\t[keybinding: string]: (event: KeyboardEvent) => void\n}\n\nexport interface KeyBindingHandlerOptions {\n\t/**\n\t * Keybinding sequences will wait this long between key presses before\n\t * cancelling (default: 1000).\n\t *\n\t * **Note:** Setting this value too low (i.e. `300`) will be too fast for many\n\t * of your users.\n\t */\n\ttimeout?: number\n}\n\n/**\n * Options to configure the behavior of keybindings.\n */\nexport interface KeyBindingOptions extends KeyBindingHandlerOptions {\n\t/**\n\t * Key presses will listen to this event (default: \"keydown\").\n\t */\n\tevent?: \"keydown\" | \"keyup\"\n\n\t/**\n\t * Key presses will use a capture listener (default: false)\n\t */\n\tcapture?: boolean\n}\n\n/**\n * These are the modifier keys that change the meaning of keybindings.\n *\n * Note: Ignoring \"AltGraph\" because it is covered by the others.\n */\nlet KEYBINDING_MODIFIER_KEYS = [\"Shift\", \"Meta\", \"Alt\", \"Control\"]\n\n/**\n * Keybinding sequences should timeout if individual key presses are more than\n * 1s apart by default.\n */\nlet DEFAULT_TIMEOUT = 1000\n\n/**\n * Keybinding sequences should bind to this event by default.\n */\nlet DEFAULT_EVENT = \"keydown\" as const\n\n/**\n * Platform detection code.\n * @see https://github.com/jamiebuilds/tinykeys/issues/184\n */\nlet PLATFORM = typeof navigator === \"object\" ? navigator.platform : \"\"\nlet APPLE_DEVICE = /Mac|iPod|iPhone|iPad/.test(PLATFORM)\n\n/**\n * An alias for creating platform-specific keybinding aliases.\n */\nlet MOD = APPLE_DEVICE ? \"Meta\" : \"Control\"\n\n/**\n * Meaning of `AltGraph`, from MDN:\n * - Windows: Both Alt and Ctrl keys are pressed, or AltGr key is pressed\n * - Mac: ⌥ Option key pressed\n * - Linux: Level 3 Shift key (or Level 5 Shift key) pressed\n * - Android: Not supported\n * @see https://github.com/jamiebuilds/tinykeys/issues/185\n */\nlet ALT_GRAPH_ALIASES =\n\tPLATFORM === \"Win32\" ? [\"Control\", \"Alt\"] : APPLE_DEVICE ? [\"Alt\"] : []\n\n/**\n * There's a bug in Chrome that causes event.getModifierState not to exist on\n * KeyboardEvent's for F1/F2/etc keys.\n */\nfunction getModifierState(event: KeyboardEvent, mod: string) {\n\treturn typeof event.getModifierState === \"function\"\n\t\t? event.getModifierState(mod) ||\n\t\t\t\t(ALT_GRAPH_ALIASES.includes(mod) && event.getModifierState(\"AltGraph\"))\n\t\t: false\n}\n\n/**\n * Parses a \"Key Binding String\" into its parts\n *\n * grammar    = `<sequence>`\n * <sequence> = `<press> <press> <press> ...`\n * <press>    = `<key>` or `<mods>+<key>`\n * <mods>     = `<mod>+<mod>+...`\n * <key>      = `<KeyboardEvent.key>` or `<KeyboardEvent.code>` (case-insensitive)\n * <key>      = `(<regex>)` -> `/^(?:<regex>)$/` (case-sensitive)\n */\nexport function parseKeybinding(str: string): KeyBindingPress[] {\n\treturn str\n\t\t.trim()\n\t\t.split(\" \")\n\t\t.map(press => {\n\t\t\tlet mods = press.split(/\\b\\+/)\n\t\t\tlet key: string | RegExp = mods.pop() as string\n\t\t\tlet match = key.match(/^\\((.+)\\)$/)\n\t\t\tif (match) {\n\t\t\t\tkey = new RegExp(`^(?:${match[1]})$`, \"iv\")\n\t\t\t}\n\t\t\tmods = mods.map(mod => (mod === \"$mod\" ? MOD : mod))\n\t\t\treturn [mods, key]\n\t\t})\n}\n\n/**\n * This tells us if a single keyboard event matches a single keybinding press.\n */\nexport function matchKeyBindingPress(\n\tevent: KeyboardEvent,\n\t[mods, key]: KeyBindingPress,\n): boolean {\n\t// prettier-ignore\n\treturn !(\n\t\t// Allow either the `event.key` or the `event.code`\n\t\t// MDN event.key: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n\t\t// MDN event.code: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code\n\t\t(\n\t\t\tkey instanceof RegExp ? !(key.test(event.key) || key.test(event.code)) :\n\t\t\t(key.toUpperCase() !== event.key.toUpperCase() &&\n\t\t\tkey !== event.code)\n\t\t) ||\n\n\t\t// Ensure all the modifiers in the keybinding are pressed.\n\t\tmods.find(mod => {\n\t\t\treturn !getModifierState(event, mod)\n\t\t}) ||\n\n\t\t// KEYBINDING_MODIFIER_KEYS (Shift/Control/etc) change the meaning of a\n\t\t// keybinding. So if they are pressed but aren't part of the current\n\t\t// keybinding press, then we don't have a match.\n\t\tKEYBINDING_MODIFIER_KEYS.find(mod => {\n\t\t\treturn !mods.includes(mod) && key !== mod && getModifierState(event, mod)\n\t\t})\n\t)\n}\n\n/**\n * Creates an event listener for handling keybindings.\n *\n * @example\n * ```js\n * import { createKeybindingsHandler } from \"../src/keybindings\"\n *\n * let handler = createKeybindingsHandler({\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n *\n * window.addEvenListener(\"keydown\", handler)\n * ```\n */\nexport function createKeybindingsHandler(\n\tkeyBindingMap: KeyBindingMap,\n\toptions: KeyBindingHandlerOptions = {},\n): EventListener {\n\tlet timeout = options.timeout ?? DEFAULT_TIMEOUT\n\n\tlet keyBindings = Object.keys(keyBindingMap).map(key => {\n\t\treturn [parseKeybinding(key), keyBindingMap[key]] as const\n\t})\n\n\tlet possibleMatches = new Map<KeyBindingPress[], KeyBindingPress[]>()\n\tlet timer: number | null = null\n\n\treturn event => {\n\t\t// Ensure and stop any event that isn't a full keyboard event.\n\t\t// Autocomplete option navigation and selection would fire a instanceof Event,\n\t\t// instead of the expected KeyboardEvent\n\t\tif (!(event instanceof KeyboardEvent)) {\n\t\t\treturn\n\t\t}\n\n\t\tkeyBindings.forEach(keyBinding => {\n\t\t\tlet sequence = keyBinding[0]\n\t\t\tlet callback = keyBinding[1]\n\n\t\t\tlet prev = possibleMatches.get(sequence)\n\t\t\tlet remainingExpectedPresses = prev ? prev : sequence\n\t\t\tlet currentExpectedPress = remainingExpectedPresses[0]\n\n\t\t\tlet matches = matchKeyBindingPress(event, currentExpectedPress)\n\n\t\t\tif (!matches) {\n\t\t\t\t// Modifier keydown events shouldn't break sequences\n\t\t\t\t// Note: This works because:\n\t\t\t\t// - non-modifiers will always return false\n\t\t\t\t// - if the current keypress is a modifier then it will return true when we check its state\n\t\t\t\t// MDN: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState\n\t\t\t\tif (!getModifierState(event, event.key)) {\n\t\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\t}\n\t\t\t} else if (remainingExpectedPresses.length > 1) {\n\t\t\t\tpossibleMatches.set(sequence, remainingExpectedPresses.slice(1))\n\t\t\t} else {\n\t\t\t\tpossibleMatches.delete(sequence)\n\t\t\t\tcallback(event)\n\t\t\t}\n\t\t})\n\n\t\tif (timer) {\n\t\t\tclearTimeout(timer)\n\t\t}\n\n\t\ttimer = setTimeout(possibleMatches.clear.bind(possibleMatches), timeout)\n\t}\n}\n\n/**\n * Subscribes to keybindings.\n *\n * Returns an unsubscribe method.\n *\n * @example\n * ```js\n * import { tinykeys } from \"../src/tinykeys\"\n *\n * tinykeys(window, {\n * \t\"Shift+d\": () => {\n * \t\talert(\"The 'Shift' and 'd' keys were pressed at the same time\")\n * \t},\n * \t\"y e e t\": () => {\n * \t\talert(\"The keys 'y', 'e', 'e', and 't' were pressed in order\")\n * \t},\n * \t\"$mod+d\": () => {\n * \t\talert(\"Either 'Control+d' or 'Meta+d' were pressed\")\n * \t},\n * })\n * ```\n */\nexport function tinykeys(\n\ttarget: Window | HTMLElement,\n\tkeyBindingMap: KeyBindingMap,\n\t{ event = DEFAULT_EVENT, capture, timeout }: KeyBindingOptions = {},\n): () => void {\n\tlet onKeyEvent = createKeybindingsHandler(keyBindingMap, { timeout })\n\ttarget.addEventListener(event, onKeyEvent, capture)\n\treturn () => {\n\t\ttarget.removeEventListener(event, onKeyEvent, capture)\n\t}\n}\n"],"names":["KEYBINDING_MODIFIER_KEYS","PLATFORM","navigator","platform","APPLE_DEVICE","test","MOD","ALT_GRAPH_ALIASES","getModifierState","event","mod","includes","parseKeybinding","str","trim","split","map","press","mods","key","pop","match","RegExp","matchKeyBindingPress","_ref","code","toUpperCase","find","createKeybindingsHandler","keyBindingMap","options","timeout","_options$timeout","keyBindings","Object","keys","possibleMatches","Map","timer","KeyboardEvent","forEach","keyBinding","sequence","callback","remainingExpectedPresses","get","length","set","slice","clearTimeout","setTimeout","clear","bind","tinykeys","target","_temp","_ref2$event","_ref2","capture","onKeyEvent","addEventListener","removeEventListener"],"mappings":"AA2CA,IAAIA,EAA2B,CAAC,QAAS,OAAQ,MAAO,WAiBpDC,EAAgC,iBAAdC,UAAyBA,UAAUC,SAAW,GAChEC,EAAe,uBAAuBC,KAAKJ,GAK3CK,EAAMF,EAAe,OAAS,UAU9BG,EACU,UAAbN,EAAuB,CAAC,UAAW,OAASG,EAAe,CAAC,OAAS,GAMtE,SAASI,EAAiBC,EAAsBC,GAC/C,MAAyC,mBAA3BD,EAAMD,mBACjBC,EAAMD,iBAAiBE,IACtBH,EAAkBI,SAASD,IAAQD,EAAMD,iBAAiB,sBAc/CI,EAAgBC,GAC/B,OAAOA,EACLC,OACAC,MAAM,KACNC,IAAI,SAAAC,GACJ,IAAIC,EAAOD,EAAMF,MAAM,QACnBI,EAAuBD,EAAKE,MAC5BC,EAAQF,EAAIE,MAAM,cAKtB,OAJIA,IACHF,EAAM,IAAIG,cAAcD,EAAM,QAAQ,OAGhC,CADPH,EAAOA,EAAKF,IAAI,SAAAN,SAAgB,SAARA,EAAiBJ,EAAMI,IACjCS,cAODI,EACfd,EAAoBe,OACnBN,EAAIM,KAAEL,EAAGK,KAGV,SAKEL,aAAeG,QAAWH,EAAId,KAAKI,EAAMU,OAAQA,EAAId,KAAKI,EAAMgB,MAC/DN,EAAIO,gBAAkBjB,EAAMU,IAAIO,eACjCP,IAAQV,EAAMgB,OAIfP,EAAKS,KAAK,SAAAjB,GACT,OAAQF,EAAiBC,EAAOC,MAMjCV,EAAyB2B,KAAK,SAAAjB,GAC7B,OAAQQ,EAAKP,SAASD,IAAQS,IAAQT,GAAOF,EAAiBC,EAAOC,eA2BxDkB,EACfC,EACAC,kBAAAA,IAAAA,EAAoC,IAEpC,IAAIC,SAAOC,EAAGF,EAAQC,SAAOC,EA7HR,IA+HjBC,EAAcC,OAAOC,KAAKN,GAAeb,IAAI,SAAAG,GAChD,MAAO,CAACP,EAAgBO,GAAMU,EAAcV,MAGzCiB,EAAkB,IAAIC,IACtBC,EAAuB,KAE3B,gBAAO7B,GAIAA,aAAiB8B,gBAIvBN,EAAYO,QAAQ,SAAAC,GACnB,IAAIC,EAAWD,EAAW,GACtBE,EAAWF,EAAW,GAGtBG,EADOR,EAAgBS,IAAIH,IACcA,EAG/BnB,EAAqBd,EAFRmC,EAAyB,IAazCA,EAAyBE,OAAS,EAC5CV,EAAgBW,IAAIL,EAAUE,EAAyBI,MAAM,KAE7DZ,SAAuBM,GACvBC,EAASlC,IAPJD,EAAiBC,EAAOA,EAAMU,MAClCiB,SAAuBM,KAUtBJ,GACHW,aAAaX,GAGdA,EAAQY,WAAWd,EAAgBe,MAAMC,KAAKhB,GAAkBL,cA0BlDsB,EACfC,EACAzB,EAA4B0B,oBACqC,GAAEA,EAAAC,EAAAC,EAAjEhD,MAAAA,WAAK+C,EArMY,UAqMIA,EAAEE,EAAOD,EAAPC,QAErBC,EAAa/B,EAAyBC,EAAe,CAAEE,QAFlB0B,EAAP1B,UAIlC,OADAuB,EAAOM,iBAAiBnD,EAAOkD,EAAYD,cAE1CJ,EAAOO,oBAAoBpD,EAAOkD,EAAYD"}