use-kbd 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -2,9 +2,19 @@
 
 var jsxRuntime = require('react/jsx-runtime');
 var react = require('react');
-var base = require('@rdub/base');
 
-// src/TwoColumnRenderer.tsx
+// src/types.ts
+function extractCaptures(state) {
+  return state.filter(
+    (e) => (e.type === "digit" || e.type === "digits") && e.value !== void 0
+  ).map((e) => e.value);
+}
+function isDigitPlaceholder(elem) {
+  return elem.type === "digit" || elem.type === "digits";
+}
+function countPlaceholders(seq) {
+  return seq.filter(isDigitPlaceholder).length;
+}
 function createTwoColumnRenderer(config) {
   const { headers, getRows } = config;
   const [labelHeader, leftHeader, rightHeader] = headers;
@@ -187,34 +197,55 @@ function useActionsRegistry(options = {}) {
     }
     return bindings;
   }, [keymap]);
+  const getFirstBindingForAction = react.useCallback((actionId) => {
+    return getBindingsForAction(actionId)[0];
+  }, [getBindingsForAction]);
   const setBinding = react.useCallback((actionId, key) => {
-    updateOverrides((prev) => ({
-      ...prev,
-      [key]: actionId
-    }));
-  }, [updateOverrides]);
-  const removeBinding = react.useCallback((key) => {
-    const actionsWithDefault = [];
-    for (const [id, { config }] of actionsRef.current) {
-      if (config.defaultBindings?.includes(key)) {
-        actionsWithDefault.push(id);
-      }
-    }
-    if (actionsWithDefault.length > 0) {
+    if (isDefaultBinding(key, actionId)) {
       updateRemovedDefaults((prev) => {
-        const next = { ...prev };
-        for (const actionId of actionsWithDefault) {
-          const existing = next[actionId] ?? [];
-          if (!existing.includes(key)) {
-            next[actionId] = [...existing, key];
+        const existing = prev[actionId] ?? [];
+        if (existing.includes(key)) {
+          const filtered = existing.filter((k) => k !== key);
+          if (filtered.length === 0) {
+            const { [actionId]: _, ...rest } = prev;
+            return rest;
           }
+          return { ...prev, [actionId]: filtered };
         }
-        return next;
+        return prev;
+      });
+    } else {
+      updateOverrides((prev) => ({
+        ...prev,
+        [key]: actionId
+      }));
+    }
+  }, [updateOverrides, updateRemovedDefaults, isDefaultBinding]);
+  const removeBinding = react.useCallback((actionId, key) => {
+    const action = actionsRef.current.get(actionId);
+    const isDefault = action?.config.defaultBindings?.includes(key);
+    if (isDefault) {
+      updateRemovedDefaults((prev) => {
+        const existing = prev[actionId] ?? [];
+        if (existing.includes(key)) return prev;
+        return { ...prev, [actionId]: [...existing, key] };
       });
     }
     updateOverrides((prev) => {
-      const { [key]: _, ...rest } = prev;
-      return rest;
+      const boundAction = prev[key];
+      if (boundAction === actionId) {
+        const { [key]: _, ...rest } = prev;
+        return rest;
+      }
+      if (Array.isArray(boundAction) && boundAction.includes(actionId)) {
+        const newActions = boundAction.filter((a) => a !== actionId);
+        if (newActions.length === 0) {
+          const { [key]: _, ...rest } = prev;
+          return rest;
+        }
+        return { ...prev, [key]: newActions.length === 1 ? newActions[0] : newActions };
+      }
+      return prev;
     });
   }, [updateOverrides, updateRemovedDefaults]);
   const resetOverrides = react.useCallback(() => {
@@ -232,6 +263,7 @@ function useActionsRegistry(options = {}) {
     keymap,
     actionRegistry,
     getBindingsForAction,
+    getFirstBindingForAction,
     overrides,
     setBinding,
     removeBinding,
@@ -244,12 +276,48 @@ function useActionsRegistry(options = {}) {
     keymap,
     actionRegistry,
     getBindingsForAction,
+    getFirstBindingForAction,
     overrides,
     setBinding,
     removeBinding,
     resetOverrides
   ]);
 }
+
+// src/constants.ts
+var DEFAULT_SEQUENCE_TIMEOUT = Infinity;
+var ACTION_MODAL = "__hotkeys:modal";
+var ACTION_OMNIBAR = "__hotkeys:omnibar";
+var ACTION_LOOKUP = "__hotkeys:lookup";
+
+// src/utils.ts
+var { max } = Math;
+var SHIFTED_SYMBOLS = /* @__PURE__ */ new Set([
+  "!",
+  "@",
+  "#",
+  "$",
+  "%",
+  "^",
+  "&",
+  "*",
+  "(",
+  ")",
+  "_",
+  "+",
+  "{",
+  "}",
+  "|",
+  ":",
+  '"',
+  "<",
+  ">",
+  "?",
+  "~"
+]);
+function isShiftedSymbol(key) {
+  return SHIFTED_SYMBOLS.has(key);
+}
 function isMac() {
   if (typeof navigator === "undefined") return false;
   return /Mac|iPod|iPhone|iPad/.test(navigator.platform);
@@ -310,7 +378,18 @@ function formatKeyForDisplay(key) {
   }
   return key;
 }
+var DIGIT_PLACEHOLDER = "__DIGIT__";
+var DIGITS_PLACEHOLDER = "__DIGITS__";
+function isPlaceholderSentinel(key) {
+  return key === DIGIT_PLACEHOLDER || key === DIGITS_PLACEHOLDER;
+}
 function formatSingleCombination(combo) {
+  if (combo.key === DIGIT_PLACEHOLDER) {
+    return { display: "#", id: "\\d" };
+  }
+  if (combo.key === DIGITS_PLACEHOLDER) {
+    return { display: "##", id: "\\d+" };
+  }
   const mac = isMac();
   const parts = [];
   const idParts = [];
@@ -356,6 +435,10 @@ function formatCombination(input) {
   const single = formatSingleCombination(input);
   return { ...single, isSequence: false };
 }
+function formatBinding(binding) {
+  const parsed = parseHotkeyString(binding);
+  return formatCombination(parsed).display;
+}
 function isModifierKey(key) {
   return ["Control", "Alt", "Shift", "Meta"].includes(key);
 }
@@ -419,6 +502,111 @@ function parseCombinationId(id) {
   }
   return sequence[0];
 }
+var NO_MODIFIERS = { ctrl: false, alt: false, shift: false, meta: false };
+function parseSeqElem(str) {
+  if (str === "\\d") {
+    return { type: "digit" };
+  }
+  if (str === "\\d+") {
+    return { type: "digits" };
+  }
+  if (str.length === 1 && /^[A-Z]$/.test(str)) {
+    return {
+      type: "key",
+      key: str.toLowerCase(),
+      modifiers: { ctrl: false, alt: false, shift: true, meta: false }
+    };
+  }
+  const parts = str.toLowerCase().split("+");
+  const key = parts[parts.length - 1];
+  return {
+    type: "key",
+    key,
+    modifiers: {
+      ctrl: parts.includes("ctrl") || parts.includes("control"),
+      alt: parts.includes("alt") || parts.includes("option"),
+      shift: parts.includes("shift"),
+      meta: parts.includes("meta") || parts.includes("cmd") || parts.includes("command")
+    }
+  };
+}
+function parseKeySeq(hotkeyStr) {
+  if (!hotkeyStr.trim()) return [];
+  const parts = hotkeyStr.trim().split(/\s+/);
+  return parts.map(parseSeqElem);
+}
+function formatSeqElem(elem) {
+  if (elem.type === "digit") {
+    return { display: "\u27E8#\u27E9", id: "\\d" };
+  }
+  if (elem.type === "digits") {
+    return { display: "\u27E8##\u27E9", id: "\\d+" };
+  }
+  const mac = isMac();
+  const parts = [];
+  const idParts = [];
+  if (elem.modifiers.ctrl) {
+    parts.push(mac ? "\u2303" : "Ctrl");
+    idParts.push("ctrl");
+  }
+  if (elem.modifiers.meta) {
+    parts.push(mac ? "\u2318" : "Win");
+    idParts.push("meta");
+  }
+  if (elem.modifiers.alt) {
+    parts.push(mac ? "\u2325" : "Alt");
+    idParts.push("alt");
+  }
+  if (elem.modifiers.shift) {
+    parts.push(mac ? "\u21E7" : "Shift");
+    idParts.push("shift");
+  }
+  parts.push(formatKeyForDisplay(elem.key));
+  idParts.push(elem.key);
+  return {
+    display: mac ? parts.join("") : parts.join("+"),
+    id: idParts.join("+")
+  };
+}
+function formatKeySeq(seq) {
+  if (seq.length === 0) {
+    return { display: "", id: "", isSequence: false };
+  }
+  const formatted = seq.map(formatSeqElem);
+  if (seq.length === 1) {
+    return { ...formatted[0], isSequence: false };
+  }
+  return {
+    display: formatted.map((f) => f.display).join(" "),
+    id: formatted.map((f) => f.id).join(" "),
+    isSequence: true
+  };
+}
+function hasDigitPlaceholders(seq) {
+  return seq.some((elem) => elem.type === "digit" || elem.type === "digits");
+}
+function keySeqToHotkeySequence(seq) {
+  return seq.map((elem) => {
+    if (elem.type === "digit") {
+      return { key: "\\d", modifiers: NO_MODIFIERS };
+    }
+    if (elem.type === "digits") {
+      return { key: "\\d+", modifiers: NO_MODIFIERS };
+    }
+    return { key: elem.key, modifiers: elem.modifiers };
+  });
+}
+function hotkeySequenceToKeySeq(seq) {
+  return seq.map((combo) => {
+    if (combo.key === "\\d" && !combo.modifiers.ctrl && !combo.modifiers.alt && !combo.modifiers.shift && !combo.modifiers.meta) {
+      return { type: "digit" };
+    }
+    if (combo.key === "\\d+" && !combo.modifiers.ctrl && !combo.modifiers.alt && !combo.modifiers.shift && !combo.modifiers.meta) {
+      return { type: "digits" };
+    }
+    return { type: "key", key: combo.key, modifiers: combo.modifiers };
+  });
+}
 function isPrefix(a, b) {
   if (a.length >= b.length) return false;
   for (let i = 0; i < a.length; i++) {
@@ -429,11 +617,43 @@ function isPrefix(a, b) {
 function combinationsEqual(a, b) {
   return a.key === b.key && a.modifiers.ctrl === b.modifiers.ctrl && a.modifiers.alt === b.modifiers.alt && a.modifiers.shift === b.modifiers.shift && a.modifiers.meta === b.modifiers.meta;
 }
+function isDigitKey(key) {
+  return /^[0-9]$/.test(key);
+}
+function seqElemsCouldConflict(a, b) {
+  if (a.type === "digit" && b.type === "digit") return true;
+  if (a.type === "digit" && b.type === "key" && isDigitKey(b.key)) return true;
+  if (a.type === "key" && isDigitKey(a.key) && b.type === "digit") return true;
+  if (a.type === "digits" && b.type === "digits") return true;
+  if (a.type === "digits" && b.type === "digit") return true;
+  if (a.type === "digit" && b.type === "digits") return true;
+  if (a.type === "digits" && b.type === "key" && isDigitKey(b.key)) return true;
+  if (a.type === "key" && isDigitKey(a.key) && b.type === "digits") return true;
+  if (a.type === "key" && b.type === "key") {
+    return a.key === b.key && a.modifiers.ctrl === b.modifiers.ctrl && a.modifiers.alt === b.modifiers.alt && a.modifiers.shift === b.modifiers.shift && a.modifiers.meta === b.modifiers.meta;
+  }
+  return false;
+}
+function keySeqIsPrefix(a, b) {
+  if (a.length >= b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!seqElemsCouldConflict(a[i], b[i])) return false;
+  }
+  return true;
+}
+function keySeqsCouldConflict(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!seqElemsCouldConflict(a[i], b[i])) return false;
+  }
+  return true;
+}
 function findConflicts(keymap) {
   const conflicts = /* @__PURE__ */ new Map();
   const entries = Object.entries(keymap).map(([key, actionOrActions]) => ({
     key,
     sequence: parseHotkeyString(key),
+    keySeq: parseKeySeq(key),
     actions: Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
   }));
   const keyToActions = /* @__PURE__ */ new Map();
@@ -450,7 +670,36 @@ function findConflicts(keymap) {
     for (let j = i + 1; j < entries.length; j++) {
       const a = entries[i];
       const b = entries[j];
-      if (isPrefix(a.sequence, b.sequence)) {
+      if (keySeqsCouldConflict(a.keySeq, b.keySeq) && a.key !== b.key) {
+        const existingA = conflicts.get(a.key) ?? [];
+        if (!existingA.includes(`conflicts with: ${b.key}`)) {
+          conflicts.set(a.key, [...existingA, ...a.actions, `conflicts with: ${b.key}`]);
+        }
+        const existingB = conflicts.get(b.key) ?? [];
+        if (!existingB.includes(`conflicts with: ${a.key}`)) {
+          conflicts.set(b.key, [...existingB, ...b.actions, `conflicts with: ${a.key}`]);
+        }
+        continue;
+      }
+      if (keySeqIsPrefix(a.keySeq, b.keySeq)) {
+        const existingA = conflicts.get(a.key) ?? [];
+        if (!existingA.includes(`prefix of: ${b.key}`)) {
+          conflicts.set(a.key, [...existingA, ...a.actions, `prefix of: ${b.key}`]);
+        }
+        const existingB = conflicts.get(b.key) ?? [];
+        if (!existingB.includes(`has prefix: ${a.key}`)) {
+          conflicts.set(b.key, [...existingB, ...b.actions, `has prefix: ${a.key}`]);
+        }
+      } else if (keySeqIsPrefix(b.keySeq, a.keySeq)) {
+        const existingB = conflicts.get(b.key) ?? [];
+        if (!existingB.includes(`prefix of: ${a.key}`)) {
+          conflicts.set(b.key, [...existingB, ...b.actions, `prefix of: ${a.key}`]);
+        }
+        const existingA = conflicts.get(a.key) ?? [];
+        if (!existingA.includes(`has prefix: ${b.key}`)) {
+          conflicts.set(a.key, [...existingA, ...a.actions, `has prefix: ${b.key}`]);
+        }
+      } else if (isPrefix(a.sequence, b.sequence)) {
         const existingA = conflicts.get(a.key) ?? [];
         if (!existingA.includes(`prefix of: ${b.key}`)) {
           conflicts.set(a.key, [...existingA, ...a.actions, `prefix of: ${b.key}`]);
@@ -489,6 +738,7 @@ function getSequenceCompletions(pendingKeys, keymap) {
   const completions = [];
   for (const [hotkeyStr, actionOrActions] of Object.entries(keymap)) {
     const sequence = parseHotkeyString(hotkeyStr);
+    const keySeq = parseKeySeq(hotkeyStr);
     if (sequence.length <= pendingKeys.length) continue;
     let isPrefix2 = true;
     for (let i = 0; i < pendingKeys.length; i++) {
@@ -498,13 +748,13 @@ function getSequenceCompletions(pendingKeys, keymap) {
       }
     }
     if (isPrefix2) {
-      const remainingKeys = sequence.slice(pendingKeys.length);
-      const nextKeys = formatCombination(remainingKeys).id;
+      const remainingKeySeq = keySeq.slice(pendingKeys.length);
+      const nextKeys = formatKeySeq(remainingKeySeq).display;
       const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
       completions.push({
         nextKeys,
         fullSequence: hotkeyStr,
-        display: formatCombination(sequence),
+        display: formatKeySeq(keySeq),
         actions
       });
     }
@@ -593,7 +843,7 @@ function searchActions(query, actions, keymap) {
       for (const keyword of action.keywords) {
         const kwMatch = fuzzyMatch(query, keyword);
         if (kwMatch.matched) {
-          keywordScore = base.max(keywordScore, kwMatch.score);
+          keywordScore = max(keywordScore, kwMatch.score);
         }
       }
     }
@@ -646,6 +896,92 @@ function sequencesMatch(a, b) {
   }
   return true;
 }
+function isDigit(key) {
+  return /^[0-9]$/.test(key);
+}
+function initMatchState(seq) {
+  return seq.map((elem) => {
+    if (elem.type === "digit") return { type: "digit" };
+    if (elem.type === "digits") return { type: "digits" };
+    return { type: "key", key: elem.key, modifiers: elem.modifiers };
+  });
+}
+function matchesKeyElem(combo, elem) {
+  const shiftMatches = isShiftedChar(combo.key) ? elem.modifiers.shift ? combo.modifiers.shift : true : combo.modifiers.shift === elem.modifiers.shift;
+  return combo.modifiers.ctrl === elem.modifiers.ctrl && combo.modifiers.alt === elem.modifiers.alt && shiftMatches && combo.modifiers.meta === elem.modifiers.meta && combo.key === elem.key;
+}
+function advanceMatchState(state, pattern, combo) {
+  const newState = [...state];
+  let pos = 0;
+  for (let i = 0; i < state.length; i++) {
+    const elem = state[i];
+    if (elem.type === "key" && !elem.matched) break;
+    if (elem.type === "digit" && elem.value === void 0) break;
+    if (elem.type === "digits" && elem.value === void 0) {
+      if (!elem.partial) break;
+      if (isDigit(combo.key)) {
+        const newPartial = (elem.partial || "") + combo.key;
+        newState[i] = { type: "digits", partial: newPartial };
+        return { status: "partial", state: newState };
+      } else {
+        const digitValue = parseInt(elem.partial, 10);
+        newState[i] = { type: "digits", value: digitValue };
+        pos = i + 1;
+        break;
+      }
+    }
+    pos++;
+  }
+  if (pos >= pattern.length) {
+    return { status: "failed" };
+  }
+  const currentPattern = pattern[pos];
+  if (currentPattern.type === "digit") {
+    if (!isDigit(combo.key) || combo.modifiers.ctrl || combo.modifiers.alt || combo.modifiers.meta) {
+      return { status: "failed" };
+    }
+    newState[pos] = { type: "digit", value: parseInt(combo.key, 10) };
+  } else if (currentPattern.type === "digits") {
+    if (!isDigit(combo.key) || combo.modifiers.ctrl || combo.modifiers.alt || combo.modifiers.meta) {
+      return { status: "failed" };
+    }
+    newState[pos] = { type: "digits", partial: combo.key };
+  } else {
+    if (!matchesKeyElem(combo, currentPattern)) {
+      return { status: "failed" };
+    }
+    newState[pos] = { type: "key", key: currentPattern.key, modifiers: currentPattern.modifiers, matched: true };
+  }
+  const isComplete = newState.every((elem) => {
+    if (elem.type === "key") return elem.matched === true;
+    if (elem.type === "digit") return elem.value !== void 0;
+    if (elem.type === "digits") return elem.value !== void 0;
+    return false;
+  });
+  if (isComplete) {
+    const captures = newState.filter(
+      (e) => (e.type === "digit" || e.type === "digits") && e.value !== void 0
+    ).map((e) => e.value);
+    return { status: "matched", state: newState, captures };
+  }
+  return { status: "partial", state: newState };
+}
+function isCollectingDigits(state) {
+  return state.some((elem) => elem.type === "digits" && elem.partial !== void 0 && elem.value === void 0);
+}
+function finalizeDigits(state) {
+  return state.map((elem) => {
+    if (elem.type === "digits" && elem.partial !== void 0 && elem.value === void 0) {
+      return { type: "digits", value: parseInt(elem.partial, 10) };
+    }
+    return elem;
+  });
+}
+function extractMatchCaptures(state) {
+  return state.filter(
+    (e) => (e.type === "digit" || e.type === "digits") && e.value !== void 0
+  ).map((e) => e.value);
+}
 function useHotkeys(keymap, handlers, options = {}) {
   const {
     enabled = true,
@@ -653,7 +989,7 @@ function useHotkeys(keymap, handlers, options = {}) {
     preventDefault = true,
     stopPropagation = true,
     enableOnFormTags = false,
-    sequenceTimeout = 1e3,
+    sequenceTimeout = DEFAULT_SEQUENCE_TIMEOUT,
     onTimeout = "submit",
     onSequenceStart,
     onSequenceProgress,
@@ -669,11 +1005,13 @@ function useHotkeys(keymap, handlers, options = {}) {
   const timeoutRef = react.useRef(null);
   const pendingKeysRef = react.useRef([]);
   pendingKeysRef.current = pendingKeys;
+  const matchStatesRef = react.useRef(/* @__PURE__ */ new Map());
   const parsedKeymapRef = react.useRef([]);
   react.useEffect(() => {
     parsedKeymapRef.current = Object.entries(keymap).map(([key, actionOrActions]) => ({
       key,
       sequence: parseHotkeyString(key),
+      keySeq: parseKeySeq(key),
       actions: Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
     }));
   }, [keymap]);
@@ -681,6 +1019,7 @@ function useHotkeys(keymap, handlers, options = {}) {
     setPendingKeys([]);
     setIsAwaitingSequence(false);
     setTimeoutStartedAt(null);
+    matchStatesRef.current.clear();
     if (timeoutRef.current) {
       clearTimeout(timeoutRef.current);
       timeoutRef.current = null;
@@ -690,7 +1029,7 @@ function useHotkeys(keymap, handlers, options = {}) {
     clearPending();
     onSequenceCancel?.();
   }, [clearPending, onSequenceCancel]);
-  const tryExecute = react.useCallback((sequence, e) => {
+  const tryExecute = react.useCallback((sequence, e, captures) => {
     for (const entry of parsedKeymapRef.current) {
       if (sequencesMatch(sequence, entry.sequence)) {
         for (const action of entry.actions) {
@@ -702,7 +1041,27 @@ function useHotkeys(keymap, handlers, options = {}) {
             if (stopPropagation) {
               e.stopPropagation();
             }
-            handler(e);
+            handler(e, captures);
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }, [preventDefault, stopPropagation]);
+  const tryExecuteKeySeq = react.useCallback((matchKey, matchState, captures, e) => {
+    for (const entry of parsedKeymapRef.current) {
+      if (entry.key === matchKey) {
+        for (const action of entry.actions) {
+          const handler = handlersRef.current[action];
+          if (handler) {
+            if (preventDefault) {
+              e.preventDefault();
+            }
+            if (stopPropagation) {
+              e.stopPropagation();
+            }
+            handler(e, captures.length > 0 ? captures : void 0);
             return true;
           }
         }
@@ -732,7 +1091,8 @@ function useHotkeys(keymap, handlers, options = {}) {
     const handleKeyDown = (e) => {
       if (!enableOnFormTags) {
         const eventTarget = e.target;
-        if (eventTarget instanceof HTMLInputElement || eventTarget instanceof HTMLTextAreaElement || eventTarget instanceof HTMLSelectElement || eventTarget.isContentEditable) {
+        const isTextInput = eventTarget instanceof HTMLInputElement && ["text", "email", "password", "search", "tel", "url", "number", "date", "datetime-local", "month", "time", "week"].includes(eventTarget.type);
+        if (isTextInput || eventTarget instanceof HTMLTextAreaElement || eventTarget instanceof HTMLSelectElement || eventTarget.isContentEditable) {
           return;
         }
       }
@@ -759,6 +1119,77 @@ function useHotkeys(keymap, handlers, options = {}) {
       }
       const currentCombo = eventToCombination(e);
       const newSequence = [...pendingKeysRef.current, currentCombo];
+      let keySeqMatched = false;
+      let keySeqPartial = false;
+      const matchStates = matchStatesRef.current;
+      const hasPartialMatches = matchStates.size > 0;
+      for (const entry of parsedKeymapRef.current) {
+        let state = matchStates.get(entry.key);
+        if (hasPartialMatches && !state) {
+          continue;
+        }
+        if (!state) {
+          state = initMatchState(entry.keySeq);
+          matchStates.set(entry.key, state);
+        }
+        const result = advanceMatchState(state, entry.keySeq, currentCombo);
+        if (result.status === "matched") {
+          if (tryExecuteKeySeq(entry.key, result.state, result.captures, e)) {
+            clearPending();
+            keySeqMatched = true;
+            break;
+          }
+        } else if (result.status === "partial") {
+          matchStates.set(entry.key, result.state);
+          keySeqPartial = true;
+        } else {
+          matchStates.delete(entry.key);
+        }
+      }
+      if (keySeqMatched) {
+        return;
+      }
+      if (keySeqPartial) {
+        setPendingKeys(newSequence);
+        setIsAwaitingSequence(true);
+        if (pendingKeysRef.current.length === 0) {
+          onSequenceStart?.(newSequence);
+        } else {
+          onSequenceProgress?.(newSequence);
+        }
+        if (preventDefault) {
+          e.preventDefault();
+        }
+        if (Number.isFinite(sequenceTimeout)) {
+          setTimeoutStartedAt(Date.now());
+          timeoutRef.current = setTimeout(() => {
+            for (const [key, state] of matchStates.entries()) {
+              if (isCollectingDigits(state)) {
+                const finalizedState = finalizeDigits(state);
+                const entry = parsedKeymapRef.current.find((e2) => e2.key === key);
+                if (entry) {
+                  const isComplete = finalizedState.every((elem) => {
+                    if (elem.type === "key") return elem.matched === true;
+                    if (elem.type === "digit") return elem.value !== void 0;
+                    if (elem.type === "digits") return elem.value !== void 0;
+                    return false;
+                  });
+                  if (isComplete) {
+                    void extractMatchCaptures(finalizedState);
+                  }
+                }
+              }
+            }
+            setPendingKeys([]);
+            setIsAwaitingSequence(false);
+            setTimeoutStartedAt(null);
+            matchStatesRef.current.clear();
+            onSequenceCancel?.();
+            timeoutRef.current = null;
+          }, sequenceTimeout);
+        }
+        return;
+      }
       const exactMatch = tryExecute(newSequence, e);
       if (exactMatch) {
         clearPending();
@@ -773,25 +1204,27 @@ function useHotkeys(keymap, handlers, options = {}) {
           } else {
             onSequenceProgress?.(newSequence);
           }
-          setTimeoutStartedAt(Date.now());
-          timeoutRef.current = setTimeout(() => {
-            if (onTimeout === "submit") {
-              setPendingKeys((current) => {
-                if (current.length > 0) {
-                  onSequenceCancel?.();
-                }
-                return [];
-              });
-              setIsAwaitingSequence(false);
-              setTimeoutStartedAt(null);
-            } else {
-              setPendingKeys([]);
-              setIsAwaitingSequence(false);
-              setTimeoutStartedAt(null);
-              onSequenceCancel?.();
-            }
-            timeoutRef.current = null;
-          }, sequenceTimeout);
+          if (Number.isFinite(sequenceTimeout)) {
+            setTimeoutStartedAt(Date.now());
+            timeoutRef.current = setTimeout(() => {
+              if (onTimeout === "submit") {
+                setPendingKeys((current) => {
+                  if (current.length > 0) {
+                    onSequenceCancel?.();
+                  }
+                  return [];
+                });
+                setIsAwaitingSequence(false);
+                setTimeoutStartedAt(null);
+              } else {
+                setPendingKeys([]);
+                setIsAwaitingSequence(false);
+                setTimeoutStartedAt(null);
+                onSequenceCancel?.();
+              }
+              timeoutRef.current = null;
+            }, sequenceTimeout);
+          }
           if (preventDefault) {
             e.preventDefault();
           }
@@ -811,21 +1244,23 @@ function useHotkeys(keymap, handlers, options = {}) {
           if (preventDefault) {
             e.preventDefault();
           }
-          setTimeoutStartedAt(Date.now());
-          timeoutRef.current = setTimeout(() => {
-            if (onTimeout === "submit") {
-              setPendingKeys([]);
-              setIsAwaitingSequence(false);
-              setTimeoutStartedAt(null);
-              onSequenceCancel?.();
-            } else {
-              setPendingKeys([]);
-              setIsAwaitingSequence(false);
-              setTimeoutStartedAt(null);
-              onSequenceCancel?.();
-            }
-            timeoutRef.current = null;
-          }, sequenceTimeout);
+          if (Number.isFinite(sequenceTimeout)) {
+            setTimeoutStartedAt(Date.now());
+            timeoutRef.current = setTimeout(() => {
+              if (onTimeout === "submit") {
+                setPendingKeys([]);
+                setIsAwaitingSequence(false);
+                setTimeoutStartedAt(null);
+                onSequenceCancel?.();
+              } else {
+                setPendingKeys([]);
+                setIsAwaitingSequence(false);
+                setTimeoutStartedAt(null);
+                onSequenceCancel?.();
+              }
+              timeoutRef.current = null;
+            }, sequenceTimeout);
+          }
         }
       }
     };
@@ -847,6 +1282,7 @@ function useHotkeys(keymap, handlers, options = {}) {
     clearPending,
     cancelSequence,
     tryExecute,
+    tryExecuteKeySeq,
     hasPotentialMatch,
     hasSequenceExtension,
     onSequenceStart,
@@ -858,12 +1294,10 @@ function useHotkeys(keymap, handlers, options = {}) {
 var HotkeysContext = react.createContext(null);
 var DEFAULT_CONFIG = {
   storageKey: "use-kbd",
-  sequenceTimeout: 1e3,
+  sequenceTimeout: DEFAULT_SEQUENCE_TIMEOUT,
   disableConflicts: true,
   minViewportWidth: 768,
-  enableOnTouch: false,
-  modalTrigger: "?",
-  omnibarTrigger: "meta+k"
+  enableOnTouch: false
 };
 function HotkeysProvider({
   config: configProp = {},
@@ -912,16 +1346,12 @@ function HotkeysProvider({
   const openOmnibar = react.useCallback(() => setIsOmnibarOpen(true), []);
   const closeOmnibar = react.useCallback(() => setIsOmnibarOpen(false), []);
   const toggleOmnibar = react.useCallback(() => setIsOmnibarOpen((prev) => !prev), []);
-  const keymap = react.useMemo(() => {
-    const map = { ...registry.keymap };
-    if (config.modalTrigger !== false) {
-      map[config.modalTrigger] = "__hotkeys:modal";
-    }
-    if (config.omnibarTrigger !== false) {
-      map[config.omnibarTrigger] = "__hotkeys:omnibar";
-    }
-    return map;
-  }, [registry.keymap, config.modalTrigger, config.omnibarTrigger]);
+  const [isLookupOpen, setIsLookupOpen] = react.useState(false);
+  const openLookup = react.useCallback(() => setIsLookupOpen(true), []);
+  const closeLookup = react.useCallback(() => setIsLookupOpen(false), []);
+  const toggleLookup = react.useCallback(() => setIsLookupOpen((prev) => !prev), []);
+  const [isEditingBinding, setIsEditingBinding] = react.useState(false);
+  const keymap = registry.keymap;
   const conflicts = react.useMemo(() => findConflicts(keymap), [keymap]);
   const hasConflicts2 = conflicts.size > 0;
   const effectiveKeymap = react.useMemo(() => {
@@ -941,20 +1371,24 @@ function HotkeysProvider({
     for (const [id, action] of registry.actions) {
       map[id] = action.config.handler;
     }
-    map["__hotkeys:modal"] = toggleModal;
-    map["__hotkeys:omnibar"] = toggleOmnibar;
     return map;
-  }, [registry.actions, toggleModal, toggleOmnibar]);
-  const hotkeysEnabled = isEnabled && !isModalOpen && !isOmnibarOpen;
+  }, [registry.actions]);
+  const hotkeysEnabled = isEnabled && !isEditingBinding && !isOmnibarOpen && !isLookupOpen;
   const {
     pendingKeys,
     isAwaitingSequence,
+    cancelSequence,
     timeoutStartedAt: sequenceTimeoutStartedAt,
     sequenceTimeout
   } = useHotkeys(effectiveKeymap, handlers, {
     enabled: hotkeysEnabled,
     sequenceTimeout: config.sequenceTimeout
   });
+  react.useEffect(() => {
+    if (isAwaitingSequence && isModalOpen) {
+      closeModal();
+    }
+  }, [isAwaitingSequence, isModalOpen, closeModal]);
   const searchActionsHelper = react.useCallback(
     (query) => searchActions(query, registry.actionRegistry, keymap),
     [registry.actionRegistry, keymap]
@@ -974,9 +1408,16 @@ function HotkeysProvider({
     openOmnibar,
     closeOmnibar,
     toggleOmnibar,
+    isLookupOpen,
+    openLookup,
+    closeLookup,
+    toggleLookup,
+    isEditingBinding,
+    setIsEditingBinding,
     executeAction: registry.execute,
     pendingKeys,
     isAwaitingSequence,
+    cancelSequence,
     sequenceTimeoutStartedAt,
     sequenceTimeout,
     conflicts,
@@ -994,8 +1435,14 @@ function HotkeysProvider({
     openOmnibar,
     closeOmnibar,
     toggleOmnibar,
+    isLookupOpen,
+    openLookup,
+    closeLookup,
+    toggleLookup,
+    isEditingBinding,
     pendingKeys,
     isAwaitingSequence,
+    cancelSequence,
     sequenceTimeoutStartedAt,
     sequenceTimeout,
     conflicts,
@@ -1029,9 +1476,9 @@ function useAction(id, config) {
   react.useEffect(() => {
     registryRef.current.register(id, {
       ...config,
-      handler: () => {
+      handler: (e, captures) => {
         if (enabledRef.current) {
-          handlerRef.current();
+          handlerRef.current(e, captures);
         }
       }
     });
@@ -1065,9 +1512,9 @@ function useActions(actions) {
     for (const [id, config] of Object.entries(actions)) {
       registryRef.current.register(id, {
         ...config,
-        handler: () => {
+        handler: (e, captures) => {
           if (enabledRef.current[id]) {
-            handlersRef.current[id]?.();
+            handlersRef.current[id]?.(e, captures);
           }
         }
       });
@@ -1103,7 +1550,7 @@ function useRecordHotkey(options = {}) {
     onTab: onTabProp,
     onShiftTab: onShiftTabProp,
     preventDefault = true,
-    sequenceTimeout = 1e3,
+    sequenceTimeout = DEFAULT_SEQUENCE_TIMEOUT,
     pauseTimeout = false
   } = options;
   const onCapture = useEventCallback(onCaptureProp);
@@ -1121,6 +1568,7 @@ function useRecordHotkey(options = {}) {
   const pauseTimeoutRef = react.useRef(pauseTimeout);
   pauseTimeoutRef.current = pauseTimeout;
   const pendingKeysRef = react.useRef([]);
+  const hashCycleRef = react.useRef(0);
   const clearTimeout_ = react.useCallback(() => {
     if (timeoutRef.current) {
       clearTimeout(timeoutRef.current);
@@ -1150,6 +1598,7 @@ function useRecordHotkey(options = {}) {
     pressedKeysRef.current.clear();
     hasNonModifierRef.current = false;
     currentComboRef.current = null;
+    hashCycleRef.current = 0;
     onCancel?.();
   }, [clearTimeout_, onCancel]);
   const commit = react.useCallback(() => {
@@ -1170,6 +1619,7 @@ function useRecordHotkey(options = {}) {
     pressedKeysRef.current.clear();
     hasNonModifierRef.current = false;
     currentComboRef.current = null;
+    hashCycleRef.current = 0;
     return cancel;
   }, [cancel, clearTimeout_]);
   react.useEffect(() => {
@@ -1180,9 +1630,13 @@ function useRecordHotkey(options = {}) {
       }
     } else if (isRecording && pendingKeysRef.current.length > 0 && !timeoutRef.current) {
       const currentSequence = pendingKeysRef.current;
-      timeoutRef.current = setTimeout(() => {
+      if (sequenceTimeout === 0) {
         submit(currentSequence);
-      }, sequenceTimeout);
+      } else if (Number.isFinite(sequenceTimeout)) {
+        timeoutRef.current = setTimeout(() => {
+          submit(currentSequence);
+        }, sequenceTimeout);
+      }
     }
   }, [pauseTimeout, isRecording, sequenceTimeout, submit]);
   react.useEffect(() => {
@@ -1241,22 +1695,23 @@ function useRecordHotkey(options = {}) {
         key = e.code.slice(5);
       }
       pressedKeysRef.current.add(key);
+      let nonModifierKey = "";
+      for (const k of pressedKeysRef.current) {
+        if (!isModifierKey(k)) {
+          nonModifierKey = normalizeKey(k);
+          hasNonModifierRef.current = true;
+          break;
+        }
+      }
       const combo = {
-        key: "",
+        key: nonModifierKey,
         modifiers: {
           ctrl: e.ctrlKey,
           alt: e.altKey,
-          shift: e.shiftKey,
+          shift: e.shiftKey && !isShiftedSymbol(nonModifierKey),
           meta: e.metaKey
         }
       };
-      for (const k of pressedKeysRef.current) {
-        if (!isModifierKey(k)) {
-          combo.key = normalizeKey(k);
-          hasNonModifierRef.current = true;
-          break;
-        }
-      }
       if (combo.key) {
         currentComboRef.current = combo;
         setActiveKeys(combo);
@@ -1281,16 +1736,41 @@ function useRecordHotkey(options = {}) {
       pressedKeysRef.current.delete(key);
       const shouldComplete = pressedKeysRef.current.size === 0 || e.key === "Meta" && hasNonModifierRef.current;
       if (shouldComplete && hasNonModifierRef.current && currentComboRef.current) {
-        const combo = currentComboRef.current;
+        let combo = currentComboRef.current;
         pressedKeysRef.current.clear();
         hasNonModifierRef.current = false;
         currentComboRef.current = null;
         setActiveKeys(null);
-        const newSequence = [...pendingKeysRef.current, combo];
+        let newSequence;
+        const noModifiers = !combo.modifiers.ctrl && !combo.modifiers.alt && !combo.modifiers.meta && !combo.modifiers.shift;
+        if (combo.key === "#" && noModifiers) {
+          const pending = pendingKeysRef.current;
+          const lastCombo = pending[pending.length - 1];
+          if (hashCycleRef.current === 0) {
+            combo = { key: DIGIT_PLACEHOLDER, modifiers: { ctrl: false, alt: false, shift: false, meta: false } };
+            newSequence = [...pending, combo];
+            hashCycleRef.current = 1;
+          } else if (hashCycleRef.current === 1 && lastCombo?.key === DIGIT_PLACEHOLDER) {
+            newSequence = [...pending.slice(0, -1), { key: DIGITS_PLACEHOLDER, modifiers: { ctrl: false, alt: false, shift: false, meta: false } }];
+            hashCycleRef.current = 2;
+          } else if (hashCycleRef.current === 2 && lastCombo?.key === DIGITS_PLACEHOLDER) {
+            newSequence = [...pending.slice(0, -1), { key: "#", modifiers: { ctrl: false, alt: false, shift: false, meta: false } }];
+            hashCycleRef.current = 3;
+          } else {
+            combo = { key: DIGIT_PLACEHOLDER, modifiers: { ctrl: false, alt: false, shift: false, meta: false } };
+            newSequence = [...pending, combo];
+            hashCycleRef.current = 1;
+          }
+        } else {
+          hashCycleRef.current = 0;
+          newSequence = [...pendingKeysRef.current, combo];
+        }
         pendingKeysRef.current = newSequence;
         setPendingKeys(newSequence);
         clearTimeout_();
-        if (!pauseTimeoutRef.current) {
+        if (sequenceTimeout === 0) {
+          submit(newSequence);
+        } else if (!pauseTimeoutRef.current && Number.isFinite(sequenceTimeout)) {
           timeoutRef.current = setTimeout(() => {
             submit(newSequence);
           }, sequenceTimeout);
@@ -1316,6 +1796,7 @@ function useRecordHotkey(options = {}) {
     display,
     pendingKeys,
     activeKeys,
+    sequenceTimeout,
     combination
     // deprecated
   };
@@ -1416,6 +1897,7 @@ function useEditableHotkeys(defaults, handlers, options = {}) {
     sequenceTimeout
   };
 }
+var { max: max2, min } = Math;
 function useOmnibar(options) {
   const {
     actions,
@@ -1492,10 +1974,10 @@ function useOmnibar(options) {
     });
   }, [onOpen, onClose]);
   const selectNext = react.useCallback(() => {
-    setSelectedIndex((prev) => base.min(prev + 1, results.length - 1));
+    setSelectedIndex((prev) => min(prev + 1, results.length - 1));
   }, [results.length]);
   const selectPrev = react.useCallback(() => {
-    setSelectedIndex((prev) => base.max(prev - 1, 0));
+    setSelectedIndex((prev) => max2(prev - 1, 0));
   }, []);
   const resetSelection = react.useCallback(() => {
     setSelectedIndex(0);
@@ -1561,23 +2043,377 @@ function useOmnibar(options) {
     isAwaitingSequence
   };
 }
-function buildActionMap(keymap) {
-  const map = /* @__PURE__ */ new Map();
-  for (const [key, actionOrActions] of Object.entries(keymap)) {
-    const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
-    for (const action of actions) {
-      map.set(action, key);
-    }
-  }
-  return map;
-}
-function KeybindingEditor({
-  keymap,
-  defaults,
-  descriptions,
-  onChange,
-  onReset,
-  className,
+var baseStyle = {
+  width: "1em",
+  height: "1em",
+  verticalAlign: "middle"
+};
+function Up({ className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      className,
+      style: { ...baseStyle, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "3",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 19V5M5 12l7-7 7 7" })
+    }
+  );
+}
+function Down({ className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      className,
+      style: { ...baseStyle, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "3",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 5v14M5 12l7 7 7-7" })
+    }
+  );
+}
+function Left({ className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      className,
+      style: { ...baseStyle, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "3",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M19 12H5M12 5l-7 7 7 7" })
+    }
+  );
+}
+function Right({ className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      className,
+      style: { ...baseStyle, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "3",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M5 12h14M12 5l7 7-7 7" })
+    }
+  );
+}
+function Enter({ className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      className,
+      style: { ...baseStyle, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "3",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M9 10l-4 4 4 4" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M19 6v8a2 2 0 01-2 2H5" })
+      ]
+    }
+  );
+}
+function Backspace({ className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      className,
+      style: { ...baseStyle, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 4H8l-7 8 7 8h13a2 2 0 002-2V6a2 2 0 00-2-2z" }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "9", x2: "12", y2: "15" }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "9", x2: "18", y2: "15" })
+      ]
+    }
+  );
+}
+function getKeyIcon(key) {
+  switch (key.toLowerCase()) {
+    case "arrowup":
+      return Up;
+    case "arrowdown":
+      return Down;
+    case "arrowleft":
+      return Left;
+    case "arrowright":
+      return Right;
+    case "enter":
+      return Enter;
+    case "backspace":
+      return Backspace;
+    default:
+      return null;
+  }
+}
+var baseStyle2 = {
+  width: "1.2em",
+  height: "1.2em",
+  marginRight: "2px",
+  verticalAlign: "middle"
+};
+var wideStyle = {
+  ...baseStyle2,
+  width: "1.4em"
+};
+var Command = react.forwardRef(
+  ({ className, style, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      ref,
+      className,
+      style: { ...baseStyle2, ...style },
+      viewBox: "0 0 24 24",
+      fill: "currentColor",
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M6 4a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2v4H6a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2h4v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2a2 2 0 0 0-2-2h-2v-4h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v2h-4V6a2 2 0 0 0-2-2H6zm4 6h4v4h-4v-4z" })
+    }
+  )
+);
+Command.displayName = "Command";
+var Ctrl = react.forwardRef(
+  ({ className, style, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      ref,
+      className,
+      style: { ...baseStyle2, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "3",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M6 15l6-6 6 6" })
+    }
+  )
+);
+Ctrl.displayName = "Ctrl";
+var Shift = react.forwardRef(
+  ({ className, style, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      ref,
+      className,
+      style: { ...wideStyle, ...style },
+      viewBox: "0 0 28 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinejoin: "round",
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M14 3L3 14h6v7h10v-7h6L14 3z" })
+    }
+  )
+);
+Shift.displayName = "Shift";
+var Option = react.forwardRef(
+  ({ className, style, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      ref,
+      className,
+      style: { ...baseStyle2, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 6h6l8 12h6M14 6h6" })
+    }
+  )
+);
+Option.displayName = "Option";
+var Alt = react.forwardRef(
+  ({ className, style, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      ref,
+      className,
+      style: { ...baseStyle2, ...style },
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 18h8M12 18l4-6M12 18l4 0M16 12l4-6h-8" })
+    }
+  )
+);
+Alt.displayName = "Alt";
+var isMac2 = typeof navigator !== "undefined" && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
+function getModifierIcon(modifier) {
+  switch (modifier) {
+    case "meta":
+      return Command;
+    case "ctrl":
+      return Ctrl;
+    case "shift":
+      return Shift;
+    case "opt":
+      return Option;
+    case "alt":
+      return isMac2 ? Option : Alt;
+  }
+}
+var ModifierIcon = react.forwardRef(
+  ({ modifier, ...props }, ref) => {
+    const Icon = getModifierIcon(modifier);
+    return /* @__PURE__ */ jsxRuntime.jsx(Icon, { ref, ...props });
+  }
+);
+ModifierIcon.displayName = "ModifierIcon";
+function KeyCombo({ combo }) {
+  const { key, modifiers } = combo;
+  const parts = [];
+  if (modifiers.meta) {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "meta", className: "kbd-modifier-icon" }, "meta"));
+  }
+  if (modifiers.ctrl) {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "ctrl", className: "kbd-modifier-icon" }, "ctrl"));
+  }
+  if (modifiers.alt) {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "alt", className: "kbd-modifier-icon" }, "alt"));
+  }
+  if (modifiers.shift) {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "shift", className: "kbd-modifier-icon" }, "shift"));
+  }
+  const KeyIcon = getKeyIcon(key);
+  if (KeyIcon) {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx(KeyIcon, { className: "kbd-key-icon" }, "key"));
+  } else {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx("span", { children: formatKeyForDisplay(key) }, "key"));
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: parts });
+}
+function SeqElemDisplay({ elem }) {
+  if (elem.type === "digit") {
+    return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-placeholder", title: "Any single digit (0-9)", children: "#" });
+  }
+  if (elem.type === "digits") {
+    return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-placeholder", title: "One or more digits (0-9)", children: "##" });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(KeyCombo, { combo: { key: elem.key, modifiers: elem.modifiers } });
+}
+function BindingDisplay({ binding }) {
+  const sequence = parseKeySeq(binding);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: sequence.map((elem, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
+    i > 0 && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-sequence-sep", children: " " }),
+    /* @__PURE__ */ jsxRuntime.jsx(SeqElemDisplay, { elem })
+  ] }, i)) });
+}
+function Kbd({
+  action,
+  separator = " / ",
+  all = false,
+  fallback = null,
+  className,
+  clickable = true
+}) {
+  const ctx = useMaybeHotkeysContext();
+  const warnedRef = react.useRef(false);
+  const bindings = ctx ? all ? ctx.registry.getBindingsForAction(action) : [ctx.registry.getFirstBindingForAction(action)].filter(Boolean) : [];
+  react.useEffect(() => {
+    if (!ctx) return;
+    if (warnedRef.current) return;
+    const timer = setTimeout(() => {
+      if (!ctx.registry.actions.has(action)) {
+        console.warn(`Kbd: Action "${action}" not found in registry`);
+        warnedRef.current = true;
+      }
+    }, 100);
+    return () => clearTimeout(timer);
+  }, [ctx, action]);
+  if (!ctx) {
+    return null;
+  }
+  if (bindings.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
+  }
+  const content = bindings.map((binding, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
+    i > 0 && separator,
+    /* @__PURE__ */ jsxRuntime.jsx(BindingDisplay, { binding })
+  ] }, binding));
+  if (clickable) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "kbd",
+      {
+        className: `${className || ""} kbd-clickable`.trim(),
+        onClick: () => ctx.executeAction(action),
+        role: "button",
+        tabIndex: 0,
+        onKeyDown: (e) => {
+          if (e.key === "Enter" || e.key === " ") {
+            e.preventDefault();
+            ctx.executeAction(action);
+          }
+        },
+        children: content
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("kbd", { className, children: content });
+}
+function Key(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(Kbd, { ...props, clickable: false });
+}
+function Kbds(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(Kbd, { ...props, all: true });
+}
+function KbdModal(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(Kbd, { ...props, action: ACTION_MODAL });
+}
+function KbdOmnibar(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(Kbd, { ...props, action: ACTION_OMNIBAR });
+}
+function KbdLookup(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(Kbd, { ...props, action: ACTION_LOOKUP });
+}
+function buildActionMap(keymap) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, actionOrActions] of Object.entries(keymap)) {
+    const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
+    for (const action of actions) {
+      map.set(action, key);
+    }
+  }
+  return map;
+}
+function KeybindingEditor({
+  keymap,
+  defaults,
+  descriptions,
+  onChange,
+  onReset,
+  className,
   children
 }) {
   const [editingAction, setEditingAction] = react.useState(null);
@@ -1748,127 +2584,203 @@ function KeybindingEditor({
     ] })
   ] });
 }
-var baseStyle = {
-  width: "1.2em",
-  height: "1.2em",
-  marginRight: "2px",
-  verticalAlign: "middle"
-};
-var wideStyle = {
-  ...baseStyle,
-  width: "1.4em"
-};
-function CommandIcon({ className, style }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      className,
-      style: { ...baseStyle, ...style },
-      viewBox: "0 0 24 24",
-      fill: "currentColor",
-      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M6 4a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2v4H6a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2h4v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2a2 2 0 0 0-2-2h-2v-4h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v2h-4V6a2 2 0 0 0-2-2H6zm4 6h4v4h-4v-4z" })
-    }
-  );
-}
-function CtrlIcon({ className, style }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      className,
-      style: { ...baseStyle, ...style },
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "3",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M6 15l6-6 6 6" })
-    }
-  );
-}
-function ShiftIcon({ className, style }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      className,
-      style: { ...wideStyle, ...style },
-      viewBox: "0 0 28 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinejoin: "round",
-      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M14 3L3 14h6v7h10v-7h6L14 3z" })
-    }
-  );
-}
-function OptIcon({ className, style }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      className,
-      style: { ...baseStyle, ...style },
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2.5",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 6h6l8 12h6M14 6h6" })
+function LookupModal({ defaultBinding = "meta+shift+k" } = {}) {
+  const {
+    isLookupOpen,
+    closeLookup,
+    toggleLookup,
+    registry,
+    executeAction
+  } = useHotkeysContext();
+  useAction(ACTION_LOOKUP, {
+    label: "Key lookup",
+    group: "Global",
+    defaultBindings: defaultBinding ? [defaultBinding] : [],
+    handler: react.useCallback(() => toggleLookup(), [toggleLookup])
+  });
+  const [pendingKeys, setPendingKeys] = react.useState([]);
+  const [selectedIndex, setSelectedIndex] = react.useState(0);
+  const allBindings = react.useMemo(() => {
+    const results = [];
+    const keymap = registry.keymap;
+    for (const [binding, actionOrActions] of Object.entries(keymap)) {
+      if (binding.startsWith("__")) continue;
+      const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
+      const sequence = parseHotkeyString(binding);
+      const keySeq = parseKeySeq(binding);
+      const display = formatKeySeq(keySeq).display;
+      const labels = actions.map((actionId) => {
+        const action = registry.actions.get(actionId);
+        return action?.config.label || actionId;
+      });
+      results.push({ binding, sequence, keySeq, display, actions, labels });
+    }
+    results.sort((a, b) => a.binding.localeCompare(b.binding));
+    return results;
+  }, [registry.keymap, registry.actions]);
+  const filteredBindings = react.useMemo(() => {
+    if (pendingKeys.length === 0) return allBindings;
+    return allBindings.filter((result) => {
+      if (result.sequence.length < pendingKeys.length) return false;
+      for (let i = 0; i < pendingKeys.length; i++) {
+        const pending = pendingKeys[i];
+        const target = result.sequence[i];
+        if (pending.key !== target.key) return false;
+        if (pending.modifiers.ctrl !== target.modifiers.ctrl) return false;
+        if (pending.modifiers.alt !== target.modifiers.alt) return false;
+        if (pending.modifiers.shift !== target.modifiers.shift) return false;
+        if (pending.modifiers.meta !== target.modifiers.meta) return false;
+      }
+      return true;
+    });
+  }, [allBindings, pendingKeys]);
+  const groupedByNextKey = react.useMemo(() => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const result of filteredBindings) {
+      if (result.sequence.length > pendingKeys.length) {
+        const nextCombo = result.sequence[pendingKeys.length];
+        const nextKey = formatCombination([nextCombo]).display;
+        const existing = groups.get(nextKey) || [];
+        existing.push(result);
+        groups.set(nextKey, existing);
+      } else {
+        const existing = groups.get("") || [];
+        existing.push(result);
+        groups.set("", existing);
+      }
     }
-  );
-}
-function AltIcon({ className, style }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      className,
-      style: { ...baseStyle, ...style },
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2.5",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 18h8M12 18l4-6M12 18l4 0M16 12l4-6h-8" })
+    return groups;
+  }, [filteredBindings, pendingKeys]);
+  const formattedPendingKeys = react.useMemo(() => {
+    if (pendingKeys.length === 0) return "";
+    return formatCombination(pendingKeys).display;
+  }, [pendingKeys]);
+  react.useEffect(() => {
+    if (isLookupOpen) {
+      setPendingKeys([]);
+      setSelectedIndex(0);
     }
-  );
+  }, [isLookupOpen]);
+  react.useEffect(() => {
+    setSelectedIndex(0);
+  }, [filteredBindings.length]);
+  react.useEffect(() => {
+    if (!isLookupOpen) return;
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        if (pendingKeys.length > 0) {
+          setPendingKeys([]);
+        } else {
+          closeLookup();
+        }
+        return;
+      }
+      if (e.key === "Backspace") {
+        e.preventDefault();
+        setPendingKeys((prev) => prev.slice(0, -1));
+        return;
+      }
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setSelectedIndex((prev) => Math.min(prev + 1, filteredBindings.length - 1));
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setSelectedIndex((prev) => Math.max(prev - 1, 0));
+        return;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        const selected = filteredBindings[selectedIndex];
+        if (selected && selected.actions.length > 0) {
+          closeLookup();
+          executeAction(selected.actions[0]);
+        }
+        return;
+      }
+      if (isModifierKey(e.key)) return;
+      e.preventDefault();
+      const newCombo = {
+        key: normalizeKey(e.key),
+        modifiers: {
+          ctrl: e.ctrlKey,
+          alt: e.altKey,
+          shift: e.shiftKey,
+          meta: e.metaKey
+        }
+      };
+      setPendingKeys((prev) => [...prev, newCombo]);
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [isLookupOpen, pendingKeys, filteredBindings, selectedIndex, closeLookup, executeAction]);
+  const handleBackdropClick = react.useCallback(() => {
+    closeLookup();
+  }, [closeLookup]);
+  if (!isLookupOpen) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-lookup-backdrop", onClick: handleBackdropClick, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-lookup", onClick: (e) => e.stopPropagation(), children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-lookup-header", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-lookup-search", children: formattedPendingKeys ? /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-sequence-keys", children: formattedPendingKeys }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-lookup-placeholder", children: "Type keys to filter..." }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "kbd-lookup-hint", children: [
+        "\u2191\u2193 navigate \xB7 Enter select \xB7 Esc ",
+        pendingKeys.length > 0 ? "clear" : "close",
+        " \xB7 \u232B back"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-lookup-results", children: filteredBindings.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-lookup-empty", children: "No matching shortcuts" }) : filteredBindings.map((result, index) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: `kbd-lookup-result ${index === selectedIndex ? "selected" : ""}`,
+        onClick: () => {
+          closeLookup();
+          if (result.actions.length > 0) {
+            executeAction(result.actions[0]);
+          }
+        },
+        onMouseEnter: () => setSelectedIndex(index),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-kbd", children: result.display }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-lookup-labels", children: result.labels.join(", ") })
+        ]
+      },
+      result.binding
+    )) }),
+    pendingKeys.length > 0 && groupedByNextKey.size > 1 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-lookup-continuations", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-lookup-continuations-label", children: "Continue with:" }),
+      Array.from(groupedByNextKey.keys()).filter((k) => k !== "").slice(0, 8).map((nextKey) => /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-kbd kbd-small", children: nextKey }, nextKey)),
+      groupedByNextKey.size > 9 && /* @__PURE__ */ jsxRuntime.jsx("span", { children: "..." })
+    ] })
+  ] }) });
 }
-var isMac2 = typeof navigator !== "undefined" && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
-function getModifierIcon(modifier) {
-  switch (modifier) {
-    case "meta":
-      return CommandIcon;
-    case "ctrl":
-      return CtrlIcon;
-    case "shift":
-      return ShiftIcon;
-    case "opt":
-      return OptIcon;
-    case "alt":
-      return isMac2 ? OptIcon : AltIcon;
+function SeqElemBadge({ elem }) {
+  if (elem.type === "digit") {
+    return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-placeholder", title: "Any single digit (0-9)", children: "#" });
   }
-}
-function ModifierIcon({ modifier, ...props }) {
-  const Icon = getModifierIcon(modifier);
-  return /* @__PURE__ */ jsxRuntime.jsx(Icon, { ...props });
+  if (elem.type === "digits") {
+    return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-placeholder", title: "One or more digits (0-9)", children: "##" });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    elem.modifiers.meta && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "meta", className: "kbd-modifier-icon" }),
+    elem.modifiers.ctrl && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "ctrl", className: "kbd-modifier-icon" }),
+    elem.modifiers.alt && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "alt", className: "kbd-modifier-icon" }),
+    elem.modifiers.shift && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "shift", className: "kbd-modifier-icon" }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { children: formatKeyForDisplay(elem.key) })
+  ] });
 }
 function BindingBadge({ binding }) {
-  const sequence = parseHotkeyString(binding);
-  return /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-kbd", children: sequence.map((combo, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
+  const keySeq = parseKeySeq(binding);
+  return /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-kbd", children: keySeq.map((elem, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
     i > 0 && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-sequence-sep", children: " " }),
-    combo.modifiers.meta && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "meta", className: "kbd-modifier-icon" }),
-    combo.modifiers.ctrl && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "ctrl", className: "kbd-modifier-icon" }),
-    combo.modifiers.alt && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "alt", className: "kbd-modifier-icon" }),
-    combo.modifiers.shift && /* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "shift", className: "kbd-modifier-icon" }),
-    /* @__PURE__ */ jsxRuntime.jsx("span", { children: combo.key.length === 1 ? combo.key.toUpperCase() : combo.key })
+    /* @__PURE__ */ jsxRuntime.jsx(SeqElemBadge, { elem })
   ] }, i)) });
 }
 function Omnibar({
   actions: actionsProp,
   handlers: handlersProp,
   keymap: keymapProp,
-  openKey = "meta+k",
-  enabled: enabledProp,
+  defaultBinding = "meta+k",
   isOpen: isOpenProp,
   onOpen: onOpenProp,
   onClose: onCloseProp,
@@ -1883,7 +2795,12 @@ function Omnibar({
   const ctx = useMaybeHotkeysContext();
   const actions = actionsProp ?? ctx?.registry.actionRegistry ?? {};
   const keymap = keymapProp ?? ctx?.registry.keymap ?? {};
-  const enabled = enabledProp ?? !ctx;
+  useAction(ACTION_OMNIBAR, {
+    label: "Command palette",
+    group: "Global",
+    defaultBindings: defaultBinding ? [defaultBinding] : [],
+    handler: react.useCallback(() => ctx?.toggleOmnibar(), [ctx?.toggleOmnibar])
+  });
   const handleExecute = react.useCallback((actionId) => {
     if (onExecuteProp) {
       onExecuteProp(actionId);
@@ -1922,9 +2839,9 @@ function Omnibar({
     actions,
     handlers: handlersProp,
     keymap,
-    openKey,
-    enabled: isOpenProp === void 0 && ctx === null ? enabled : false,
-    // Disable hotkey if controlled or using context
+    openKey: "",
+    // Trigger is handled via useAction, not useOmnibar
+    enabled: false,
     onOpen: handleOpen,
     onClose: handleClose,
     onExecute: handleExecute,
@@ -1938,6 +2855,18 @@ function Omnibar({
       });
     }
   }, [isOpen]);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    const handleGlobalKeyDown = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        close();
+      }
+    };
+    document.addEventListener("keydown", handleGlobalKeyDown, true);
+    return () => document.removeEventListener("keydown", handleGlobalKeyDown, true);
+  }, [isOpen, close]);
   const handleKeyDown = react.useCallback(
     (e) => {
       switch (e.key) {
@@ -2024,6 +2953,7 @@ function SequenceModal() {
   const {
     pendingKeys,
     isAwaitingSequence,
+    cancelSequence,
     sequenceTimeoutStartedAt: timeoutStartedAt,
     sequenceTimeout,
     getCompletions,
@@ -2056,7 +2986,7 @@ function SequenceModal() {
   if (!isAwaitingSequence || pendingKeys.length === 0) {
     return null;
   }
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-sequence-backdrop", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-sequence", children: [
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-sequence-backdrop", onClick: cancelSequence, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-sequence", onClick: (e) => e.stopPropagation(), children: [
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-sequence-current", children: [
       /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-sequence-keys", children: formattedPendingKeys }),
       /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-sequence-ellipsis", children: "\u2026" })
@@ -2070,7 +3000,7 @@ function SequenceModal() {
       timeoutStartedAt
     ),
     completions.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-sequence-completions", children: Array.from(groupedCompletions.entries()).map(([nextKey, comps]) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-sequence-completion", children: [
-      /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-kbd", children: nextKey.toUpperCase() }),
+      /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "kbd-kbd", children: nextKey }),
       /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-sequence-arrow", children: "\u2192" }),
       /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-sequence-actions", children: comps.flatMap((c) => c.actions).map((action, i) => /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
         i > 0 && ", ",
@@ -2080,6 +3010,8 @@ function SequenceModal() {
     completions.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kbd-sequence-empty", children: "No matching shortcuts" })
   ] }) });
 }
+var DefaultTooltip = ({ children }) => /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+var TooltipContext = react.createContext(DefaultTooltip);
 function parseActionId(actionId) {
   const colonIndex = actionId.indexOf(":");
   if (colonIndex > 0) {
@@ -2087,22 +3019,47 @@ function parseActionId(actionId) {
   }
   return { group: "General", name: actionId };
 }
-function organizeShortcuts(keymap, labels, descriptions, groupNames, groupOrder) {
+function organizeShortcuts(keymap, labels, descriptions, groupNames, groupOrder, actionRegistry, showUnbound = true) {
   const actionBindings = getActionBindings(keymap);
   const groupMap = /* @__PURE__ */ new Map();
+  const includedActions = /* @__PURE__ */ new Set();
+  const getGroupName = (actionId) => {
+    const registeredGroup = actionRegistry?.[actionId]?.group;
+    if (registeredGroup) return registeredGroup;
+    const { group: groupKey } = parseActionId(actionId);
+    return groupNames?.[groupKey] ?? groupKey;
+  };
   for (const [actionId, bindings] of actionBindings) {
-    const { group: groupKey, name } = parseActionId(actionId);
-    const groupName = groupNames?.[groupKey] ?? groupKey;
+    includedActions.add(actionId);
+    const { name } = parseActionId(actionId);
+    const groupName = getGroupName(actionId);
     if (!groupMap.has(groupName)) {
       groupMap.set(groupName, { name: groupName, shortcuts: [] });
     }
     groupMap.get(groupName).shortcuts.push({
       actionId,
-      label: labels?.[actionId] ?? name,
+      label: labels?.[actionId] ?? actionRegistry?.[actionId]?.label ?? name,
       description: descriptions?.[actionId],
       bindings
     });
   }
+  if (actionRegistry && showUnbound) {
+    for (const [actionId, action] of Object.entries(actionRegistry)) {
+      if (includedActions.has(actionId)) continue;
+      const { name } = parseActionId(actionId);
+      const groupName = getGroupName(actionId);
+      if (!groupMap.has(groupName)) {
+        groupMap.set(groupName, { name: groupName, shortcuts: [] });
+      }
+      groupMap.get(groupName).shortcuts.push({
+        actionId,
+        label: labels?.[actionId] ?? action.label ?? name,
+        description: descriptions?.[actionId],
+        bindings: []
+        // No bindings
+      });
+    }
+  }
   for (const group of groupMap.values()) {
     group.shortcuts.sort((a, b) => a.actionId.localeCompare(b.actionId));
   }
@@ -2143,11 +3100,25 @@ function KeyDisplay({
   if (modifiers.shift) {
     parts.push(/* @__PURE__ */ jsxRuntime.jsx(ModifierIcon, { modifier: "shift", className: "kbd-modifier-icon" }, "shift"));
   }
-  const keyDisplay = key.length === 1 ? key.toUpperCase() : key.charAt(0).toUpperCase() + key.slice(1);
-  parts.push(/* @__PURE__ */ jsxRuntime.jsx("span", { children: keyDisplay }, "key"));
+  const KeyIcon = getKeyIcon(key);
+  if (KeyIcon) {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx(KeyIcon, { className: "kbd-key-icon" }, "key"));
+  } else {
+    parts.push(/* @__PURE__ */ jsxRuntime.jsx("span", { children: formatKeyForDisplay(key) }, "key"));
+  }
   return /* @__PURE__ */ jsxRuntime.jsx("span", { className, children: parts });
 }
-function BindingDisplay({
+function SeqElemDisplay2({ elem, className }) {
+  const Tooltip = react.useContext(TooltipContext);
+  if (elem.type === "digit") {
+    return /* @__PURE__ */ jsxRuntime.jsx(Tooltip, { title: "Any single digit (0-9)", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: `kbd-placeholder ${className || ""}`, children: "#" }) });
+  }
+  if (elem.type === "digits") {
+    return /* @__PURE__ */ jsxRuntime.jsx(Tooltip, { title: "One or more digits (0-9)", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: `kbd-placeholder ${className || ""}`, children: "##" }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(KeyDisplay, { combo: { key: elem.key, modifiers: elem.modifiers }, className });
+}
+function BindingDisplay2({
   binding,
   className,
   editable,
@@ -2158,10 +3129,12 @@ function BindingDisplay({
   onEdit,
   onRemove,
   pendingKeys,
-  activeKeys
+  activeKeys,
+  timeoutDuration = DEFAULT_SEQUENCE_TIMEOUT
 }) {
   const sequence = parseHotkeyString(binding);
-  const display = formatCombination(sequence);
+  const keySeq = parseKeySeq(binding);
+  formatKeySeq(keySeq);
   let kbdClassName = "kbd-kbd";
   if (editable && !isEditing) kbdClassName += " editable";
   if (isEditing) kbdClassName += " editing";
@@ -2192,7 +3165,17 @@ function BindingDisplay({
     } else {
       content = "...";
     }
-    return /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: kbdClassName, tabIndex: editable ? 0 : void 0, children: content });
+    return /* @__PURE__ */ jsxRuntime.jsxs("kbd", { className: kbdClassName, tabIndex: editable ? 0 : void 0, children: [
+      content,
+      pendingKeys && pendingKeys.length > 0 && Number.isFinite(timeoutDuration) && /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          className: "kbd-timeout-bar",
+          style: { animationDuration: `${timeoutDuration}ms` }
+        },
+        pendingKeys.length
+      )
+    ] });
   }
   return /* @__PURE__ */ jsxRuntime.jsxs("kbd", { className: kbdClassName, onClick: handleClick, tabIndex: editable ? 0 : void 0, onKeyDown: editable && onEdit ? (e) => {
     if (e.key === "Enter" || e.key === " ") {
@@ -2200,10 +3183,13 @@ function BindingDisplay({
       onEdit();
     }
   } : void 0, children: [
-    display.isSequence ? sequence.map((combo, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
+    keySeq.length > 1 ? keySeq.map((elem, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
       i > 0 && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kbd-sequence-sep", children: " " }),
-      /* @__PURE__ */ jsxRuntime.jsx(KeyDisplay, { combo })
-    ] }, i)) : /* @__PURE__ */ jsxRuntime.jsx(KeyDisplay, { combo: sequence[0] }),
+      /* @__PURE__ */ jsxRuntime.jsx(SeqElemDisplay2, { elem })
+    ] }, i)) : keySeq.length === 1 ? /* @__PURE__ */ jsxRuntime.jsx(SeqElemDisplay2, { elem: keySeq[0] }) : (
+      // Fallback for legacy parsing
+      /* @__PURE__ */ jsxRuntime.jsx(KeyDisplay, { combo: sequence[0] })
+    ),
     editable && onRemove && /* @__PURE__ */ jsxRuntime.jsx(
       "button",
       {
@@ -2228,8 +3214,7 @@ function ShortcutsModal({
   groupRenderers,
   isOpen: isOpenProp,
   onClose: onCloseProp,
-  openKey = "?",
-  autoRegisterOpen,
+  defaultBinding = "?",
   editable = false,
   onBindingChange,
   onBindingAdd,
@@ -2240,7 +3225,9 @@ function ShortcutsModal({
   backdropClassName = "kbd-backdrop",
   modalClassName = "kbd-modal",
   title = "Keyboard Shortcuts",
-  hint
+  hint,
+  showUnbound,
+  TooltipComponent: TooltipComponentProp = DefaultTooltip
 }) {
   const ctx = useMaybeHotkeysContext();
   const contextLabels = react.useMemo(() => {
@@ -2279,28 +3266,30 @@ function ShortcutsModal({
   const descriptions = descriptionsProp ?? contextDescriptions;
   const groupNames = groupNamesProp ?? contextGroups;
   const handleBindingChange = onBindingChange ?? (ctx ? (action, oldKey, newKey) => {
-    if (oldKey) ctx.registry.removeBinding(oldKey);
+    if (oldKey) ctx.registry.removeBinding(action, oldKey);
     ctx.registry.setBinding(action, newKey);
   } : void 0);
   const handleBindingAdd = onBindingAdd ?? (ctx ? (action, key) => {
     ctx.registry.setBinding(action, key);
   } : void 0);
-  const handleBindingRemove = onBindingRemove ?? (ctx ? (_action, key) => {
-    ctx.registry.removeBinding(key);
+  const handleBindingRemove = onBindingRemove ?? (ctx ? (action, key) => {
+    ctx.registry.removeBinding(action, key);
   } : void 0);
   const handleReset = onReset ?? (ctx ? () => {
     ctx.registry.resetOverrides();
   } : void 0);
-  const shouldAutoRegisterOpen = autoRegisterOpen ?? !ctx;
   const [internalIsOpen, setInternalIsOpen] = react.useState(false);
   const isOpen = isOpenProp ?? ctx?.isModalOpen ?? internalIsOpen;
   const [editingAction, setEditingAction] = react.useState(null);
   const [editingKey, setEditingKey] = react.useState(null);
   const [addingAction, setAddingAction] = react.useState(null);
   const [pendingConflict, setPendingConflict] = react.useState(null);
+  const [hasPendingConflictState, setHasPendingConflictState] = react.useState(false);
   const editingActionRef = react.useRef(null);
   const editingKeyRef = react.useRef(null);
   const addingActionRef = react.useRef(null);
+  const setIsEditingBindingRef = react.useRef(ctx?.setIsEditingBinding);
+  setIsEditingBindingRef.current = ctx?.setIsEditingBinding;
   const conflicts = react.useMemo(() => findConflicts(keymap), [keymap]);
   const actionBindings = react.useMemo(() => getActionBindings(keymap), [keymap]);
   const close = react.useCallback(() => {
@@ -2318,13 +3307,19 @@ function ShortcutsModal({
       ctx.closeModal();
     }
   }, [onCloseProp, ctx]);
-  const open = react.useCallback(() => {
+  react.useCallback(() => {
     if (ctx?.openModal) {
       ctx.openModal();
     } else {
       setInternalIsOpen(true);
     }
   }, [ctx]);
+  useAction(ACTION_MODAL, {
+    label: "Show shortcuts",
+    group: "Global",
+    defaultBindings: defaultBinding ? [defaultBinding] : [],
+    handler: react.useCallback(() => ctx?.toggleModal() ?? setInternalIsOpen((prev) => !prev), [ctx?.toggleModal])
+  });
   const checkConflict = react.useCallback((newKey, forAction) => {
     const existingActions = keymap[newKey];
     if (!existingActions) return null;
@@ -2332,7 +3327,24 @@ function ShortcutsModal({
     const conflicts2 = actions.filter((a) => a !== forAction);
     return conflicts2.length > 0 ? conflicts2 : null;
   }, [keymap]);
-  const { isRecording, startRecording, cancel, pendingKeys, activeKeys } = useRecordHotkey({
+  const combinationsEqual2 = react.useCallback((a, b) => {
+    return a.key === b.key && a.modifiers.ctrl === b.modifiers.ctrl && a.modifiers.alt === b.modifiers.alt && a.modifiers.shift === b.modifiers.shift && a.modifiers.meta === b.modifiers.meta;
+  }, []);
+  const isSequencePrefix = react.useCallback((a, b) => {
+    if (a.length >= b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!combinationsEqual2(a[i], b[i])) return false;
+    }
+    return true;
+  }, [combinationsEqual2]);
+  const sequencesEqual = react.useCallback((a, b) => {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!combinationsEqual2(a[i], b[i])) return false;
+    }
+    return true;
+  }, [combinationsEqual2]);
+  const { isRecording, startRecording, cancel, pendingKeys, activeKeys, sequenceTimeout } = useRecordHotkey({
     onCapture: react.useCallback(
       (_sequence, display) => {
         const currentAddingAction = addingActionRef.current;
@@ -2360,6 +3372,7 @@ function ShortcutsModal({
         setEditingAction(null);
         setEditingKey(null);
         setAddingAction(null);
+        setIsEditingBindingRef.current?.(false);
       },
       [checkConflict, handleBindingChange, handleBindingAdd]
     ),
@@ -2371,6 +3384,7 @@ function ShortcutsModal({
       setEditingKey(null);
       setAddingAction(null);
       setPendingConflict(null);
+      setIsEditingBindingRef.current?.(false);
     }, []),
     // Tab to next/prev editable kbd and start editing
     onTab: react.useCallback(() => {
@@ -2395,7 +3409,7 @@ function ShortcutsModal({
         prev.click();
       }
     }, []),
-    pauseTimeout: pendingConflict !== null
+    pauseTimeout: pendingConflict !== null || hasPendingConflictState
   });
   const startEditingBinding = react.useCallback(
     (action, key) => {
@@ -2406,9 +3420,10 @@ function ShortcutsModal({
       setEditingAction(action);
       setEditingKey(key);
       setPendingConflict(null);
+      ctx?.setIsEditingBinding(true);
       startRecording();
     },
-    [startRecording]
+    [startRecording, ctx?.setIsEditingBinding]
   );
   const startAddingBinding = react.useCallback(
     (action) => {
@@ -2419,9 +3434,10 @@ function ShortcutsModal({
       setEditingKey(null);
       setAddingAction(action);
       setPendingConflict(null);
+      ctx?.setIsEditingBinding(true);
       startRecording();
     },
-    [startRecording]
+    [startRecording, ctx?.setIsEditingBinding]
   );
   const startEditing = react.useCallback(
     (action, bindingIndex) => {
@@ -2443,7 +3459,8 @@ function ShortcutsModal({
     setEditingKey(null);
     setAddingAction(null);
     setPendingConflict(null);
-  }, [cancel]);
+    ctx?.setIsEditingBinding(false);
+  }, [cancel, ctx?.setIsEditingBinding]);
   const removeBinding = react.useCallback(
     (action, key) => {
       handleBindingRemove?.(action, key);
@@ -2453,6 +3470,31 @@ function ShortcutsModal({
   const reset = react.useCallback(() => {
     handleReset?.();
   }, [handleReset]);
+  const pendingConflictInfo = react.useMemo(() => {
+    if (!isRecording || pendingKeys.length === 0) {
+      return { hasConflict: false, conflictingKeys: /* @__PURE__ */ new Set() };
+    }
+    const conflictingKeys = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(keymap)) {
+      if (editingKey && key.toLowerCase() === editingKey.toLowerCase()) continue;
+      const keySequence = parseHotkeyString(key);
+      if (sequencesEqual(pendingKeys, keySequence)) {
+        conflictingKeys.add(key);
+        continue;
+      }
+      if (isSequencePrefix(pendingKeys, keySequence)) {
+        conflictingKeys.add(key);
+        continue;
+      }
+      if (isSequencePrefix(keySequence, pendingKeys)) {
+        conflictingKeys.add(key);
+      }
+    }
+    return { hasConflict: conflictingKeys.size > 0, conflictingKeys };
+  }, [isRecording, pendingKeys, keymap, editingKey, sequencesEqual, isSequencePrefix]);
+  react.useEffect(() => {
+    setHasPendingConflictState(pendingConflictInfo.hasConflict);
+  }, [pendingConflictInfo.hasConflict]);
   const renderEditableKbd = react.useCallback(
     (actionId, key, showRemove = false) => {
       const isEditingThis = editingAction === actionId && editingKey === key && !addingAction;
@@ -2464,13 +3506,15 @@ function ShortcutsModal({
         const defaultActions = Array.isArray(defaultAction) ? defaultAction : [defaultAction];
         return defaultActions.includes(actionId);
       })() : true;
+      const isPendingConflict = pendingConflictInfo.conflictingKeys.has(key);
       return /* @__PURE__ */ jsxRuntime.jsx(
-        BindingDisplay,
+        BindingDisplay2,
         {
           binding: key,
           editable,
           isEditing: isEditingThis,
           isConflict,
+          isPendingConflict,
           isDefault,
           onEdit: () => {
             if (isRecording && !(editingAction === actionId && editingKey === key)) {
@@ -2491,24 +3535,27 @@ function ShortcutsModal({
           },
           onRemove: editable && showRemove ? () => removeBinding(actionId, key) : void 0,
           pendingKeys,
-          activeKeys
+          activeKeys,
+          timeoutDuration: pendingConflictInfo.hasConflict ? Infinity : sequenceTimeout
         },
         key
       );
     },
-    [editingAction, editingKey, addingAction, conflicts, defaults, editable, startEditingBinding, removeBinding, pendingKeys, activeKeys, isRecording, cancel, handleBindingAdd, handleBindingChange]
+    [editingAction, editingKey, addingAction, conflicts, defaults, editable, startEditingBinding, removeBinding, pendingKeys, activeKeys, isRecording, cancel, handleBindingAdd, handleBindingChange, sequenceTimeout, pendingConflictInfo]
   );
   const renderAddButton = react.useCallback(
     (actionId) => {
       const isAddingThis = addingAction === actionId;
       if (isAddingThis) {
         return /* @__PURE__ */ jsxRuntime.jsx(
-          BindingDisplay,
+          BindingDisplay2,
           {
             binding: "",
             isEditing: true,
+            isPendingConflict: pendingConflictInfo.hasConflict,
             pendingKeys,
-            activeKeys
+            activeKeys,
+            timeoutDuration: pendingConflictInfo.hasConflict ? Infinity : sequenceTimeout
           }
         );
       }
@@ -2537,13 +3584,14 @@ function ShortcutsModal({
         }
       );
     },
-    [addingAction, pendingKeys, activeKeys, startAddingBinding, isRecording, cancel, handleBindingAdd, handleBindingChange]
+    [addingAction, pendingKeys, activeKeys, startAddingBinding, isRecording, cancel, handleBindingAdd, handleBindingChange, sequenceTimeout, pendingConflictInfo]
   );
   const renderCell = react.useCallback(
     (actionId, keys) => {
+      const showAddButton = editable && (multipleBindings || keys.length === 0);
       return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "kbd-action-bindings", children: [
         keys.map((key) => /* @__PURE__ */ jsxRuntime.jsx(react.Fragment, { children: renderEditableKbd(actionId, key, true) }, key)),
-        editable && multipleBindings && renderAddButton(actionId)
+        showAddButton && renderAddButton(actionId)
       ] });
     },
     [renderEditableKbd, renderAddButton, editable, multipleBindings]
@@ -2560,14 +3608,10 @@ function ShortcutsModal({
     editingKey,
     addingAction
   }), [renderCell, renderEditableKbd, renderAddButton, startEditingBinding, startAddingBinding, removeBinding, isRecording, editingAction, editingKey, addingAction]);
-  const modalKeymap = shouldAutoRegisterOpen ? { [openKey]: "openShortcuts" } : {};
   useHotkeys(
-    { ...modalKeymap, escape: "closeShortcuts" },
-    {
-      openShortcuts: open,
-      closeShortcuts: close
-    },
-    { enabled: shouldAutoRegisterOpen || isOpen }
+    { escape: "closeShortcuts" },
+    { closeShortcuts: close },
+    { enabled: isOpen }
   );
   react.useEffect(() => {
     if (!isOpen || !editingAction && !addingAction) return;
@@ -2581,6 +3625,19 @@ function ShortcutsModal({
     window.addEventListener("keydown", handleEscape, true);
     return () => window.removeEventListener("keydown", handleEscape, true);
   }, [isOpen, editingAction, addingAction, cancelEditing]);
+  react.useEffect(() => {
+    if (!isOpen || !ctx) return;
+    const handleMetaK = (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "k") {
+        e.preventDefault();
+        e.stopPropagation();
+        close();
+        ctx.openOmnibar();
+      }
+    };
+    window.addEventListener("keydown", handleMetaK, true);
+    return () => window.removeEventListener("keydown", handleMetaK, true);
+  }, [isOpen, ctx, close]);
   const handleBackdropClick = react.useCallback(
     (e) => {
       if (e.target === e.currentTarget) {
@@ -2600,9 +3657,10 @@ function ShortcutsModal({
     },
     [editingAction, addingAction, cancelEditing]
   );
+  const effectiveShowUnbound = showUnbound ?? editable;
   const shortcutGroups = react.useMemo(
-    () => organizeShortcuts(keymap, labels, descriptions, groupNames, groupOrder),
-    [keymap, labels, descriptions, groupNames, groupOrder]
+    () => organizeShortcuts(keymap, labels, descriptions, groupNames, groupOrder, ctx?.registry.actionRegistry, effectiveShowUnbound),
+    [keymap, labels, descriptions, groupNames, groupOrder, ctx?.registry.actionRegistry, effectiveShowUnbound]
   );
   if (!isOpen) return null;
   if (children) {
@@ -2632,7 +3690,7 @@ function ShortcutsModal({
       renderCell(actionId, bindings)
     ] }, actionId));
   };
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: backdropClassName, onClick: handleBackdropClick, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: modalClassName, role: "dialog", "aria-modal": "true", "aria-label": "Keyboard shortcuts", onClick: handleModalClick, children: [
+  return /* @__PURE__ */ jsxRuntime.jsx(TooltipContext.Provider, { value: TooltipComponentProp, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: backdropClassName, onClick: handleBackdropClick, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: modalClassName, role: "dialog", "aria-modal": "true", "aria-label": "Keyboard shortcuts", onClick: handleModalClick, children: [
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-modal-header", children: [
       /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "kbd-modal-title", children: title }),
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kbd-modal-header-buttons", children: [
@@ -2701,37 +3759,68 @@ function ShortcutsModal({
         )
       ] })
     ] })
-  ] }) });
+  ] }) }) });
 }
 
+exports.ACTION_LOOKUP = ACTION_LOOKUP;
+exports.ACTION_MODAL = ACTION_MODAL;
+exports.ACTION_OMNIBAR = ACTION_OMNIBAR;
 exports.ActionsRegistryContext = ActionsRegistryContext;
-exports.AltIcon = AltIcon;
-exports.CommandIcon = CommandIcon;
-exports.CtrlIcon = CtrlIcon;
+exports.Alt = Alt;
+exports.Backspace = Backspace;
+exports.Command = Command;
+exports.Ctrl = Ctrl;
+exports.DEFAULT_SEQUENCE_TIMEOUT = DEFAULT_SEQUENCE_TIMEOUT;
+exports.DIGITS_PLACEHOLDER = DIGITS_PLACEHOLDER;
+exports.DIGIT_PLACEHOLDER = DIGIT_PLACEHOLDER;
+exports.Down = Down;
+exports.Enter = Enter;
 exports.HotkeysProvider = HotkeysProvider;
+exports.Kbd = Kbd;
+exports.KbdLookup = KbdLookup;
+exports.KbdModal = KbdModal;
+exports.KbdOmnibar = KbdOmnibar;
+exports.Kbds = Kbds;
+exports.Key = Key;
 exports.KeybindingEditor = KeybindingEditor;
+exports.Left = Left;
+exports.LookupModal = LookupModal;
 exports.ModifierIcon = ModifierIcon;
 exports.Omnibar = Omnibar;
-exports.OptIcon = OptIcon;
+exports.Option = Option;
+exports.Right = Right;
 exports.SequenceModal = SequenceModal;
-exports.ShiftIcon = ShiftIcon;
+exports.Shift = Shift;
 exports.ShortcutsModal = ShortcutsModal;
+exports.Up = Up;
+exports.countPlaceholders = countPlaceholders;
 exports.createTwoColumnRenderer = createTwoColumnRenderer;
+exports.extractCaptures = extractCaptures;
 exports.findConflicts = findConflicts;
+exports.formatBinding = formatBinding;
 exports.formatCombination = formatCombination;
 exports.formatKeyForDisplay = formatKeyForDisplay;
+exports.formatKeySeq = formatKeySeq;
 exports.fuzzyMatch = fuzzyMatch;
 exports.getActionBindings = getActionBindings;
 exports.getConflictsArray = getConflictsArray;
+exports.getKeyIcon = getKeyIcon;
 exports.getModifierIcon = getModifierIcon;
 exports.getSequenceCompletions = getSequenceCompletions;
 exports.hasConflicts = hasConflicts;
+exports.hasDigitPlaceholders = hasDigitPlaceholders;
+exports.hotkeySequenceToKeySeq = hotkeySequenceToKeySeq;
+exports.isDigitPlaceholder = isDigitPlaceholder;
 exports.isMac = isMac;
 exports.isModifierKey = isModifierKey;
+exports.isPlaceholderSentinel = isPlaceholderSentinel;
 exports.isSequence = isSequence;
+exports.isShiftedSymbol = isShiftedSymbol;
+exports.keySeqToHotkeySequence = keySeqToHotkeySequence;
 exports.normalizeKey = normalizeKey;
 exports.parseCombinationId = parseCombinationId;
 exports.parseHotkeyString = parseHotkeyString;
+exports.parseKeySeq = parseKeySeq;
 exports.searchActions = searchActions;
 exports.useAction = useAction;
 exports.useActions = useActions;