@tanstack/hotkeys 0.8.0 → 0.10.0

package/dist/parse.d.cts

@@ -1,128 +0,0 @@
-import { Hotkey, Key, ParsedHotkey, RawHotkey, RegisterableHotkey } from "./hotkey.cjs";
-import { MODIFIER_ALIASES } from "./constants.cjs";
-
-//#region src/parse.d.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 object with the key 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'] }
- * ```
- */
-declare function parseHotkey(hotkey: Hotkey | (string & {}), platform?: 'mac' | 'windows' | 'linux'): ParsedHotkey;
-/**
- * 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'] }
- * ```
- */
-declare function rawHotkeyToParsedHotkey(raw: RawHotkey, platform?: 'mac' | 'windows' | 'linux'): ParsedHotkey;
-/**
- * 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'
- * ```
- */
-declare function normalizeHotkey(hotkey: Key | (string & {}), platform?: 'mac' | 'windows' | 'linux'): Hotkey;
-/**
- * Same canonical string as {@link normalizeHotkey}, but from an already-parsed hotkey.
- */
-declare function normalizeHotkeyFromParsed(parsed: ParsedHotkey, platform?: 'mac' | 'windows' | 'linux'): Hotkey;
-/**
- * Normalizes a string or {@link RawHotkey} object to the same canonical hotkey string.
- * Use this in framework adapters instead of branching on `formatHotkey(rawHotkeyToParsedHotkey(...))`.
- */
-declare function normalizeRegisterableHotkey(hotkey: RegisterableHotkey, platform?: 'mac' | 'windows' | 'linux'): Hotkey;
-/**
- * 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
- */
-declare function isModifierKey(key: Key | (string & {})): key is keyof typeof 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, ... }
- * })
- * ```
- */
-declare function parseKeyboardEvent(event: KeyboardEvent): ParsedHotkey;
-/**
- * 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
- */
-declare function normalizeHotkeyFromEvent(event: KeyboardEvent, platform?: 'mac' | 'windows' | 'linux'): Hotkey;
-/**
- * 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
- * ```
- */
-declare function hasNonModifierKey(hotkey: Hotkey | ParsedHotkey | (string & {}), platform?: 'mac' | 'windows' | 'linux'): boolean;
-//#endregion
-export { hasNonModifierKey, isModifierKey, normalizeHotkey, normalizeHotkeyFromEvent, normalizeHotkeyFromParsed, normalizeRegisterableHotkey, parseHotkey, parseKeyboardEvent, rawHotkeyToParsedHotkey };
-//# sourceMappingURL=parse.d.cts.map

package/dist/parse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.js","names":[],"sources":["../src/parse.ts"],"sourcesContent":["import {\n  MODIFIER_ALIASES,\n  MODIFIER_ORDER,\n  detectPlatform,\n  normalizeKeyName,\n  resolveModifier,\n} from './constants'\nimport type {\n  CanonicalModifier,\n  Hotkey,\n  Key,\n  ParsedHotkey,\n  RawHotkey,\n  RegisterableHotkey,\n} from './hotkey'\n\n/**\n * Parses a hotkey string into its component parts.\n *\n * @param hotkey - The hotkey string to parse (e.g., 'Mod+Shift+S')\n * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)\n * @returns A ParsedHotkey object with the key and modifier flags\n *\n * @example\n * ```ts\n * parseHotkey('Mod+S') // On Mac: { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }\n * parseHotkey('Mod+S') // On Windows: { key: 'S', ctrl: true, shift: false, alt: false, meta: false, modifiers: ['Control'] }\n * parseHotkey('Control+Shift+A') // { key: 'A', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }\n * ```\n */\nexport function parseHotkey(\n  hotkey: Hotkey | (string & {}),\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): ParsedHotkey {\n  const parts = hotkey.split('+')\n  const modifiers: Set<CanonicalModifier> = new Set()\n  let key = ''\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]!.trim()\n\n    if (i === parts.length - 1) {\n      // Last part is always the key\n      key = normalizeKeyName(part)\n    } else {\n      // All other parts are modifiers\n      const alias =\n        MODIFIER_ALIASES[part] ?? MODIFIER_ALIASES[part.toLowerCase()]\n\n      if (alias) {\n        const resolved = resolveModifier(alias, platform)\n        modifiers.add(resolved)\n      } else {\n        // Unknown modifier, treat as part of the key if it's the only part\n        // or ignore if there are more parts\n        if (parts.length === 1) {\n          key = normalizeKeyName(part)\n        }\n      }\n    }\n  }\n\n  // If no key was found (empty string), use the last part as-is\n  if (!key && parts.length > 0) {\n    key = normalizeKeyName(parts[parts.length - 1]!.trim())\n  }\n\n  return {\n    key,\n    ctrl: modifiers.has('Control'),\n    shift: modifiers.has('Shift'),\n    alt: modifiers.has('Alt'),\n    meta: modifiers.has('Meta'),\n    modifiers: MODIFIER_ORDER.filter((m) => modifiers.has(m)),\n  }\n}\n\n/**\n * Converts a RawHotkey object to a ParsedHotkey.\n * Optional modifier booleans default to false; modifiers array is derived from them.\n * When `mod` is true, it is resolved to Control or Meta based on platform.\n *\n * @param raw - The raw hotkey object\n * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)\n * @returns A ParsedHotkey suitable for matching and formatting\n *\n * @example\n * ```ts\n * rawHotkeyToParsedHotkey({ key: 'Escape' })\n * // { key: 'Escape', ctrl: false, shift: false, alt: false, meta: false, modifiers: [] }\n *\n * rawHotkeyToParsedHotkey({ key: 'S', mod: true }, 'mac')\n * // { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }\n *\n * rawHotkeyToParsedHotkey({ key: 'S', mod: true, shift: true }, 'windows')\n * // { key: 'S', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }\n * ```\n */\nexport function rawHotkeyToParsedHotkey(\n  raw: RawHotkey,\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): ParsedHotkey {\n  let ctrl = raw.ctrl ?? false\n  const shift = raw.shift ?? false\n  const alt = raw.alt ?? false\n  let meta = raw.meta ?? false\n\n  if (raw.mod) {\n    const resolved = resolveModifier('Mod', platform)\n    if (resolved === 'Control') {\n      ctrl = true\n    } else {\n      meta = true\n    }\n  }\n\n  const modifiers: Array<CanonicalModifier> = MODIFIER_ORDER.filter((m) => {\n    switch (m) {\n      case 'Control':\n        return ctrl\n      case 'Shift':\n        return shift\n      case 'Alt':\n        return alt\n      case 'Meta':\n        return meta\n      default:\n        return false\n    }\n  })\n  return {\n    key: raw.key,\n    ctrl,\n    shift,\n    alt,\n    meta,\n    modifiers,\n  }\n}\n\n/**\n * Serializes a parsed hotkey to the canonical string form used for registration\n * and storage: `Mod` first when the platform allows, then `Alt`, then `Shift`;\n * otherwise full `Control+Alt+Shift+Meta` order.\n */\nfunction normalizedHotkeyStringFromParsed(\n  parsed: ParsedHotkey,\n  platform: 'mac' | 'windows' | 'linux',\n): Hotkey {\n  const canUseMod =\n    platform === 'mac'\n      ? parsed.meta && !parsed.ctrl\n      : parsed.ctrl && !parsed.meta\n\n  const parts: Array<string> = []\n\n  if (canUseMod) {\n    parts.push('Mod')\n    if (parsed.alt) {\n      parts.push('Alt')\n    }\n    if (parsed.shift) {\n      parts.push('Shift')\n    }\n  } else {\n    for (const modifier of MODIFIER_ORDER) {\n      if (parsed.modifiers.includes(modifier)) {\n        parts.push(modifier)\n      }\n    }\n  }\n\n  parts.push(normalizeKeyName(parsed.key))\n  return parts.join('+') as Hotkey\n}\n\n/**\n * Normalizes a hotkey string to its canonical form.\n *\n * - When `Mod` is allowed for the platform (Command on Mac without Control;\n *   Control on Windows/Linux without Meta): emits `Mod`, then `Alt`, then `Shift`,\n *   then the key (e.g. `Mod+Shift+E`, `Mod+S`).\n * - Otherwise: literal modifiers in `Control+Alt+Shift+Meta` order, then the key.\n * - Resolves aliases and normalizes key casing (e.g. `esc` → `Escape`, `a` → `A`).\n *\n * @param hotkey - The hotkey string to normalize\n * @param platform - The target platform for resolving `Mod` (defaults to auto-detection)\n * @returns The normalized hotkey string\n *\n * @example\n * ```ts\n * normalizeHotkey('shift+meta+e', 'mac') // 'Mod+Shift+E'\n * normalizeHotkey('ctrl+a', 'windows') // 'Mod+A'\n * normalizeHotkey('esc') // 'Escape'\n * ```\n */\nexport function normalizeHotkey(\n  hotkey: Key | (string & {}),\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): Hotkey {\n  return normalizedHotkeyStringFromParsed(\n    parseHotkey(hotkey, platform),\n    platform,\n  )\n}\n\n/**\n * Same canonical string as {@link normalizeHotkey}, but from an already-parsed hotkey.\n */\nexport function normalizeHotkeyFromParsed(\n  parsed: ParsedHotkey,\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): Hotkey {\n  return normalizedHotkeyStringFromParsed(parsed, platform)\n}\n\n/**\n * Normalizes a string or {@link RawHotkey} object to the same canonical hotkey string.\n * Use this in framework adapters instead of branching on `formatHotkey(rawHotkeyToParsedHotkey(...))`.\n */\nexport function normalizeRegisterableHotkey(\n  hotkey: RegisterableHotkey,\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): Hotkey {\n  return typeof hotkey === 'string'\n    ? normalizeHotkey(hotkey, platform)\n    : normalizeHotkeyFromParsed(\n        rawHotkeyToParsedHotkey(hotkey, platform),\n        platform,\n      )\n}\n\n/**\n * Checks if a string is a recognized modifier token (including aliases).\n *\n * For a `KeyboardEvent`, use `isModifier(normalizeKeyName(event.key))` so DOM\n * spellings like `OS` / `Win` match the same alias table.\n *\n * @param key - Key name or alias (e.g. from a hotkey string or `event.key`)\n * @returns True if the string is a recognized modifier\n */\nexport function isModifierKey(\n  key: Key | (string & {}),\n): key is keyof typeof MODIFIER_ALIASES {\n  return key in MODIFIER_ALIASES || key.toLowerCase() in MODIFIER_ALIASES\n}\n\n/**\n * Parses a KeyboardEvent into a ParsedHotkey object.\n *\n * This function extracts the key and modifier state from a keyboard event\n * and converts it into the same format used by `parseHotkey()`.\n *\n * @param event - The KeyboardEvent to parse\n * @param platform - The target platform for resolving modifiers (defaults to auto-detection)\n * @returns A ParsedHotkey object representing the keyboard event\n *\n * @example\n * ```ts\n * document.addEventListener('keydown', (event) => {\n *   const parsed = parseKeyboardEvent(event)\n *   console.log(parsed) // { key: 'S', ctrl: true, shift: false, ... }\n * })\n * ```\n */\nexport function parseKeyboardEvent(event: KeyboardEvent): ParsedHotkey {\n  const normalizedKey = normalizeKeyName(event.key)\n\n  // Build modifiers array in canonical order\n  const modifiers: Array<CanonicalModifier> = []\n  if (event.ctrlKey) modifiers.push('Control')\n  if (event.altKey) modifiers.push('Alt')\n  if (event.shiftKey) modifiers.push('Shift')\n  if (event.metaKey) modifiers.push('Meta')\n\n  return {\n    key: normalizedKey,\n    ctrl: event.ctrlKey,\n    shift: event.shiftKey,\n    alt: event.altKey,\n    meta: event.metaKey,\n    modifiers,\n  }\n}\n\n/**\n * Normalizes a keyboard event to the same canonical hotkey string as {@link normalizeHotkey}.\n *\n * @param event - The keyboard event (typically `keydown`)\n * @param platform - Target platform for `Mod` eligibility\n */\nexport function normalizeHotkeyFromEvent(\n  event: KeyboardEvent,\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): Hotkey {\n  return normalizedHotkeyStringFromParsed(parseKeyboardEvent(event), platform)\n}\n\n/**\n * Checks if a hotkey or ParsedHotkey contains at least one non-modifier key.\n *\n * This is useful for validating that a recorded hotkey is complete and not\n * just a combination of modifiers without an action key.\n *\n * @param hotkey - The hotkey string or ParsedHotkey to check\n * @param platform - The target platform for parsing (defaults to auto-detection)\n * @returns True if the hotkey contains at least one non-modifier key\n *\n * @example\n * ```ts\n * hasNonModifierKey('Control+Shift+S') // true\n * hasNonModifierKey('Control+Shift') // false (no action key)\n * hasNonModifierKey(parseHotkey('Mod+A')) // true\n * ```\n */\nexport function hasNonModifierKey(\n  hotkey: Hotkey | ParsedHotkey | (string & {}),\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): boolean {\n  const parsed =\n    typeof hotkey === 'string' ? parseHotkey(hotkey, platform) : hotkey\n\n  // Check if the key part is actually a modifier\n  const keyIsModifier = isModifierKey(parsed.key)\n\n  // A valid hotkey must have a non-modifier key\n  return !keyIsModifier && parsed.key.length > 0\n}\n"],"mappings":"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"}

package/dist/recorder-chord.cjs

@@ -1,18 +0,0 @@
-const require_constants = require('./constants.cjs');
-const require_parse = require('./parse.cjs');
-
-//#region src/recorder-chord.ts
-/**
-* Parses a keydown event into a single normalized hotkey chord, or null if
-* the event should be ignored (modifier-only or invalid).
-*/
-function hotkeyChordFromKeydown(event, platform) {
-	if (require_parse.isModifierKey(require_constants.normalizeKeyName(event.key))) return null;
-	const finalHotkey = require_parse.normalizeHotkeyFromEvent(event, platform);
-	if (!require_parse.hasNonModifierKey(finalHotkey, platform)) return null;
-	return finalHotkey;
-}
-
-//#endregion
-exports.hotkeyChordFromKeydown = hotkeyChordFromKeydown;
-//# sourceMappingURL=recorder-chord.cjs.map

package/dist/recorder-chord.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"recorder-chord.cjs","names":["isModifierKey","normalizeKeyName","normalizeHotkeyFromEvent","hasNonModifierKey"],"sources":["../src/recorder-chord.ts"],"sourcesContent":["import { normalizeKeyName } from './constants'\nimport {\n  hasNonModifierKey,\n  isModifierKey,\n  normalizeHotkeyFromEvent,\n} from './parse'\nimport type { Hotkey } from './hotkey'\n\n/**\n * Parses a keydown event into a single normalized hotkey chord, or null if\n * the event should be ignored (modifier-only or invalid).\n */\nexport function hotkeyChordFromKeydown(\n  event: KeyboardEvent,\n  platform: 'mac' | 'windows' | 'linux',\n): Hotkey | null {\n  if (isModifierKey(normalizeKeyName(event.key))) {\n    return null\n  }\n  const finalHotkey = normalizeHotkeyFromEvent(event, platform)\n  if (!hasNonModifierKey(finalHotkey, platform)) {\n    return null\n  }\n  return finalHotkey\n}\n"],"mappings":";;;;;;;;AAYA,SAAgB,uBACd,OACA,UACe;AACf,KAAIA,4BAAcC,mCAAiB,MAAM,IAAI,CAAC,CAC5C,QAAO;CAET,MAAM,cAAcC,uCAAyB,OAAO,SAAS;AAC7D,KAAI,CAACC,gCAAkB,aAAa,SAAS,CAC3C,QAAO;AAET,QAAO"}

package/dist/recorder-chord.js

@@ -1,18 +0,0 @@
-import { normalizeKeyName } from "./constants.js";
-import { hasNonModifierKey, isModifierKey, normalizeHotkeyFromEvent } from "./parse.js";
-
-//#region src/recorder-chord.ts
-/**
-* Parses a keydown event into a single normalized hotkey chord, or null if
-* the event should be ignored (modifier-only or invalid).
-*/
-function hotkeyChordFromKeydown(event, platform) {
-	if (isModifierKey(normalizeKeyName(event.key))) return null;
-	const finalHotkey = normalizeHotkeyFromEvent(event, platform);
-	if (!hasNonModifierKey(finalHotkey, platform)) return null;
-	return finalHotkey;
-}
-
-//#endregion
-export { hotkeyChordFromKeydown };
-//# sourceMappingURL=recorder-chord.js.map

package/dist/recorder-chord.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"recorder-chord.js","names":[],"sources":["../src/recorder-chord.ts"],"sourcesContent":["import { normalizeKeyName } from './constants'\nimport {\n  hasNonModifierKey,\n  isModifierKey,\n  normalizeHotkeyFromEvent,\n} from './parse'\nimport type { Hotkey } from './hotkey'\n\n/**\n * Parses a keydown event into a single normalized hotkey chord, or null if\n * the event should be ignored (modifier-only or invalid).\n */\nexport function hotkeyChordFromKeydown(\n  event: KeyboardEvent,\n  platform: 'mac' | 'windows' | 'linux',\n): Hotkey | null {\n  if (isModifierKey(normalizeKeyName(event.key))) {\n    return null\n  }\n  const finalHotkey = normalizeHotkeyFromEvent(event, platform)\n  if (!hasNonModifierKey(finalHotkey, platform)) {\n    return null\n  }\n  return finalHotkey\n}\n"],"mappings":";;;;;;;;AAYA,SAAgB,uBACd,OACA,UACe;AACf,KAAI,cAAc,iBAAiB,MAAM,IAAI,CAAC,CAC5C,QAAO;CAET,MAAM,cAAc,yBAAyB,OAAO,SAAS;AAC7D,KAAI,CAAC,kBAAkB,aAAa,SAAS,CAC3C,QAAO;AAET,QAAO"}

package/dist/sequence-manager.cjs

@@ -1,415 +0,0 @@
-const require_constants = require('./constants.cjs');
-const require_parse = require('./parse.cjs');
-const require_format = require('./format.cjs');
-const require_match = require('./match.cjs');
-const require_manager_utils = require('./manager.utils.cjs');
-let _tanstack_store = require("@tanstack/store");
-
-//#region src/sequence-manager.ts
-/**
-* Default timeout between keys in a sequence (in milliseconds).
-* Exported for consumers that display sequence state (e.g. devtools).
-*/
-const DEFAULT_SEQUENCE_TIMEOUT = 1e3;
-let sequenceIdCounter = 0;
-/**
-* Generates a unique ID for sequence registrations.
-*/
-function generateSequenceId() {
-	return `sequence_${++sequenceIdCounter}`;
-}
-/**
-* Returns a canonical string for sequence conflict comparison.
-*/
-function sequenceKey(sequence) {
-	return sequence.join("|");
-}
-/**
-* Manages keyboard sequence matching for Vim-style shortcuts.
-*
-* This class allows registering multi-key sequences like 'g g' or 'd d'
-* that trigger callbacks when the full sequence is pressed within
-* a configurable timeout.
-*
-* Modifier-only `keydown` / `keyup` events (Shift, Control, Alt, or Meta
-* alone) are not processed: they neither match a step nor reset progress.
-* That supports chained modifier chords (e.g. `Shift+R` then `Shift+T`) when
-* the user presses a modifier alone between steps.
-*
-* @example
-* ```ts
-* const matcher = SequenceManager.getInstance()
-*
-* // Register 'g g' to go to top
-* const unregister = matcher.register(['G', 'G'], (event, context) => {
-*   scrollToTop()
-* }, { timeout: 500 })
-*
-* // Later, to unregister:
-* unregister()
-* ```
-*/
-/**
-* Builds a devtools view from an internal registration.
-*/
-function toRegistrationView(reg) {
-	const len = reg.parsedSequence.length;
-	const inProgress = reg.currentIndex > 0 && reg.currentIndex < len;
-	return {
-		id: reg.id,
-		sequence: reg.sequence,
-		options: reg.options,
-		target: reg.target,
-		triggerCount: reg.triggerCount,
-		hasFired: reg.hasFired,
-		matchedStepCount: inProgress ? reg.currentIndex : 0,
-		partialMatchLastKeyTime: inProgress ? reg.lastKeyTime : 0
-	};
-}
-var SequenceManager = class SequenceManager {
-	static #instance = null;
-	#registrations = /* @__PURE__ */ new Map();
-	#targetListeners = /* @__PURE__ */ new Map();
-	#targetRegistrations = /* @__PURE__ */ new Map();
-	#platform;
-	constructor() {
-		this.registrations = new _tanstack_store.Store(/* @__PURE__ */ new Map());
-		this.#platform = require_constants.detectPlatform();
-	}
-	/**
-	* Gets the singleton instance of SequenceManager.
-	*/
-	static getInstance() {
-		if (!SequenceManager.#instance) SequenceManager.#instance = new SequenceManager();
-		return SequenceManager.#instance;
-	}
-	/**
-	* Resets the singleton instance. Useful for testing.
-	*/
-	static resetInstance() {
-		if (SequenceManager.#instance) {
-			SequenceManager.#instance.destroy();
-			SequenceManager.#instance = null;
-		}
-	}
-	#syncRegistrationView(registration) {
-		this.registrations.setState((prev) => new Map(prev).set(registration.id, toRegistrationView(registration)));
-	}
-	/**
-	* Registers a hotkey sequence handler.
-	*
-	* @param sequence - Array of hotkey strings that form the sequence
-	* @param callback - Function to call when the sequence is completed
-	* @param options - Options for the sequence behavior
-	* @returns A handle to update or unregister the sequence
-	*/
-	register(sequence, callback, options = {}) {
-		if (sequence.length === 0) throw new Error("Sequence must contain at least one hotkey");
-		const id = generateSequenceId();
-		const platform = options.platform ?? this.#platform;
-		const parsedSequence = sequence.map((hotkey) => require_parse.parseHotkey(hotkey, platform));
-		const target = options.target ?? (typeof document !== "undefined" ? document : {});
-		const conflictBehavior = options.conflictBehavior ?? "warn";
-		const conflictingRegistration = this.#findConflictingSequence(sequence, target);
-		if (conflictingRegistration) require_manager_utils.handleConflict(conflictingRegistration.id, require_format.formatHotkeySequence(sequence), conflictBehavior, (regId) => this.#unregister(regId));
-		const firstStep = parsedSequence[0];
-		const resolvedIgnoreInputs = options.ignoreInputs ?? require_manager_utils.getDefaultIgnoreInputs(firstStep);
-		const registration = {
-			id,
-			sequence,
-			parsedSequence,
-			callback,
-			options: {
-				...require_manager_utils.defaultHotkeyOptions,
-				timeout: DEFAULT_SEQUENCE_TIMEOUT,
-				...options,
-				platform,
-				ignoreInputs: resolvedIgnoreInputs
-			},
-			target,
-			currentIndex: 0,
-			lastKeyTime: 0,
-			triggerCount: 0,
-			hasFired: false
-		};
-		this.#registrations.set(id, registration);
-		this.registrations.setState((prev) => new Map(prev).set(id, toRegistrationView(registration)));
-		if (!this.#targetRegistrations.has(target)) this.#targetRegistrations.set(target, /* @__PURE__ */ new Set());
-		this.#targetRegistrations.get(target).add(id);
-		this.#ensureListenersForTarget(target);
-		const manager = this;
-		return {
-			get id() {
-				return id;
-			},
-			get isActive() {
-				return manager.#registrations.has(id);
-			},
-			get callback() {
-				return manager.#registrations.get(id)?.callback ?? callback;
-			},
-			set callback(newCallback) {
-				const reg = manager.#registrations.get(id);
-				if (reg) reg.callback = newCallback;
-			},
-			setOptions: (newOptions) => {
-				const reg = manager.#registrations.get(id);
-				if (reg) {
-					reg.options = {
-						...reg.options,
-						...newOptions
-					};
-					manager.registrations.setState((prev) => new Map(prev).set(id, toRegistrationView(reg)));
-				}
-			},
-			unregister: () => {
-				manager.#unregister(id);
-			}
-		};
-	}
-	/**
-	* Unregisters a sequence by its registration ID.
-	*/
-	#unregister(id) {
-		const registration = this.#registrations.get(id);
-		if (!registration) return;
-		const target = registration.target;
-		this.#registrations.delete(id);
-		this.registrations.setState((prev) => {
-			const next = new Map(prev);
-			next.delete(id);
-			return next;
-		});
-		const targetRegs = this.#targetRegistrations.get(target);
-		if (targetRegs) {
-			targetRegs.delete(id);
-			if (targetRegs.size === 0) this.#removeListenersForTarget(target);
-		}
-	}
-	/**
-	* Ensures event listeners are attached for a specific target.
-	*/
-	#ensureListenersForTarget(target) {
-		if (typeof document === "undefined") return;
-		if (this.#targetListeners.has(target)) return;
-		const keydownHandler = this.#createTargetKeyDownHandler(target);
-		const keyupHandler = this.#createTargetKeyUpHandler(target);
-		target.addEventListener("keydown", keydownHandler);
-		target.addEventListener("keyup", keyupHandler);
-		this.#targetListeners.set(target, {
-			keydown: keydownHandler,
-			keyup: keyupHandler
-		});
-	}
-	/**
-	* Removes event listeners for a specific target.
-	*/
-	#removeListenersForTarget(target) {
-		if (typeof document === "undefined") return;
-		const listeners = this.#targetListeners.get(target);
-		if (!listeners) return;
-		target.removeEventListener("keydown", listeners.keydown);
-		target.removeEventListener("keyup", listeners.keyup);
-		this.#targetListeners.delete(target);
-		this.#targetRegistrations.delete(target);
-	}
-	/**
-	* Creates a keydown handler for a specific target.
-	*/
-	#createTargetKeyDownHandler(target) {
-		return (event) => {
-			this.#processTargetEvent(event, target, "keydown");
-		};
-	}
-	/**
-	* Creates a keyup handler for a specific target.
-	*/
-	#createTargetKeyUpHandler(target) {
-		return (event) => {
-			this.#processTargetEvent(event, target, "keyup");
-		};
-	}
-	/**
-	* Processes keyboard events for a specific target and event type.
-	*/
-	#processTargetEvent(event, target, eventType) {
-		if (require_parse.isModifierKey(require_constants.normalizeKeyName(event.key))) return;
-		const targetRegs = this.#targetRegistrations.get(target);
-		if (!targetRegs) return;
-		const now = Date.now();
-		registrationIds: for (const id of targetRegs) {
-			const registration = this.#registrations.get(id);
-			if (!registration) continue;
-			if (!require_manager_utils.isEventForTarget(event, target)) continue;
-			if (!registration.options.enabled) continue;
-			if (registration.options.ignoreInputs !== false) {
-				if (require_manager_utils.shouldIgnoreInputEvent(event, target, registration.target)) continue registrationIds;
-			}
-			if (registration.options.eventType !== eventType) continue;
-			const timeout = registration.options.timeout ?? 1e3;
-			if (registration.currentIndex > 0 && now - registration.lastKeyTime > timeout) {
-				registration.currentIndex = 0;
-				this.#syncRegistrationView(registration);
-			}
-			const expectedHotkey = registration.parsedSequence[registration.currentIndex];
-			if (!expectedHotkey) continue;
-			if (require_match.matchesKeyboardEvent(event, expectedHotkey, registration.options.platform)) {
-				registration.lastKeyTime = now;
-				registration.currentIndex++;
-				if (registration.currentIndex >= registration.parsedSequence.length) {
-					if (registration.options.preventDefault) event.preventDefault();
-					if (registration.options.stopPropagation) event.stopPropagation();
-					const context = {
-						hotkey: registration.sequence.join(" "),
-						parsedHotkey: registration.parsedSequence[registration.parsedSequence.length - 1]
-					};
-					registration.triggerCount++;
-					registration.hasFired = true;
-					registration.currentIndex = 0;
-					this.#syncRegistrationView(registration);
-					registration.callback(event, context);
-				} else this.#syncRegistrationView(registration);
-			} else if (registration.currentIndex > 0) {
-				const firstHotkey = registration.parsedSequence[0];
-				if (require_match.matchesKeyboardEvent(event, firstHotkey, registration.options.platform)) {
-					registration.currentIndex = 1;
-					registration.lastKeyTime = now;
-				} else registration.currentIndex = 0;
-				this.#syncRegistrationView(registration);
-			}
-		}
-	}
-	/**
-	* Finds an existing registration with the same sequence and target.
-	*/
-	#findConflictingSequence(sequence, target) {
-		const key = sequenceKey(sequence);
-		for (const registration of this.#registrations.values()) if (sequenceKey(registration.sequence) === key && registration.target === target) return registration;
-		return null;
-	}
-	/**
-	* Resets all sequence progress.
-	*/
-	resetAll() {
-		for (const registration of this.#registrations.values()) {
-			registration.currentIndex = 0;
-			registration.lastKeyTime = 0;
-			this.#syncRegistrationView(registration);
-		}
-	}
-	/**
-	* Triggers a sequence's callback programmatically from devtools.
-	* Creates a synthetic KeyboardEvent from the last key in the sequence.
-	*
-	* @param id - The registration ID to trigger
-	* @returns True if the registration was found and triggered
-	*/
-	triggerSequence(id) {
-		const registration = this.#registrations.get(id);
-		if (!registration) return false;
-		const lastParsed = registration.parsedSequence[registration.parsedSequence.length - 1];
-		if (!lastParsed) return false;
-		const syntheticEvent = new KeyboardEvent(registration.options.eventType ?? "keydown", {
-			key: lastParsed.key,
-			ctrlKey: lastParsed.ctrl,
-			shiftKey: lastParsed.shift,
-			altKey: lastParsed.alt,
-			metaKey: lastParsed.meta,
-			bubbles: true,
-			cancelable: true
-		});
-		registration.triggerCount++;
-		registration.hasFired = true;
-		this.#syncRegistrationView(registration);
-		const context = {
-			hotkey: registration.sequence.join(" "),
-			parsedHotkey: lastParsed
-		};
-		registration.callback(syntheticEvent, context);
-		return true;
-	}
-	/**
-	* Gets the number of registered sequences.
-	*/
-	getRegistrationCount() {
-		return this.#registrations.size;
-	}
-	/**
-	* Destroys the manager and removes all listeners.
-	*/
-	destroy() {
-		for (const target of this.#targetListeners.keys()) this.#removeListenersForTarget(target);
-		this.#registrations.clear();
-		this.registrations.setState(() => /* @__PURE__ */ new Map());
-	}
-};
-/**
-* Gets the singleton SequenceManager instance.
-* Convenience function for accessing the manager.
-*/
-function getSequenceManager() {
-	return SequenceManager.getInstance();
-}
-/**
-* Creates a simple sequence matcher for one-off use.
-*
-* This is a low-level helper that does not support ignoreInputs, target,
-* or other HotkeyOptions. Callers must handle input filtering themselves
-* if attaching to document.
-*
-* @param sequence - The sequence of hotkeys to match
-* @param options - Options including timeout
-* @returns An object with match() and reset() methods
-*
-* @example
-* ```ts
-* const matcher = createSequenceMatcher(['G', 'G'], { timeout: 500 })
-*
-* document.addEventListener('keydown', (event) => {
-*   if (matcher.match(event)) {
-*     console.log('Sequence matched!')
-*   }
-* })
-* ```
-*/
-function createSequenceMatcher(sequence, options = {}) {
-	const platform = options.platform ?? require_constants.detectPlatform();
-	const timeout = options.timeout ?? 1e3;
-	const parsedSequence = sequence.map((hotkey) => require_parse.parseHotkey(hotkey, platform));
-	let currentIndex = 0;
-	let lastKeyTime = 0;
-	return {
-		match(event) {
-			const now = Date.now();
-			if (currentIndex > 0 && now - lastKeyTime > timeout) currentIndex = 0;
-			const expected = parsedSequence[currentIndex];
-			if (!expected) return false;
-			if (require_match.matchesKeyboardEvent(event, expected, platform)) {
-				lastKeyTime = now;
-				currentIndex++;
-				if (currentIndex >= parsedSequence.length) {
-					currentIndex = 0;
-					return true;
-				}
-			} else if (currentIndex > 0) if (require_match.matchesKeyboardEvent(event, parsedSequence[0], platform)) {
-				currentIndex = 1;
-				lastKeyTime = now;
-			} else currentIndex = 0;
-			return false;
-		},
-		reset() {
-			currentIndex = 0;
-			lastKeyTime = 0;
-		},
-		getProgress() {
-			return currentIndex;
-		}
-	};
-}
-
-//#endregion
-exports.DEFAULT_SEQUENCE_TIMEOUT = DEFAULT_SEQUENCE_TIMEOUT;
-exports.SequenceManager = SequenceManager;
-exports.createSequenceMatcher = createSequenceMatcher;
-exports.getSequenceManager = getSequenceManager;
-//# sourceMappingURL=sequence-manager.cjs.map