import { C as CanonicalKey, h as ShortcutRegistry, g as ShortcutEntry, K as KeyComparator, S as SortMode } from '../controller-UD1Fmtsm.js';
export { d as CheatsheetEntry, e as CheatsheetGroup, f as CheatsheetModel, G as GroupEntry, L as LayerHandle, a as ShortcutHandler, b as ShortcutOptions, i as WhichKeyCandidate, W as WhichKeyEngine, j as WhichKeyOptions, k as WhichKeySnapshot, c as WhichKeyState, l as createWhichKey } from '../controller-UD1Fmtsm.js';

/**
 * Canonicalizes a live `KeyboardEvent` — the runtime half of the canonical-key
 * contract. Its output must stay byte-identical to `parseKey`'s for the same
 * chord: registry lookups are plain `Map` gets, so any divergence surfaces as a
 * shortcut that silently never fires.
 */
declare const eventToCanonical: (event: KeyboardEvent) => CanonicalKey;
/**
 * True when the keydown is a bare `Shift`/`Control`/`Alt`/`AltGraph`/`Meta`
 * press with nothing chorded onto it yet. The matcher ignores these, so
 * holding a modifier never aborts a pending sequence.
 */
declare const isModifierOnlyEvent: (event: KeyboardEvent) => boolean;
/**
 * Canonicalizes one chord written as a key string — the registration half of
 * the canonical-key contract, which `eventToCanonical` must match byte for
 * byte.
 *
 * Modifier names are case-insensitive and accept the usual aliases
 * (`control`, `option`, `meta`/`command`, `mod`); `Mod` resolves to `Cmd` on
 * macOS and `Ctrl` everywhere else. A bare uppercase letter implies Shift, so
 * `parseKey('N')` matches a real Shift+n press.
 *
 * Throws on an empty string, an unknown modifier, or a missing base after a
 * `+`. A base that is not a key name this library recognises only warns and
 * passes through verbatim, so exotic `event.key` values stay bindable.
 */
declare const parseKey: (input: string) => CanonicalKey;
/**
 * Splits a space-separated sequence and canonicalizes each chord with
 * `parseKey`. Throws on an empty or whitespace-only string, and on any chord
 * `parseKey` itself rejects.
 */
declare const parseSequence: (input: string) => CanonicalKey[];
/**
 * True when `target` is a text-entry element — an `<input>`, a `<textarea>`, or
 * anything content-editable. Backs the `enableOnInputs` guard: a shortcut
 * registered without it is suppressed while such an element has focus.
 */
declare const isInputTarget: (target: EventTarget | null) => boolean;

/**
 * Callbacks the `Matcher` drives as each keystroke resolves. `createWhichKey`
 * supplies these; they are not part of the public engine surface.
 */
type MatcherOptions = {
    /** How long a committed prefix waits before its popup shows or its leaf fires. */
    timeoutMs: number;
    /** Fires a resolved shortcut, passing the original `keydown` that completed it. */
    onFire: (entry: ShortcutEntry, event: KeyboardEvent) => void;
    /**
     * Shows or refreshes the popup for the sequence committed so far.
     * `currentSequence` is a per-call copy of the matcher's buffer; treat it as
     * read-only.
     */
    onShowPopup: (state: {
        currentSequence: string[];
    }) => void;
    /**
     * Hides the popup. Called on every buffer reset, so it can fire when nothing
     * is on screen.
     */
    onHidePopup: () => void;
};
/**
 * Resolves `keydown` events against the registry, owning the pending-sequence
 * buffer and every timer involved.
 *
 * Canonicalizing a key onto the buffer leads to one of three outcomes: a pure
 * leaf (a match with no continuations) fires immediately; a key that is both a
 * leaf and a prefix commits the buffer and fires after `timeoutMs` unless a
 * continuation arrives first; a prefix-only key commits the buffer and shows
 * the popup after `timeoutMs`, refreshing it immediately if it is already up.
 * `Escape` cancels a partial sequence unless an explicit `Escape` leaf exists
 * for the prospective sequence.
 */
declare class Matcher {
    private readonly registry;
    private readonly options;
    private buffer;
    private timer;
    private popupVisible;
    private bufferTouchedInput;
    constructor(registry: ShortcutRegistry, options: MatcherOptions);
    /** Feeds one `keydown` through the matcher, advancing, firing, or aborting the sequence. */
    handleKeyDown(event: KeyboardEvent): void;
    /** Drops the pending sequence, clears the timer, and hides the popup. */
    cancel(): void;
    private commitBuffer;
    private resetBuffer;
    private clearTimer;
}

/**
 * Vim-style alphabetical comparator: case-insensitive primary sort,
 * lowercase before uppercase as the tiebreak. So `a` < `A` < `b` < `B`.
 *
 * Works on full canonical key strings (e.g. `'g a'` < `'g A'` < `'g b'`).
 */
declare const alphabeticalKeysSort: KeyComparator;
/**
 * Resolve a SortMode to a concrete comparator (or undefined for "no sort").
 */
declare const resolveSort: (mode: SortMode | undefined) => KeyComparator | undefined;

export { CanonicalKey, KeyComparator, Matcher, type MatcherOptions, ShortcutEntry, ShortcutRegistry, SortMode, alphabeticalKeysSort, eventToCanonical, isInputTarget, isModifierOnlyEvent, parseKey, parseSequence, resolveSort };