@lacspace/hotkeys 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,205 @@
+import { RefObject } from 'react';
+
+/**
+ * @lacspace/hotkeys — ergonomic keyboard shortcuts for React.
+ *
+ * Combos (`mod+k`), key sequences (`g then d`), scopes, and pretty display
+ * formatting (`⌘K`). SSR-safe, respects form fields, zero-dependency, fully typed.
+ *
+ * @packageDocumentation
+ */
+
+/** A parsed hotkey combo: the resolved key plus each modifier requirement. */
+interface ParsedHotkey {
+    /** Normalized key (e.g. `"k"`, `"escape"`, `" "`, `"arrowup"`). */
+    key: string;
+    /** `mod` — Cmd on mac, Ctrl elsewhere. */
+    mod: boolean;
+    /** Control key. */
+    ctrl: boolean;
+    /** Alt / Option key. */
+    alt: boolean;
+    /** Shift key. */
+    shift: boolean;
+    /** Meta / Cmd / Win key. */
+    meta: boolean;
+}
+/** The handler invoked when a hotkey (or the final step of a sequence) fires. */
+type HotkeyHandler = (event: KeyboardEvent, combo: string) => void;
+/** Where to attach the key listener. */
+type HotkeyTarget = Window | HTMLElement | RefObject<HTMLElement | null>;
+/** Options for {@link useHotkeys}. */
+interface HotkeyOptions {
+    /** Master switch. When `false`, nothing fires. @default true */
+    enabled?: boolean;
+    /** Call `event.preventDefault()` when a hotkey matches. @default true */
+    preventDefault?: boolean;
+    /**
+     * Allow firing while an `input` / `textarea` / `select` / `contentEditable`
+     * element is the event source. @default false
+     */
+    enableOnFormTags?: boolean;
+    /** Which key event to listen for. @default "keydown" */
+    eventType?: "keydown" | "keyup";
+    /** Where to bind the listener. @default window */
+    target?: HotkeyTarget;
+    /**
+     * Scope name(s). The hotkey only fires when at least one is active
+     * (see {@link enableScope}). Omit to always fire.
+     */
+    scopes?: string | string[];
+}
+/**
+ * Detects whether the current platform is a Mac (or iOS device).
+ *
+ * SSR-safe: always returns `false` when there is no `navigator`.
+ *
+ * @returns `true` on macOS / iOS, `false` otherwise (and on the server).
+ *
+ * @example
+ * ```ts
+ * const symbol = isMac() ? "⌘" : "Ctrl";
+ * ```
+ */
+declare function isMac(): boolean;
+/**
+ * Parses a combo string like `"mod+shift+k"` into modifier flags and a key.
+ *
+ * Tokens split on `"+"`, case-insensitive. Modifiers: `mod` (Cmd on mac / Ctrl
+ * elsewhere), `ctrl`/`control`, `alt`/`option`, `shift`, `meta`/`cmd`/`command`/`win`.
+ * The remaining token is the key (`esc`→`escape`, `space`→`" "`, arrows→`arrowup`…,
+ * single letters lowercased).
+ *
+ * @param str - The combo string, e.g. `"mod+k"` or `"ctrl+shift+escape"`.
+ * @returns The parsed combo.
+ *
+ * @example
+ * ```ts
+ * parseHotkey("mod+shift+k");
+ * // { key: "k", mod: true, ctrl: false, alt: false, shift: true, meta: false }
+ * ```
+ */
+declare function parseHotkey(str: string): ParsedHotkey;
+/**
+ * Returns `true` when a keyboard event satisfies a combo string.
+ *
+ * `mod` resolves to `metaKey` on mac and `ctrlKey` elsewhere. Modifiers must
+ * match exactly (so `"ctrl+k"` does not fire when `Ctrl+Shift+K` is pressed).
+ *
+ * @param event - The keyboard event.
+ * @param combo - The combo string, e.g. `"mod+k"`.
+ * @returns Whether the event satisfies the combo.
+ *
+ * @example
+ * ```ts
+ * window.addEventListener("keydown", (e) => {
+ *   if (matchesHotkey(e, "mod+k")) openPalette();
+ * });
+ * ```
+ */
+declare function matchesHotkey(event: KeyboardEvent, combo: string): boolean;
+/**
+ * Formats a combo for display, e.g. mac → `"⌘⇧K"`, non-mac → `"Ctrl+Shift+K"`.
+ *
+ * Auto-detects the platform when `opts.mac` is omitted.
+ *
+ * @param combo - The combo string, e.g. `"mod+shift+k"`.
+ * @param opts - Optional overrides.
+ * @param opts.mac - Force mac (`true`) or non-mac (`false`) rendering.
+ * @returns A human-friendly label.
+ *
+ * @example
+ * ```tsx
+ * <kbd>{formatHotkey("mod+k")}</kbd>            // "⌘K" on mac, "Ctrl+K" elsewhere
+ * formatHotkey("ctrl+shift+k", { mac: false }); // "Ctrl+Shift+K"
+ * ```
+ */
+declare function formatHotkey(combo: string, opts?: {
+    mac?: boolean;
+}): string;
+/**
+ * Activates a scope. Hotkeys bound to this scope will start firing.
+ *
+ * @param name - The scope name.
+ *
+ * @example
+ * ```ts
+ * enableScope("editor"); // now editor hotkeys are live
+ * ```
+ */
+declare function enableScope(name: string): void;
+/**
+ * Deactivates a scope. Hotkeys bound only to this scope stop firing.
+ *
+ * @param name - The scope name.
+ */
+declare function disableScope(name: string): void;
+/**
+ * Toggles a scope on or off.
+ *
+ * @param name - The scope name.
+ */
+declare function toggleScope(name: string): void;
+/** Returns whether a scope is currently active. */
+declare function isScopeActive(name: string): boolean;
+/**
+ * Subscribes to the set of active scopes and exposes controls.
+ *
+ * The component re-renders whenever scopes change (backed by
+ * `useSyncExternalStore`, so it is concurrent-safe and SSR-safe).
+ *
+ * @returns `{ activeScopes, enableScope, disableScope, toggleScope }`.
+ *
+ * @example
+ * ```tsx
+ * function ScopeBadge() {
+ *   const { activeScopes, toggleScope } = useHotkeysScopes();
+ *   return (
+ *     <button onClick={() => toggleScope("editor")}>
+ *       {activeScopes.includes("editor") ? "Editor on" : "Editor off"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useHotkeysScopes(): {
+    activeScopes: readonly string[];
+    enableScope: (name: string) => void;
+    disableScope: (name: string) => void;
+    toggleScope: (name: string) => void;
+};
+/**
+ * Binds keyboard shortcut(s) — combos and/or sequences — for the lifetime of a component.
+ *
+ * Supports:
+ * - **Combos**: `"mod+k"`, `"ctrl+shift+p"`.
+ * - **Multiple combos**: pass an array — any match fires the handler.
+ * - **Sequences**: `"g then d"` or `"g d"` — press keys in order within ~1s.
+ * - **Scopes**: only fire while a named scope is active (see {@link enableScope}).
+ *
+ * The handler is kept in a ref, so `deps` are optional — the latest closure is
+ * always used without re-binding the listener.
+ *
+ * @param keys - A combo/sequence string, or an array of them.
+ * @param handler - Called with the event and the matched combo string.
+ * @param options - See {@link HotkeyOptions}.
+ * @param deps - Optional dependency list (rarely needed thanks to the latest-ref).
+ *
+ * @example
+ * ```tsx
+ * // Open a command palette with ⌘K / Ctrl+K
+ * useHotkeys("mod+k", (e) => {
+ *   e.preventDefault();
+ *   setPaletteOpen(true);
+ * });
+ *
+ * // Navigate with a sequence: press "g" then "d"
+ * useHotkeys("g then d", () => router.push("/dashboard"));
+ *
+ * // Scoped: only while the "editor" scope is active
+ * useHotkeys("mod+b", toggleBold, { scopes: "editor" });
+ * ```
+ */
+declare function useHotkeys(keys: string | string[], handler: HotkeyHandler, options?: HotkeyOptions, deps?: unknown[]): void;
+
+export { type HotkeyHandler, type HotkeyOptions, type HotkeyTarget, type ParsedHotkey, disableScope, enableScope, formatHotkey, isMac, isScopeActive, matchesHotkey, parseHotkey, toggleScope, useHotkeys, useHotkeysScopes };

package/dist/index.d.ts

@@ -0,0 +1,205 @@
+import { RefObject } from 'react';
+
+/**
+ * @lacspace/hotkeys — ergonomic keyboard shortcuts for React.
+ *
+ * Combos (`mod+k`), key sequences (`g then d`), scopes, and pretty display
+ * formatting (`⌘K`). SSR-safe, respects form fields, zero-dependency, fully typed.
+ *
+ * @packageDocumentation
+ */
+
+/** A parsed hotkey combo: the resolved key plus each modifier requirement. */
+interface ParsedHotkey {
+    /** Normalized key (e.g. `"k"`, `"escape"`, `" "`, `"arrowup"`). */
+    key: string;
+    /** `mod` — Cmd on mac, Ctrl elsewhere. */
+    mod: boolean;
+    /** Control key. */
+    ctrl: boolean;
+    /** Alt / Option key. */
+    alt: boolean;
+    /** Shift key. */
+    shift: boolean;
+    /** Meta / Cmd / Win key. */
+    meta: boolean;
+}
+/** The handler invoked when a hotkey (or the final step of a sequence) fires. */
+type HotkeyHandler = (event: KeyboardEvent, combo: string) => void;
+/** Where to attach the key listener. */
+type HotkeyTarget = Window | HTMLElement | RefObject<HTMLElement | null>;
+/** Options for {@link useHotkeys}. */
+interface HotkeyOptions {
+    /** Master switch. When `false`, nothing fires. @default true */
+    enabled?: boolean;
+    /** Call `event.preventDefault()` when a hotkey matches. @default true */
+    preventDefault?: boolean;
+    /**
+     * Allow firing while an `input` / `textarea` / `select` / `contentEditable`
+     * element is the event source. @default false
+     */
+    enableOnFormTags?: boolean;
+    /** Which key event to listen for. @default "keydown" */
+    eventType?: "keydown" | "keyup";
+    /** Where to bind the listener. @default window */
+    target?: HotkeyTarget;
+    /**
+     * Scope name(s). The hotkey only fires when at least one is active
+     * (see {@link enableScope}). Omit to always fire.
+     */
+    scopes?: string | string[];
+}
+/**
+ * Detects whether the current platform is a Mac (or iOS device).
+ *
+ * SSR-safe: always returns `false` when there is no `navigator`.
+ *
+ * @returns `true` on macOS / iOS, `false` otherwise (and on the server).
+ *
+ * @example
+ * ```ts
+ * const symbol = isMac() ? "⌘" : "Ctrl";
+ * ```
+ */
+declare function isMac(): boolean;
+/**
+ * Parses a combo string like `"mod+shift+k"` into modifier flags and a key.
+ *
+ * Tokens split on `"+"`, case-insensitive. Modifiers: `mod` (Cmd on mac / Ctrl
+ * elsewhere), `ctrl`/`control`, `alt`/`option`, `shift`, `meta`/`cmd`/`command`/`win`.
+ * The remaining token is the key (`esc`→`escape`, `space`→`" "`, arrows→`arrowup`…,
+ * single letters lowercased).
+ *
+ * @param str - The combo string, e.g. `"mod+k"` or `"ctrl+shift+escape"`.
+ * @returns The parsed combo.
+ *
+ * @example
+ * ```ts
+ * parseHotkey("mod+shift+k");
+ * // { key: "k", mod: true, ctrl: false, alt: false, shift: true, meta: false }
+ * ```
+ */
+declare function parseHotkey(str: string): ParsedHotkey;
+/**
+ * Returns `true` when a keyboard event satisfies a combo string.
+ *
+ * `mod` resolves to `metaKey` on mac and `ctrlKey` elsewhere. Modifiers must
+ * match exactly (so `"ctrl+k"` does not fire when `Ctrl+Shift+K` is pressed).
+ *
+ * @param event - The keyboard event.
+ * @param combo - The combo string, e.g. `"mod+k"`.
+ * @returns Whether the event satisfies the combo.
+ *
+ * @example
+ * ```ts
+ * window.addEventListener("keydown", (e) => {
+ *   if (matchesHotkey(e, "mod+k")) openPalette();
+ * });
+ * ```
+ */
+declare function matchesHotkey(event: KeyboardEvent, combo: string): boolean;
+/**
+ * Formats a combo for display, e.g. mac → `"⌘⇧K"`, non-mac → `"Ctrl+Shift+K"`.
+ *
+ * Auto-detects the platform when `opts.mac` is omitted.
+ *
+ * @param combo - The combo string, e.g. `"mod+shift+k"`.
+ * @param opts - Optional overrides.
+ * @param opts.mac - Force mac (`true`) or non-mac (`false`) rendering.
+ * @returns A human-friendly label.
+ *
+ * @example
+ * ```tsx
+ * <kbd>{formatHotkey("mod+k")}</kbd>            // "⌘K" on mac, "Ctrl+K" elsewhere
+ * formatHotkey("ctrl+shift+k", { mac: false }); // "Ctrl+Shift+K"
+ * ```
+ */
+declare function formatHotkey(combo: string, opts?: {
+    mac?: boolean;
+}): string;
+/**
+ * Activates a scope. Hotkeys bound to this scope will start firing.
+ *
+ * @param name - The scope name.
+ *
+ * @example
+ * ```ts
+ * enableScope("editor"); // now editor hotkeys are live
+ * ```
+ */
+declare function enableScope(name: string): void;
+/**
+ * Deactivates a scope. Hotkeys bound only to this scope stop firing.
+ *
+ * @param name - The scope name.
+ */
+declare function disableScope(name: string): void;
+/**
+ * Toggles a scope on or off.
+ *
+ * @param name - The scope name.
+ */
+declare function toggleScope(name: string): void;
+/** Returns whether a scope is currently active. */
+declare function isScopeActive(name: string): boolean;
+/**
+ * Subscribes to the set of active scopes and exposes controls.
+ *
+ * The component re-renders whenever scopes change (backed by
+ * `useSyncExternalStore`, so it is concurrent-safe and SSR-safe).
+ *
+ * @returns `{ activeScopes, enableScope, disableScope, toggleScope }`.
+ *
+ * @example
+ * ```tsx
+ * function ScopeBadge() {
+ *   const { activeScopes, toggleScope } = useHotkeysScopes();
+ *   return (
+ *     <button onClick={() => toggleScope("editor")}>
+ *       {activeScopes.includes("editor") ? "Editor on" : "Editor off"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useHotkeysScopes(): {
+    activeScopes: readonly string[];
+    enableScope: (name: string) => void;
+    disableScope: (name: string) => void;
+    toggleScope: (name: string) => void;
+};
+/**
+ * Binds keyboard shortcut(s) — combos and/or sequences — for the lifetime of a component.
+ *
+ * Supports:
+ * - **Combos**: `"mod+k"`, `"ctrl+shift+p"`.
+ * - **Multiple combos**: pass an array — any match fires the handler.
+ * - **Sequences**: `"g then d"` or `"g d"` — press keys in order within ~1s.
+ * - **Scopes**: only fire while a named scope is active (see {@link enableScope}).
+ *
+ * The handler is kept in a ref, so `deps` are optional — the latest closure is
+ * always used without re-binding the listener.
+ *
+ * @param keys - A combo/sequence string, or an array of them.
+ * @param handler - Called with the event and the matched combo string.
+ * @param options - See {@link HotkeyOptions}.
+ * @param deps - Optional dependency list (rarely needed thanks to the latest-ref).
+ *
+ * @example
+ * ```tsx
+ * // Open a command palette with ⌘K / Ctrl+K
+ * useHotkeys("mod+k", (e) => {
+ *   e.preventDefault();
+ *   setPaletteOpen(true);
+ * });
+ *
+ * // Navigate with a sequence: press "g" then "d"
+ * useHotkeys("g then d", () => router.push("/dashboard"));
+ *
+ * // Scoped: only while the "editor" scope is active
+ * useHotkeys("mod+b", toggleBold, { scopes: "editor" });
+ * ```
+ */
+declare function useHotkeys(keys: string | string[], handler: HotkeyHandler, options?: HotkeyOptions, deps?: unknown[]): void;
+
+export { type HotkeyHandler, type HotkeyOptions, type HotkeyTarget, type ParsedHotkey, disableScope, enableScope, formatHotkey, isMac, isScopeActive, matchesHotkey, parseHotkey, toggleScope, useHotkeys, useHotkeysScopes };

package/dist/index.js

@@ -0,0 +1,281 @@
+import { useSyncExternalStore, useRef, useEffect } from 'react';
+
+// src/index.ts
+function isMac() {
+  if (typeof navigator === "undefined") return false;
+  const uaData = navigator.userAgentData;
+  if (uaData && typeof uaData.platform === "string" && uaData.platform) {
+    return /mac/i.test(uaData.platform);
+  }
+  const platform = navigator.platform || "";
+  if (platform) return /mac|iphone|ipad|ipod/i.test(platform);
+  return /mac|iphone|ipad|ipod/i.test(navigator.userAgent || "");
+}
+var MOD_TOKENS = {
+  mod: "mod",
+  ctrl: "ctrl",
+  control: "ctrl",
+  alt: "alt",
+  option: "alt",
+  opt: "alt",
+  shift: "shift",
+  meta: "meta",
+  cmd: "meta",
+  command: "meta",
+  win: "meta",
+  super: "meta"
+};
+var KEY_ALIASES = {
+  esc: "escape",
+  space: " ",
+  spacebar: " ",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright",
+  return: "enter",
+  del: "delete",
+  ins: "insert",
+  pgup: "pageup",
+  pgdn: "pagedown"
+};
+function normalizeKey(raw) {
+  const k = raw.toLowerCase();
+  const aliased = KEY_ALIASES[k];
+  if (aliased !== void 0) return aliased;
+  return k;
+}
+function parseHotkey(str) {
+  const parsed = {
+    key: "",
+    mod: false,
+    ctrl: false,
+    alt: false,
+    shift: false,
+    meta: false
+  };
+  const tokens = str.split("+");
+  for (const token of tokens) {
+    const t = token.trim().toLowerCase();
+    if (t === "") continue;
+    const modKey = MOD_TOKENS[t];
+    if (modKey) {
+      parsed[modKey] = true;
+    } else {
+      parsed.key = normalizeKey(token.trim());
+    }
+  }
+  return parsed;
+}
+function matchesParsed(event, parsed, mac) {
+  const wantMeta = parsed.meta || mac && parsed.mod;
+  const wantCtrl = parsed.ctrl || !mac && parsed.mod;
+  if (event.metaKey !== wantMeta) return false;
+  if (event.ctrlKey !== wantCtrl) return false;
+  if (event.altKey !== parsed.alt) return false;
+  if (event.shiftKey !== parsed.shift) return false;
+  return event.key.toLowerCase() === parsed.key;
+}
+function matchesHotkey(event, combo) {
+  return matchesParsed(event, parseHotkey(combo), isMac());
+}
+function formatKeyLabel(key, mac) {
+  if (!key) return "";
+  switch (key) {
+    case " ":
+      return "Space";
+    case "escape":
+      return "Esc";
+    case "enter":
+      return mac ? "\u21B5" : "Enter";
+    case "arrowup":
+      return mac ? "\u2191" : "Up";
+    case "arrowdown":
+      return mac ? "\u2193" : "Down";
+    case "arrowleft":
+      return mac ? "\u2190" : "Left";
+    case "arrowright":
+      return mac ? "\u2192" : "Right";
+    case "backspace":
+      return mac ? "\u232B" : "Backspace";
+    case "delete":
+      return mac ? "\u2326" : "Del";
+    case "tab":
+      return mac ? "\u21E5" : "Tab";
+  }
+  if (key.length === 1) return key.toUpperCase();
+  return key.charAt(0).toUpperCase() + key.slice(1);
+}
+function formatHotkey(combo, opts = {}) {
+  const mac = opts.mac ?? isMac();
+  const p = parseHotkey(combo);
+  const parts = [];
+  if (mac) {
+    if (p.meta || p.mod) parts.push("\u2318");
+    if (p.ctrl) parts.push("\u2303");
+    if (p.alt) parts.push("\u2325");
+    if (p.shift) parts.push("\u21E7");
+    parts.push(formatKeyLabel(p.key, true));
+    return parts.join("");
+  }
+  if (p.ctrl || p.mod) parts.push("Ctrl");
+  if (p.alt) parts.push("Alt");
+  if (p.shift) parts.push("Shift");
+  if (p.meta) parts.push("Win");
+  parts.push(formatKeyLabel(p.key, false));
+  return parts.join("+");
+}
+var activeScopeSet = /* @__PURE__ */ new Set();
+var scopeListeners = /* @__PURE__ */ new Set();
+var EMPTY_SCOPES = Object.freeze([]);
+var scopesSnapshot = [];
+function refreshScopesSnapshot() {
+  scopesSnapshot = Array.from(activeScopeSet);
+}
+function emitScopeChange() {
+  for (const listener of scopeListeners) listener();
+}
+function enableScope(name) {
+  if (!activeScopeSet.has(name)) {
+    activeScopeSet.add(name);
+    refreshScopesSnapshot();
+    emitScopeChange();
+  }
+}
+function disableScope(name) {
+  if (activeScopeSet.delete(name)) {
+    refreshScopesSnapshot();
+    emitScopeChange();
+  }
+}
+function toggleScope(name) {
+  if (activeScopeSet.has(name)) disableScope(name);
+  else enableScope(name);
+}
+function isScopeActive(name) {
+  return activeScopeSet.has(name);
+}
+function subscribeScopes(callback) {
+  scopeListeners.add(callback);
+  return () => {
+    scopeListeners.delete(callback);
+  };
+}
+function getScopesSnapshot() {
+  return scopesSnapshot;
+}
+function getServerScopesSnapshot() {
+  return EMPTY_SCOPES;
+}
+function useHotkeysScopes() {
+  const active = useSyncExternalStore(
+    subscribeScopes,
+    getScopesSnapshot,
+    getServerScopesSnapshot
+  );
+  return { activeScopes: active, enableScope, disableScope, toggleScope };
+}
+var SEQUENCE_TIMEOUT = 1e3;
+function isModifierKey(key) {
+  return key === "Control" || key === "Shift" || key === "Alt" || key === "Meta" || key === "OS" || key === "AltGraph";
+}
+function isFromFormField(target) {
+  if (typeof HTMLElement === "undefined") return false;
+  if (!(target instanceof HTMLElement)) return false;
+  const tag = target.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  return target.isContentEditable;
+}
+function resolveTarget(target) {
+  if (typeof window === "undefined") return null;
+  if (!target) return window;
+  if (target === window) return window;
+  if (typeof HTMLElement !== "undefined" && target instanceof HTMLElement) {
+    return target;
+  }
+  return target.current;
+}
+function toEntries(keys) {
+  const list = Array.isArray(keys) ? keys : [keys];
+  return list.map((raw) => {
+    const steps = raw.replace(/\s+then\s+/gi, " ").trim().split(/\s+/).filter(Boolean).map(parseHotkey);
+    return { raw, steps, isSequence: steps.length > 1 };
+  });
+}
+function useHotkeys(keys, handler, options = {}, deps) {
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const entriesRef = useRef([]);
+  entriesRef.current = toEntries(keys);
+  const progressRef = useRef(/* @__PURE__ */ new Map());
+  const eventType = options.eventType ?? "keydown";
+  const depList = deps ?? [];
+  useEffect(() => {
+    const el = resolveTarget(optionsRef.current.target);
+    if (!el) return;
+    const listener = (rawEvent) => {
+      const event = rawEvent;
+      const o = optionsRef.current;
+      if (o.enabled === false) return;
+      const enableOnFormTags = o.enableOnFormTags ?? false;
+      if (!enableOnFormTags && isFromFormField(event.target)) return;
+      const rawScopes = o.scopes;
+      const scopeArr = rawScopes == null ? [] : Array.isArray(rawScopes) ? rawScopes : [rawScopes];
+      if (scopeArr.length > 0 && !scopeArr.some((s) => activeScopeSet.has(s))) {
+        return;
+      }
+      const mac = isMac();
+      const preventDefault = o.preventDefault ?? true;
+      const lone = isModifierKey(event.key);
+      const progress = progressRef.current;
+      for (const entry of entriesRef.current) {
+        if (entry.isSequence) {
+          if (lone) continue;
+          let state = progress.get(entry.raw);
+          if (!state) {
+            state = { index: 0, time: 0 };
+            progress.set(entry.raw, state);
+          }
+          const now = Date.now();
+          if (state.index > 0 && now - state.time > SEQUENCE_TIMEOUT) {
+            state.index = 0;
+          }
+          const expected = entry.steps[state.index];
+          if (expected && matchesParsed(event, expected, mac)) {
+            state.index += 1;
+            state.time = now;
+            if (state.index >= entry.steps.length) {
+              state.index = 0;
+              if (preventDefault) event.preventDefault();
+              handlerRef.current(event, entry.raw);
+            }
+          } else {
+            const first = entry.steps[0];
+            if (first && matchesParsed(event, first, mac)) {
+              state.index = 1;
+              state.time = now;
+            } else {
+              state.index = 0;
+            }
+          }
+        } else {
+          const combo = entry.steps[0];
+          if (combo && matchesParsed(event, combo, mac)) {
+            if (preventDefault) event.preventDefault();
+            handlerRef.current(event, entry.raw);
+          }
+        }
+      }
+    };
+    el.addEventListener(eventType, listener);
+    return () => {
+      el.removeEventListener(eventType, listener);
+    };
+  }, [eventType, ...depList]);
+}
+
+export { disableScope, enableScope, formatHotkey, isMac, isScopeActive, matchesHotkey, parseHotkey, toggleScope, useHotkeys, useHotkeysScopes };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map