@tanstack/hotkeys 0.9.0 → 0.10.1

package/dist/key-state-tracker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-state-tracker.js","names":["#instance","#setupListeners","#keydownListener","#heldEntries","#syncState","#keyupListener","#blurListener","#removeListeners"],"sources":["../src/key-state-tracker.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { MODIFIER_KEYS, normalizeKeyName } from './constants'\n\n/**\n * State interface for the KeyStateTracker.\n */\nexport interface KeyStateTrackerState {\n  /**\n   * Array of currently held key names (normalized, e.g. \"Control\", \"A\").\n   */\n  heldKeys: Array<string>\n  /**\n   * Map from normalized key name to the physical `event.code` (e.g. \"KeyA\", \"ShiftLeft\").\n   * Useful for debugging which physical key was pressed.\n   */\n  heldCodes: Record<string, string>\n}\n\n/**\n * Returns the default state for KeyStateTracker.\n */\nfunction getDefaultKeyStateTrackerState(): KeyStateTrackerState {\n  return {\n    heldKeys: [],\n    heldCodes: {},\n  }\n}\n\n/**\n * Singleton tracker for currently held keyboard keys.\n *\n * This class maintains a list of all keys currently being pressed,\n * which is useful for:\n * - Displaying currently held keys to users\n * - Custom shortcut recording for rebinding\n * - Complex chord detection\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - State can be accessed via `tracker.store.state` when using the class directly\n * - When using framework adapters (React), use `useHeldKeys` and `useHeldKeyCodes` hooks for reactive state\n *\n * @example\n * ```ts\n * const tracker = KeyStateTracker.getInstance()\n *\n * // Access state directly\n * console.log(tracker.store.state.heldKeys) // ['Control', 'Shift']\n *\n * // Subscribe to changes with TanStack Store\n * const unsubscribe = tracker.store.subscribe(() => {\n *   console.log('Currently held:', tracker.store.state.heldKeys)\n * })\n *\n * // Check current state\n * console.log(tracker.getHeldKeys()) // ['Control', 'Shift']\n * console.log(tracker.isKeyHeld('Control')) // true\n *\n * // Cleanup\n * unsubscribe()\n * ```\n */\nexport class KeyStateTracker {\n  static #instance: KeyStateTracker | null = null\n\n  /**\n   * The TanStack Store instance containing the tracker state.\n   * Use this to subscribe to state changes or access current state.\n   */\n  readonly store: Store<KeyStateTrackerState> = new Store(\n    getDefaultKeyStateTrackerState(),\n  )\n\n  #heldEntries: Map<string, { key: string; code: string }> = new Map()\n  #keydownListener: ((event: KeyboardEvent) => void) | null = null\n  #keyupListener: ((event: KeyboardEvent) => void) | null = null\n  #blurListener: (() => void) | null = null\n\n  private constructor() {\n    this.#setupListeners()\n  }\n\n  /**\n   * Gets the singleton instance of KeyStateTracker.\n   */\n  static getInstance(): KeyStateTracker {\n    if (!KeyStateTracker.#instance) {\n      KeyStateTracker.#instance = new KeyStateTracker()\n    }\n    return KeyStateTracker.#instance\n  }\n\n  /**\n   * Resets the singleton instance. Useful for testing.\n   */\n  static resetInstance(): void {\n    if (KeyStateTracker.#instance) {\n      KeyStateTracker.#instance.destroy()\n      KeyStateTracker.#instance = null\n    }\n  }\n\n  /**\n   * Sets up the keyboard event listeners.\n   */\n  #setupListeners(): void {\n    if (typeof document === 'undefined') {\n      return // SSR safety\n    }\n\n    this.#keydownListener = (event: KeyboardEvent) => {\n      const key = normalizeKeyName(event.key)\n      const identity = event.code || `key:${key}`\n      if (!this.#heldEntries.has(identity)) {\n        this.#heldEntries.set(identity, { key, code: event.code })\n        this.#syncState()\n      }\n    }\n\n    this.#keyupListener = (event: KeyboardEvent) => {\n      const key = normalizeKeyName(event.key)\n      const identity = event.code || `key:${key}`\n      this.#heldEntries.delete(identity)\n\n      // Code-less keyup events can only be paired by their logical key.\n      if (!event.code) {\n        for (const [entryIdentity, entry] of this.#heldEntries) {\n          if (entry.key === key) this.#heldEntries.delete(entryIdentity)\n        }\n      }\n\n      // When a modifier key is released, clear any non-modifier keys still\n      // marked as held. On macOS, the OS intercepts modifier+key combos\n      // (e.g. Cmd+S) and swallows the keyup event for the non-modifier key,\n      // leaving it permanently stuck in the held set.\n      if (MODIFIER_KEYS.has(key)) {\n        for (const [entryIdentity, entry] of this.#heldEntries) {\n          if (!MODIFIER_KEYS.has(entry.key)) {\n            this.#heldEntries.delete(entryIdentity)\n          }\n        }\n      }\n\n      this.#syncState()\n    }\n\n    // Clear all keys when window loses focus (keys might be released while not focused)\n    this.#blurListener = () => {\n      if (this.#heldEntries.size > 0) {\n        this.#heldEntries.clear()\n        this.#syncState()\n      }\n    }\n\n    document.addEventListener('keydown', this.#keydownListener, true)\n    document.addEventListener('keyup', this.#keyupListener, true)\n    window.addEventListener('blur', this.#blurListener)\n  }\n\n  /**\n   * Syncs the internal Set to the Store state.\n   */\n  #syncState(): void {\n    const heldKeys = Array.from(\n      new Set(Array.from(this.#heldEntries.values(), (entry) => entry.key)),\n    )\n    const heldCodes = Object.fromEntries(\n      Array.from(this.#heldEntries.values(), (entry) => [\n        entry.key,\n        entry.code,\n      ]),\n    )\n    this.store.setState(() => ({\n      heldKeys,\n      heldCodes,\n    }))\n  }\n\n  /**\n   * Removes the keyboard event listeners.\n   */\n  #removeListeners(): void {\n    if (typeof document === 'undefined') {\n      return\n    }\n\n    if (this.#keydownListener) {\n      document.removeEventListener('keydown', this.#keydownListener, true)\n      this.#keydownListener = null\n    }\n\n    if (this.#keyupListener) {\n      document.removeEventListener('keyup', this.#keyupListener, true)\n      this.#keyupListener = null\n    }\n\n    if (this.#blurListener) {\n      window.removeEventListener('blur', this.#blurListener)\n      this.#blurListener = null\n    }\n  }\n\n  /**\n   * Gets an array of currently held key names.\n   *\n   * @returns Array of key names currently being pressed\n   */\n  getHeldKeys(): Array<string> {\n    return this.store.state.heldKeys\n  }\n\n  /**\n   * Checks if a specific key is currently being held.\n   *\n   * @param key - The key name to check (case-insensitive)\n   * @returns True if the key is currently held\n   */\n  isKeyHeld(key: string): boolean {\n    const normalizedKey = normalizeKeyName(key)\n    return Array.from(this.#heldEntries.values()).some(\n      (entry) => entry.key === normalizedKey,\n    )\n  }\n\n  /**\n   * Checks if any of the given keys are currently held.\n   *\n   * @param keys - Array of key names to check\n   * @returns True if any of the keys are currently held\n   */\n  isAnyKeyHeld(keys: Array<string>): boolean {\n    return keys.some((key) => this.isKeyHeld(key))\n  }\n\n  /**\n   * Checks if all of the given keys are currently held.\n   *\n   * @param keys - Array of key names to check\n   * @returns True if all of the keys are currently held\n   */\n  areAllKeysHeld(keys: Array<string>): boolean {\n    return keys.every((key) => this.isKeyHeld(key))\n  }\n\n  /**\n   * Destroys the tracker and removes all listeners.\n   */\n  destroy(): void {\n    this.#removeListeners()\n    this.#heldEntries.clear()\n    this.store.setState(() => getDefaultKeyStateTrackerState())\n  }\n}\n\n/**\n * Gets the singleton KeyStateTracker instance.\n * Convenience function for accessing the tracker.\n */\nexport function getKeyStateTracker(): KeyStateTracker {\n  return KeyStateTracker.getInstance()\n}\n"],"mappings":"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"}

package/dist/key.types.d.cts

@@ -1,82 +0,0 @@
-import { LOGICAL_ONLY_NAMED_KEYS, SHARED_NAMED_KEYS } from "./_named-keys.cjs";
-
-//#region src/key.types.d.ts
-/**
- * All supported modifier key names, including aliases.
- * - Control/Ctrl: The Control key
- * - Shift: The Shift key
- * - Alt/Option: The Alt key (Option on macOS)
- * - Command/Cmd: The Command key (macOS only)
- * - CommandOrControl/Mod: Command on macOS, Control on other platforms
- */
-type Modifier = 'Control' | 'Ctrl' | 'Shift' | 'Alt' | 'Option' | 'Command' | 'Cmd' | 'CommandOrControl' | 'Mod';
-/**
- * Canonical modifier names that map to KeyboardEvent properties.
- */
-type CanonicalModifier = 'Control' | 'Shift' | 'Alt' | 'Meta';
-/**
- * Letter keys A-Z (case-insensitive in matching).
- */
-type LetterKey = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
-/**
- * Number keys 0-9.
- */
-type NumberKey = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
-/**
- * Function keys F1-F24, supported as both logical keys and physical codes.
- */
-type FunctionKey = 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12' | 'F13' | 'F14' | 'F15' | 'F16' | 'F17' | 'F18' | 'F19' | 'F20' | 'F21' | 'F22' | 'F23' | 'F24';
-/**
- * Navigation keys for cursor movement.
- */
-type NavigationKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'Home' | 'End' | 'PageUp' | 'PageDown';
-/**
- * Editing and special keys.
- */
-type EditingKey = 'Enter' | 'Escape' | 'Space' | 'Tab' | 'Backspace' | 'Delete';
-/**
- * Printable punctuation glyphs used in keyboard shortcuts. Matching uses the
- * final KeyboardEvent.key glyph, independent of which layout produced it.
- */
-type PunctuationKey = '/' | '[' | ']' | '\\' | '=' | '-' | ',' | '.' | ';' | '`' | "'" | '+' | '?' | '!' | '@' | '#' | '$' | '%' | '^' | '&' | '*' | '(' | ')' | '_' | '{' | '}' | '|' | ':' | '"' | '<' | '>' | '~';
-/** Additional named logical keys, including media, browser, lock, and input-mode keys. */
-type NamedKey = (typeof SHARED_NAMED_KEYS)[number] | (typeof LOGICAL_ONLY_NAMED_KEYS)[number];
-/** Supported logical key names other than printable punctuation. */
-type NonPunctuationKey = LetterKey | NumberKey | EditingKey | NavigationKey | FunctionKey | NamedKey;
-/**
- * Supported physical KeyboardEvent.code names, independent of keyboard layout.
- * Letter, digit, numpad, and sided modifier names use finite template unions.
- * `Unidentified` is excluded because it cannot identify a physical key.
- *
- * @see https://www.w3.org/TR/uievents-code/
- */
-type PhysicalKeyCode = `Key${LetterKey}` | `Digit${NumberKey}` | `Numpad${NumberKey}` | `${'Alt' | 'Control' | 'Meta' | 'Shift'}${'Left' | 'Right'}` | EditingKey | NavigationKey | FunctionKey | (typeof SHARED_NAMED_KEYS)[number] | 'Backquote' | 'Backslash' | 'BracketLeft' | 'BracketRight' | 'Comma' | 'Equal' | 'IntlBackslash' | 'IntlRo' | 'IntlYen' | 'Minus' | 'Period' | 'Quote' | 'Semicolon' | 'Slash' | `Lang${1 | 2 | 3 | 4 | 5}` | `Numpad${'Add' | 'Backspace' | 'Clear' | 'ClearEntry' | 'Comma' | 'Decimal' | 'Divide' | 'Enter' | 'Equal' | 'Hash' | 'MemoryAdd' | 'MemoryClear' | 'MemoryRecall' | 'MemoryStore' | 'MemorySubtract' | 'Multiply' | 'ParenLeft' | 'ParenRight' | 'Star' | 'Subtract'}` | 'LaunchApp1' | 'LaunchApp2' | 'MediaSelect' | 'Sleep' | 'Turbo' | 'Abort' | 'Resume' | 'Suspend';
-/**
- * An explicit physical key token. All codes use brackets, including names such
- * as `[Enter]` that also exist as logical keys. Invalid code names are rejected
- * by TypeScript, and supported names are available in autocomplete.
- */
-type PhysicalKey = `[${PhysicalKeyCode}]`;
-/** Supported logical key names, excluding bracketed physical-code syntax. */
-type LogicalKey = NonPunctuationKey | PunctuationKey;
-/** All supported logical keys and bracketed physical key tokens. */
-type Key = LogicalKey | PhysicalKey;
-/**
- * Includes both modifier keys and regular keys.
- */
-type IndividualKey = CanonicalModifier | Key;
-/** Keyboard event properties normalized for internal matching and recording. */
-interface NormalizedKeyboardEvent {
-  key: string;
-  code: string;
-  ctrl: boolean;
-  shift: boolean;
-  alt: boolean;
-  meta: boolean;
-  altGraph: boolean;
-  location: number;
-  isComposing: boolean;
-}
-//#endregion
-export { CanonicalModifier, EditingKey, FunctionKey, IndividualKey, Key, LetterKey, LogicalKey, Modifier, NamedKey, NavigationKey, NonPunctuationKey, NormalizedKeyboardEvent, NumberKey, PhysicalKey, PhysicalKeyCode, PunctuationKey };
-//# sourceMappingURL=key.types.d.cts.map

package/dist/match.cjs

@@ -1,144 +0,0 @@
-const require_platform = require('./platform.cjs');
-const require__keyboard_event = require('./_keyboard-event.cjs');
-const require_parse = require('./parse.cjs');
-const require__match = require('./_match.cjs');
-
-//#region src/match.ts
-/**
-* Checks if a KeyboardEvent matches a hotkey.
-*
-* Physical bindings such as `Mod+[KeyS]` match `event.code` exactly.
-* Logical bindings use `event.key`, with a fallback to `code`
-* for letter keys, digit keys (0-9), and punctuation keys when `key` produces special
-* characters (e.g., macOS Option+letter, Shift+number, or Option+punctuation).
-* Letter keys are matched case-insensitively.
-*
-* Also handles "dead key" events where `event.key` is `'Dead'` instead of the expected
-* character. This commonly occurs on macOS with Option+letter combinations (e.g., Option+E,
-* Option+I, Option+U, Option+N) and on Windows/Linux with international keyboard layouts.
-* In these cases, `event.code` is used to determine the physical key.
-*
-* @param event - The KeyboardEvent to check
-* @param hotkey - The hotkey string or ParsedHotkey to match against
-* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
-* @returns True if the event matches the hotkey
-*
-* @example
-* ```ts
-* document.addEventListener('keydown', (event) => {
-*   if (matchesKeyboardEvent(event, 'Mod+S')) {
-*     event.preventDefault()
-*     handleSave()
-*   }
-* })
-* ```
-*/
-function matchesKeyboardEvent(event, hotkey, platform = require_platform.detectPlatform()) {
-	return require__match.matchKeyboardEvent(event, hotkey, platform).matched;
-}
-/**
-* Creates a keyboard event handler that calls the callback when the hotkey matches.
-*
-* @param hotkey - The hotkey string or ParsedHotkey to match
-* @param callback - The function to call when the hotkey matches
-* @param options - Options for matching and handling
-* @returns A function that can be used as an event handler
-*
-* @example
-* ```ts
-* const handler = createHotkeyHandler('Mod+S', (event, { hotkey, parsedHotkey }) => {
-*   console.log(`${hotkey} was pressed`)
-*   handleSave()
-* })
-*
-* document.addEventListener('keydown', handler)
-* ```
-*/
-function createHotkeyHandler(hotkey, callback, options = {}) {
-	const { preventDefault = true, stopPropagation = true, platform } = options;
-	const resolvedPlatform = platform ?? require_platform.detectPlatform();
-	const hotkeyString = typeof hotkey === "string" ? hotkey : formatParsedHotkey(hotkey);
-	const parsed = typeof hotkey === "string" ? require_parse.parseHotkey(hotkey, resolvedPlatform) : hotkey;
-	const context = {
-		hotkey: hotkeyString,
-		parsedHotkey: parsed
-	};
-	return (event) => {
-		if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {
-			if (preventDefault) event.preventDefault();
-			if (stopPropagation) event.stopPropagation();
-			callback(event, context);
-		}
-	};
-}
-/**
-* Creates a handler that matches multiple hotkeys.
-*
-* @param handlers - A map of hotkey strings to their handlers
-* @param options - Options for matching and handling
-* @returns A function that can be used as an event handler
-*
-* @example
-* ```ts
-* const handler = createMultiHotkeyHandler({
-*   'Mod+S': (event, { hotkey }) => handleSave(),
-*   'Mod+Z': (event, { hotkey }) => handleUndo(),
-*   'Mod+Shift+Z': (event, { hotkey }) => handleRedo(),
-* })
-*
-* document.addEventListener('keydown', handler)
-* ```
-*/
-function createMultiHotkeyHandler(handlers, options = {}) {
-	const { preventDefault = true, stopPropagation = true, platform } = options;
-	const resolvedPlatform = platform ?? require_platform.detectPlatform();
-	const parsedHandlers = Object.entries(handlers).filter((entry) => Boolean(entry[1])).map(([hotkey, handler]) => {
-		const parsed = require_parse.parseHotkey(hotkey, resolvedPlatform);
-		return {
-			parsed,
-			handler,
-			context: {
-				hotkey,
-				parsedHotkey: parsed
-			}
-		};
-	});
-	return (event) => {
-		for (const { parsed, handler, context } of parsedHandlers) if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {
-			if (preventDefault) event.preventDefault();
-			if (stopPropagation) event.stopPropagation();
-			handler(event, context);
-			return;
-		}
-	};
-}
-/**
-* Formats a ParsedHotkey back to a hotkey string.
-* Used internally to provide the hotkey string in callback context.
-*/
-function formatParsedHotkey(parsed) {
-	const parts = [];
-	if (parsed.ctrl) parts.push("Control");
-	if (parsed.alt) parts.push("Alt");
-	if (parsed.shift) parts.push("Shift");
-	if (parsed.meta) parts.push("Meta");
-	parts.push(parsed.code !== void 0 ? `[${parsed.code}]` : parsed.key);
-	return parts.join("+");
-}
-/**
-* Compares normalized binding identity, including all four modifiers.
-* Aliases resolve on the supplied platform. A physical code and a logical key
-* remain distinct even when one keyboard event could match both.
-*/
-function areHotkeysEqual(left, right, platform = require_platform.detectPlatform()) {
-	const a = require_parse.parseRegisterableHotkey(left, platform);
-	const b = require_parse.parseRegisterableHotkey(right, platform);
-	return a.ctrl === b.ctrl && a.alt === b.alt && a.shift === b.shift && a.meta === b.meta && (a.code !== void 0 || b.code !== void 0 ? a.code === b.code : require__keyboard_event.keysEqual(a.key, b.key));
-}
-
-//#endregion
-exports.areHotkeysEqual = areHotkeysEqual;
-exports.createHotkeyHandler = createHotkeyHandler;
-exports.createMultiHotkeyHandler = createMultiHotkeyHandler;
-exports.matchesKeyboardEvent = matchesKeyboardEvent;
-//# sourceMappingURL=match.cjs.map

package/dist/match.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"match.cjs","names":["detectPlatform","matchKeyboardEvent","parseHotkey","parseRegisterableHotkey","keysEqual"],"sources":["../src/match.ts"],"sourcesContent":["import { matchKeyboardEvent } from './_match'\nimport { parseHotkey, parseRegisterableHotkey } from './parse'\nimport { detectPlatform } from './platform'\nimport { keysEqual } from './_keyboard-event'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyCallbackContext,\n  ParsedHotkey,\n  RegisterableHotkey,\n} from './hotkey.types'\n\nexport interface KeyboardEventMatch {\n  matched: boolean\n  score: 0 | 1 | 2 | 3\n  source?: 'key' | 'code' | 'fallback'\n  identity?: { key: string; code: string }\n}\n\n/**\n * Checks if a KeyboardEvent matches a hotkey.\n *\n * Physical bindings such as `Mod+[KeyS]` match `event.code` exactly.\n * Logical bindings use `event.key`, with a fallback to `code`\n * for letter keys, digit keys (0-9), and punctuation keys when `key` produces special\n * characters (e.g., macOS Option+letter, Shift+number, or Option+punctuation).\n * Letter keys are matched case-insensitively.\n *\n * Also handles \"dead key\" events where `event.key` is `'Dead'` instead of the expected\n * character. This commonly occurs on macOS with Option+letter combinations (e.g., Option+E,\n * Option+I, Option+U, Option+N) and on Windows/Linux with international keyboard layouts.\n * In these cases, `event.code` is used to determine the physical key.\n *\n * @param event - The KeyboardEvent to check\n * @param hotkey - The hotkey string or ParsedHotkey to match against\n * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)\n * @returns True if the event matches the hotkey\n *\n * @example\n * ```ts\n * document.addEventListener('keydown', (event) => {\n *   if (matchesKeyboardEvent(event, 'Mod+S')) {\n *     event.preventDefault()\n *     handleSave()\n *   }\n * })\n * ```\n */\nexport function matchesKeyboardEvent(\n  event: KeyboardEvent,\n  hotkey: Hotkey | ParsedHotkey,\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): boolean {\n  return matchKeyboardEvent(event, hotkey, platform).matched\n}\n\n/**\n * Options for creating a hotkey handler.\n */\nexport interface CreateHotkeyHandlerOptions {\n  /** Prevent the default browser action when the hotkey matches. Defaults to true */\n  preventDefault?: boolean\n  /** Stop event propagation when the hotkey matches. Defaults to true */\n  stopPropagation?: boolean\n  /** The target platform for resolving 'Mod' */\n  platform?: 'mac' | 'windows' | 'linux'\n}\n\n/**\n * Creates a keyboard event handler that calls the callback when the hotkey matches.\n *\n * @param hotkey - The hotkey string or ParsedHotkey to match\n * @param callback - The function to call when the hotkey matches\n * @param options - Options for matching and handling\n * @returns A function that can be used as an event handler\n *\n * @example\n * ```ts\n * const handler = createHotkeyHandler('Mod+S', (event, { hotkey, parsedHotkey }) => {\n *   console.log(`${hotkey} was pressed`)\n *   handleSave()\n * })\n *\n * document.addEventListener('keydown', handler)\n * ```\n */\nexport function createHotkeyHandler(\n  hotkey: Hotkey | ParsedHotkey,\n  callback: HotkeyCallback,\n  options: CreateHotkeyHandlerOptions = {},\n): (event: KeyboardEvent) => void {\n  const { preventDefault = true, stopPropagation = true, platform } = options\n  const resolvedPlatform = platform ?? detectPlatform()\n\n  const hotkeyString: Hotkey =\n    typeof hotkey === 'string' ? hotkey : formatParsedHotkey(hotkey)\n  const parsed =\n    typeof hotkey === 'string' ? parseHotkey(hotkey, resolvedPlatform) : hotkey\n\n  const context: HotkeyCallbackContext = {\n    hotkey: hotkeyString,\n    parsedHotkey: parsed,\n  }\n\n  return (event: KeyboardEvent) => {\n    if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {\n      if (preventDefault) {\n        event.preventDefault()\n      }\n      if (stopPropagation) {\n        event.stopPropagation()\n      }\n      callback(event, context)\n    }\n  }\n}\n\nexport type MultiHotkeyHandler = { [K in Hotkey]?: HotkeyCallback }\n\n/**\n * Creates a handler that matches multiple hotkeys.\n *\n * @param handlers - A map of hotkey strings to their handlers\n * @param options - Options for matching and handling\n * @returns A function that can be used as an event handler\n *\n * @example\n * ```ts\n * const handler = createMultiHotkeyHandler({\n *   'Mod+S': (event, { hotkey }) => handleSave(),\n *   'Mod+Z': (event, { hotkey }) => handleUndo(),\n *   'Mod+Shift+Z': (event, { hotkey }) => handleRedo(),\n * })\n *\n * document.addEventListener('keydown', handler)\n * ```\n */\nexport function createMultiHotkeyHandler(\n  handlers: MultiHotkeyHandler,\n  options: CreateHotkeyHandlerOptions = {},\n): (event: KeyboardEvent) => void {\n  const { preventDefault = true, stopPropagation = true, platform } = options\n  const resolvedPlatform = platform ?? detectPlatform()\n\n  // Pre-parse all hotkeys for efficiency\n  const parsedHandlers = Object.entries(handlers)\n    .filter((entry): entry is [string, HotkeyCallback] => Boolean(entry[1]))\n    .map(([hotkey, handler]) => {\n      const parsed = parseHotkey(hotkey as Hotkey, resolvedPlatform)\n      const context: HotkeyCallbackContext = {\n        hotkey: hotkey as Hotkey,\n        parsedHotkey: parsed,\n      }\n      return { parsed, handler, context }\n    })\n\n  return (event: KeyboardEvent) => {\n    for (const { parsed, handler, context } of parsedHandlers) {\n      if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {\n        if (preventDefault) {\n          event.preventDefault()\n        }\n        if (stopPropagation) {\n          event.stopPropagation()\n        }\n        handler(event, context)\n        return // Only handle the first match\n      }\n    }\n  }\n}\n\n/**\n * Formats a ParsedHotkey back to a hotkey string.\n * Used internally to provide the hotkey string in callback context.\n */\nfunction formatParsedHotkey(parsed: ParsedHotkey): Hotkey {\n  const parts: Array<string> = []\n\n  if (parsed.ctrl) parts.push('Control')\n  if (parsed.alt) parts.push('Alt')\n  if (parsed.shift) parts.push('Shift')\n  if (parsed.meta) parts.push('Meta')\n  parts.push(parsed.code !== undefined ? `[${parsed.code}]` : parsed.key)\n\n  return parts.join('+') as Hotkey\n}\n\n/**\n * Compares normalized binding identity, including all four modifiers.\n * Aliases resolve on the supplied platform. A physical code and a logical key\n * remain distinct even when one keyboard event could match both.\n */\nexport function areHotkeysEqual(\n  left: RegisterableHotkey,\n  right: RegisterableHotkey,\n  platform = detectPlatform(),\n): boolean {\n  const a = parseRegisterableHotkey(left, platform)\n  const b = parseRegisterableHotkey(right, platform)\n  return (\n    a.ctrl === b.ctrl &&\n    a.alt === b.alt &&\n    a.shift === b.shift &&\n    a.meta === b.meta &&\n    (a.code !== undefined || b.code !== undefined\n      ? a.code === b.code\n      : keysEqual(a.key, b.key))\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,qBACd,OACA,QACA,WAAwCA,iCAAgB,EAC/C;AACT,QAAOC,kCAAmB,OAAO,QAAQ,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;AAiCrD,SAAgB,oBACd,QACA,UACA,UAAsC,EAAE,EACR;CAChC,MAAM,EAAE,iBAAiB,MAAM,kBAAkB,MAAM,aAAa;CACpE,MAAM,mBAAmB,YAAYD,iCAAgB;CAErD,MAAM,eACJ,OAAO,WAAW,WAAW,SAAS,mBAAmB,OAAO;CAClE,MAAM,SACJ,OAAO,WAAW,WAAWE,0BAAY,QAAQ,iBAAiB,GAAG;CAEvE,MAAM,UAAiC;EACrC,QAAQ;EACR,cAAc;EACf;AAED,SAAQ,UAAyB;AAC/B,MAAI,qBAAqB,OAAO,QAAQ,iBAAiB,EAAE;AACzD,OAAI,eACF,OAAM,gBAAgB;AAExB,OAAI,gBACF,OAAM,iBAAiB;AAEzB,YAAS,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;AAyB9B,SAAgB,yBACd,UACA,UAAsC,EAAE,EACR;CAChC,MAAM,EAAE,iBAAiB,MAAM,kBAAkB,MAAM,aAAa;CACpE,MAAM,mBAAmB,YAAYF,iCAAgB;CAGrD,MAAM,iBAAiB,OAAO,QAAQ,SAAS,CAC5C,QAAQ,UAA6C,QAAQ,MAAM,GAAG,CAAC,CACvE,KAAK,CAAC,QAAQ,aAAa;EAC1B,MAAM,SAASE,0BAAY,QAAkB,iBAAiB;AAK9D,SAAO;GAAE;GAAQ;GAAS,SAJa;IAC7B;IACR,cAAc;IACf;GACkC;GACnC;AAEJ,SAAQ,UAAyB;AAC/B,OAAK,MAAM,EAAE,QAAQ,SAAS,aAAa,eACzC,KAAI,qBAAqB,OAAO,QAAQ,iBAAiB,EAAE;AACzD,OAAI,eACF,OAAM,gBAAgB;AAExB,OAAI,gBACF,OAAM,iBAAiB;AAEzB,WAAQ,OAAO,QAAQ;AACvB;;;;;;;;AAUR,SAAS,mBAAmB,QAA8B;CACxD,MAAM,QAAuB,EAAE;AAE/B,KAAI,OAAO,KAAM,OAAM,KAAK,UAAU;AACtC,KAAI,OAAO,IAAK,OAAM,KAAK,MAAM;AACjC,KAAI,OAAO,MAAO,OAAM,KAAK,QAAQ;AACrC,KAAI,OAAO,KAAM,OAAM,KAAK,OAAO;AACnC,OAAM,KAAK,OAAO,SAAS,SAAY,IAAI,OAAO,KAAK,KAAK,OAAO,IAAI;AAEvE,QAAO,MAAM,KAAK,IAAI;;;;;;;AAQxB,SAAgB,gBACd,MACA,OACA,WAAWF,iCAAgB,EAClB;CACT,MAAM,IAAIG,sCAAwB,MAAM,SAAS;CACjD,MAAM,IAAIA,sCAAwB,OAAO,SAAS;AAClD,QACE,EAAE,SAAS,EAAE,QACb,EAAE,QAAQ,EAAE,OACZ,EAAE,UAAU,EAAE,SACd,EAAE,SAAS,EAAE,SACZ,EAAE,SAAS,UAAa,EAAE,SAAS,SAChC,EAAE,SAAS,EAAE,OACbC,kCAAU,EAAE,KAAK,EAAE,IAAI"}

package/dist/match.d.cts

@@ -1,101 +0,0 @@
-import { Hotkey, HotkeyCallback, ParsedHotkey, RegisterableHotkey } from "./hotkey.types.cjs";
-
-//#region src/match.d.ts
-interface KeyboardEventMatch {
-  matched: boolean;
-  score: 0 | 1 | 2 | 3;
-  source?: 'key' | 'code' | 'fallback';
-  identity?: {
-    key: string;
-    code: string;
-  };
-}
-/**
- * Checks if a KeyboardEvent matches a hotkey.
- *
- * Physical bindings such as `Mod+[KeyS]` match `event.code` exactly.
- * Logical bindings use `event.key`, with a fallback to `code`
- * for letter keys, digit keys (0-9), and punctuation keys when `key` produces special
- * characters (e.g., macOS Option+letter, Shift+number, or Option+punctuation).
- * Letter keys are matched case-insensitively.
- *
- * Also handles "dead key" events where `event.key` is `'Dead'` instead of the expected
- * character. This commonly occurs on macOS with Option+letter combinations (e.g., Option+E,
- * Option+I, Option+U, Option+N) and on Windows/Linux with international keyboard layouts.
- * In these cases, `event.code` is used to determine the physical key.
- *
- * @param event - The KeyboardEvent to check
- * @param hotkey - The hotkey string or ParsedHotkey to match against
- * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
- * @returns True if the event matches the hotkey
- *
- * @example
- * ```ts
- * document.addEventListener('keydown', (event) => {
- *   if (matchesKeyboardEvent(event, 'Mod+S')) {
- *     event.preventDefault()
- *     handleSave()
- *   }
- * })
- * ```
- */
-declare function matchesKeyboardEvent(event: KeyboardEvent, hotkey: Hotkey | ParsedHotkey, platform?: 'mac' | 'windows' | 'linux'): boolean;
-/**
- * Options for creating a hotkey handler.
- */
-interface CreateHotkeyHandlerOptions {
-  /** Prevent the default browser action when the hotkey matches. Defaults to true */
-  preventDefault?: boolean;
-  /** Stop event propagation when the hotkey matches. Defaults to true */
-  stopPropagation?: boolean;
-  /** The target platform for resolving 'Mod' */
-  platform?: 'mac' | 'windows' | 'linux';
-}
-/**
- * Creates a keyboard event handler that calls the callback when the hotkey matches.
- *
- * @param hotkey - The hotkey string or ParsedHotkey to match
- * @param callback - The function to call when the hotkey matches
- * @param options - Options for matching and handling
- * @returns A function that can be used as an event handler
- *
- * @example
- * ```ts
- * const handler = createHotkeyHandler('Mod+S', (event, { hotkey, parsedHotkey }) => {
- *   console.log(`${hotkey} was pressed`)
- *   handleSave()
- * })
- *
- * document.addEventListener('keydown', handler)
- * ```
- */
-declare function createHotkeyHandler(hotkey: Hotkey | ParsedHotkey, callback: HotkeyCallback, options?: CreateHotkeyHandlerOptions): (event: KeyboardEvent) => void;
-type MultiHotkeyHandler = { [K in Hotkey]?: HotkeyCallback };
-/**
- * Creates a handler that matches multiple hotkeys.
- *
- * @param handlers - A map of hotkey strings to their handlers
- * @param options - Options for matching and handling
- * @returns A function that can be used as an event handler
- *
- * @example
- * ```ts
- * const handler = createMultiHotkeyHandler({
- *   'Mod+S': (event, { hotkey }) => handleSave(),
- *   'Mod+Z': (event, { hotkey }) => handleUndo(),
- *   'Mod+Shift+Z': (event, { hotkey }) => handleRedo(),
- * })
- *
- * document.addEventListener('keydown', handler)
- * ```
- */
-declare function createMultiHotkeyHandler(handlers: MultiHotkeyHandler, options?: CreateHotkeyHandlerOptions): (event: KeyboardEvent) => void;
-/**
- * Compares normalized binding identity, including all four modifiers.
- * Aliases resolve on the supplied platform. A physical code and a logical key
- * remain distinct even when one keyboard event could match both.
- */
-declare function areHotkeysEqual(left: RegisterableHotkey, right: RegisterableHotkey, platform?: "mac" | "windows" | "linux"): boolean;
-//#endregion
-export { CreateHotkeyHandlerOptions, KeyboardEventMatch, MultiHotkeyHandler, areHotkeysEqual, createHotkeyHandler, createMultiHotkeyHandler, matchesKeyboardEvent };
-//# sourceMappingURL=match.d.cts.map

package/dist/match.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"match.js","names":[],"sources":["../src/match.ts"],"sourcesContent":["import { matchKeyboardEvent } from './_match'\nimport { parseHotkey, parseRegisterableHotkey } from './parse'\nimport { detectPlatform } from './platform'\nimport { keysEqual } from './_keyboard-event'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyCallbackContext,\n  ParsedHotkey,\n  RegisterableHotkey,\n} from './hotkey.types'\n\nexport interface KeyboardEventMatch {\n  matched: boolean\n  score: 0 | 1 | 2 | 3\n  source?: 'key' | 'code' | 'fallback'\n  identity?: { key: string; code: string }\n}\n\n/**\n * Checks if a KeyboardEvent matches a hotkey.\n *\n * Physical bindings such as `Mod+[KeyS]` match `event.code` exactly.\n * Logical bindings use `event.key`, with a fallback to `code`\n * for letter keys, digit keys (0-9), and punctuation keys when `key` produces special\n * characters (e.g., macOS Option+letter, Shift+number, or Option+punctuation).\n * Letter keys are matched case-insensitively.\n *\n * Also handles \"dead key\" events where `event.key` is `'Dead'` instead of the expected\n * character. This commonly occurs on macOS with Option+letter combinations (e.g., Option+E,\n * Option+I, Option+U, Option+N) and on Windows/Linux with international keyboard layouts.\n * In these cases, `event.code` is used to determine the physical key.\n *\n * @param event - The KeyboardEvent to check\n * @param hotkey - The hotkey string or ParsedHotkey to match against\n * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)\n * @returns True if the event matches the hotkey\n *\n * @example\n * ```ts\n * document.addEventListener('keydown', (event) => {\n *   if (matchesKeyboardEvent(event, 'Mod+S')) {\n *     event.preventDefault()\n *     handleSave()\n *   }\n * })\n * ```\n */\nexport function matchesKeyboardEvent(\n  event: KeyboardEvent,\n  hotkey: Hotkey | ParsedHotkey,\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): boolean {\n  return matchKeyboardEvent(event, hotkey, platform).matched\n}\n\n/**\n * Options for creating a hotkey handler.\n */\nexport interface CreateHotkeyHandlerOptions {\n  /** Prevent the default browser action when the hotkey matches. Defaults to true */\n  preventDefault?: boolean\n  /** Stop event propagation when the hotkey matches. Defaults to true */\n  stopPropagation?: boolean\n  /** The target platform for resolving 'Mod' */\n  platform?: 'mac' | 'windows' | 'linux'\n}\n\n/**\n * Creates a keyboard event handler that calls the callback when the hotkey matches.\n *\n * @param hotkey - The hotkey string or ParsedHotkey to match\n * @param callback - The function to call when the hotkey matches\n * @param options - Options for matching and handling\n * @returns A function that can be used as an event handler\n *\n * @example\n * ```ts\n * const handler = createHotkeyHandler('Mod+S', (event, { hotkey, parsedHotkey }) => {\n *   console.log(`${hotkey} was pressed`)\n *   handleSave()\n * })\n *\n * document.addEventListener('keydown', handler)\n * ```\n */\nexport function createHotkeyHandler(\n  hotkey: Hotkey | ParsedHotkey,\n  callback: HotkeyCallback,\n  options: CreateHotkeyHandlerOptions = {},\n): (event: KeyboardEvent) => void {\n  const { preventDefault = true, stopPropagation = true, platform } = options\n  const resolvedPlatform = platform ?? detectPlatform()\n\n  const hotkeyString: Hotkey =\n    typeof hotkey === 'string' ? hotkey : formatParsedHotkey(hotkey)\n  const parsed =\n    typeof hotkey === 'string' ? parseHotkey(hotkey, resolvedPlatform) : hotkey\n\n  const context: HotkeyCallbackContext = {\n    hotkey: hotkeyString,\n    parsedHotkey: parsed,\n  }\n\n  return (event: KeyboardEvent) => {\n    if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {\n      if (preventDefault) {\n        event.preventDefault()\n      }\n      if (stopPropagation) {\n        event.stopPropagation()\n      }\n      callback(event, context)\n    }\n  }\n}\n\nexport type MultiHotkeyHandler = { [K in Hotkey]?: HotkeyCallback }\n\n/**\n * Creates a handler that matches multiple hotkeys.\n *\n * @param handlers - A map of hotkey strings to their handlers\n * @param options - Options for matching and handling\n * @returns A function that can be used as an event handler\n *\n * @example\n * ```ts\n * const handler = createMultiHotkeyHandler({\n *   'Mod+S': (event, { hotkey }) => handleSave(),\n *   'Mod+Z': (event, { hotkey }) => handleUndo(),\n *   'Mod+Shift+Z': (event, { hotkey }) => handleRedo(),\n * })\n *\n * document.addEventListener('keydown', handler)\n * ```\n */\nexport function createMultiHotkeyHandler(\n  handlers: MultiHotkeyHandler,\n  options: CreateHotkeyHandlerOptions = {},\n): (event: KeyboardEvent) => void {\n  const { preventDefault = true, stopPropagation = true, platform } = options\n  const resolvedPlatform = platform ?? detectPlatform()\n\n  // Pre-parse all hotkeys for efficiency\n  const parsedHandlers = Object.entries(handlers)\n    .filter((entry): entry is [string, HotkeyCallback] => Boolean(entry[1]))\n    .map(([hotkey, handler]) => {\n      const parsed = parseHotkey(hotkey as Hotkey, resolvedPlatform)\n      const context: HotkeyCallbackContext = {\n        hotkey: hotkey as Hotkey,\n        parsedHotkey: parsed,\n      }\n      return { parsed, handler, context }\n    })\n\n  return (event: KeyboardEvent) => {\n    for (const { parsed, handler, context } of parsedHandlers) {\n      if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {\n        if (preventDefault) {\n          event.preventDefault()\n        }\n        if (stopPropagation) {\n          event.stopPropagation()\n        }\n        handler(event, context)\n        return // Only handle the first match\n      }\n    }\n  }\n}\n\n/**\n * Formats a ParsedHotkey back to a hotkey string.\n * Used internally to provide the hotkey string in callback context.\n */\nfunction formatParsedHotkey(parsed: ParsedHotkey): Hotkey {\n  const parts: Array<string> = []\n\n  if (parsed.ctrl) parts.push('Control')\n  if (parsed.alt) parts.push('Alt')\n  if (parsed.shift) parts.push('Shift')\n  if (parsed.meta) parts.push('Meta')\n  parts.push(parsed.code !== undefined ? `[${parsed.code}]` : parsed.key)\n\n  return parts.join('+') as Hotkey\n}\n\n/**\n * Compares normalized binding identity, including all four modifiers.\n * Aliases resolve on the supplied platform. A physical code and a logical key\n * remain distinct even when one keyboard event could match both.\n */\nexport function areHotkeysEqual(\n  left: RegisterableHotkey,\n  right: RegisterableHotkey,\n  platform = detectPlatform(),\n): boolean {\n  const a = parseRegisterableHotkey(left, platform)\n  const b = parseRegisterableHotkey(right, platform)\n  return (\n    a.ctrl === b.ctrl &&\n    a.alt === b.alt &&\n    a.shift === b.shift &&\n    a.meta === b.meta &&\n    (a.code !== undefined || b.code !== undefined\n      ? a.code === b.code\n      : keysEqual(a.key, b.key))\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,qBACd,OACA,QACA,WAAwC,gBAAgB,EAC/C;AACT,QAAO,mBAAmB,OAAO,QAAQ,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;AAiCrD,SAAgB,oBACd,QACA,UACA,UAAsC,EAAE,EACR;CAChC,MAAM,EAAE,iBAAiB,MAAM,kBAAkB,MAAM,aAAa;CACpE,MAAM,mBAAmB,YAAY,gBAAgB;CAErD,MAAM,eACJ,OAAO,WAAW,WAAW,SAAS,mBAAmB,OAAO;CAClE,MAAM,SACJ,OAAO,WAAW,WAAW,YAAY,QAAQ,iBAAiB,GAAG;CAEvE,MAAM,UAAiC;EACrC,QAAQ;EACR,cAAc;EACf;AAED,SAAQ,UAAyB;AAC/B,MAAI,qBAAqB,OAAO,QAAQ,iBAAiB,EAAE;AACzD,OAAI,eACF,OAAM,gBAAgB;AAExB,OAAI,gBACF,OAAM,iBAAiB;AAEzB,YAAS,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;AAyB9B,SAAgB,yBACd,UACA,UAAsC,EAAE,EACR;CAChC,MAAM,EAAE,iBAAiB,MAAM,kBAAkB,MAAM,aAAa;CACpE,MAAM,mBAAmB,YAAY,gBAAgB;CAGrD,MAAM,iBAAiB,OAAO,QAAQ,SAAS,CAC5C,QAAQ,UAA6C,QAAQ,MAAM,GAAG,CAAC,CACvE,KAAK,CAAC,QAAQ,aAAa;EAC1B,MAAM,SAAS,YAAY,QAAkB,iBAAiB;AAK9D,SAAO;GAAE;GAAQ;GAAS,SAJa;IAC7B;IACR,cAAc;IACf;GACkC;GACnC;AAEJ,SAAQ,UAAyB;AAC/B,OAAK,MAAM,EAAE,QAAQ,SAAS,aAAa,eACzC,KAAI,qBAAqB,OAAO,QAAQ,iBAAiB,EAAE;AACzD,OAAI,eACF,OAAM,gBAAgB;AAExB,OAAI,gBACF,OAAM,iBAAiB;AAEzB,WAAQ,OAAO,QAAQ;AACvB;;;;;;;;AAUR,SAAS,mBAAmB,QAA8B;CACxD,MAAM,QAAuB,EAAE;AAE/B,KAAI,OAAO,KAAM,OAAM,KAAK,UAAU;AACtC,KAAI,OAAO,IAAK,OAAM,KAAK,MAAM;AACjC,KAAI,OAAO,MAAO,OAAM,KAAK,QAAQ;AACrC,KAAI,OAAO,KAAM,OAAM,KAAK,OAAO;AACnC,OAAM,KAAK,OAAO,SAAS,SAAY,IAAI,OAAO,KAAK,KAAK,OAAO,IAAI;AAEvE,QAAO,MAAM,KAAK,IAAI;;;;;;;AAQxB,SAAgB,gBACd,MACA,OACA,WAAW,gBAAgB,EAClB;CACT,MAAM,IAAI,wBAAwB,MAAM,SAAS;CACjD,MAAM,IAAI,wBAAwB,OAAO,SAAS;AAClD,QACE,EAAE,SAAS,EAAE,QACb,EAAE,QAAQ,EAAE,OACZ,EAAE,UAAU,EAAE,SACd,EAAE,SAAS,EAAE,SACZ,EAAE,SAAS,UAAa,EAAE,SAAS,SAChC,EAAE,SAAS,EAAE,OACb,UAAU,EAAE,KAAK,EAAE,IAAI"}

package/dist/parse.cjs

@@ -1,245 +0,0 @@
-const require_constants = require('./constants.cjs');
-const require_platform = require('./platform.cjs');
-const require__keyboard_event = require('./_keyboard-event.cjs');
-
-//#region src/parse.ts
-/**
-* Parses a hotkey string into its component parts.
-*
-* @param hotkey - The hotkey string to parse (e.g., 'Mod+Shift+S')
-* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
-* @returns A ParsedHotkey with either logical key or physical code and modifier flags
-*
-* @example
-* ```ts
-* parseHotkey('Mod+S') // On Mac: { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }
-* parseHotkey('Mod+S') // On Windows: { key: 'S', ctrl: true, shift: false, alt: false, meta: false, modifiers: ['Control'] }
-* parseHotkey('Control+Shift+A') // { key: 'A', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }
-* ```
-*/
-function parseHotkey(hotkey, platform = require_platform.detectPlatform()) {
-	const parts = require__keyboard_event.splitHotkeyParts(hotkey);
-	const modifiers = /* @__PURE__ */ new Set();
-	let key = "";
-	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i].trim();
-		if (i === parts.length - 1) key = require_constants.normalizeKeyName(part);
-		else {
-			const alias = require_constants.MODIFIER_ALIASES[part] ?? require_constants.MODIFIER_ALIASES[part.toLowerCase()];
-			if (alias) {
-				const resolved = require_platform.resolveModifier(alias, platform);
-				modifiers.add(resolved);
-			} else if (parts.length === 1) key = require_constants.normalizeKeyName(part);
-		}
-	}
-	if (!key && parts.length > 0) key = require_constants.normalizeKeyName(parts[parts.length - 1].trim());
-	const code = /^\[([A-Za-z][A-Za-z0-9]*)\]$/.exec(key)?.[1];
-	return {
-		...code !== void 0 ? { code } : { key },
-		ctrl: modifiers.has("Control"),
-		shift: modifiers.has("Shift"),
-		alt: modifiers.has("Alt"),
-		meta: modifiers.has("Meta"),
-		modifiers: require_constants.MODIFIER_ORDER.filter((m) => modifiers.has(m))
-	};
-}
-/**
-* Converts a RawHotkey object to a ParsedHotkey.
-* Optional modifier booleans default to false; modifiers array is derived from them.
-* When `mod` is true, it is resolved to Control or Meta based on platform.
-*
-* @param raw - The raw hotkey object
-* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
-* @returns A ParsedHotkey suitable for matching and formatting
-*
-* @example
-* ```ts
-* rawHotkeyToParsedHotkey({ key: 'Escape' })
-* // { key: 'Escape', ctrl: false, shift: false, alt: false, meta: false, modifiers: [] }
-*
-* rawHotkeyToParsedHotkey({ key: 'S', mod: true }, 'mac')
-* // { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }
-*
-* rawHotkeyToParsedHotkey({ key: 'S', mod: true, shift: true }, 'windows')
-* // { key: 'S', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }
-* ```
-*/
-function rawHotkeyToParsedHotkey(raw, platform = require_platform.detectPlatform()) {
-	if (raw.code === void 0) require__keyboard_event.assertLogicalKey(raw.key);
-	let ctrl = raw.ctrl ?? false;
-	const shift = raw.shift ?? false;
-	const alt = raw.alt ?? false;
-	let meta = raw.meta ?? false;
-	if (raw.mod) if (require_platform.resolveModifier("Mod", platform) === "Control") ctrl = true;
-	else meta = true;
-	const modifiers = require_constants.MODIFIER_ORDER.filter((m) => {
-		switch (m) {
-			case "Control": return ctrl;
-			case "Shift": return shift;
-			case "Alt": return alt;
-			case "Meta": return meta;
-			default: return false;
-		}
-	});
-	return {
-		...raw.code !== void 0 ? { code: raw.code } : { key: require_constants.normalizeKeyName(raw.key) },
-		ctrl,
-		shift,
-		alt,
-		meta,
-		modifiers
-	};
-}
-/**
-* Serializes a parsed hotkey to the canonical string form used for registration
-* and storage: `Mod` first when the platform allows, then `Alt`, then `Shift`;
-* otherwise full `Control+Alt+Shift+Meta` order.
-*/
-function normalizedHotkeyStringFromParsed(parsed, platform) {
-	if (parsed.code === void 0) require__keyboard_event.assertLogicalKey(parsed.key);
-	const canUseMod = platform === "mac" ? parsed.meta && !parsed.ctrl : parsed.ctrl && !parsed.meta;
-	const parts = [];
-	if (canUseMod) {
-		parts.push("Mod");
-		if (parsed.alt) parts.push("Alt");
-		if (parsed.shift) parts.push("Shift");
-	} else for (const modifier of require_constants.MODIFIER_ORDER) if (parsed.modifiers.includes(modifier)) parts.push(modifier);
-	parts.push(parsed.code !== void 0 ? `[${parsed.code}]` : require_constants.normalizeKeyName(parsed.key));
-	return parts.join("+");
-}
-/**
-* Normalizes a hotkey string to its canonical form.
-*
-* - When `Mod` is allowed for the platform (Command on Mac without Control;
-*   Control on Windows/Linux without Meta): emits `Mod`, then `Alt`, then `Shift`,
-*   then the key (e.g. `Mod+Shift+E`, `Mod+S`).
-* - Otherwise: literal modifiers in `Control+Alt+Shift+Meta` order, then the key.
-* - Resolves aliases and normalizes key casing (e.g. `esc` → `Escape`, `a` → `A`).
-*
-* @param hotkey - The hotkey string to normalize
-* @param platform - The target platform for resolving `Mod` (defaults to auto-detection)
-* @returns The normalized hotkey string
-*
-* @example
-* ```ts
-* normalizeHotkey('shift+meta+e', 'mac') // 'Mod+Shift+E'
-* normalizeHotkey('ctrl+a', 'windows') // 'Mod+A'
-* normalizeHotkey('esc') // 'Escape'
-* ```
-*/
-function normalizeHotkey(hotkey, platform = require_platform.detectPlatform()) {
-	return normalizedHotkeyStringFromParsed(parseHotkey(hotkey, platform), platform);
-}
-/**
-* Same canonical string as {@link normalizeHotkey}, but from an already-parsed hotkey.
-*/
-function normalizeHotkeyFromParsed(parsed, platform = require_platform.detectPlatform()) {
-	return normalizedHotkeyStringFromParsed(parsed, platform);
-}
-/**
-* Normalizes a string or {@link RawHotkey} object to the same canonical hotkey string.
-* Use this in framework adapters instead of branching on `formatHotkey(rawHotkeyToParsedHotkey(...))`.
-*/
-function normalizeRegisterableHotkey(hotkey, platform = require_platform.detectPlatform()) {
-	return typeof hotkey === "string" ? normalizeHotkey(hotkey, platform) : normalizeHotkeyFromParsed(rawHotkeyToParsedHotkey(hotkey, platform), platform);
-}
-/**
-* Checks if a string is a recognized modifier token (including aliases).
-*
-* For a `KeyboardEvent`, use `isModifier(normalizeKeyName(event.key))` so DOM
-* spellings like `OS` / `Win` match the same alias table.
-*
-* @param key - Key name or alias (e.g. from a hotkey string or `event.key`)
-* @returns True if the string is a recognized modifier
-*/
-function isModifierKey(key) {
-	return key in require_constants.MODIFIER_ALIASES || key.toLowerCase() in require_constants.MODIFIER_ALIASES;
-}
-/**
-* Parses a KeyboardEvent into a ParsedHotkey object.
-*
-* This function extracts the key and modifier state from a keyboard event
-* and converts it into the same format used by `parseHotkey()`.
-*
-* @param event - The KeyboardEvent to parse
-* @param platform - The target platform for resolving modifiers (defaults to auto-detection)
-* @returns A ParsedHotkey object representing the keyboard event
-*
-* @example
-* ```ts
-* document.addEventListener('keydown', (event) => {
-*   const parsed = parseKeyboardEvent(event)
-*   console.log(parsed) // { key: 'S', ctrl: true, shift: false, ... }
-* })
-* ```
-*/
-function parseKeyboardEvent(event, platform) {
-	const normalized = require__keyboard_event.normalizeKeyboardEvent(event, platform);
-	const ctrl = normalized.altGraph ? false : normalized.ctrl;
-	const alt = normalized.altGraph ? false : normalized.alt;
-	const shift = normalized.shift;
-	const modifiers = [];
-	if (ctrl) modifiers.push("Control");
-	if (alt) modifiers.push("Alt");
-	if (shift) modifiers.push("Shift");
-	if (normalized.meta) modifiers.push("Meta");
-	return {
-		key: normalized.key,
-		ctrl,
-		shift,
-		alt,
-		meta: normalized.meta,
-		modifiers
-	};
-}
-/**
-* Normalizes a keyboard event to the same canonical hotkey string as {@link normalizeHotkey}.
-*
-* @param event - The keyboard event (typically `keydown`)
-* @param platform - Target platform for `Mod` eligibility
-*/
-function normalizeHotkeyFromEvent(event, platform = require_platform.detectPlatform()) {
-	return normalizedHotkeyStringFromParsed(parseKeyboardEvent(event, platform), platform);
-}
-/**
-* Checks if a hotkey or ParsedHotkey contains at least one non-modifier key.
-*
-* This is useful for validating that a recorded hotkey is complete and not
-* just a combination of modifiers without an action key.
-*
-* @param hotkey - The hotkey string or ParsedHotkey to check
-* @param platform - The target platform for parsing (defaults to auto-detection)
-* @returns True if the hotkey contains at least one non-modifier key
-*
-* @example
-* ```ts
-* hasNonModifierKey('Control+Shift+S') // true
-* hasNonModifierKey('Control+Shift') // false (no action key)
-* hasNonModifierKey(parseHotkey('Mod+A')) // true
-* ```
-*/
-function hasNonModifierKey(hotkey, platform = require_platform.detectPlatform()) {
-	const parsed = typeof hotkey === "string" ? parseHotkey(hotkey, platform) : hotkey;
-	if (parsed.code !== void 0) return parsed.code.length > 0 && !/^(Control|Shift|Alt|Meta)(Left|Right)$/.test(parsed.code);
-	return !isModifierKey(parsed.key) && parsed.key.length > 0;
-}
-/**
-* Parses a string or raw binding, resolving Mod for the supplied platform.
-* Physical tokens such as `[KeyQ]` retain `code`; they never become logical Q.
-*/
-function parseRegisterableHotkey(hotkey, platform = require_platform.detectPlatform()) {
-	return typeof hotkey === "string" ? parseHotkey(hotkey, platform) : rawHotkeyToParsedHotkey(hotkey, platform);
-}
-
-//#endregion
-exports.hasNonModifierKey = hasNonModifierKey;
-exports.isModifierKey = isModifierKey;
-exports.normalizeHotkey = normalizeHotkey;
-exports.normalizeHotkeyFromEvent = normalizeHotkeyFromEvent;
-exports.normalizeHotkeyFromParsed = normalizeHotkeyFromParsed;
-exports.normalizeRegisterableHotkey = normalizeRegisterableHotkey;
-exports.parseHotkey = parseHotkey;
-exports.parseKeyboardEvent = parseKeyboardEvent;
-exports.parseRegisterableHotkey = parseRegisterableHotkey;
-exports.rawHotkeyToParsedHotkey = rawHotkeyToParsedHotkey;
-//# sourceMappingURL=parse.cjs.map