@opentui/keymap 0.0.0-20260423-76a94f40

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@opentui/keymap",
+  "module": "index.js",
+  "main": "index.js",
+  "types": "src/index.d.ts",
+  "type": "module",
+  "version": "0.0.0-20260423-76a94f40",
+  "description": "Standalone keymap package for OpenTUI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anomalyco/opentui",
+    "directory": "packages/keymap"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./index.js",
+      "require": "./index.js"
+    },
+    "./addons": {
+      "types": "./src/addons/index.d.ts",
+      "import": "./addons/index.js",
+      "require": "./addons/index.js"
+    },
+    "./addons/opentui": {
+      "types": "./src/addons/opentui/index.d.ts",
+      "import": "./addons/opentui/index.js",
+      "require": "./addons/opentui/index.js"
+    },
+    "./html": {
+      "types": "./src/html.d.ts",
+      "import": "./html.js",
+      "require": "./html.js"
+    },
+    "./opentui": {
+      "types": "./src/opentui.d.ts",
+      "import": "./opentui.js",
+      "require": "./opentui.js"
+    },
+    "./react": {
+      "types": "./src/react/index.d.ts",
+      "import": "./react/index.js",
+      "require": "./react/index.js"
+    },
+    "./solid": {
+      "types": "./src/solid/index.d.ts",
+      "import": "./solid/index.js",
+      "require": "./solid/index.js"
+    }
+  },
+  "dependencies": {
+    "@opentui/core": "0.0.0-20260423-76a94f40"
+  },
+  "devDependencies": {
+    "@opentui/react": "workspace:*",
+    "@opentui/solid": "workspace:*",
+    "@types/bun": "latest",
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.0.0",
+    "react": ">=19.0.0",
+    "solid-js": "1.9.11",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "@opentui/react": "0.0.0-20260423-76a94f40",
+    "@opentui/solid": "0.0.0-20260423-76a94f40",
+    "react": ">=19.0.0",
+    "solid-js": "1.9.11"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/react": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  }
+}

package/react/index.js

@@ -0,0 +1,151 @@
+// @bun
+// src/react/index.ts
+import {
+  createElement,
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef
+} from "react";
+var KeymapContext = createContext(null);
+function KeymapProvider({ keymap, children }) {
+  return createElement(KeymapContext.Provider, { value: keymap }, children);
+}
+function resolveBindingsTarget(target) {
+  if (typeof target === "function") {
+    return target() ?? undefined;
+  }
+  return target ?? undefined;
+}
+var useKeymap = () => {
+  const keymap = useContext(KeymapContext);
+  if (!keymap) {
+    throw new Error("Keymap not found. Wrap the tree in <KeymapProvider>.");
+  }
+  return keymap;
+};
+function useKeymapStateVersion(keymap) {
+  const [version, bumpVersion] = useReducer((value) => value + 1, 0);
+  useLayoutEffect(() => {
+    const dispose = keymap.on("state", () => {
+      bumpVersion();
+    });
+    return () => {
+      dispose();
+    };
+  }, [keymap]);
+  return version;
+}
+var useActiveKeys = (options) => {
+  const keymap = useKeymap();
+  const version = useKeymapStateVersion(keymap);
+  return useMemo(() => {
+    return keymap.getActiveKeys(options);
+  }, [keymap, options, version]);
+};
+var usePendingSequence = () => {
+  const keymap = useKeymap();
+  const version = useKeymapStateVersion(keymap);
+  return useMemo(() => {
+    return keymap.getPendingSequence();
+  }, [keymap, version]);
+};
+function useBindings(createLayer, deps = []) {
+  const keymap = useKeymap();
+  const layer = useMemo(createLayer, deps);
+  const layerRef = useRef(layer);
+  const refTargetRef = useRef(undefined);
+  const disposeRef = useRef(undefined);
+  const mountedRef = useRef(false);
+  const registeredScopeRef = useRef(undefined);
+  const registeredTargetRef = useRef(undefined);
+  layerRef.current = layer;
+  const unregister = useCallback(() => {
+    disposeRef.current?.();
+    disposeRef.current = undefined;
+    registeredScopeRef.current = undefined;
+    registeredTargetRef.current = undefined;
+  }, []);
+  const register = useCallback(() => {
+    if (disposeRef.current) {
+      return;
+    }
+    const currentLayer = layerRef.current;
+    const explicitTarget = resolveBindingsTarget(currentLayer.target);
+    const resolvedTarget = explicitTarget ?? refTargetRef.current;
+    const resolvedScope = currentLayer.scope ?? (resolvedTarget ? "focus-within" : "global");
+    if (currentLayer.target !== undefined && !explicitTarget) {
+      throw new Error("useBindings target was not available during mount");
+    }
+    if (resolvedScope !== "global" && !resolvedTarget) {
+      throw new Error("useBindings local bindings need a target or the returned ref callback attached to a renderable");
+    }
+    const { scope: _scope, target: _target, ...baseLayer } = currentLayer;
+    const resolvedLayer = resolvedScope === "global" ? {
+      ...baseLayer,
+      scope: "global"
+    } : {
+      ...baseLayer,
+      scope: resolvedScope,
+      target: resolvedTarget
+    };
+    disposeRef.current = keymap.registerLayer(resolvedLayer);
+    registeredScopeRef.current = resolvedScope;
+    registeredTargetRef.current = resolvedScope === "global" ? undefined : resolvedTarget;
+  }, [keymap]);
+  const ref = useCallback((value) => {
+    refTargetRef.current = value ?? undefined;
+  }, []);
+  useEffect(() => {
+    mountedRef.current = true;
+    unregister();
+    register();
+    return () => {
+      mountedRef.current = false;
+      unregister();
+    };
+  }, [layer, register, unregister]);
+  useEffect(() => {
+    if (!mountedRef.current) {
+      return;
+    }
+    const currentLayer = layerRef.current;
+    if (currentLayer.target !== undefined || currentLayer.scope === "global") {
+      return;
+    }
+    const resolvedTarget = refTargetRef.current;
+    const resolvedScope = currentLayer.scope ?? (resolvedTarget ? "focus-within" : "global");
+    const nextTarget = resolvedScope === "global" ? undefined : resolvedTarget;
+    if (registeredScopeRef.current === resolvedScope && registeredTargetRef.current === nextTarget) {
+      return;
+    }
+    unregister();
+    if (!nextTarget && currentLayer.scope !== undefined) {
+      return;
+    }
+    register();
+  });
+  return ref;
+}
+function reactiveMatcherFromStore(subscribe, getSnapshot, predicate) {
+  return {
+    get() {
+      return predicate ? predicate(getSnapshot()) : Boolean(getSnapshot());
+    },
+    subscribe(onChange) {
+      return subscribe(onChange);
+    }
+  };
+}
+export {
+  usePendingSequence,
+  useKeymap,
+  useBindings,
+  useActiveKeys,
+  reactiveMatcherFromStore,
+  KeymapProvider
+};

package/solid/index.js

@@ -0,0 +1,119 @@
+// @bun
+// src/solid/index.ts
+import {
+  createComponent,
+  createContext,
+  createEffect,
+  createMemo,
+  createRoot,
+  createSignal,
+  on,
+  onCleanup,
+  onMount,
+  useContext
+} from "solid-js";
+var KeymapContext = createContext();
+function KeymapProvider(props) {
+  return createComponent(KeymapContext.Provider, {
+    get value() {
+      return props.keymap;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+}
+function resolveBindingsTarget(target) {
+  if (typeof target === "function") {
+    return target() ?? undefined;
+  }
+  return target ?? undefined;
+}
+var useKeymap = () => {
+  const keymap = useContext(KeymapContext);
+  if (!keymap) {
+    throw new Error("Keymap not found. Wrap the tree in <KeymapProvider>.");
+  }
+  return keymap;
+};
+function useKeymapStateVersion(keymap) {
+  const [version, setVersion] = createSignal(0);
+  let dispose;
+  onMount(() => {
+    dispose = keymap.on("state", () => {
+      setVersion((value) => value + 1);
+    });
+    setVersion((value) => value + 1);
+  });
+  onCleanup(() => {
+    dispose?.();
+  });
+  return version;
+}
+var useKeymapSelector = (selector) => {
+  const keymap = useKeymap();
+  const version = useKeymapStateVersion(keymap);
+  return createMemo((previous) => {
+    version();
+    try {
+      return selector(keymap);
+    } catch (error) {
+      if (previous !== undefined && error instanceof Error && error.message === "Cannot use a keymap after its host was destroyed") {
+        return previous;
+      }
+      throw error;
+    }
+  });
+};
+function useBindings(createLayer) {
+  const keymap = useKeymap();
+  const [refTarget, setRefTarget] = createSignal(undefined);
+  createEffect(() => {
+    const layer = createLayer();
+    const explicitTarget = resolveBindingsTarget(layer.target);
+    const resolvedTarget = explicitTarget ?? refTarget();
+    const resolvedScope = layer.scope ?? (resolvedTarget ? "focus-within" : "global");
+    if (layer.target !== undefined && !explicitTarget) {
+      throw new Error("useBindings target was not available during mount");
+    }
+    if (resolvedScope !== "global" && !resolvedTarget) {
+      throw new Error("useBindings local bindings need a target or the returned ref callback attached to a renderable");
+    }
+    const { scope: _scope, target: _target, ...baseLayer } = layer;
+    const resolvedLayer = resolvedScope === "global" ? {
+      ...baseLayer,
+      scope: "global"
+    } : {
+      ...baseLayer,
+      scope: resolvedScope,
+      target: resolvedTarget
+    };
+    const dispose = keymap.registerLayer(resolvedLayer);
+    onCleanup(() => {
+      dispose();
+    });
+  });
+  return (value) => {
+    setRefTarget(() => value);
+  };
+}
+function reactiveMatcherFromSignal(accessor, predicate) {
+  return {
+    get() {
+      return predicate ? predicate(accessor()) : Boolean(accessor());
+    },
+    subscribe(onChange) {
+      return createRoot((dispose) => {
+        createEffect(on(accessor, () => onChange(), { defer: true }));
+        return dispose;
+      });
+    }
+  };
+}
+export {
+  useKeymapSelector,
+  useKeymap,
+  useBindings,
+  reactiveMatcherFromSignal,
+  KeymapProvider
+};

package/src/addons/index.d.ts

@@ -0,0 +1 @@
+export * from "./universal/index.js";

package/src/addons/opentui/base-layout.d.ts

@@ -0,0 +1,7 @@
+import type { KeyEvent, Renderable } from "@opentui/core";
+import type { Keymap } from "../../index.js";
+/**
+ * Falls back to the event's base layout code so bindings can ignore active
+ * keyboard layout changes.
+ */
+export declare function registerBaseLayoutFallback(keymap: Keymap<Renderable, KeyEvent>): () => void;

package/src/addons/opentui/edit-buffer-bindings.d.ts

@@ -0,0 +1,38 @@
+import { type CliRenderer, type KeyEvent, type Renderable } from "@opentui/core";
+import type { BindingInput, Bindings, Keymap, Layer } from "../../index.js";
+declare const editBufferCommandNames: readonly ["move-left", "move-right", "move-up", "move-down", "select-left", "select-right", "select-up", "select-down", "line-home", "line-end", "select-line-home", "select-line-end", "visual-line-home", "visual-line-end", "select-visual-line-home", "select-visual-line-end", "buffer-home", "buffer-end", "select-buffer-home", "select-buffer-end", "delete-line", "delete-to-line-end", "delete-to-line-start", "backspace", "delete", "newline", "undo", "redo", "word-forward", "word-backward", "select-word-forward", "select-word-backward", "delete-word-forward", "delete-word-backward", "select-all", "submit"];
+export type EditBufferCommandName = (typeof editBufferCommandNames)[number];
+export interface EditBufferCommandOptions {
+    descriptions?: Partial<Record<EditBufferCommandName, string>>;
+}
+export type ManagedTextareaLayer = Omit<Layer<Renderable, KeyEvent>, "bindings"> & {
+    bindings?: Bindings<Renderable, KeyEvent>;
+};
+/**
+ * Returns the default textarea bindings with any overrides prepended so they
+ * take precedence. Prefer `registerManagedTextareaLayer` unless you are
+ * composing a custom textarea integration.
+ */
+export declare function createTextareaBindings(overrides?: readonly BindingInput[]): BindingInput[];
+/**
+ * Suspends a focused `TextareaRenderable`'s own key handling so keymap
+ * bindings can take over, restoring the previous suspend state on cleanup or
+ * focus change. Reference-counted per `Keymap`; prefer
+ * `registerManagedTextareaLayer` unless you need this separately.
+ */
+export declare function registerTextareaMappingSuspension(keymap: Keymap<Renderable, KeyEvent>, renderer: CliRenderer): () => void;
+/**
+ * Registers the standard edit-buffer commands against
+ * `renderer.currentFocusedEditor`. Reference-counted per `Keymap`; prefer
+ * `registerManagedTextareaLayer` unless you need the commands without the
+ * default bindings or textarea suspension.
+ */
+export declare function registerEditBufferCommands(keymap: Keymap<Renderable, KeyEvent>, renderer: CliRenderer, options?: EditBufferCommandOptions): () => void;
+/**
+ * High-level textarea integration: registers the edit-buffer commands,
+ * suspends the textarea's built-in key handling while focused, and installs
+ * the layer with default bindings plus overrides. Safe to combine with the
+ * lower-level helpers because they are reference-counted.
+ */
+export declare function registerManagedTextareaLayer(keymap: Keymap<Renderable, KeyEvent>, renderer: CliRenderer, layer: ManagedTextareaLayer, options?: EditBufferCommandOptions): () => void;
+export {};

package/src/addons/opentui/index.d.ts

@@ -0,0 +1,4 @@
+export * from "../universal/index.js";
+export { registerBaseLayoutFallback } from "./base-layout.js";
+export { createTextareaBindings, registerEditBufferCommands, registerManagedTextareaLayer, registerTextareaMappingSuspension, } from "./edit-buffer-bindings.js";
+export type { EditBufferCommandName, EditBufferCommandOptions } from "./edit-buffer-bindings.js";

package/src/addons/universal/aliases.d.ts

@@ -0,0 +1,7 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+export type Aliases = Record<string, string>;
+/**
+ * Adds an `aliases` layer field for remapping single-key binding names within
+ * that layer.
+ */
+export declare function registerAliasesField<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/addons/universal/backspace-pops-pending-sequence.d.ts

@@ -0,0 +1,13 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+export interface BackspacePopsPendingSequenceOptions {
+    /**
+     * When true, consume Backspace after popping the sequence so it does not
+     * reach the focused target or lower-priority listeners. Default: `true`.
+     */
+    preventDefault?: boolean;
+    priority?: number;
+}
+/**
+ * Lets `Backspace` step back through the current pending multi-key sequence.
+ */
+export declare function registerBackspacePopsPendingSequence<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>, options?: BackspacePopsPendingSequenceOptions): () => void;

package/src/addons/universal/comma-bindings.d.ts

@@ -0,0 +1,6 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+/**
+ * Expands comma-separated binding strings such as `j,k` into separate
+ * bindings.
+ */
+export declare function registerCommaBindings<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/addons/universal/dead-bindings.d.ts

@@ -0,0 +1,6 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+/**
+ * Warns about bindings that can never trigger because they have no command and
+ * no reachable continuation.
+ */
+export declare function registerDeadBindingWarnings<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/addons/universal/default-parser.d.ts

@@ -0,0 +1,16 @@
+import type { BindingParser, EventMatchResolver, Keymap, KeymapEvent } from "../../index.js";
+export declare const defaultBindingParser: BindingParser;
+export declare const defaultEventMatchResolver: EventMatchResolver<KeymapEvent>;
+/**
+ * Parses the built-in string binding syntax, including modifiers and
+ * `<token>` segments.
+ */
+export declare function registerDefaultBindingParser<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;
+/**
+ * Matches incoming key events against their canonical normalized stroke.
+ */
+export declare function registerDefaultEventMatchResolver<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;
+/**
+ * Installs the standard parser and event matcher used by most keymaps.
+ */
+export declare function registerDefaultKeys<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/addons/universal/emacs-bindings.d.ts

@@ -0,0 +1,5 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+/**
+ * Parses Emacs-style space-separated chords such as `ctrl+x ctrl+s`.
+ */
+export declare function registerEmacsBindings<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/addons/universal/enabled.d.ts

@@ -0,0 +1,16 @@
+import type { Keymap, KeymapEvent, ReactiveMatcher } from "../../index.js";
+/**
+ * Accepted `enabled` values: boolean, raw `() => boolean`, or an
+ * `ReactiveMatcher` for subscription-driven invalidation.
+ */
+export type Enabled = boolean | (() => boolean) | ReactiveMatcher;
+/**
+ * Adds an `enabled` layer field for boolean, callback, or reactive matcher
+ * gating.
+ */
+export declare function registerEnabledField<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;
+/**
+ * Adds an `enabled` command field for boolean, callback, or reactive matcher
+ * gating.
+ */
+export declare function registerEnabledCommandField<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/addons/universal/escape-clears-pending-sequence.d.ts

@@ -0,0 +1,14 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+export interface EscapeClearsPendingSequenceOptions {
+    /**
+     * When true, consume Escape after clearing the sequence so it does not
+     * reach the focused renderable or lower-priority listeners. Default: `true`.
+     */
+    preventDefault?: boolean;
+    priority?: number;
+}
+/**
+ * Lets `Escape` cancel an in-progress multi-key sequence before it dispatches
+ * further.
+ */
+export declare function registerEscapeClearsPendingSequence<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>, options?: EscapeClearsPendingSequenceOptions): () => void;

package/src/addons/universal/ex-commands.d.ts

@@ -0,0 +1,16 @@
+import type { CommandContext, Keymap, KeymapEvent } from "../../index.js";
+export interface ExCommand<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> {
+    name: string;
+    aliases?: string[];
+    nargs?: "0" | "1" | "?" | "*" | "+";
+    run: (ctx: CommandContext<TTarget, TEvent> & {
+        raw: string;
+        args: string[];
+    }) => void | Promise<void>;
+    [key: string]: unknown;
+}
+/**
+ * Resolves `:name ...args` strings against the provided Ex commands and
+ * validated argument lists.
+ */
+export declare function registerExCommands<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>, commands: ExCommand<TTarget, TEvent>[]): () => void;

package/src/addons/universal/index.d.ts

@@ -0,0 +1,21 @@
+export { defaultBindingParser, defaultEventMatchResolver, registerDefaultBindingParser, registerDefaultEventMatchResolver, registerDefaultKeys, } from "./default-parser.js";
+export { registerAliasesField } from "./aliases.js";
+export { registerBackspacePopsPendingSequence } from "./backspace-pops-pending-sequence.js";
+export { registerCommaBindings } from "./comma-bindings.js";
+export { registerDeadBindingWarnings } from "./dead-bindings.js";
+export { registerEscapeClearsPendingSequence } from "./escape-clears-pending-sequence.js";
+export { registerEnabledField } from "./enabled.js";
+export { registerEnabledCommandField } from "./enabled.js";
+export { registerEmacsBindings } from "./emacs-bindings.js";
+export { registerExCommands } from "./ex-commands.js";
+export { registerLeader } from "./leader.js";
+export { registerMetadataFields } from "./metadata.js";
+export { registerTimedLeader } from "./timed-leader.js";
+export { registerUnresolvedCommandWarnings } from "./unresolved-commands.js";
+export type { Aliases } from "./aliases.js";
+export type { BackspacePopsPendingSequenceOptions } from "./backspace-pops-pending-sequence.js";
+export type { EscapeClearsPendingSequenceOptions } from "./escape-clears-pending-sequence.js";
+export type { Enabled } from "./enabled.js";
+export type { ExCommand } from "./ex-commands.js";
+export type { LeaderOptions } from "./leader.js";
+export type { TimedLeaderOptions } from "./timed-leader.js";

package/src/addons/universal/leader.d.ts

@@ -0,0 +1,9 @@
+import type { KeyLike, Keymap, KeymapEvent } from "../../index.js";
+export interface LeaderOptions {
+    trigger: KeyLike;
+    name?: string;
+}
+/**
+ * Defines a token such as `<leader>` that expands to a chosen trigger key.
+ */
+export declare function registerLeader<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>, options: LeaderOptions): () => void;

package/src/addons/universal/metadata.d.ts

@@ -0,0 +1,6 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+/**
+ * Maps `desc`, `group`, `title`, and `category` fields into binding and
+ * command attrs.
+ */
+export declare function registerMetadataFields<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/addons/universal/timed-leader.d.ts

@@ -0,0 +1,12 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+import { type LeaderOptions } from "./leader.js";
+export interface TimedLeaderOptions extends LeaderOptions {
+    timeoutMs?: number;
+    onArm?: () => void;
+    onDisarm?: () => void;
+}
+/**
+ * Defines a leader token and clears it if no follow-up key arrives before the
+ * timeout.
+ */
+export declare function registerTimedLeader<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>, options: TimedLeaderOptions): () => void;

package/src/addons/universal/unresolved-commands.d.ts

@@ -0,0 +1,6 @@
+import type { Keymap, KeymapEvent } from "../../index.js";
+/**
+ * Warns when a string command name cannot be resolved by registered commands
+ * or resolvers.
+ */
+export declare function registerUnresolvedCommandWarnings<TTarget extends object, TEvent extends KeymapEvent>(keymap: Keymap<TTarget, TEvent>): () => void;

package/src/html.d.ts

@@ -0,0 +1,21 @@
+import { Keymap } from "./keymap.js";
+import type { EventMatchResolver, KeymapEvent, KeymapHost } from "./types.js";
+export * from "./index.js";
+export interface HtmlKeymapEvent extends KeymapEvent {
+    readonly originalEvent?: KeyboardEvent;
+}
+interface HtmlKeyboardEventLike {
+    key: string;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+export declare function normalizeHtmlKeyName(key: string): string;
+export declare function createHtmlKeymapEvent(event?: KeyboardEvent | HtmlKeyboardEventLike): HtmlKeymapEvent;
+export declare function createHtmlKeymapHost(root: HTMLElement): KeymapHost<HTMLElement, HtmlKeymapEvent>;
+export declare const htmlEventMatchResolver: EventMatchResolver<HtmlKeymapEvent>;
+export declare function createHtmlKeymap(root: HTMLElement): Keymap<HTMLElement, HtmlKeymapEvent>;
+export declare function createDefaultHtmlKeymap(root: HTMLElement): Keymap<HTMLElement, HtmlKeymapEvent>;

package/src/index.d.ts

@@ -0,0 +1,3 @@
+export { Keymap } from "./keymap.js";
+export { stringifyKeySequence, stringifyKeyStroke } from "./services/keys.js";
+export type { KeyLike, KeyMatch, ActiveBinding, KeyStringifyInput, StringifyOptions, Attributes, BindingCommand, BindingParser, BindingParserContext, BindingParserResult, BindingExpander, BindingExpanderContext, BindingEvent, BindingFieldCompiler, BindingFieldContext, BindingInput, BindingTransformer, BindingTransformerContext, ParsedBindingInput, BindingShorthand, Bindings, ActiveKey, ActiveKeyOptions, KeymapActiveKey, KeymapBindingInput, KeymapCommandEntry, KeymapCommandDefinition, KeymapCommandRecord, Listener, ErrorEvent, CommandDefinition, CommandEntry, CommandFilter, CommandQuery, CommandQueryValue, CommandRecord, RunCommandOptions, RunCommandResult, CommandHandler, CommandFieldCompiler, CommandFieldContext, CommandContext, CommandResolver, CommandResolverContext, CommandResult, EventData, KeyInputContext, KeymapEvent, KeymapHost, FocusLayer, FocusWithinLayer, GlobalLayer, LayerAnalysisContext, LayerBindingAnalysis, LayerAnalyzer, LayerFieldCompiler, LayerFieldContext, LayerFields, Layer, EventName, Events, InterceptName, Intercepts, KeyInterceptOptions, ParsedCommand, RawInterceptOptions, RawInputContext, ReactiveMatcher, WarningEvent, ResolvedBindingCommand, Scope, EventMatchResolverContext, EventMatchResolver, TargetLayer, KeyToken, ResolvedKeyToken, KeySequencePart, NormalizedKeyStroke, KeyStrokeInput, } from "./types.js";

package/src/keymap-benchmark.d.ts

@@ -0,0 +1 @@
+export {};