@remcostoeten/use-shortcut 1.3.0 → 2.0.0

package/dist/index.mjs

@@ -1,17 +1,35 @@
 import { useRef, useMemo, useEffect } from 'react';
 
 // src/constants.ts
-var Platform = {
+var OS = {
   MAC: "mac",
   WINDOWS: "windows",
   LINUX: "linux"
 };
+var Platform = OS;
+var _cachedPlatform = null;
 function detectPlatform() {
-  if (typeof navigator === "undefined") return Platform.WINDOWS;
-  const platform = navigator.platform.toLowerCase();
-  if (platform.includes("mac")) return Platform.MAC;
-  if (platform.includes("linux")) return Platform.LINUX;
-  return Platform.WINDOWS;
+  if (_cachedPlatform) return _cachedPlatform;
+  if (typeof navigator === "undefined") {
+    _cachedPlatform = OS.WINDOWS;
+    return _cachedPlatform;
+  }
+  const uaPlatform = navigator.userAgentData?.platform?.toLowerCase();
+  const platform = (uaPlatform ?? navigator.platform ?? navigator.userAgent ?? "").toLowerCase();
+  if (platform.includes("mac") || platform.includes("iphone") || platform.includes("ipad") || platform.includes("ipod")) {
+    _cachedPlatform = OS.MAC;
+    return _cachedPlatform;
+  }
+  if (platform.includes("linux") || platform.includes("android")) {
+    _cachedPlatform = OS.LINUX;
+    return _cachedPlatform;
+  }
+  if (platform.includes("win")) {
+    _cachedPlatform = OS.WINDOWS;
+    return _cachedPlatform;
+  }
+  _cachedPlatform = OS.WINDOWS;
+  return _cachedPlatform;
 }
 var ModifierKey = {
   META: "meta",
@@ -81,19 +99,19 @@ var SpecialKeyMap = {
   closebracket: "]"
 };
 var ModifierDisplaySymbols = {
-  [Platform.MAC]: {
+  [OS.MAC]: {
     [ModifierKey.META]: "\u2318",
     [ModifierKey.CTRL]: "\u2303",
     [ModifierKey.ALT]: "\u2325",
     [ModifierKey.SHIFT]: "\u21E7"
   },
-  [Platform.WINDOWS]: {
+  [OS.WINDOWS]: {
     [ModifierKey.META]: "Ctrl",
     [ModifierKey.CTRL]: "Ctrl",
     [ModifierKey.ALT]: "Alt",
     [ModifierKey.SHIFT]: "Shift"
   },
-  [Platform.LINUX]: {
+  [OS.LINUX]: {
     [ModifierKey.META]: "Super",
     [ModifierKey.CTRL]: "Ctrl",
     [ModifierKey.ALT]: "Alt",
@@ -101,12 +119,15 @@ var ModifierDisplaySymbols = {
   }
 };
 var ModifierDisplayOrder = {
-  [Platform.MAC]: [ModifierKey.CTRL, ModifierKey.ALT, ModifierKey.SHIFT, ModifierKey.META],
-  [Platform.WINDOWS]: [ModifierKey.META, ModifierKey.ALT, ModifierKey.SHIFT, ModifierKey.CTRL],
-  [Platform.LINUX]: [ModifierKey.META, ModifierKey.ALT, ModifierKey.SHIFT, ModifierKey.CTRL]
+  [OS.MAC]: [ModifierKey.CTRL, ModifierKey.ALT, ModifierKey.SHIFT, ModifierKey.META],
+  [OS.WINDOWS]: [ModifierKey.META, ModifierKey.ALT, ModifierKey.SHIFT, ModifierKey.CTRL],
+  [OS.LINUX]: [ModifierKey.META, ModifierKey.ALT, ModifierKey.SHIFT, ModifierKey.CTRL]
 };
 
 // src/parser.ts
+function _normalizeKeyToken(key) {
+  return key === " " ? "space" : key.toLowerCase();
+}
 function parseShortcut(shortcut) {
   const platform = detectPlatform();
   const normalized = shortcut.toLowerCase().trim();
@@ -158,9 +179,9 @@ function getModifiersFromEvent(event) {
 }
 function matchesShortcut(event, parsed) {
   const eventModifiers = getModifiersFromEvent(event);
-  const eventKey = event.key.toLowerCase();
+  const eventKey = _normalizeKeyToken(event.key);
   const modifiersMatch = eventModifiers.meta === parsed.modifiers.meta && eventModifiers.ctrl === parsed.modifiers.ctrl && eventModifiers.alt === parsed.modifiers.alt && eventModifiers.shift === parsed.modifiers.shift;
-  const keyMatches = eventKey === parsed.key.toLowerCase();
+  const keyMatches = eventKey === _normalizeKeyToken(parsed.key);
   return modifiersMatch && keyMatches;
 }
 function matchesAnyShortcut(event, parsedShortcuts) {
@@ -168,6 +189,34 @@ function matchesAnyShortcut(event, parsedShortcuts) {
 }
 
 // src/formatter.ts
+var _BASE_DISPLAY_NAMES = {
+  ArrowUp: "\u2191",
+  ArrowDown: "\u2193",
+  ArrowLeft: "\u2190",
+  ArrowRight: "\u2192",
+  Home: "Home",
+  End: "End",
+  PageUp: "PgUp",
+  PageDown: "PgDn"
+};
+var _MAC_DISPLAY_NAMES = {
+  ..._BASE_DISPLAY_NAMES,
+  Enter: "\u21A9",
+  Tab: "\u21E5",
+  Escape: "\u238B",
+  Backspace: "\u232B",
+  Delete: "\u2326",
+  " ": "\u2423"
+};
+var _NON_MAC_DISPLAY_NAMES = {
+  ..._BASE_DISPLAY_NAMES,
+  Enter: "Enter",
+  Tab: "Tab",
+  Escape: "Esc",
+  Backspace: "Backspace",
+  Delete: "Del",
+  " ": "Space"
+};
 function formatShortcut(shortcut, platform) {
   const targetPlatform = platform ?? detectPlatform();
   const parsed = parseShortcut(shortcut);
@@ -179,151 +228,87 @@ function formatShortcut(shortcut, platform) {
       parts.push(symbols[modifier]);
     }
   }
-  const displayKey = formatKey(parsed.key, targetPlatform);
+  const displayKey = _formatKey(parsed.key, targetPlatform);
   parts.push(displayKey);
-  const separator = targetPlatform === Platform.MAC ? "" : "+";
+  const separator = targetPlatform === OS.MAC ? "" : "+";
   return parts.join(separator);
 }
-function formatKey(key, platform) {
-  const displayNames = {
-    ArrowUp: "\u2191",
-    ArrowDown: "\u2193",
-    ArrowLeft: "\u2190",
-    ArrowRight: "\u2192",
-    Enter: platform === Platform.MAC ? "\u21A9" : "Enter",
-    Tab: platform === Platform.MAC ? "\u21E5" : "Tab",
-    Escape: platform === Platform.MAC ? "\u238B" : "Esc",
-    Backspace: platform === Platform.MAC ? "\u232B" : "Backspace",
-    Delete: platform === Platform.MAC ? "\u2326" : "Del",
-    " ": platform === Platform.MAC ? "\u2423" : "Space",
-    Home: "Home",
-    End: "End",
-    PageUp: "PgUp",
-    PageDown: "PgDn"
-  };
+function _formatKey(key, platform) {
+  const displayNames = platform === OS.MAC ? _MAC_DISPLAY_NAMES : _NON_MAC_DISPLAY_NAMES;
   return displayNames[key] || key.toUpperCase();
 }
-function getModifierSymbols(platform) {
-  const targetPlatform = platform ?? detectPlatform();
-  return ModifierDisplaySymbols[targetPlatform];
-}
 
-// src/builder.ts
-var MODIFIER_KEYS = /* @__PURE__ */ new Set(["ctrl", "shift", "alt", "cmd", "mod"]);
-var IGNORED_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
-var EXCEPT_PREDICATES = {
-  input: (e) => {
-    const target = e.target;
-    return IGNORED_TAGS.has(target.tagName);
-  },
-  editable: (e) => {
-    const target = e.target;
-    return target.isContentEditable;
-  },
-  typing: (e) => {
-    const target = e.target;
-    return IGNORED_TAGS.has(target.tagName) || target.isContentEditable;
-  },
-  modal: () => {
-    return document.querySelector('[data-modal="true"], [role="dialog"]') !== null;
-  },
-  disabled: (e) => {
-    const target = e.target;
-    return target.hasAttribute("disabled") || target.getAttribute("aria-disabled") === "true";
-  }
-};
-function shouldExcept(event, except) {
-  if (!except) return false;
-  if (typeof except === "function") {
-    return except(event);
-  }
-  if (Array.isArray(except)) {
-    return except.some((preset) => EXCEPT_PREDICATES[preset]?.(event));
-  }
-  return EXCEPT_PREDICATES[except]?.(event) ?? false;
-}
-function normalizeScopes(scopes) {
-  if (!scopes) return [];
-  return (Array.isArray(scopes) ? scopes : [scopes]).map((scope) => scope.trim()).filter(Boolean);
-}
-function scopeMatch(requiredScopes, activeScopes) {
-  if (requiredScopes.size === 0) return true;
-  for (const required of requiredScopes) {
-    if (activeScopes.has(required)) return true;
+// src/runtime/debug.ts
+function _debugLog(debug, ...args) {
+  if (debug) {
+    console.log("[useShortcut]", ...args);
   }
-  return false;
 }
-function getActiveModifierTokens(modifiers) {
+
+// src/runtime/keys.ts
+function _getActiveModifierTokens(modifiers) {
   const platform = detectPlatform();
   const order = ModifierDisplayOrder[platform];
-  return order.filter((key) => {
-    if (key === ModifierKey.CTRL) return modifiers.ctrl;
-    if (key === ModifierKey.ALT) return modifiers.alt;
-    if (key === ModifierKey.SHIFT) return modifiers.shift;
-    if (key === ModifierKey.META) return modifiers.cmd;
-    return false;
-  }).map((key) => {
-    if (key === ModifierKey.CTRL) return "ctrl";
-    if (key === ModifierKey.ALT) return "alt";
-    if (key === ModifierKey.SHIFT) return "shift";
-    if (key === ModifierKey.META) return "cmd";
-    return "";
-  });
+  const tokens = [];
+  for (const key of order) {
+    if (key === ModifierKey.CTRL && modifiers.ctrl) tokens.push("ctrl");
+    if (key === ModifierKey.ALT && modifiers.alt) tokens.push("alt");
+    if (key === ModifierKey.SHIFT && modifiers.shift) tokens.push("shift");
+    if (key === ModifierKey.META && modifiers.cmd) tokens.push("cmd");
+  }
+  return tokens;
 }
-function buildComboString(modifiers, key) {
-  const tokens = getActiveModifierTokens(modifiers);
+function _buildComboString(modifiers, key) {
+  const tokens = _getActiveModifierTokens(modifiers);
   return [...tokens, key].join("+");
 }
-function formatSequenceDisplay(steps) {
+function _formatSequenceDisplay(steps) {
   return steps.map((step) => formatShortcut(step)).join(" then ");
 }
-function debugLog(debug, ...args) {
-  if (debug) {
-    console.log("[useShortcut]", ...args);
-  }
-}
-function canonicalizeParsed(parsed) {
+function _canonicalizeParsed(parsed) {
   const modifiers = [];
   if (parsed.modifiers.ctrl) modifiers.push("ctrl");
   if (parsed.modifiers.alt) modifiers.push("alt");
   if (parsed.modifiers.shift) modifiers.push("shift");
   if (parsed.modifiers.meta) modifiers.push("cmd");
-  return [...modifiers, parsed.key.toLowerCase()].join("+");
-}
-function isPureModifier(event) {
-  const key = event.key.toLowerCase();
-  return key === "shift" || key === "control" || key === "alt" || key === "meta";
+  const key = parsed.key === " " || parsed.key === "Spacebar" ? "space" : parsed.key.toLowerCase();
+  return [...modifiers, key].join("+");
 }
-function eventToCombo(event) {
-  const platform = detectPlatform();
-  const symbols = ModifierDisplaySymbols[platform];
+function _eventToCombo(event) {
   const modifiers = [];
-  if (event.ctrlKey) modifiers.push(symbols[ModifierKey.CTRL] === "\u2303" ? "ctrl" : "ctrl");
+  if (event.ctrlKey) modifiers.push("ctrl");
   if (event.altKey) modifiers.push("alt");
   if (event.shiftKey) modifiers.push("shift");
   if (event.metaKey) modifiers.push("cmd");
-  const key = event.key.length === 1 ? event.key.toLowerCase() : event.key.toLowerCase();
+  const key = event.key === " " || event.key === "Spacebar" ? "space" : event.key.toLowerCase();
   return [...modifiers, key].join("+");
 }
-function isPrefix(a, b) {
+function _eventToMatchStep(event) {
+  return _eventToCombo(event);
+}
+
+// src/runtime/conflicts.ts
+function _isPrefix(a, b) {
   if (a.length > b.length) return false;
   for (let i = 0; i < a.length; i += 1) {
-    if (canonicalizeParsed(a[i]) !== canonicalizeParsed(b[i])) {
+    if (a[i] !== b[i]) {
       return false;
     }
   }
   return true;
 }
-function detectConflict(newSteps, existingSteps) {
-  const newCombo = newSteps.map(canonicalizeParsed).join(" ");
-  const existingCombo = existingSteps.map(canonicalizeParsed).join(" ");
+function _detectConflict(newSteps, existingSteps) {
+  const newCanonicalSteps = newSteps.map(_canonicalizeParsed);
+  const existingCanonicalSteps = existingSteps.map(_canonicalizeParsed);
+  const newCombo = newCanonicalSteps.join(" ");
+  const existingCombo = existingCanonicalSteps.join(" ");
   if (newCombo === existingCombo) return "exact";
-  if (isPrefix(newSteps, existingSteps) || isPrefix(existingSteps, newSteps)) {
+  if (_isPrefix(newCanonicalSteps, existingCanonicalSteps) || _isPrefix(existingCanonicalSteps, newCanonicalSteps)) {
     return "sequence-prefix";
   }
   return null;
 }
-function emitConflict(registry, conflict) {
+function _emitConflict(registry, conflict) {
   const conflictWarnings = registry.options.conflictWarnings ?? true;
   if (registry.options.onConflict) {
     registry.options.onConflict(conflict);
@@ -334,37 +319,195 @@ function emitConflict(registry, conflict) {
     `[useShortcut] Conflict detected (${conflict.reason}) between "${conflict.combo}" and "${conflict.existingCombo}"`
   );
 }
-function sortEntries(entries) {
+
+// src/runtime/guards.ts
+var _IGNORED_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
+var _EXCEPT_PREDICATES = {
+  input: (e) => {
+    if (!(e.target instanceof HTMLElement)) return false;
+    const target = e.target;
+    return _IGNORED_TAGS.has(target.tagName);
+  },
+  editable: (e) => {
+    if (!(e.target instanceof HTMLElement)) return false;
+    const target = e.target;
+    return target.isContentEditable;
+  },
+  typing: (e) => {
+    if (!(e.target instanceof HTMLElement)) return false;
+    const target = e.target;
+    return _IGNORED_TAGS.has(target.tagName) || target.isContentEditable;
+  },
+  modal: () => {
+    if (typeof document === "undefined" || typeof document.querySelector !== "function")
+      return false;
+    return document.querySelector('[data-modal="true"], [role="dialog"]') !== null;
+  },
+  disabled: (e) => {
+    if (!(e.target instanceof HTMLElement)) return false;
+    const target = e.target;
+    return target.hasAttribute("disabled") || target.getAttribute("aria-disabled") === "true";
+  }
+};
+function _shouldExcept(event, except) {
+  if (!except) return false;
+  if (typeof except === "function") {
+    return except(event);
+  }
+  if (Array.isArray(except)) {
+    return except.some((preset) => _EXCEPT_PREDICATES[preset]?.(event));
+  }
+  return _EXCEPT_PREDICATES[except]?.(event) ?? false;
+}
+function _normalizeScopes(scopes) {
+  if (!scopes) return [];
+  return (Array.isArray(scopes) ? scopes : [scopes]).map((scope) => scope.trim()).filter(Boolean);
+}
+function _scopeMatch(requiredScopes, activeScopes) {
+  if (requiredScopes.size === 0) return true;
+  for (const required of requiredScopes) {
+    if (activeScopes.has(required)) return true;
+  }
+  return false;
+}
+function _isPureModifier(event) {
+  const key = event.key.toLowerCase();
+  return key === "shift" || key === "control" || key === "alt" || key === "meta";
+}
+
+// src/runtime/listener.ts
+function _sortEntries(entries) {
+  if (entries.length <= 1) return entries;
   return [...entries].sort((a, b) => {
     if (b.priority !== a.priority) return b.priority - a.priority;
     return a.id - b.id;
   });
 }
-function createBinding(state, handler, handlerOptions = {}, registry) {
+function _dispatchRegistryEvent(registry, event) {
+  const runtimeOptions = registry.options;
+  if (runtimeOptions.disabled) return;
+  if (runtimeOptions.eventFilter && !runtimeOptions.eventFilter(event)) return;
+  const candidateCombos = /* @__PURE__ */ new Set();
+  const firstStepCombos = registry.firstStepIndex.get(_eventToMatchStep(event));
+  if (firstStepCombos) {
+    for (const combo of firstStepCombos) candidateCombos.add(combo);
+  }
+  for (const combo of registry.activeSequenceCombos) {
+    candidateCombos.add(combo);
+  }
+  for (const combo of candidateCombos) {
+    const comboEntries = registry.listeners.get(combo);
+    if (!comboEntries) continue;
+    const orderedEntries = _sortEntries(comboEntries);
+    for (const item of orderedEntries) {
+      if (!item.isEnabled) continue;
+      if (!_scopeMatch(item.scopes, registry.activeScopes)) {
+        continue;
+      }
+      if (runtimeOptions.ignoreInputs !== false && !item.except) {
+        const targetEl = event.target;
+        if (targetEl && (_IGNORED_TAGS.has(targetEl.tagName) || targetEl.isContentEditable)) {
+          continue;
+        }
+      }
+      if (_shouldExcept(event, item.except)) {
+        _debugLog(runtimeOptions.debug, "Skipped due to except condition:", combo);
+        continue;
+      }
+      const expected = item.parsedSteps[item.progress];
+      const now = Date.now();
+      if (item.progress > 0 && now - item.lastMatchedAt > item.sequenceTimeout) {
+        item.progress = 0;
+      }
+      let matched = false;
+      if (matchesShortcut(event, expected)) {
+        item.progress += 1;
+        item.lastMatchedAt = now;
+        if (item.progress === item.parsedSteps.length) {
+          matched = true;
+          item.progress = 0;
+        }
+      } else if (item.progress > 0 && matchesShortcut(event, item.parsedSteps[0])) {
+        item.progress = 1;
+        item.lastMatchedAt = now;
+      } else {
+        item.progress = 0;
+      }
+      for (const cb of item.attemptCallbacks) {
+        cb(matched, event);
+      }
+      if (!matched) continue;
+      _debugLog(runtimeOptions.debug, "MATCHED:", combo);
+      if (item.preventDefault) {
+        event.preventDefault();
+      }
+      if (item.stopPropagation) {
+        event.stopPropagation();
+      }
+      const executeHandler = () => item.userHandler(event);
+      if (item.delay > 0) {
+        _debugLog(runtimeOptions.debug, "Delaying execution by", item.delay, "ms");
+        setTimeout(executeHandler, item.delay);
+      } else {
+        executeHandler();
+      }
+      if (item.stopOnMatch) {
+        break;
+      }
+    }
+    if (comboEntries.some((entry) => entry.progress > 0)) {
+      registry.activeSequenceCombos.add(combo);
+    } else {
+      registry.activeSequenceCombos.delete(combo);
+    }
+  }
+}
+function _attachRegistryListener(registry) {
+  if (registry.listener) return;
+  const target = registry.options.target ?? (typeof window !== "undefined" ? window : null);
+  if (!target) return;
+  const eventType = registry.options.eventType ?? "keydown";
+  const listener = (event) => _dispatchRegistryEvent(registry, event);
+  target.addEventListener(eventType, listener);
+  registry.listener = listener;
+  registry.listenerTarget = target;
+  registry.listenerEventType = eventType;
+  _debugLog(registry.options.debug, "Listener attached");
+}
+function _detachRegistryListener(registry) {
+  if (!registry.listener || !registry.listenerTarget) return;
+  registry.listenerTarget.removeEventListener(registry.listenerEventType, registry.listener);
+  registry.listener = null;
+  registry.listenerTarget = null;
+  _debugLog(registry.options.debug, "Listener detached");
+}
+
+// src/runtime/binding.ts
+function _createBinding(state, handler, handlerOptions = {}, registry) {
   const { options, except: stateExcept } = state;
   const rawSteps = state.steps;
   if (rawSteps.length === 0) {
     throw new Error("[useShortcut] No key specified. Use .key() to set the action key.");
   }
   const parsedSteps = rawSteps.map((step) => parseShortcut(step));
-  const combo = parsedSteps.map(canonicalizeParsed).join(" ");
-  const display = formatSequenceDisplay(rawSteps);
+  const combo = parsedSteps.map(_canonicalizeParsed).join(" ");
+  const display = _formatSequenceDisplay(rawSteps);
   const debug = options.debug ?? false;
   const except = stateExcept ?? handlerOptions.except;
-  for (const [existingCombo, listener] of registry.listeners.entries()) {
-    for (const existing of listener.entries) {
+  for (const [existingCombo, entries] of registry.listeners.entries()) {
+    for (const existing of entries) {
       if (existingCombo === combo) continue;
-      const reason = detectConflict(parsedSteps, existing.parsedSteps);
+      const reason = _detectConflict(parsedSteps, existing.parsedSteps);
       if (!reason) continue;
-      emitConflict(registry, { combo, existingCombo, reason });
+      _emitConflict(registry, { combo, existingCombo, reason });
     }
   }
   const isEnabled = !handlerOptions.disabled && !options.disabled;
   const delay = handlerOptions.delay ?? options.delay ?? 0;
   const sequenceTimeout = handlerOptions.sequenceTimeout ?? options.sequenceTimeout ?? 800;
-  const requiredScopes = new Set(normalizeScopes(state.scopes ?? handlerOptions.scopes));
+  const requiredScopes = new Set(_normalizeScopes(state.scopes ?? handlerOptions.scopes));
   const attemptCallbacks = /* @__PURE__ */ new Set();
-  debugLog(debug, "Registering:", combo, "\u2192", display, {
+  _debugLog(debug, "Registering:", combo, "\u2192", display, {
     parsedSteps,
     except: !!except,
     scopes: [...requiredScopes]
@@ -386,97 +529,41 @@ function createBinding(state, handler, handlerOptions = {}, registry) {
     stopOnMatch: handlerOptions.stopOnMatch ?? false,
     priority: handlerOptions.priority ?? 0
   };
-  let comboListener = registry.listeners.get(combo);
-  if (!comboListener) {
-    const target = options.target ?? (typeof window !== "undefined" ? window : null);
-    const eventType = options.eventType ?? "keydown";
-    const listener = (event) => {
-      const runtimeOptions = registry.options;
-      if (runtimeOptions.disabled) return;
-      if (runtimeOptions.eventFilter && !runtimeOptions.eventFilter(event)) return;
-      const current = registry.listeners.get(combo);
-      if (!current) return;
-      const orderedEntries = sortEntries(current.entries);
-      for (const item of orderedEntries) {
-        if (!item.isEnabled) continue;
-        if (!scopeMatch(item.scopes, registry.activeScopes)) {
-          continue;
-        }
-        if (runtimeOptions.ignoreInputs !== false && !item.except) {
-          const targetEl = event.target;
-          if (targetEl && (IGNORED_TAGS.has(targetEl.tagName) || targetEl.isContentEditable)) {
-            continue;
-          }
-        }
-        if (shouldExcept(event, item.except)) {
-          debugLog(debug, "Skipped due to except condition:", combo);
-          continue;
-        }
-        const expected = item.parsedSteps[item.progress];
-        const now = Date.now();
-        if (item.progress > 0 && now - item.lastMatchedAt > item.sequenceTimeout) {
-          item.progress = 0;
-        }
-        let matched = false;
-        if (matchesShortcut(event, expected)) {
-          item.progress += 1;
-          item.lastMatchedAt = now;
-          if (item.progress === item.parsedSteps.length) {
-            matched = true;
-            item.progress = 0;
-          }
-        } else if (item.progress > 0 && matchesShortcut(event, item.parsedSteps[0])) {
-          item.progress = 1;
-          item.lastMatchedAt = now;
-        } else {
-          item.progress = 0;
-        }
-        item.attemptCallbacks.forEach((cb) => cb(matched, event));
-        if (!matched) continue;
-        debugLog(debug, "MATCHED:", combo, "\u2192", display);
-        if (item.preventDefault) {
-          event.preventDefault();
-        }
-        if (item.stopPropagation) {
-          event.stopPropagation();
-        }
-        const executeHandler = () => item.userHandler(event);
-        if (item.delay > 0) {
-          debugLog(debug, "Delaying execution by", item.delay, "ms");
-          setTimeout(executeHandler, item.delay);
-        } else {
-          executeHandler();
-        }
-        if (item.stopOnMatch) {
-          break;
-        }
-      }
-    };
-    if (target) {
-      target.addEventListener(eventType, listener);
-      debugLog(debug, "Listener attached for:", combo);
+  const comboEntries = registry.listeners.get(combo);
+  if (comboEntries) {
+    comboEntries.push(entry);
+  } else {
+    registry.listeners.set(combo, [entry]);
+    const firstStep = _canonicalizeParsed(parsedSteps[0]);
+    const indexedCombos = registry.firstStepIndex.get(firstStep);
+    if (indexedCombos) {
+      indexedCombos.add(combo);
+    } else {
+      registry.firstStepIndex.set(firstStep, /* @__PURE__ */ new Set([combo]));
     }
-    const unbind = () => {
-      if (target) {
-        target.removeEventListener(eventType, listener);
-        registry.listeners.delete(combo);
-        debugLog(debug, "Unregistered:", combo);
-      }
-    };
-    comboListener = {
-      listener,
-      entries: [],
-      unbind
-    };
-    registry.listeners.set(combo, comboListener);
   }
-  comboListener.entries.push(entry);
+  _attachRegistryListener(registry);
   const unbindEntry = () => {
-    const current = registry.listeners.get(combo);
-    if (!current) return;
-    current.entries = current.entries.filter((item) => item.id !== entry.id);
-    if (current.entries.length === 0) {
-      current.unbind();
+    const currentEntries = registry.listeners.get(combo);
+    if (!currentEntries) return;
+    const nextEntries = currentEntries.filter((item) => item.id !== entry.id);
+    if (nextEntries.length === 0) {
+      registry.listeners.delete(combo);
+      registry.activeSequenceCombos.delete(combo);
+      const firstStep = _canonicalizeParsed(parsedSteps[0]);
+      const indexedCombos = registry.firstStepIndex.get(firstStep);
+      if (indexedCombos) {
+        indexedCombos.delete(combo);
+        if (indexedCombos.size === 0) {
+          registry.firstStepIndex.delete(firstStep);
+        }
+      }
+      _debugLog(debug, "Unregistered:", combo);
+    } else {
+      registry.listeners.set(combo, nextEntries);
+    }
+    if (registry.listeners.size === 0) {
+      _detachRegistryListener(registry);
     }
   };
   return {
@@ -499,7 +586,9 @@ function createBinding(state, handler, handlerOptions = {}, registry) {
     }
   };
 }
-function createRecorder(options) {
+
+// src/runtime/recording.ts
+function _createRecorder(options) {
   return (recordingOptions = {}) => {
     return new Promise((resolve, reject) => {
       const target = recordingOptions.target ?? options.target ?? (typeof window !== "undefined" ? window : null);
@@ -511,13 +600,13 @@ function createRecorder(options) {
       let timeout;
       const listener = (event) => {
         const keyboardEvent = event;
-        if (isPureModifier(keyboardEvent)) return;
+        if (_isPureModifier(keyboardEvent)) return;
         keyboardEvent.preventDefault();
         target.removeEventListener(eventType, listener);
         if (timeout) clearTimeout(timeout);
-        resolve(eventToCombo(keyboardEvent));
+        resolve(_eventToCombo(keyboardEvent));
       };
-      target.addEventListener(eventType, listener, { once: false });
+      target.addEventListener(eventType, listener);
       const timeoutMs = recordingOptions.timeoutMs;
       if (timeoutMs && timeoutMs > 0) {
         timeout = setTimeout(() => {
@@ -528,43 +617,51 @@ function createRecorder(options) {
     });
   };
 }
-function createShortcutBuilder(options = {}) {
+
+// src/builder.ts
+var _MODIFIER_KEYS = /* @__PURE__ */ new Set(["ctrl", "shift", "alt", "cmd", "mod"]);
+function _createShortcutBuilder(options = {}) {
   const registry = {
     listeners: /* @__PURE__ */ new Map(),
+    firstStepIndex: /* @__PURE__ */ new Map(),
+    activeSequenceCombos: /* @__PURE__ */ new Set(),
     options,
-    activeScopes: new Set(normalizeScopes(options.activeScopes)),
-    nextId: 1
+    activeScopes: new Set(_normalizeScopes(options.activeScopes)),
+    nextId: 1,
+    listener: null,
+    listenerTarget: null,
+    listenerEventType: options.eventType ?? "keydown"
   };
-  debugLog(options.debug, "Builder created with options:", options);
-  function createProxy(currentState) {
+  _debugLog(options.debug, "Builder created with options:", options);
+  function _createProxy(currentState) {
     return new Proxy({}, {
       get(_, prop) {
         if (prop === "__debug") {
           return currentState.options.debug;
         }
-        if (MODIFIER_KEYS.has(prop)) {
+        if (_MODIFIER_KEYS.has(prop)) {
           const platform = detectPlatform();
           const modKey = prop === "mod" ? platform === Platform.MAC ? "cmd" : "ctrl" : prop;
           const newState = {
             ...currentState,
             modifiers: { ...currentState.modifiers, [modKey]: true }
           };
-          debugLog(currentState.options.debug, `Chain: +${prop} \u2192`, newState.modifiers);
-          return createProxy(newState);
+          _debugLog(currentState.options.debug, `Chain: +${prop} \u2192`, newState.modifiers);
+          return _createProxy(newState);
         }
         if (prop === "in") {
           return (scopes) => {
-            const nextScopes = [...normalizeScopes(currentState.scopes), ...normalizeScopes(scopes)];
+            const nextScopes = [..._normalizeScopes(currentState.scopes), ..._normalizeScopes(scopes)];
             const newState = {
               ...currentState,
               scopes: nextScopes
             };
-            return createProxy(newState);
+            return _createProxy(newState);
           };
         }
         if (prop === "setScopes") {
           return (scopes) => {
-            registry.activeScopes = new Set(normalizeScopes(scopes));
+            registry.activeScopes = new Set(_normalizeScopes(scopes));
           };
         }
         if (prop === "enableScope") {
@@ -586,18 +683,18 @@ function createShortcutBuilder(options = {}) {
           return (scope) => registry.activeScopes.has(scope);
         }
         if (prop === "record") {
-          return createRecorder(registry.options);
+          return _createRecorder(registry.options);
         }
         if (prop === "key") {
           return (key) => {
-            const nextStep = buildComboString(currentState.modifiers, key);
+            const nextStep = _buildComboString(currentState.modifiers, key);
             const newState = {
               ...currentState,
               modifiers: {},
               steps: [...currentState.steps, nextStep]
             };
-            debugLog(currentState.options.debug, `Chain: .key("${key}")`);
-            return createProxy(newState);
+            _debugLog(currentState.options.debug, `Chain: .key("${key}")`);
+            return _createProxy(newState);
           };
         }
         if (prop === "then") {
@@ -610,8 +707,8 @@ function createShortcutBuilder(options = {}) {
               ...currentState,
               steps: [...currentState.steps, nextStep]
             };
-            debugLog(currentState.options.debug, `Chain: .then("${nextStep}")`);
-            return createProxy(newState);
+            _debugLog(currentState.options.debug, `Chain: .then("${nextStep}")`);
+            return _createProxy(newState);
           };
         }
         if (prop === "except") {
@@ -620,19 +717,19 @@ function createShortcutBuilder(options = {}) {
               ...currentState,
               except: condition
             };
-            debugLog(currentState.options.debug, "Chain: .except()", condition);
-            return createProxy(newState);
+            _debugLog(currentState.options.debug, "Chain: .except()", condition);
+            return _createProxy(newState);
           };
         }
         if (prop === "on") {
           return (handler, handlerOptions) => {
-            return createBinding(currentState, handler, handlerOptions, registry);
+            return _createBinding(currentState, handler, handlerOptions, registry);
           };
         }
         if (prop === "handle") {
           return (opts) => {
             const { handler, ...rest } = opts;
-            return createBinding(currentState, handler, rest, registry);
+            return _createBinding(currentState, handler, rest, registry);
           };
         }
         return void 0;
@@ -645,79 +742,17 @@ function createShortcutBuilder(options = {}) {
     options
   };
   return {
-    builder: createProxy(initialState),
+    builder: _createProxy(initialState),
     registry
   };
 }
 
 // src/hook.ts
-function normalizeShortcutMapKeys(keys) {
-  if (Array.isArray(keys)) {
-    return keys.map((key) => key.trim()).filter(Boolean);
-  }
-  const trimmed = keys.trim();
-  if (!trimmed) return [];
-  if (trimmed.includes(" then ")) {
-    return trimmed.split(/\s+then\s+/i).map((key) => key.trim()).filter(Boolean);
-  }
-  if (trimmed.includes(" ") && !trimmed.includes("+")) {
-    return trimmed.split(/\s+/).map((key) => key.trim()).filter(Boolean);
-  }
-  return [trimmed];
-}
-function applyStep(builder, step) {
-  const tokens = step.toLowerCase().split("+").map((token) => token.trim()).filter(Boolean);
-  if (tokens.length === 0) {
-    throw new Error("[useShortcutMap] Invalid step: empty shortcut step");
-  }
-  const key = tokens.pop();
-  let chain = builder;
-  for (const token of tokens) {
-    if (token === "ctrl" || token === "control") {
-      chain = chain.ctrl;
-      continue;
-    }
-    if (token === "shift") {
-      chain = chain.shift;
-      continue;
-    }
-    if (token === "alt" || token === "option") {
-      chain = chain.alt;
-      continue;
-    }
-    if (token === "cmd" || token === "command" || token === "meta") {
-      chain = chain.cmd;
-      continue;
-    }
-    if (token === "mod") {
-      chain = chain.mod;
-      continue;
-    }
-    throw new Error(`[useShortcutMap] Unsupported modifier token "${token}" in step "${step}"`);
-  }
-  return chain.key(key);
-}
-function registerShortcutMap(builder, shortcutMap) {
-  const results = {};
-  for (const id of Object.keys(shortcutMap)) {
-    const entry = shortcutMap[id];
-    const steps = normalizeShortcutMapKeys(entry.keys);
-    if (steps.length === 0) {
-      throw new Error(`[useShortcutMap] Shortcut "${String(id)}" has no key steps`);
-    }
-    let chain = applyStep(builder, steps[0]);
-    for (const step of steps.slice(1)) {
-      chain = chain.then(step);
-    }
-    results[id] = chain.on(entry.handler, entry.options);
-  }
-  return results;
-}
 function useShortcut(options = {}) {
   const optionsRef = useRef(options);
   optionsRef.current = options;
   const { builder, registry } = useMemo(() => {
-    return createShortcutBuilder(optionsRef.current);
+    return _createShortcutBuilder(optionsRef.current);
   }, []);
   useEffect(() => {
     registry.options = optionsRef.current;
@@ -725,60 +760,22 @@ function useShortcut(options = {}) {
       const scopes = Array.isArray(optionsRef.current.activeScopes) ? optionsRef.current.activeScopes : [optionsRef.current.activeScopes];
       registry.activeScopes = new Set(scopes.map((scope) => scope.trim()).filter(Boolean));
     }
-  });
+  }, [registry, options]);
   useEffect(() => {
     return () => {
-      registry.listeners.forEach((entry) => entry.unbind());
       registry.listeners.clear();
+      registry.firstStepIndex.clear();
+      registry.activeSequenceCombos.clear();
+      if (registry.listener && registry.listenerTarget) {
+        registry.listenerTarget.removeEventListener(registry.listenerEventType, registry.listener);
+        registry.listener = null;
+        registry.listenerTarget = null;
+      }
     };
   }, [registry]);
   return builder;
 }
-function useShortcutMap(shortcutMap, options = {}) {
-  const $ = useShortcut(options);
-  return registerShortcutMap($, shortcutMap);
-}
-function createShortcut(options = {}) {
-  const { builder } = createShortcutBuilder(options);
-  return builder;
-}
-function createShortcutMap(shortcutMap, options = {}) {
-  const builder = createShortcut(options);
-  return registerShortcutMap(builder, shortcutMap);
-}
-function createShortcutGroup() {
-  const results = [];
-  return {
-    add: (...entries) => {
-      results.push(...entries);
-    },
-    addMany: (entries) => {
-      if (Array.isArray(entries)) {
-        results.push(...entries);
-        return;
-      }
-      results.push(...Object.values(entries));
-    },
-    unbindAll: () => {
-      for (const entry of results) {
-        entry.unbind();
-      }
-      results.length = 0;
-    },
-    clear: () => {
-      results.length = 0;
-    },
-    getResults: () => [...results]
-  };
-}
-function useShortcutGroup() {
-  const groupRef = useRef(null);
-  if (!groupRef.current) {
-    groupRef.current = createShortcutGroup();
-  }
-  return groupRef.current;
-}
 
-export { ModifierAliases, ModifierDisplayOrder, ModifierDisplaySymbols, ModifierKey, Platform, SpecialKeyMap, createShortcut, createShortcutGroup, createShortcutMap, detectPlatform, formatShortcut, getModifierSymbols, getModifiersFromEvent, matchesAnyShortcut, matchesShortcut, parseShortcut, parseShortcuts, registerShortcutMap, useShortcut, useShortcutGroup, useShortcutMap };
+export { ModifierAliases, ModifierDisplayOrder, ModifierDisplaySymbols, ModifierKey, Platform, SpecialKeyMap, detectPlatform, formatShortcut, matchesAnyShortcut, matchesShortcut, parseShortcut, parseShortcuts, useShortcut };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map