keystra 0.0.0-stage → 0.1.0

package/dist/core.d.cts

@@ -0,0 +1,41 @@
+export { E as EventManager, I as ItemCollection, a as ItemCollectionOptions, K as KeyMatcher, M as MatchResult, N as NavigationController, R as ResolvedOptions, T as TypeaheadController, c as createKeyMatcher, b as createKeystra, d as createRafThrottle, e as createRectOf, f as createTypeahead, k as keyEquals, p as parseKeyBinding, r as resolveOptions } from './engine-DcbkGRgz.cjs';
+import { y as NormalizedKeyEvent, K as KeyAction, k as KeyBindingInput, m as KeyBindingOptions, j as KeyBindingHandle, H as HookOptions, s as KeystraHandle, n as KeyMap, N as NavigationMode } from './index-IZkcWAXP.cjs';
+export { A as AutoFocusOptions, B as BaseOptions, C as CommandPaletteInstance, a as CommandPaletteOptions, D as DefaultKeyMap, b as Direction, c as DropdownInstance, d as DropdownOptions, E as ElementTarget, e as EventHandler, f as EventName, g as EventPayload, G as GridInstance, h as GridOptions, I as ItemSelector, i as KeyBinding, l as KeyBindingObject, o as KeySequenceBinding, p as KeySequenceInput, q as KeySequenceOptions, r as KeystraEventMap, t as KeystraInstance, u as KeystraOptions, L as ListOptions, M as MenuInstance, v as MenuOptions, w as NavigationStrategy, x as NavigationStrategyContext, P as ParsedKeyBinding, R as RovingFocusOptions, z as RovingOptions, S as SelectionController, F as SelectionMode, J as SelectionOptions, T as TabsInstance, O as TabsOptions, Q as TreeInstance, U as TreeOptions, V as TypeaheadOptions, W as Unsubscribe } from './index-IZkcWAXP.cjs';
+import './focus.cjs';
+import './selection.cjs';
+import './layout-CBzD-87D.cjs';
+
+declare function normalizeKeyName(key: string): string;
+declare function isPrintableKey(key: string): boolean;
+declare function isModifierKey(key: string): boolean;
+declare function normalizeKeyEvent(event: KeyboardEvent): NormalizedKeyEvent;
+declare function codeToKey(code: string): string;
+declare function formatKeyCombo(key: string, modifiers?: {
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}): string;
+declare function describeEvent(event: KeyboardEvent): string;
+
+declare function useKeystra(options?: HookOptions): KeystraHandle;
+interface KeyBindingInfo {
+    readonly action: KeyAction;
+    readonly fromSequence: boolean;
+}
+type KeyBindingHandler = (event: KeyboardEvent, info: KeyBindingInfo) => void;
+declare function createKeyBinding(binding: KeyBindingInput, handler: KeyBindingHandler, options?: KeyBindingOptions): KeyBindingHandle;
+
+declare const VERTICAL_KEYS: KeyMap;
+declare const HORIZONTAL_KEYS: KeyMap;
+declare const TABS_KEYS_HORIZONTAL: KeyMap;
+declare const TABS_KEYS_VERTICAL: KeyMap;
+declare const GRID_KEYS: KeyMap;
+declare const MENU_KEYS: KeyMap;
+declare const TREE_KEYS: KeyMap;
+declare const LIST_KEYS: KeyMap;
+declare const COMMAND_PALETTE_KEYS: KeyMap;
+declare function defaultKeysFor(mode: NavigationMode): KeyMap;
+declare function mergeKeys(defaults: KeyMap, user: KeyMap | undefined | null, useDefaults: boolean): KeyMap;
+
+export { COMMAND_PALETTE_KEYS, GRID_KEYS, HORIZONTAL_KEYS, HookOptions, KeyAction, KeyBindingHandle, type KeyBindingHandler, type KeyBindingInfo, KeyBindingInput, KeyBindingOptions, KeyMap, KeystraHandle, LIST_KEYS, MENU_KEYS, NavigationMode, NormalizedKeyEvent, TABS_KEYS_HORIZONTAL, TABS_KEYS_VERTICAL, TREE_KEYS, VERTICAL_KEYS, codeToKey, createKeyBinding, defaultKeysFor, describeEvent, formatKeyCombo, isModifierKey, isPrintableKey, mergeKeys, normalizeKeyEvent, normalizeKeyName, useKeystra };

package/dist/core.d.ts

@@ -0,0 +1,41 @@
+export { E as EventManager, I as ItemCollection, a as ItemCollectionOptions, K as KeyMatcher, M as MatchResult, N as NavigationController, R as ResolvedOptions, T as TypeaheadController, c as createKeyMatcher, b as createKeystra, d as createRafThrottle, e as createRectOf, f as createTypeahead, k as keyEquals, p as parseKeyBinding, r as resolveOptions } from './engine-COPfXXTp.js';
+import { y as NormalizedKeyEvent, K as KeyAction, k as KeyBindingInput, m as KeyBindingOptions, j as KeyBindingHandle, H as HookOptions, s as KeystraHandle, n as KeyMap, N as NavigationMode } from './index-IZkcWAXP.js';
+export { A as AutoFocusOptions, B as BaseOptions, C as CommandPaletteInstance, a as CommandPaletteOptions, D as DefaultKeyMap, b as Direction, c as DropdownInstance, d as DropdownOptions, E as ElementTarget, e as EventHandler, f as EventName, g as EventPayload, G as GridInstance, h as GridOptions, I as ItemSelector, i as KeyBinding, l as KeyBindingObject, o as KeySequenceBinding, p as KeySequenceInput, q as KeySequenceOptions, r as KeystraEventMap, t as KeystraInstance, u as KeystraOptions, L as ListOptions, M as MenuInstance, v as MenuOptions, w as NavigationStrategy, x as NavigationStrategyContext, P as ParsedKeyBinding, R as RovingFocusOptions, z as RovingOptions, S as SelectionController, F as SelectionMode, J as SelectionOptions, T as TabsInstance, O as TabsOptions, Q as TreeInstance, U as TreeOptions, V as TypeaheadOptions, W as Unsubscribe } from './index-IZkcWAXP.js';
+import './focus.js';
+import './selection.js';
+import './layout-C2-n8aUI.js';
+
+declare function normalizeKeyName(key: string): string;
+declare function isPrintableKey(key: string): boolean;
+declare function isModifierKey(key: string): boolean;
+declare function normalizeKeyEvent(event: KeyboardEvent): NormalizedKeyEvent;
+declare function codeToKey(code: string): string;
+declare function formatKeyCombo(key: string, modifiers?: {
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}): string;
+declare function describeEvent(event: KeyboardEvent): string;
+
+declare function useKeystra(options?: HookOptions): KeystraHandle;
+interface KeyBindingInfo {
+    readonly action: KeyAction;
+    readonly fromSequence: boolean;
+}
+type KeyBindingHandler = (event: KeyboardEvent, info: KeyBindingInfo) => void;
+declare function createKeyBinding(binding: KeyBindingInput, handler: KeyBindingHandler, options?: KeyBindingOptions): KeyBindingHandle;
+
+declare const VERTICAL_KEYS: KeyMap;
+declare const HORIZONTAL_KEYS: KeyMap;
+declare const TABS_KEYS_HORIZONTAL: KeyMap;
+declare const TABS_KEYS_VERTICAL: KeyMap;
+declare const GRID_KEYS: KeyMap;
+declare const MENU_KEYS: KeyMap;
+declare const TREE_KEYS: KeyMap;
+declare const LIST_KEYS: KeyMap;
+declare const COMMAND_PALETTE_KEYS: KeyMap;
+declare function defaultKeysFor(mode: NavigationMode): KeyMap;
+declare function mergeKeys(defaults: KeyMap, user: KeyMap | undefined | null, useDefaults: boolean): KeyMap;
+
+export { COMMAND_PALETTE_KEYS, GRID_KEYS, HORIZONTAL_KEYS, HookOptions, KeyAction, KeyBindingHandle, type KeyBindingHandler, type KeyBindingInfo, KeyBindingInput, KeyBindingOptions, KeyMap, KeystraHandle, LIST_KEYS, MENU_KEYS, NavigationMode, NormalizedKeyEvent, TABS_KEYS_HORIZONTAL, TABS_KEYS_VERTICAL, TREE_KEYS, VERTICAL_KEYS, codeToKey, createKeyBinding, defaultKeysFor, describeEvent, formatKeyCombo, isModifierKey, isPrintableKey, mergeKeys, normalizeKeyEvent, normalizeKeyName, useKeystra };

package/dist/core.js

@@ -0,0 +1,7 @@
+export { createKeyBinding, useKeystra } from './chunk-LYYUOTBP.js';
+export { COMMAND_PALETTE_KEYS, EventManager, GRID_KEYS, HORIZONTAL_KEYS, ItemCollection, KeyMatcher, LIST_KEYS, MENU_KEYS, NavigationController, TABS_KEYS_HORIZONTAL, TABS_KEYS_VERTICAL, TREE_KEYS, VERTICAL_KEYS, codeToKey, createKeyMatcher, createKeystra, createRafThrottle, createRectOf, createTypeahead, defaultKeysFor, describeEvent, formatKeyCombo, isModifierKey, isPrintableKey, keyEquals, mergeKeys, normalizeKeyEvent, normalizeKeyName, parseKeyBinding, resolveOptions } from './chunk-U7YK6PPT.js';
+import './chunk-XFNYIPOW.js';
+import './chunk-ZOJRXXQN.js';
+import './chunk-SSIKGDD4.js';
+import './chunk-S5YVXIMA.js';
+import './chunk-77GGU3AX.js';

package/dist/engine-COPfXXTp.d.ts

@@ -0,0 +1,229 @@
+import { I as ItemSelector, x as NavigationStrategyContext, n as KeyMap, p as KeySequenceInput, K as KeyAction, y as NormalizedKeyEvent, P as ParsedKeyBinding, i as KeyBinding, V as TypeaheadOptions, t as KeystraInstance, N as NavigationMode, w as NavigationStrategy, u as KeystraOptions, z as RovingOptions, A as AutoFocusOptions, J as SelectionOptions, S as SelectionController, b as Direction, E as ElementTarget, f as EventName, e as EventHandler, W as Unsubscribe } from './index-IZkcWAXP.js';
+import { FocusManager } from './focus.js';
+import { SelectionManager } from './selection.js';
+import { L as LayoutCache, E as Emitter } from './layout-C2-n8aUI.js';
+
+type Listener = (event: Event) => void;
+declare class EventManager {
+    private records;
+    add(target: EventTarget | null | undefined, type: string, listener: Listener, options?: AddEventListenerOptions | boolean): () => void;
+    private removeRecord;
+    dispose(): void;
+    get count(): number;
+}
+declare function createRafThrottle(callback: () => void): {
+    schedule: () => void;
+    cancel: () => void;
+};
+
+interface ItemCollectionOptions<T extends Element> {
+    selector: ItemSelector<T>;
+    disabledSelector: string | null;
+    skipHidden: boolean;
+    filter?: ((element: T, index: number) => boolean) | null;
+    observe: boolean | MutationObserverInit;
+}
+declare class ItemCollection<T extends Element = HTMLElement> {
+    private container;
+    private options;
+    private onInvalidate?;
+    private list;
+    private extra;
+    private removed;
+    private explicit;
+    private built;
+    private observer;
+    private observerKey;
+    readonly layout: LayoutCache;
+    private _version;
+    constructor(container: Element | null, options: ItemCollectionOptions<T>, onInvalidate?: (() => void) | undefined);
+    get version(): number;
+    get items(): readonly T[];
+    get size(): number;
+    setContainer(container: Element | null): void;
+    setItems(elements: readonly T[] | null): void;
+    add(element: T | readonly T[]): void;
+    remove(element: T | readonly T[]): void;
+    invalidate(): void;
+    refresh(): readonly T[];
+    revalidate(): void;
+    indexOf(element: T | null | undefined): number;
+    at(index: number): T | null;
+    startObserving(): void;
+    stopObserving(): void;
+    dispose(): void;
+    private build;
+}
+declare function createRectOf<T extends Element>(collection: ItemCollection<T>): NavigationStrategyContext<T>["rectOf"];
+
+declare function parseKeyBinding(binding: KeyBinding): ParsedKeyBinding | null;
+interface MatchResult {
+    readonly actions: readonly KeyAction[];
+    readonly binding: ParsedKeyBinding;
+    readonly fromSequence: boolean;
+    readonly complete: boolean;
+    readonly preventDefault: boolean;
+}
+declare class KeyMatcher {
+    private readonly byId;
+    private readonly loose;
+    private readonly actions;
+    private readonly sequences;
+    private sequenceIndex;
+    private sequenceOwner;
+    private sequenceTimer;
+    private sequenceCandidates;
+    constructor(map?: KeyMap, sequences?: readonly KeySequenceInput[]);
+    loadMap(map: KeyMap): void;
+    loadSequences(sequences: readonly KeySequenceInput[]): void;
+    has(action: KeyAction): boolean;
+    get boundActions(): readonly KeyAction[];
+    get size(): number;
+    match(event: NormalizedKeyEvent, owner?: object): MatchResult | null;
+    resetSequence(): void;
+    dispose(): void;
+    private matchSequence;
+    private armSequenceTimer;
+    private clearSequenceTimer;
+}
+declare function keyEquals(bindingKey: string, eventKey: string): boolean;
+declare function createKeyMatcher(map?: KeyMap, sequences?: readonly KeySequenceInput[]): KeyMatcher;
+
+interface TypeaheadController<T extends Element = HTMLElement> {
+    handle(character: string, items: readonly T[], currentIndex: number): T | null;
+    readonly query: string;
+    reset(): void;
+    dispose(): void;
+}
+declare function createTypeahead<T extends Element = HTMLElement>(options?: TypeaheadOptions<T>): TypeaheadController<T>;
+
+interface ResolvedOptions<T extends Element> {
+    container: Element | null;
+    listenTarget: EventTarget | null;
+    pinnedTarget: boolean;
+    selector: ItemSelector<T>;
+    disabledSelector: string | null;
+    skipHidden: boolean;
+    filter: ((element: T, index: number) => boolean) | null;
+    mode: NavigationMode;
+    loop: boolean;
+    columns: number;
+    pageSize: number;
+    strategy: NavigationStrategy<T>;
+    userStrategy: NavigationStrategy<T> | null;
+    onBeforeNavigate: NavigationStrategy<T> | null;
+    keys: KeyMap;
+    defaultKeys: KeyMap | null;
+    userKeys: KeyMap | null;
+    useDefaultKeys: boolean;
+    sequences: KeystraOptions<T>["sequences"];
+    typeahead: (TypeaheadOptions<T> & {
+        enabled: true;
+    }) | null;
+    roving: RovingOptions;
+    activeDescendant: boolean;
+    descendantOwner: (() => Element | null) | null;
+    autoFocus: AutoFocusOptions<T>;
+    selectionOptions: SelectionOptions<T> | null;
+    observe: boolean | MutationObserverInit;
+    onlyWhenFocusedInside: boolean;
+    when: (() => boolean) | null;
+    ignoreEditable: boolean;
+    editableSelector: string | null;
+    stopPropagation: boolean;
+    preventDefault: boolean;
+    capture: boolean;
+    pointerSync: boolean;
+    handlers: {
+        onFocus?: (element: T, index: number) => void;
+        onBlur?: (element: T, index: number) => void;
+        onSelect?: (element: T, index: number) => void;
+        onAction?: (action: KeyAction, event: KeyboardEvent | null, element: T | null, index: number) => void;
+        onEscape?: (event: KeyboardEvent | null) => void;
+        onRefresh?: (items: readonly T[]) => void;
+    };
+}
+declare function resolveOptions<T extends Element = HTMLElement>(options?: KeystraOptions<T>, overrides?: Partial<ResolvedOptions<T>>): ResolvedOptions<T>;
+declare class NavigationController<T extends Element = HTMLElement> implements KeystraInstance<T> {
+    protected resolved: ResolvedOptions<T>;
+    protected readonly collection: ItemCollection<T>;
+    protected readonly focus: FocusManager<T>;
+    protected readonly events: EventManager;
+    protected readonly emitter: Emitter<T>;
+    protected readonly matcher: KeyMatcher;
+    protected typeaheadController: TypeaheadController<T> | null;
+    protected selectionManager: SelectionManager<T> | null;
+    protected keydownDisposer: (() => void) | null;
+    protected auxDisposers: (() => void)[];
+    protected syncPending: boolean;
+    protected destroyed: boolean;
+    constructor(options?: KeystraOptions<T>, overrides?: Partial<ResolvedOptions<T>>);
+    get container(): Element | null;
+    get items(): readonly T[];
+    get activeElement(): T | null;
+    get activeIndex(): number;
+    get currentIndex(): number;
+    get mode(): NavigationMode;
+    get loop(): boolean;
+    get enabled(): boolean;
+    get selection(): SelectionController<T> | null;
+    next(count?: number): T | null;
+    previous(count?: number): T | null;
+    up(): T | null;
+    down(): T | null;
+    left(): T | null;
+    right(): T | null;
+    move(direction: Direction): T | null;
+    first(): T | null;
+    last(): T | null;
+    focusFirst(): T | null;
+    focusLast(): T | null;
+    pageUp(): T | null;
+    pageDown(): T | null;
+    focusIndex(index: number): T | null;
+    setActiveIndex(index: number, options?: {
+        focus?: boolean;
+    }): T | null;
+    focusElement(element: T | null | undefined): boolean;
+    restoreFocus(): boolean;
+    protected rememberFocus(): void;
+    select(elementOrIndex?: T | number): void;
+    perform(action: KeyAction, event?: KeyboardEvent | null): boolean;
+    setContainer(container: ElementTarget<Element> | null): void;
+    refresh(): readonly T[];
+    add(element: T | readonly T[]): void;
+    remove(element: T | readonly T[]): void;
+    setItems(elements: readonly T[] | null): void;
+    enable(): void;
+    disable(): void;
+    update(options: Partial<Pick<KeystraOptions<T>, "keys" | "loop" | "mode" | "columns" | "enabled" | "pageSize" | "container">>): void;
+    on<E extends EventName>(event: E, handler: EventHandler<E, T>): Unsubscribe;
+    off<E extends EventName>(event: E, handler?: EventHandler<E, T>): void;
+    destroy(): void;
+    protected attach(): void;
+    protected detach(): void;
+    protected applyAutoFocus(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected reservedTarget(event: KeyboardEvent): boolean;
+    protected focusIsInside(): boolean;
+    protected handleTypeahead(normalized: NormalizedKeyEvent, event: KeyboardEvent): boolean;
+    protected runAction(action: KeyAction, event: KeyboardEvent | null, match: MatchResult | null): boolean;
+    protected runMovement(action: KeyAction, event: KeyboardEvent | null, items: readonly T[], fromSequence?: boolean): boolean;
+    protected isHeard(action: KeyAction): boolean;
+    protected ownsAction(_action: KeyAction): boolean;
+    protected emitAction(action: KeyAction, event: KeyboardEvent | null, element: T | null, index: number, fromSequence?: boolean): void;
+    protected afterMove(index: number, action: KeyAction, event: KeyboardEvent | null, fromSequence?: boolean): void;
+    protected resolveNavigation(action: KeyAction, direction: Direction | null, event: KeyboardEvent | null): number | null;
+    protected createContext(action: KeyAction, direction: Direction | null, event: KeyboardEvent | null): NavigationStrategyContext<T>;
+    protected step(delta: number, action: KeyAction | null): T | null;
+    protected resolveIndex(elementOrIndex?: T | number): number;
+    protected applySelection(index: number, extend?: boolean): void;
+    protected extendRangeTo(index: number): void;
+    protected onPointer(event: MouseEvent): void;
+    protected onPointerOver(event: Event): void;
+    protected itemFromEvent(event: Event): T | null;
+    protected sync(force?: boolean): void;
+}
+declare function createKeystra<T extends Element = HTMLElement>(options?: KeystraOptions<T>): KeystraInstance<T>;
+
+export { EventManager as E, ItemCollection as I, KeyMatcher as K, type MatchResult as M, NavigationController as N, type ResolvedOptions as R, type TypeaheadController as T, type ItemCollectionOptions as a, createKeystra as b, createKeyMatcher as c, createRafThrottle as d, createRectOf as e, createTypeahead as f, keyEquals as k, parseKeyBinding as p, resolveOptions as r };

package/dist/engine-DcbkGRgz.d.cts

@@ -0,0 +1,229 @@
+import { I as ItemSelector, x as NavigationStrategyContext, n as KeyMap, p as KeySequenceInput, K as KeyAction, y as NormalizedKeyEvent, P as ParsedKeyBinding, i as KeyBinding, V as TypeaheadOptions, t as KeystraInstance, N as NavigationMode, w as NavigationStrategy, u as KeystraOptions, z as RovingOptions, A as AutoFocusOptions, J as SelectionOptions, S as SelectionController, b as Direction, E as ElementTarget, f as EventName, e as EventHandler, W as Unsubscribe } from './index-IZkcWAXP.cjs';
+import { FocusManager } from './focus.cjs';
+import { SelectionManager } from './selection.cjs';
+import { L as LayoutCache, E as Emitter } from './layout-CBzD-87D.cjs';
+
+type Listener = (event: Event) => void;
+declare class EventManager {
+    private records;
+    add(target: EventTarget | null | undefined, type: string, listener: Listener, options?: AddEventListenerOptions | boolean): () => void;
+    private removeRecord;
+    dispose(): void;
+    get count(): number;
+}
+declare function createRafThrottle(callback: () => void): {
+    schedule: () => void;
+    cancel: () => void;
+};
+
+interface ItemCollectionOptions<T extends Element> {
+    selector: ItemSelector<T>;
+    disabledSelector: string | null;
+    skipHidden: boolean;
+    filter?: ((element: T, index: number) => boolean) | null;
+    observe: boolean | MutationObserverInit;
+}
+declare class ItemCollection<T extends Element = HTMLElement> {
+    private container;
+    private options;
+    private onInvalidate?;
+    private list;
+    private extra;
+    private removed;
+    private explicit;
+    private built;
+    private observer;
+    private observerKey;
+    readonly layout: LayoutCache;
+    private _version;
+    constructor(container: Element | null, options: ItemCollectionOptions<T>, onInvalidate?: (() => void) | undefined);
+    get version(): number;
+    get items(): readonly T[];
+    get size(): number;
+    setContainer(container: Element | null): void;
+    setItems(elements: readonly T[] | null): void;
+    add(element: T | readonly T[]): void;
+    remove(element: T | readonly T[]): void;
+    invalidate(): void;
+    refresh(): readonly T[];
+    revalidate(): void;
+    indexOf(element: T | null | undefined): number;
+    at(index: number): T | null;
+    startObserving(): void;
+    stopObserving(): void;
+    dispose(): void;
+    private build;
+}
+declare function createRectOf<T extends Element>(collection: ItemCollection<T>): NavigationStrategyContext<T>["rectOf"];
+
+declare function parseKeyBinding(binding: KeyBinding): ParsedKeyBinding | null;
+interface MatchResult {
+    readonly actions: readonly KeyAction[];
+    readonly binding: ParsedKeyBinding;
+    readonly fromSequence: boolean;
+    readonly complete: boolean;
+    readonly preventDefault: boolean;
+}
+declare class KeyMatcher {
+    private readonly byId;
+    private readonly loose;
+    private readonly actions;
+    private readonly sequences;
+    private sequenceIndex;
+    private sequenceOwner;
+    private sequenceTimer;
+    private sequenceCandidates;
+    constructor(map?: KeyMap, sequences?: readonly KeySequenceInput[]);
+    loadMap(map: KeyMap): void;
+    loadSequences(sequences: readonly KeySequenceInput[]): void;
+    has(action: KeyAction): boolean;
+    get boundActions(): readonly KeyAction[];
+    get size(): number;
+    match(event: NormalizedKeyEvent, owner?: object): MatchResult | null;
+    resetSequence(): void;
+    dispose(): void;
+    private matchSequence;
+    private armSequenceTimer;
+    private clearSequenceTimer;
+}
+declare function keyEquals(bindingKey: string, eventKey: string): boolean;
+declare function createKeyMatcher(map?: KeyMap, sequences?: readonly KeySequenceInput[]): KeyMatcher;
+
+interface TypeaheadController<T extends Element = HTMLElement> {
+    handle(character: string, items: readonly T[], currentIndex: number): T | null;
+    readonly query: string;
+    reset(): void;
+    dispose(): void;
+}
+declare function createTypeahead<T extends Element = HTMLElement>(options?: TypeaheadOptions<T>): TypeaheadController<T>;
+
+interface ResolvedOptions<T extends Element> {
+    container: Element | null;
+    listenTarget: EventTarget | null;
+    pinnedTarget: boolean;
+    selector: ItemSelector<T>;
+    disabledSelector: string | null;
+    skipHidden: boolean;
+    filter: ((element: T, index: number) => boolean) | null;
+    mode: NavigationMode;
+    loop: boolean;
+    columns: number;
+    pageSize: number;
+    strategy: NavigationStrategy<T>;
+    userStrategy: NavigationStrategy<T> | null;
+    onBeforeNavigate: NavigationStrategy<T> | null;
+    keys: KeyMap;
+    defaultKeys: KeyMap | null;
+    userKeys: KeyMap | null;
+    useDefaultKeys: boolean;
+    sequences: KeystraOptions<T>["sequences"];
+    typeahead: (TypeaheadOptions<T> & {
+        enabled: true;
+    }) | null;
+    roving: RovingOptions;
+    activeDescendant: boolean;
+    descendantOwner: (() => Element | null) | null;
+    autoFocus: AutoFocusOptions<T>;
+    selectionOptions: SelectionOptions<T> | null;
+    observe: boolean | MutationObserverInit;
+    onlyWhenFocusedInside: boolean;
+    when: (() => boolean) | null;
+    ignoreEditable: boolean;
+    editableSelector: string | null;
+    stopPropagation: boolean;
+    preventDefault: boolean;
+    capture: boolean;
+    pointerSync: boolean;
+    handlers: {
+        onFocus?: (element: T, index: number) => void;
+        onBlur?: (element: T, index: number) => void;
+        onSelect?: (element: T, index: number) => void;
+        onAction?: (action: KeyAction, event: KeyboardEvent | null, element: T | null, index: number) => void;
+        onEscape?: (event: KeyboardEvent | null) => void;
+        onRefresh?: (items: readonly T[]) => void;
+    };
+}
+declare function resolveOptions<T extends Element = HTMLElement>(options?: KeystraOptions<T>, overrides?: Partial<ResolvedOptions<T>>): ResolvedOptions<T>;
+declare class NavigationController<T extends Element = HTMLElement> implements KeystraInstance<T> {
+    protected resolved: ResolvedOptions<T>;
+    protected readonly collection: ItemCollection<T>;
+    protected readonly focus: FocusManager<T>;
+    protected readonly events: EventManager;
+    protected readonly emitter: Emitter<T>;
+    protected readonly matcher: KeyMatcher;
+    protected typeaheadController: TypeaheadController<T> | null;
+    protected selectionManager: SelectionManager<T> | null;
+    protected keydownDisposer: (() => void) | null;
+    protected auxDisposers: (() => void)[];
+    protected syncPending: boolean;
+    protected destroyed: boolean;
+    constructor(options?: KeystraOptions<T>, overrides?: Partial<ResolvedOptions<T>>);
+    get container(): Element | null;
+    get items(): readonly T[];
+    get activeElement(): T | null;
+    get activeIndex(): number;
+    get currentIndex(): number;
+    get mode(): NavigationMode;
+    get loop(): boolean;
+    get enabled(): boolean;
+    get selection(): SelectionController<T> | null;
+    next(count?: number): T | null;
+    previous(count?: number): T | null;
+    up(): T | null;
+    down(): T | null;
+    left(): T | null;
+    right(): T | null;
+    move(direction: Direction): T | null;
+    first(): T | null;
+    last(): T | null;
+    focusFirst(): T | null;
+    focusLast(): T | null;
+    pageUp(): T | null;
+    pageDown(): T | null;
+    focusIndex(index: number): T | null;
+    setActiveIndex(index: number, options?: {
+        focus?: boolean;
+    }): T | null;
+    focusElement(element: T | null | undefined): boolean;
+    restoreFocus(): boolean;
+    protected rememberFocus(): void;
+    select(elementOrIndex?: T | number): void;
+    perform(action: KeyAction, event?: KeyboardEvent | null): boolean;
+    setContainer(container: ElementTarget<Element> | null): void;
+    refresh(): readonly T[];
+    add(element: T | readonly T[]): void;
+    remove(element: T | readonly T[]): void;
+    setItems(elements: readonly T[] | null): void;
+    enable(): void;
+    disable(): void;
+    update(options: Partial<Pick<KeystraOptions<T>, "keys" | "loop" | "mode" | "columns" | "enabled" | "pageSize" | "container">>): void;
+    on<E extends EventName>(event: E, handler: EventHandler<E, T>): Unsubscribe;
+    off<E extends EventName>(event: E, handler?: EventHandler<E, T>): void;
+    destroy(): void;
+    protected attach(): void;
+    protected detach(): void;
+    protected applyAutoFocus(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected reservedTarget(event: KeyboardEvent): boolean;
+    protected focusIsInside(): boolean;
+    protected handleTypeahead(normalized: NormalizedKeyEvent, event: KeyboardEvent): boolean;
+    protected runAction(action: KeyAction, event: KeyboardEvent | null, match: MatchResult | null): boolean;
+    protected runMovement(action: KeyAction, event: KeyboardEvent | null, items: readonly T[], fromSequence?: boolean): boolean;
+    protected isHeard(action: KeyAction): boolean;
+    protected ownsAction(_action: KeyAction): boolean;
+    protected emitAction(action: KeyAction, event: KeyboardEvent | null, element: T | null, index: number, fromSequence?: boolean): void;
+    protected afterMove(index: number, action: KeyAction, event: KeyboardEvent | null, fromSequence?: boolean): void;
+    protected resolveNavigation(action: KeyAction, direction: Direction | null, event: KeyboardEvent | null): number | null;
+    protected createContext(action: KeyAction, direction: Direction | null, event: KeyboardEvent | null): NavigationStrategyContext<T>;
+    protected step(delta: number, action: KeyAction | null): T | null;
+    protected resolveIndex(elementOrIndex?: T | number): number;
+    protected applySelection(index: number, extend?: boolean): void;
+    protected extendRangeTo(index: number): void;
+    protected onPointer(event: MouseEvent): void;
+    protected onPointerOver(event: Event): void;
+    protected itemFromEvent(event: Event): T | null;
+    protected sync(force?: boolean): void;
+}
+declare function createKeystra<T extends Element = HTMLElement>(options?: KeystraOptions<T>): KeystraInstance<T>;
+
+export { EventManager as E, ItemCollection as I, KeyMatcher as K, type MatchResult as M, NavigationController as N, type ResolvedOptions as R, type TypeaheadController as T, type ItemCollectionOptions as a, createKeystra as b, createKeyMatcher as c, createRafThrottle as d, createRectOf as e, createTypeahead as f, keyEquals as k, parseKeyBinding as p, resolveOptions as r };