@cjhyy/code-shell 0.1.0-alpha.0

package/dist/ink/components/ScrollBox.d.ts

@@ -0,0 +1,78 @@
+import React, { type PropsWithChildren, type Ref } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { Styles } from '../styles.js';
+import '../global.d.ts';
+export type ScrollBoxHandle = {
+    scrollTo: (y: number) => void;
+    scrollBy: (dy: number) => void;
+    /**
+     * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike
+     * scrollTo which bakes a number that's stale by the time the throttled
+     * render fires, this defers the position read to render time —
+     * render-node-to-output reads `el.yogaNode.getComputedTop()` in the
+     * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.
+     */
+    scrollToElement: (el: DOMElement, offset?: number) => void;
+    scrollToBottom: () => void;
+    getScrollTop: () => number;
+    getPendingDelta: () => number;
+    getScrollHeight: () => number;
+    /**
+     * Like getScrollHeight, but reads Yoga directly instead of the cached
+     * value written by render-node-to-output (throttled, up to 16ms stale).
+     * Use when you need a fresh value in useLayoutEffect after a React commit
+     * that grew content. Slightly more expensive (native Yoga call).
+     */
+    getFreshScrollHeight: () => number;
+    getViewportHeight: () => number;
+    /**
+     * Absolute screen-buffer row of the first visible content line (inside
+     * padding). Used for drag-to-scroll edge detection.
+     */
+    getViewportTop: () => number;
+    /**
+     * True when scroll is pinned to the bottom. Set by scrollToBottom, the
+     * initial stickyScroll attribute, and by the renderer when positional
+     * follow fires (scrollTop at prevMax, content grows). Cleared by
+     * scrollTo/scrollBy. Stable signal for "at bottom" that doesn't depend on
+     * layout values (unlike scrollTop+viewportH >= scrollHeight).
+     */
+    isSticky: () => boolean;
+    /**
+     * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).
+     * Does NOT fire for stickyScroll updates done by the Ink renderer — those
+     * happen during Ink's render phase after React has committed. Callers that
+     * care about the sticky case should treat "at bottom" as a fallback.
+     */
+    subscribe: (listener: () => void) => () => void;
+    /**
+     * Set the render-time scrollTop clamp to the currently-mounted children's
+     * coverage span. Called by useVirtualScroll after computing its range;
+     * render-node-to-output clamps scrollTop to [min, max] so burst scrollTo
+     * calls that race past React's async re-render show the edge of mounted
+     * content instead of blank spacer. Pass undefined to disable (sticky,
+     * cold start).
+     */
+    setClampBounds: (min: number | undefined, max: number | undefined) => void;
+};
+export type ScrollBoxProps = Except<Styles, 'textWrap' | 'overflow' | 'overflowX' | 'overflowY'> & {
+    ref?: Ref<ScrollBoxHandle>;
+    /**
+     * When true, automatically pins scroll position to the bottom when content
+     * grows. Unset manually via scrollTo/scrollBy to break the stickiness.
+     */
+    stickyScroll?: boolean;
+};
+/**
+ * A Box with `overflow: scroll` and an imperative scroll API.
+ *
+ * Children are laid out at their full Yoga-computed height inside a
+ * constrained container. At render time, only children intersecting the
+ * visible window (scrollTop..scrollTop+height) are rendered (viewport
+ * culling). Content is translated by -scrollTop and clipped to the box bounds.
+ *
+ * Works best inside a fullscreen (constrained-height root) Ink tree.
+ */
+declare function ScrollBox({ children, ref, stickyScroll, ...style }: PropsWithChildren<ScrollBoxProps>): React.ReactNode;
+export default ScrollBox;

package/dist/ink/components/Spacer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A flexible space that expands along the major axis of its containing layout.
+ * It's useful as a shortcut for filling all the available spaces between elements.
+ */
+export default function Spacer(): any;

package/dist/ink/components/StdinContext.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from '../events/emitter.js';
+import type { TerminalQuerier } from '../terminal-querier.js';
+export type Props = {
+    /**
+     * Stdin stream passed to `render()` in `options.stdin` or `process.stdin` by default. Useful if your app needs to handle user input.
+     */
+    readonly stdin: NodeJS.ReadStream;
+    /**
+     * Ink exposes this function via own `<StdinContext>` to be able to handle Ctrl+C, that's why you should use Ink's `setRawMode` instead of `process.stdin.setRawMode`.
+     * If the `stdin` stream passed to Ink does not support setRawMode, this function does nothing.
+     */
+    readonly setRawMode: (value: boolean) => void;
+    /**
+     * A boolean flag determining if the current `stdin` supports `setRawMode`. A component using `setRawMode` might want to use `isRawModeSupported` to nicely fall back in environments where raw mode is not supported.
+     */
+    readonly isRawModeSupported: boolean;
+    readonly internal_exitOnCtrlC: boolean;
+    readonly internal_eventEmitter: EventEmitter;
+    /** Query the terminal and await responses (DECRQM, OSC 11, etc.).
+     *  Null only in the never-reached default context value. */
+    readonly internal_querier: TerminalQuerier | null;
+};
+/**
+ * `StdinContext` is a React context, which exposes input stream.
+ */
+declare const StdinContext: import("react").Context<Props>;
+export default StdinContext;

package/dist/ink/components/TerminalFocusContext.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { type TerminalFocusState } from '../terminal-focus-state.js';
+export type { TerminalFocusState };
+export type TerminalFocusContextProps = {
+    readonly isTerminalFocused: boolean;
+    readonly terminalFocusState: TerminalFocusState;
+};
+declare const TerminalFocusContext: React.Context<TerminalFocusContextProps>;
+export declare function TerminalFocusProvider(t0: any): any;
+export default TerminalFocusContext;

package/dist/ink/components/TerminalSizeContext.d.ts

@@ -0,0 +1,5 @@
+export type TerminalSize = {
+    columns: number;
+    rows: number;
+};
+export declare const TerminalSizeContext: import("react").Context<TerminalSize | null>;

package/dist/ink/components/Text.d.ts

@@ -0,0 +1,55 @@
+import type { ReactNode } from 'react';
+import type { Color, Styles } from '../styles.js';
+type BaseProps = {
+    /**
+     * Change text color. Accepts a raw color value (rgb, hex, ansi).
+     */
+    readonly color?: Color;
+    /**
+     * Same as `color`, but for background.
+     */
+    readonly backgroundColor?: Color;
+    /**
+     * Make the text italic.
+     */
+    readonly italic?: boolean;
+    /**
+     * Make the text underlined.
+     */
+    readonly underline?: boolean;
+    /**
+     * Make the text crossed with a line.
+     */
+    readonly strikethrough?: boolean;
+    /**
+     * Inverse background and foreground colors.
+     */
+    readonly inverse?: boolean;
+    /**
+     * This property tells Ink to wrap or truncate text if its width is larger than container.
+     * If `wrap` is passed (by default), Ink will wrap text and split it into multiple lines.
+     * If `truncate-*` is passed, Ink will truncate text instead, which will result in one line of text with the rest cut off.
+     */
+    readonly wrap?: Styles['textWrap'];
+    readonly children?: ReactNode;
+};
+/**
+ * Bold and dim are mutually exclusive in terminals.
+ * This type ensures you can use one or the other, but not both.
+ */
+type WeightProps = {
+    bold?: never;
+    dim?: never;
+} | {
+    bold: boolean;
+    dim?: never;
+} | {
+    dim: boolean;
+    bold?: never;
+};
+export type Props = BaseProps & WeightProps;
+/**
+ * This component can display text, and change its style to make it colorful, bold, underline, italic or strikethrough.
+ */
+export default function Text(t0: any): any;
+export {};

package/dist/ink/constants.d.ts

@@ -0,0 +1 @@
+export declare const FRAME_INTERVAL_MS = 16;

package/dist/ink/cursor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cursor type — represents terminal cursor position and visibility.
+ */
+export type Cursor = {
+    x: number;
+    y: number;
+    visible: boolean;
+};

package/dist/ink/devtools.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Devtools connection stub — conditionally imported by the reconciler
+ * when NODE_ENV === 'development'. No-op in production.
+ */
+export {};

package/dist/ink/dom.d.ts

@@ -0,0 +1,76 @@
+import type { FocusManager } from './focus.js';
+import type { LayoutNode } from './layout/node.js';
+import type { Styles, TextStyles } from './styles.js';
+type InkNode = {
+    parentNode: DOMElement | undefined;
+    yogaNode?: LayoutNode;
+    style: Styles;
+};
+export type TextName = '#text';
+export type ElementNames = 'ink-root' | 'ink-box' | 'ink-text' | 'ink-virtual-text' | 'ink-link' | 'ink-progress' | 'ink-raw-ansi';
+export type NodeNames = ElementNames | TextName;
+export type DOMElement = {
+    nodeName: ElementNames;
+    attributes: Record<string, DOMNodeAttribute>;
+    childNodes: DOMNode[];
+    textStyles?: TextStyles;
+    onComputeLayout?: () => void;
+    onRender?: () => void;
+    onImmediateRender?: () => void;
+    hasRenderedContent?: boolean;
+    dirty: boolean;
+    isHidden?: boolean;
+    _eventHandlers?: Record<string, unknown>;
+    scrollTop?: number;
+    pendingScrollDelta?: number;
+    scrollClampMin?: number;
+    scrollClampMax?: number;
+    scrollHeight?: number;
+    scrollViewportHeight?: number;
+    scrollViewportTop?: number;
+    stickyScroll?: boolean;
+    scrollAnchor?: {
+        el: DOMElement;
+        offset: number;
+    };
+    focusManager?: FocusManager;
+    debugOwnerChain?: string[];
+} & InkNode;
+export type TextNode = {
+    nodeName: TextName;
+    nodeValue: string;
+} & InkNode;
+export type DOMNode<T = {
+    nodeName: NodeNames;
+}> = T extends {
+    nodeName: infer U;
+} ? U extends '#text' ? TextNode : DOMElement : never;
+export type DOMNodeAttribute = boolean | string | number;
+export declare const createNode: (nodeName: ElementNames) => DOMElement;
+export declare const appendChildNode: (node: DOMElement, childNode: DOMElement) => void;
+export declare const insertBeforeNode: (node: DOMElement, newChildNode: DOMNode, beforeChildNode: DOMNode) => void;
+export declare const removeChildNode: (node: DOMElement, removeNode: DOMNode) => void;
+export declare const setAttribute: (node: DOMElement, key: string, value: DOMNodeAttribute) => void;
+export declare const setStyle: (node: DOMNode, style: Styles) => void;
+export declare const setTextStyles: (node: DOMElement, textStyles: TextStyles) => void;
+export declare const createTextNode: (text: string) => TextNode;
+/**
+ * Mark a node and all its ancestors as dirty for re-rendering.
+ * Also marks yoga dirty for text remeasurement if this is a text node.
+ */
+export declare const markDirty: (node?: DOMNode) => void;
+export declare const scheduleRenderFrom: (node?: DOMNode) => void;
+export declare const setTextNodeValue: (node: TextNode, text: string) => void;
+export declare const clearYogaNodeReferences: (node: DOMElement | TextNode) => void;
+/**
+ * Find the React component stack responsible for content at screen row `y`.
+ *
+ * DFS the DOM tree accumulating yoga offsets. Returns the debugOwnerChain of
+ * the deepest node whose bounding box contains `y`. Called from ink.tsx when
+ * log-update triggers a full reset, to attribute the flicker to its source.
+ *
+ * Only useful when CLAUDE_CODE_DEBUG_REPAINTS is set (otherwise chains are
+ * undefined and this returns []).
+ */
+export declare function findOwnerChainAtRow(root: DOMElement, y: number): string[];
+export {};

package/dist/ink/events/click-event.d.ts

@@ -0,0 +1,31 @@
+import { Event } from './event.js';
+/**
+ * Mouse click event. Fired on left-button release without drag, only when
+ * mouse tracking is enabled (i.e. inside <AlternateScreen>).
+ *
+ * Bubbles from the deepest hit node up through parentNode. Call
+ * stopImmediatePropagation() to prevent ancestors' onClick from firing.
+ */
+export declare class ClickEvent extends Event {
+    /** 0-indexed screen column of the click */
+    readonly col: number;
+    /** 0-indexed screen row of the click */
+    readonly row: number;
+    /**
+     * Click column relative to the current handler's Box (col - box.x).
+     * Recomputed by dispatchClick before each handler fires, so an onClick
+     * on a container sees coords relative to that container, not to any
+     * child the click landed on.
+     */
+    localCol: number;
+    /** Click row relative to the current handler's Box (row - box.y). */
+    localRow: number;
+    /**
+     * True if the clicked cell has no visible content (unwritten in the
+     * screen buffer — both packed words are 0). Handlers can check this to
+     * ignore clicks on blank space to the right of text, so accidental
+     * clicks on empty terminal space don't toggle state.
+     */
+    readonly cellIsBlank: boolean;
+    constructor(col: number, row: number, cellIsBlank: boolean);
+}

package/dist/ink/events/dispatcher.d.ts

@@ -0,0 +1,40 @@
+import type { EventTarget, TerminalEvent } from './terminal-event.js';
+type DiscreteUpdates = <A, B>(fn: (a: A, b: B) => boolean, a: A, b: B, c: undefined, d: undefined) => boolean;
+/**
+ * Owns event dispatch state and the capture/bubble dispatch loop.
+ *
+ * The reconciler host config reads currentEvent and currentUpdatePriority
+ * to implement resolveUpdatePriority, resolveEventType, and
+ * resolveEventTimeStamp — mirroring how react-dom's host config reads
+ * ReactDOMSharedInternals and window.event.
+ *
+ * discreteUpdates is injected after construction (by InkReconciler)
+ * to break the import cycle.
+ */
+export declare class Dispatcher {
+    currentEvent: TerminalEvent | null;
+    currentUpdatePriority: number;
+    discreteUpdates: DiscreteUpdates | null;
+    /**
+     * Infer event priority from the currently-dispatching event.
+     * Called by the reconciler host config's resolveUpdatePriority
+     * when no explicit priority has been set.
+     */
+    resolveEventPriority(): number;
+    /**
+     * Dispatch an event through capture and bubble phases.
+     * Returns true if preventDefault() was NOT called.
+     */
+    dispatch(target: EventTarget, event: TerminalEvent): boolean;
+    /**
+     * Dispatch with discrete (sync) priority.
+     * For user-initiated events: keyboard, click, focus, paste.
+     */
+    dispatchDiscrete(target: EventTarget, event: TerminalEvent): boolean;
+    /**
+     * Dispatch with continuous priority.
+     * For high-frequency events: resize, scroll, mouse move.
+     */
+    dispatchContinuous(target: EventTarget, event: TerminalEvent): boolean;
+}
+export {};

package/dist/ink/events/emitter.d.ts

@@ -0,0 +1,5 @@
+import { EventEmitter as NodeEventEmitter } from 'events';
+export declare class EventEmitter extends NodeEventEmitter {
+    constructor();
+    emit(type: string | symbol, ...args: unknown[]): boolean;
+}

package/dist/ink/events/event-handlers.d.ts

@@ -0,0 +1,46 @@
+import type { ClickEvent } from './click-event.js';
+import type { FocusEvent } from './focus-event.js';
+import type { KeyboardEvent } from './keyboard-event.js';
+import type { PasteEvent } from './paste-event.js';
+import type { ResizeEvent } from './resize-event.js';
+type KeyboardEventHandler = (event: KeyboardEvent) => void;
+type FocusEventHandler = (event: FocusEvent) => void;
+type PasteEventHandler = (event: PasteEvent) => void;
+type ResizeEventHandler = (event: ResizeEvent) => void;
+type ClickEventHandler = (event: ClickEvent) => void;
+type HoverEventHandler = () => void;
+/**
+ * Props for event handlers on Box and other host components.
+ *
+ * Follows the React/DOM naming convention:
+ * - onEventName: handler for bubble phase
+ * - onEventNameCapture: handler for capture phase
+ */
+export type EventHandlerProps = {
+    onKeyDown?: KeyboardEventHandler;
+    onKeyDownCapture?: KeyboardEventHandler;
+    onFocus?: FocusEventHandler;
+    onFocusCapture?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+    onBlurCapture?: FocusEventHandler;
+    onPaste?: PasteEventHandler;
+    onPasteCapture?: PasteEventHandler;
+    onResize?: ResizeEventHandler;
+    onClick?: ClickEventHandler;
+    onMouseEnter?: HoverEventHandler;
+    onMouseLeave?: HoverEventHandler;
+};
+/**
+ * Reverse lookup: event type string → handler prop names.
+ * Used by the dispatcher for O(1) handler lookup per node.
+ */
+export declare const HANDLER_FOR_EVENT: Record<string, {
+    bubble?: keyof EventHandlerProps;
+    capture?: keyof EventHandlerProps;
+}>;
+/**
+ * Set of all event handler prop names, for the reconciler to detect
+ * event props and store them in _eventHandlers instead of attributes.
+ */
+export declare const EVENT_HANDLER_PROPS: Set<string>;
+export {};

package/dist/ink/events/event.d.ts

@@ -0,0 +1,5 @@
+export declare class Event {
+    private _didStopImmediatePropagation;
+    didStopImmediatePropagation(): boolean;
+    stopImmediatePropagation(): void;
+}

package/dist/ink/events/focus-event.d.ts

@@ -0,0 +1,13 @@
+import { type EventTarget, TerminalEvent } from './terminal-event.js';
+/**
+ * Focus event for component focus changes.
+ *
+ * Dispatched when focus moves between elements. 'focus' fires on the
+ * newly focused element, 'blur' fires on the previously focused one.
+ * Both bubble, matching react-dom's use of focusin/focusout semantics
+ * so parent components can observe descendant focus changes.
+ */
+export declare class FocusEvent extends TerminalEvent {
+    readonly relatedTarget: EventTarget | null;
+    constructor(type: 'focus' | 'blur', relatedTarget?: EventTarget | null);
+}

package/dist/ink/events/input-event.d.ts

@@ -0,0 +1,30 @@
+import { type ParsedKey } from '../parse-keypress.js';
+import { Event } from './event.js';
+export type Key = {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    pageDown: boolean;
+    pageUp: boolean;
+    wheelUp: boolean;
+    wheelDown: boolean;
+    home: boolean;
+    end: boolean;
+    return: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    shift: boolean;
+    fn: boolean;
+    tab: boolean;
+    backspace: boolean;
+    delete: boolean;
+    meta: boolean;
+    super: boolean;
+};
+export declare class InputEvent extends Event {
+    readonly keypress: ParsedKey;
+    readonly key: Key;
+    readonly input: string;
+    constructor(keypress: ParsedKey);
+}

package/dist/ink/events/keyboard-event.d.ts

@@ -0,0 +1,19 @@
+import type { ParsedKey } from '../parse-keypress.js';
+import { TerminalEvent } from './terminal-event.js';
+/**
+ * Keyboard event dispatched through the DOM tree via capture/bubble.
+ *
+ * Follows browser KeyboardEvent semantics: `key` is the literal character
+ * for printable keys ('a', '3', ' ', '/') and a multi-char name for
+ * special keys ('down', 'return', 'escape', 'f1'). The idiomatic
+ * printable-char check is `e.key.length === 1`.
+ */
+export declare class KeyboardEvent extends TerminalEvent {
+    readonly key: string;
+    readonly ctrl: boolean;
+    readonly shift: boolean;
+    readonly meta: boolean;
+    readonly superKey: boolean;
+    readonly fn: boolean;
+    constructor(parsedKey: ParsedKey);
+}

package/dist/ink/events/paste-event.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PasteEvent — fired when bracketed paste data arrives from the terminal.
+ */
+import { TerminalEvent } from './terminal-event.js';
+export declare class PasteEvent extends TerminalEvent {
+    readonly text: string;
+    constructor(text: string);
+}

package/dist/ink/events/resize-event.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ResizeEvent — fired when the terminal is resized.
+ */
+import { TerminalEvent } from './terminal-event.js';
+export declare class ResizeEvent extends TerminalEvent {
+    readonly columns: number;
+    readonly rows: number;
+    constructor(columns: number, rows: number);
+}

package/dist/ink/events/terminal-event.d.ts

@@ -0,0 +1,54 @@
+import { Event } from './event.js';
+type EventPhase = 'none' | 'capturing' | 'at_target' | 'bubbling';
+type TerminalEventInit = {
+    bubbles?: boolean;
+    cancelable?: boolean;
+};
+/**
+ * Base class for all terminal events with DOM-style propagation.
+ *
+ * Extends Event so existing event types (ClickEvent, InputEvent,
+ * TerminalFocusEvent) share a common ancestor and can migrate later.
+ *
+ * Mirrors the browser's Event API: target, currentTarget, eventPhase,
+ * stopPropagation(), preventDefault(), timeStamp.
+ */
+export declare class TerminalEvent extends Event {
+    readonly type: string;
+    readonly timeStamp: number;
+    readonly bubbles: boolean;
+    readonly cancelable: boolean;
+    private _target;
+    private _currentTarget;
+    private _eventPhase;
+    private _propagationStopped;
+    private _defaultPrevented;
+    constructor(type: string, init?: TerminalEventInit);
+    get target(): EventTarget | null;
+    get currentTarget(): EventTarget | null;
+    get eventPhase(): EventPhase;
+    get defaultPrevented(): boolean;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    preventDefault(): void;
+    /** @internal */
+    _setTarget(target: EventTarget): void;
+    /** @internal */
+    _setCurrentTarget(target: EventTarget | null): void;
+    /** @internal */
+    _setEventPhase(phase: EventPhase): void;
+    /** @internal */
+    _isPropagationStopped(): boolean;
+    /** @internal */
+    _isImmediatePropagationStopped(): boolean;
+    /**
+     * Hook for subclasses to do per-node setup before each handler fires.
+     * Default is a no-op.
+     */
+    _prepareForTarget(_target: EventTarget): void;
+}
+export type EventTarget = {
+    parentNode: EventTarget | undefined;
+    _eventHandlers?: Record<string, unknown>;
+};
+export {};

package/dist/ink/events/terminal-focus-event.d.ts

@@ -0,0 +1,13 @@
+import { Event } from './event.js';
+export type TerminalFocusEventType = 'terminalfocus' | 'terminalblur';
+/**
+ * Event fired when the terminal window gains or loses focus.
+ *
+ * Uses DECSET 1004 focus reporting - the terminal sends:
+ * - CSI I (\x1b[I) when the terminal gains focus
+ * - CSI O (\x1b[O) when the terminal loses focus
+ */
+export declare class TerminalFocusEvent extends Event {
+    readonly type: TerminalFocusEventType;
+    constructor(type: TerminalFocusEventType);
+}

package/dist/ink/focus.d.ts

@@ -0,0 +1,43 @@
+import type { DOMElement } from './dom.js';
+import { FocusEvent } from './events/focus-event.js';
+/**
+ * DOM-like focus manager for the Ink terminal UI.
+ *
+ * Pure state — tracks activeElement and a focus stack. Has no reference
+ * to the tree; callers pass the root when tree walks are needed.
+ *
+ * Stored on the root DOMElement so any node can reach it by walking
+ * parentNode (like browser's `node.ownerDocument`).
+ */
+export declare class FocusManager {
+    activeElement: DOMElement | null;
+    private dispatchFocusEvent;
+    private enabled;
+    private focusStack;
+    constructor(dispatchFocusEvent: (target: DOMElement, event: FocusEvent) => boolean);
+    focus(node: DOMElement): void;
+    blur(): void;
+    /**
+     * Called by the reconciler when a node is removed from the tree.
+     * Handles both the exact node and any focused descendant within
+     * the removed subtree. Dispatches blur and restores focus from stack.
+     */
+    handleNodeRemoved(node: DOMElement, root: DOMElement): void;
+    handleAutoFocus(node: DOMElement): void;
+    handleClickFocus(node: DOMElement): void;
+    enable(): void;
+    disable(): void;
+    focusNext(root: DOMElement): void;
+    focusPrevious(root: DOMElement): void;
+    private moveFocus;
+}
+/**
+ * Walk up to root and return it. The root is the node that holds
+ * the FocusManager — like browser's `node.getRootNode()`.
+ */
+export declare function getRootNode(node: DOMElement): DOMElement;
+/**
+ * Walk up to root and return its FocusManager.
+ * Like browser's `node.ownerDocument` — focus belongs to the root.
+ */
+export declare function getFocusManager(node: DOMElement): FocusManager;