blecsd 0.1.0

package/dist/virtualViewport-Dx2iJliO.d.ts

@@ -0,0 +1,2334 @@
+import { U as Unsubscribe, W as World, E as Entity } from './types-BcsvoKzf.js';
+import { z } from 'zod';
+import { A as Attribute } from './parser-iMHmQuUh.js';
+import { S as ScreenBufferData, C as Cell } from './cell-DwIu2ryP.js';
+import { S as ScrollbackBuffer } from './virtualScrollback-DvZTRU8a.js';
+
+/**
+ * Configurable state machine framework
+ * @module core/stateMachine
+ * @internal This module is for internal use by widgets
+ */
+
+/**
+ * Action function executed on state transitions.
+ * Receives the state machine context for side effects.
+ */
+type Action<Context = unknown> = (context: Context) => void;
+/**
+ * Transition target with optional actions.
+ */
+interface TransitionConfig<S extends string, Context = unknown> {
+    target: S;
+    actions?: Action<Context>[];
+    guard?: (context: Context) => boolean;
+}
+/**
+ * State configuration with entry/exit actions and transitions.
+ */
+interface StateConfig<S extends string, E extends string, Context = unknown> {
+    /** Actions to run when entering this state */
+    entry?: Action<Context>[];
+    /** Actions to run when exiting this state */
+    exit?: Action<Context>[];
+    /** Event handlers mapping events to target states */
+    on?: Partial<Record<E, S | TransitionConfig<S, Context>>>;
+}
+/**
+ * Full state machine configuration.
+ *
+ * @typeParam S - Union type of all state names
+ * @typeParam E - Union type of all event names
+ * @typeParam Context - Optional context object passed to actions
+ */
+interface StateMachineConfig<S extends string, E extends string, Context = unknown> {
+    /** Initial state when machine starts */
+    initial: S;
+    /** State definitions */
+    states: Record<S, StateConfig<S, E, Context>>;
+    /** Optional initial context */
+    context?: Context;
+}
+/**
+ * State change listener function.
+ */
+type StateListener<S extends string> = (current: S, previous: S) => void;
+/**
+ * StateMachine interface for type-safe access.
+ *
+ * @typeParam S - Union type of all state names
+ * @typeParam E - Union type of all event names
+ * @typeParam Context - Optional context object passed to actions
+ */
+interface StateMachine<S extends string, E extends string, Context = unknown> {
+    readonly current: S;
+    readonly context: Context;
+    send(event: E): boolean;
+    can(event: E): boolean;
+    matches(state: S): boolean;
+    subscribe(listener: StateListener<S>): Unsubscribe;
+    validEvents(): E[];
+    reset(): void;
+}
+
+/**
+ * List Component
+ *
+ * Provides list/item selection functionality with keyboard and mouse support.
+ *
+ * @module components/list
+ */
+
+/**
+ * List state type.
+ */
+type ListState = 'idle' | 'focused' | 'selecting' | 'searching' | 'disabled';
+/**
+ * List event type.
+ */
+type ListEvent = 'focus' | 'blur' | 'startSelect' | 'endSelect' | 'startSearch' | 'endSearch' | 'disable' | 'enable';
+/**
+ * List item data.
+ */
+interface ListItem {
+    /** Display text */
+    readonly text: string;
+    /** Optional value associated with the item */
+    readonly value?: string;
+    /** Whether the item is disabled */
+    readonly disabled?: boolean;
+}
+/**
+ * List store for managing list-specific data.
+ */
+interface ListStore {
+    /** Whether entity is a list */
+    isList: Uint8Array;
+    /** Currently selected index (-1 if none) */
+    selectedIndex: Int32Array;
+    /** Number of items in the list */
+    itemCount: Uint32Array;
+    /** First visible item index (for virtualization) */
+    firstVisible: Uint32Array;
+    /** Number of visible items */
+    visibleCount: Uint32Array;
+    /** Whether list is interactive */
+    interactive: Uint8Array;
+    /** Whether list responds to mouse */
+    mouse: Uint8Array;
+    /** Whether list responds to keyboard */
+    keys: Uint8Array;
+    /** Whether search mode is enabled */
+    searchEnabled: Uint8Array;
+    /** Total item count for virtualized lists (may be > itemCount) */
+    totalCount: Uint32Array;
+    /** Whether items are currently loading */
+    isLoading: Uint8Array;
+}
+/**
+ * Lazy load callback for virtualized lists.
+ * Called when items need to be loaded for a range.
+ *
+ * @param startIndex - First item index to load
+ * @param count - Number of items to load
+ * @returns Promise that resolves when items are loaded
+ */
+type ListLazyLoadCallback = (startIndex: number, count: number) => Promise<ListItem[]>;
+/**
+ * Scroll event callback for infinite scroll detection.
+ *
+ * @param scrollInfo - Information about current scroll state
+ */
+type ListScrollCallback = (scrollInfo: ListScrollInfo) => void;
+/**
+ * Scroll information for infinite scroll.
+ */
+interface ListScrollInfo {
+    /** First visible item index */
+    readonly firstVisible: number;
+    /** Number of visible items */
+    readonly visibleCount: number;
+    /** Total loaded items */
+    readonly loadedCount: number;
+    /** Total items (may be larger than loaded for infinite scroll) */
+    readonly totalCount: number;
+    /** Whether we're near the end (within threshold) */
+    readonly nearEnd: boolean;
+    /** Whether we're near the start (within threshold) */
+    readonly nearStart: boolean;
+}
+/**
+ * List display configuration.
+ */
+interface ListDisplay {
+    /** Character shown before selected item */
+    readonly selectedPrefix: string;
+    /** Character shown before unselected items */
+    readonly unselectedPrefix: string;
+    /** Selected item foreground color */
+    readonly selectedFg: number;
+    /** Selected item background color */
+    readonly selectedBg: number;
+    /** Item foreground color */
+    readonly itemFg: number;
+    /** Item background color */
+    readonly itemBg: number;
+    /** Disabled item foreground color */
+    readonly disabledFg: number;
+}
+/**
+ * List display options for configuration.
+ */
+interface ListDisplayOptions {
+    selectedPrefix?: string;
+    unselectedPrefix?: string;
+    selectedFg?: number;
+    selectedBg?: number;
+    itemFg?: number;
+    itemBg?: number;
+    disabledFg?: number;
+}
+/**
+ * List selection callback function type.
+ */
+type ListSelectCallback = (index: number, item: ListItem) => void;
+/**
+ * List action returned from key press handling.
+ */
+type ListAction = {
+    type: 'selectPrev';
+} | {
+    type: 'selectNext';
+} | {
+    type: 'selectFirst';
+} | {
+    type: 'selectLast';
+} | {
+    type: 'pageUp';
+} | {
+    type: 'pageDown';
+} | {
+    type: 'confirm';
+} | {
+    type: 'cancel';
+} | {
+    type: 'startSearch';
+} | {
+    type: 'endSearch';
+} | {
+    type: 'searchChar';
+    char: string;
+} | {
+    type: 'searchBackspace';
+} | {
+    type: 'searchNextMatch';
+};
+/** Default selected prefix character */
+declare const DEFAULT_SELECTED_PREFIX = "> ";
+/** Default unselected prefix character */
+declare const DEFAULT_UNSELECTED_PREFIX = "  ";
+/** Default selected foreground color */
+declare const DEFAULT_SELECTED_FG = 4294967295;
+/** Default selected background color */
+declare const DEFAULT_SELECTED_BG = 6750207;
+/** Default item foreground color */
+declare const DEFAULT_ITEM_FG = 3435973887;
+/** Default item background color */
+declare const DEFAULT_ITEM_BG = 255;
+/** Default disabled foreground color */
+declare const DEFAULT_DISABLED_FG = 1717987071;
+/**
+ * Store for list component data.
+ */
+declare const listStore: ListStore;
+/**
+ * State machine configuration for list widgets.
+ *
+ * States:
+ * - idle: List is not focused
+ * - focused: List has focus, ready for navigation
+ * - selecting: User is actively selecting (e.g., during mouse drag)
+ * - searching: User is typing to search/filter items
+ * - disabled: List is disabled and cannot be interacted with
+ */
+declare const LIST_STATE_MACHINE_CONFIG: StateMachineConfig<ListState, ListEvent>;
+/**
+ * Attaches list behavior to an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param items - Initial items
+ * @param options - List options
+ *
+ * @example
+ * ```typescript
+ * import { attachListBehavior } from 'blecsd';
+ *
+ * attachListBehavior(world, eid, [
+ *   { text: 'Option 1', value: 'opt1' },
+ *   { text: 'Option 2', value: 'opt2' },
+ * ], { interactive: true, keys: true });
+ * ```
+ */
+declare function attachListBehavior(world: World, eid: Entity, items?: ListItem[], options?: {
+    interactive?: boolean;
+    mouse?: boolean;
+    keys?: boolean;
+    search?: boolean;
+    selectedIndex?: number;
+    visibleCount?: number;
+}): void;
+/**
+ * Checks if an entity is a list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is a list
+ */
+declare function isList(world: World, eid: Entity): boolean;
+/**
+ * Gets the current state of a list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The current state
+ */
+declare function getListState(world: World, eid: Entity): ListState;
+/**
+ * Checks if list is in a specific state.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param state - The state to check
+ * @returns true if list is in the specified state
+ */
+declare function isListInState(world: World, eid: Entity, state: ListState): boolean;
+/**
+ * Checks if list is focused.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if list is focused
+ */
+declare function isListFocused(world: World, eid: Entity): boolean;
+/**
+ * Checks if list is disabled.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if list is disabled
+ */
+declare function isListDisabled(world: World, eid: Entity): boolean;
+/**
+ * Sends an event to the list state machine.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param event - The event to send
+ * @returns true if transition occurred
+ */
+declare function sendListEvent(world: World, eid: Entity, event: ListEvent): boolean;
+/**
+ * Focuses the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if focused successfully
+ */
+declare function focusList(world: World, eid: Entity): boolean;
+/**
+ * Blurs the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if blurred successfully
+ */
+declare function blurList(world: World, eid: Entity): boolean;
+/**
+ * Disables the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if disabled successfully
+ */
+declare function disableList(world: World, eid: Entity): boolean;
+/**
+ * Enables the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if enabled successfully
+ */
+declare function enableList(world: World, eid: Entity): boolean;
+/**
+ * Gets all items from a list.
+ *
+ * @param eid - The entity ID
+ * @returns Array of list items
+ */
+declare function getItems(eid: Entity): readonly ListItem[];
+/**
+ * Sets all items in a list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param items - The items to set
+ */
+declare function setItems(world: World, eid: Entity, items: ListItem[]): void;
+/**
+ * Adds an item to the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param item - The item to add
+ * @param index - Optional index to insert at (defaults to end)
+ */
+declare function addItem(world: World, eid: Entity, item: ListItem, index?: number): void;
+/**
+ * Removes an item from the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param index - The index to remove
+ * @returns The removed item or undefined
+ */
+declare function removeItem(world: World, eid: Entity, index: number): ListItem | undefined;
+/**
+ * Gets an item by index.
+ *
+ * @param eid - The entity ID
+ * @param index - The item index
+ * @returns The item or undefined
+ */
+declare function getItem(eid: Entity, index: number): ListItem | undefined;
+/**
+ * Updates an item at a specific index.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param index - The item index
+ * @param item - The new item data
+ * @returns true if updated successfully
+ */
+declare function updateItem(world: World, eid: Entity, index: number, item: ListItem): boolean;
+/**
+ * Gets the number of items in the list.
+ *
+ * @param eid - The entity ID
+ * @returns Number of items
+ */
+declare function getItemCount(eid: Entity): number;
+/**
+ * Clears all items from the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ */
+declare function clearItems(world: World, eid: Entity): void;
+/**
+ * Gets the selected index.
+ *
+ * @param eid - The entity ID
+ * @returns Selected index or -1 if none
+ */
+declare function getSelectedIndex(eid: Entity): number;
+/**
+ * Gets the selected item.
+ *
+ * @param eid - The entity ID
+ * @returns Selected item or undefined
+ */
+declare function getSelectedItem(eid: Entity): ListItem | undefined;
+declare function setSelectedIndex(world: World, eid: Entity, index: number): boolean;
+/**
+ * Selects the previous item.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param wrap - Whether to wrap around (default: true)
+ * @returns true if selection changed
+ */
+declare function selectPrev(world: World, eid: Entity, wrap?: boolean): boolean;
+/**
+ * Selects the next item.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param wrap - Whether to wrap around (default: true)
+ * @returns true if selection changed
+ */
+declare function selectNext(world: World, eid: Entity, wrap?: boolean): boolean;
+/**
+ * Selects the first item.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if selection changed
+ */
+declare function selectFirst(world: World, eid: Entity): boolean;
+/**
+ * Selects the last item.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if selection changed
+ */
+declare function selectLast(world: World, eid: Entity): boolean;
+/**
+ * Selects an item by value.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param value - The value to select
+ * @returns true if selection changed
+ */
+declare function selectByValue(world: World, eid: Entity, value: string): boolean;
+/**
+ * Clears the selection.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ */
+declare function clearSelection(world: World, eid: Entity): void;
+/**
+ * Activates (confirms) the currently selected item.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if an item was activated
+ */
+declare function activateSelected(_world: World, eid: Entity): boolean;
+/**
+ * Gets the first visible item index.
+ *
+ * @param eid - The entity ID
+ * @returns First visible index
+ */
+declare function getFirstVisible(eid: Entity): number;
+/**
+ * Sets the first visible item index.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param index - The first visible index
+ */
+declare function setFirstVisible(world: World, eid: Entity, index: number): void;
+/**
+ * Gets the number of visible items.
+ *
+ * @param eid - The entity ID
+ * @returns Number of visible items
+ */
+declare function getVisibleCount(eid: Entity): number;
+/**
+ * Sets the number of visible items.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param count - The number of visible items
+ */
+declare function setVisibleCount(world: World, eid: Entity, count: number): void;
+/**
+ * Ensures an index is visible by scrolling if necessary.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param index - The index to make visible
+ */
+declare function ensureVisible(world: World, eid: Entity, index: number): void;
+/**
+ * Scrolls the list by a page (visibleCount items).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param direction - 1 for down, -1 for up
+ * @returns true if scrolled
+ */
+declare function scrollPage(world: World, eid: Entity, direction: 1 | -1): boolean;
+/**
+ * Gets the visible items for rendering.
+ *
+ * @param eid - The entity ID
+ * @returns Array of visible items with their indices
+ */
+declare function getVisibleItems(eid: Entity): Array<{
+    index: number;
+    item: ListItem;
+}>;
+/**
+ * Sets the total item count for virtualized lists.
+ * This can be larger than the actual loaded items count for infinite scroll.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param count - Total item count
+ */
+declare function setTotalCount(world: World, eid: Entity, count: number): void;
+/**
+ * Gets the total item count (may be larger than loaded items).
+ *
+ * @param eid - The entity ID
+ * @returns Total item count
+ */
+declare function getTotalCount(eid: Entity): number;
+/**
+ * Sets the lazy load callback for loading items on demand.
+ *
+ * @param eid - The entity ID
+ * @param callback - Callback function to load items
+ */
+declare function setLazyLoadCallback(eid: Entity, callback: ListLazyLoadCallback): void;
+/**
+ * Gets the lazy load callback.
+ *
+ * @param eid - The entity ID
+ * @returns Lazy load callback or undefined
+ */
+declare function getLazyLoadCallback(eid: Entity): ListLazyLoadCallback | undefined;
+/**
+ * Clears the lazy load callback.
+ *
+ * @param eid - The entity ID
+ */
+declare function clearLazyLoadCallback(eid: Entity): void;
+/**
+ * Registers a scroll callback for detecting scroll events.
+ *
+ * @param eid - The entity ID
+ * @param callback - Callback function
+ * @returns Unsubscribe function
+ */
+declare function onListScroll(eid: Entity, callback: ListScrollCallback): () => void;
+/**
+ * Sets the loading state for a list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param loading - Whether items are loading
+ */
+declare function setListLoading(world: World, eid: Entity, loading: boolean): void;
+/**
+ * Checks if a list is currently loading items.
+ *
+ * @param eid - The entity ID
+ * @returns true if loading
+ */
+declare function isListLoading(eid: Entity): boolean;
+/**
+ * Sets the loading placeholder text.
+ *
+ * @param eid - The entity ID
+ * @param text - Placeholder text to show while loading
+ */
+declare function setLoadingPlaceholder(eid: Entity, text: string): void;
+/**
+ * Gets the loading placeholder text.
+ *
+ * @param eid - The entity ID
+ * @returns Loading placeholder text
+ */
+declare function getLoadingPlaceholder(eid: Entity): string;
+/**
+ * Loads items for a range using the lazy load callback.
+ * Returns immediately if no callback is set or already loading.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param startIndex - First item to load
+ * @param count - Number of items to load
+ * @returns Promise that resolves when loading completes
+ */
+declare function loadItems(world: World, eid: Entity, startIndex: number, count: number): Promise<void>;
+/**
+ * Checks if items need to be loaded for the current visible range.
+ *
+ * @param eid - The entity ID
+ * @returns Object with needsLoad flag and range to load
+ */
+declare function checkNeedsLoad(eid: Entity): {
+    needsLoad: boolean;
+    startIndex: number;
+    count: number;
+};
+/**
+ * Gets scroll info for the list.
+ *
+ * @param eid - The entity ID
+ * @param threshold - Items from end to trigger nearEnd (default: visibleCount)
+ * @returns Scroll information
+ */
+declare function getScrollInfo$1(eid: Entity, threshold?: number): ListScrollInfo;
+/**
+ * Appends items to the list (useful for infinite scroll).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param newItems - Items to append
+ */
+declare function appendItems(world: World, eid: Entity, newItems: readonly ListItem[]): void;
+/**
+ * Sets the list display configuration.
+ *
+ * @param eid - The entity ID
+ * @param options - Display options
+ */
+declare function setListDisplay(eid: Entity, options: ListDisplayOptions): void;
+/**
+ * Gets the list display configuration.
+ *
+ * @param eid - The entity ID
+ * @returns Display configuration
+ */
+declare function getListDisplay(eid: Entity): ListDisplay;
+/**
+ * Clears the list display configuration.
+ *
+ * @param eid - The entity ID
+ */
+declare function clearListDisplay(eid: Entity): void;
+/**
+ * Checks if list is interactive.
+ *
+ * @param eid - The entity ID
+ * @returns true if interactive
+ */
+declare function isListInteractive(eid: Entity): boolean;
+/**
+ * Sets list interactive mode.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param interactive - Whether list is interactive
+ */
+declare function setListInteractive(world: World, eid: Entity, interactive: boolean): void;
+/**
+ * Checks if list responds to mouse.
+ *
+ * @param eid - The entity ID
+ * @returns true if mouse enabled
+ */
+declare function isListMouseEnabled(eid: Entity): boolean;
+/**
+ * Sets list mouse mode.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param mouse - Whether mouse is enabled
+ */
+declare function setListMouse(world: World, eid: Entity, mouse: boolean): void;
+/**
+ * Checks if list responds to keyboard.
+ *
+ * @param eid - The entity ID
+ * @returns true if keys enabled
+ */
+declare function isListKeysEnabled(eid: Entity): boolean;
+/**
+ * Sets list keys mode.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param keys - Whether keys are enabled
+ */
+declare function setListKeys(world: World, eid: Entity, keys: boolean): void;
+/**
+ * Checks if search mode is enabled for the list.
+ *
+ * @param eid - The entity ID
+ * @returns true if search is enabled
+ */
+declare function isListSearchEnabled(eid: Entity): boolean;
+/**
+ * Sets whether search mode is enabled for the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param enabled - Whether search is enabled
+ */
+declare function setListSearchEnabled(world: World, eid: Entity, enabled: boolean): void;
+/**
+ * Checks if list is currently in search mode.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if list is in searching state
+ */
+declare function isListSearching(world: World, eid: Entity): boolean;
+/**
+ * Starts search mode for the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if search mode was started
+ */
+declare function startListSearch(world: World, eid: Entity): boolean;
+/**
+ * Ends search mode for the list.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if search mode was ended
+ */
+declare function endListSearch(world: World, eid: Entity): boolean;
+/**
+ * Gets the current search query.
+ *
+ * @param eid - The entity ID
+ * @returns The current search query or empty string
+ */
+declare function getListSearchQuery(eid: Entity): string;
+/**
+ * Sets the search query and finds matching items.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param query - The search query
+ * @returns true if a match was found and selected
+ */
+declare function setListSearchQuery(world: World, eid: Entity, query: string): boolean;
+/**
+ * Appends a character to the search query.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param char - The character to append
+ * @returns true if a match was found and selected
+ */
+declare function appendToSearchQuery(world: World, eid: Entity, char: string): boolean;
+/**
+ * Removes the last character from the search query.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if a match was found and selected
+ */
+declare function backspaceSearchQuery(world: World, eid: Entity): boolean;
+/**
+ * Clears the search query.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ */
+declare function clearSearchQuery(world: World, eid: Entity): void;
+/**
+ * Finds and selects the first item matching the text (case-insensitive).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param text - The text to search for
+ * @returns true if a match was found and selected
+ */
+declare function findAndSelectByText(world: World, eid: Entity, text: string): boolean;
+/**
+ * Finds the next item matching the current search query.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if a match was found and selected
+ */
+declare function findNextMatch(world: World, eid: Entity): boolean;
+/**
+ * Registers a callback for when search query changes.
+ *
+ * @param eid - The entity ID
+ * @param callback - The callback function
+ * @returns Unsubscribe function
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = onListSearchChange(eid, (query) => {
+ *   console.log(`Search: ${query}`);
+ * });
+ * ```
+ */
+declare function onListSearchChange(eid: Entity, callback: (query: string) => void): () => void;
+/**
+ * Registers a callback for when selection changes.
+ *
+ * @param eid - The entity ID
+ * @param callback - The callback function
+ * @returns Unsubscribe function
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = onListSelect(eid, (index, item) => {
+ *   console.log(`Selected: ${item.text}`);
+ * });
+ * ```
+ */
+declare function onListSelect(eid: Entity, callback: ListSelectCallback): () => void;
+/**
+ * Registers a callback for when an item is activated (confirmed).
+ *
+ * @param eid - The entity ID
+ * @param callback - The callback function
+ * @returns Unsubscribe function
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = onListActivate(eid, (index, item) => {
+ *   console.log(`Activated: ${item.text}`);
+ * });
+ * ```
+ */
+declare function onListActivate(eid: Entity, callback: ListSelectCallback): () => void;
+/**
+ * Clears all callbacks for a list.
+ *
+ * @param eid - The entity ID
+ */
+declare function clearListCallbacks(eid: Entity): void;
+/**
+ * Handles key press for list widget.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param key - The key name
+ * @returns Action to perform or null
+ *
+ * @example
+ * ```typescript
+ * const action = handleListKeyPress(world, eid, 'down');
+ * if (action?.type === 'selectNext') {
+ *   selectNext(world, eid);
+ * }
+ * ```
+ */
+declare function handleListKeyPress(world: World, eid: Entity, key: string): ListAction | null;
+/**
+ * Renders list items as strings for display.
+ *
+ * @param eid - The entity ID
+ * @param width - Available width
+ * @returns Array of rendered line strings
+ */
+declare function renderListItems(eid: Entity, width: number): string[];
+/**
+ * Resets the list store. Used for testing.
+ */
+declare function resetListStore(): void;
+
+/**
+ * Scrollable component for scrolling support.
+ * @module components/scrollable
+ */
+
+/**
+ * Scrollbar visibility mode.
+ */
+declare enum ScrollbarVisibility {
+    /** Always hidden */
+    Hidden = 0,
+    /** Always visible */
+    Visible = 1,
+    /** Visible only when content overflows */
+    Auto = 2
+}
+/**
+ * Scrollable component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `scrollX`, `scrollY`: Current scroll offset
+ * - `scrollWidth`, `scrollHeight`: Total scrollable content size
+ * - `scrollbarVisible`: Scrollbar visibility mode
+ * - `trackVisible`: Whether scroll track is visible
+ * - `alwaysScroll`: Always show scrollbar even when not needed
+ *
+ * @example
+ * ```typescript
+ * import { Scrollable, setScroll, getScroll, scrollBy } from 'blecsd';
+ *
+ * setScroll(world, entity, 0, 100);
+ * scrollBy(world, entity, 0, 50);
+ *
+ * const scroll = getScroll(world, entity);
+ * console.log(scroll.y); // 150
+ * ```
+ */
+declare const Scrollable: {
+    /** Horizontal scroll offset */
+    scrollX: Float32Array<ArrayBuffer>;
+    /** Vertical scroll offset */
+    scrollY: Float32Array<ArrayBuffer>;
+    /** Total scrollable width */
+    scrollWidth: Float32Array<ArrayBuffer>;
+    /** Total scrollable height */
+    scrollHeight: Float32Array<ArrayBuffer>;
+    /** Viewport width (visible area) - used for clamping */
+    viewportWidth: Float32Array<ArrayBuffer>;
+    /** Viewport height (visible area) - used for clamping */
+    viewportHeight: Float32Array<ArrayBuffer>;
+    /** Scrollbar visibility mode (0=hidden, 1=visible, 2=auto) */
+    scrollbarVisible: Uint8Array<ArrayBuffer>;
+    /** Whether scroll track is visible */
+    trackVisible: Uint8Array<ArrayBuffer>;
+    /** Always show scrollbar (0=no, 1=yes) */
+    alwaysScroll: Uint8Array<ArrayBuffer>;
+    /** Whether clamping is enabled (0=no, 1=yes) - default yes */
+    clampEnabled: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Scrollable configuration options.
+ */
+interface ScrollableOptions {
+    /** Initial horizontal scroll offset */
+    scrollX?: number;
+    /** Initial vertical scroll offset */
+    scrollY?: number;
+    /** Total scrollable width */
+    scrollWidth?: number;
+    /** Total scrollable height */
+    scrollHeight?: number;
+    /** Viewport width (visible area) */
+    viewportWidth?: number;
+    /** Viewport height (visible area) */
+    viewportHeight?: number;
+    /** Scrollbar visibility mode */
+    scrollbarVisible?: ScrollbarVisibility;
+    /** Whether scroll track is visible */
+    trackVisible?: boolean;
+    /** Always show scrollbar */
+    alwaysScroll?: boolean;
+    /** Whether scroll clamping is enabled (default: true) */
+    clampEnabled?: boolean;
+}
+/**
+ * Scroll position data.
+ */
+interface ScrollPosition {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Scroll percentage data.
+ */
+interface ScrollPercentage {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Full scrollable data returned by getScrollable.
+ */
+interface ScrollableData {
+    readonly scrollX: number;
+    readonly scrollY: number;
+    readonly scrollWidth: number;
+    readonly scrollHeight: number;
+    readonly viewportWidth: number;
+    readonly viewportHeight: number;
+    readonly scrollbarVisible: ScrollbarVisibility;
+    readonly trackVisible: boolean;
+    readonly alwaysScroll: boolean;
+    readonly clampEnabled: boolean;
+}
+/**
+ * Makes an entity scrollable with the given options.
+ * Adds the Scrollable component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Scrollable configuration options
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setScrollable, ScrollbarVisibility } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * setScrollable(world, entity, {
+ *   scrollHeight: 1000,
+ *   scrollbarVisible: ScrollbarVisibility.Auto,
+ * });
+ * ```
+ */
+declare function setScrollable(world: World, eid: Entity, options: ScrollableOptions): Entity;
+/**
+ * Sets the scroll position of an entity.
+ * Adds the Scrollable component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param x - Horizontal scroll offset
+ * @param y - Vertical scroll offset
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setScroll } from 'blecsd';
+ *
+ * setScroll(world, entity, 0, 100);
+ * ```
+ */
+declare function setScroll(world: World, eid: Entity, x: number, y: number): Entity;
+/**
+ * Gets the scroll position of an entity.
+ * Returns { x: 0, y: 0 } if no Scrollable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Scroll position
+ *
+ * @example
+ * ```typescript
+ * import { getScroll } from 'blecsd';
+ *
+ * const scroll = getScroll(world, entity);
+ * console.log(`Scroll: ${scroll.x}, ${scroll.y}`);
+ * ```
+ */
+declare function getScroll(world: World, eid: Entity): ScrollPosition;
+/**
+ * Scrolls an entity by the given delta values.
+ * Adds the Scrollable component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param dx - Horizontal scroll delta
+ * @param dy - Vertical scroll delta
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { scrollBy } from 'blecsd';
+ *
+ * // Scroll down by 50 pixels
+ * scrollBy(world, entity, 0, 50);
+ *
+ * // Scroll right by 100 pixels
+ * scrollBy(world, entity, 100, 0);
+ * ```
+ */
+declare function scrollBy(world: World, eid: Entity, dx: number, dy: number): Entity;
+/**
+ * Scrolls an entity to the given position.
+ * Alias for setScroll for semantic clarity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param x - Target horizontal scroll offset
+ * @param y - Target vertical scroll offset
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { scrollTo } from 'blecsd';
+ *
+ * scrollTo(world, entity, 0, 0); // Scroll to top
+ * ```
+ */
+declare function scrollTo(world: World, eid: Entity, x: number, y: number): Entity;
+/**
+ * Gets the scroll percentage of an entity.
+ * Takes viewport size into account: percentage is based on scrollable range
+ * (scrollSize - viewportSize), not total content size.
+ * Returns { x: 0, y: 0 } if no scrollable area or content fits in viewport.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Scroll percentage (0-100 for each axis)
+ *
+ * @example
+ * ```typescript
+ * import { getScrollPercentage } from 'blecsd';
+ *
+ * const percent = getScrollPercentage(world, entity);
+ * console.log(`Scrolled: ${percent.y}%`);
+ * ```
+ */
+declare function getScrollPercentage(world: World, eid: Entity): ScrollPercentage;
+/**
+ * Gets the full scrollable data of an entity.
+ * Returns undefined if no Scrollable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Scrollable data or undefined
+ */
+declare function getScrollable(world: World, eid: Entity): ScrollableData | undefined;
+/**
+ * Checks if an entity has a Scrollable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Scrollable component
+ */
+declare function hasScrollable(world: World, eid: Entity): boolean;
+/**
+ * Sets the scrollable content size.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param width - Total scrollable width
+ * @param height - Total scrollable height
+ * @returns The entity ID for chaining
+ */
+declare function setScrollSize(world: World, eid: Entity, width: number, height: number): Entity;
+/**
+ * Sets the scrollbar visibility mode.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param visibility - Scrollbar visibility mode
+ * @returns The entity ID for chaining
+ */
+declare function setScrollbarVisibility(world: World, eid: Entity, visibility: ScrollbarVisibility): Entity;
+/**
+ * Scrolls an entity to the top.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function scrollToTop$1(world: World, eid: Entity): Entity;
+/**
+ * Scrolls an entity to the bottom.
+ * Takes viewport height into account: scrollY = scrollHeight - viewportHeight.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function scrollToBottom$1(world: World, eid: Entity): Entity;
+/**
+ * Checks if an entity can scroll (has content larger than visible area).
+ * If viewport is set, checks if content exceeds viewport size.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has scrollable content
+ */
+declare function canScroll(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is scrolled to the top.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if scrolled to top
+ */
+declare function isAtTop(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is scrolled to the bottom.
+ * Takes viewport height into account: true when scrollY >= scrollHeight - viewportHeight.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if scrolled to bottom
+ */
+declare function isAtBottom(world: World, eid: Entity): boolean;
+
+/**
+ * Table Component
+ *
+ * Provides table/grid data management functionality with cell-based data storage.
+ *
+ * @module components/table
+ */
+
+/**
+ * Table cell alignment.
+ */
+type CellAlign = 'left' | 'center' | 'right';
+/**
+ * Table cell data.
+ */
+interface TableCell {
+    /** Cell text value */
+    readonly value: string;
+    /** Cell foreground color (optional) */
+    readonly fg?: number;
+    /** Cell background color (optional) */
+    readonly bg?: number;
+    /** Cell alignment (optional, defaults to left) */
+    readonly align?: CellAlign;
+}
+/**
+ * Table row data.
+ */
+type TableRow = readonly TableCell[];
+/**
+ * Table data (array of rows).
+ */
+type TableData = readonly TableRow[];
+/**
+ * Table column configuration.
+ */
+interface TableColumn {
+    /** Column header text */
+    readonly header: string;
+    /** Column width (characters) */
+    readonly width?: number;
+    /** Column minimum width */
+    readonly minWidth?: number;
+    /** Column maximum width */
+    readonly maxWidth?: number;
+    /** Column alignment */
+    readonly align?: CellAlign;
+}
+/**
+ * Table store for managing table-specific data.
+ */
+interface TableStore {
+    /** Whether entity is a table */
+    isTable: Uint8Array;
+    /** Number of rows in table */
+    rowCount: Uint32Array;
+    /** Number of columns in table */
+    colCount: Uint16Array;
+    /** Number of header rows */
+    headerRows: Uint8Array;
+    /** Cell padding */
+    pad: Uint8Array;
+    /** Whether to show cell borders */
+    cellBorders: Uint8Array;
+}
+/**
+ * Table display configuration.
+ */
+interface TableDisplay {
+    /** Header foreground color */
+    readonly headerFg: number;
+    /** Header background color */
+    readonly headerBg: number;
+    /** Cell foreground color */
+    readonly cellFg: number;
+    /** Cell background color */
+    readonly cellBg: number;
+    /** Alternate row background color (for striping) */
+    readonly altRowBg?: number;
+    /** Border foreground color */
+    readonly borderFg: number;
+    /** Border background color */
+    readonly borderBg: number;
+    /** Selected row foreground color */
+    readonly selectedFg?: number;
+    /** Selected row background color */
+    readonly selectedBg?: number;
+}
+/**
+ * Table display options for configuration.
+ */
+interface TableDisplayOptions {
+    headerFg?: number;
+    headerBg?: number;
+    cellFg?: number;
+    cellBg?: number;
+    altRowBg?: number;
+    borderFg?: number;
+    borderBg?: number;
+    selectedFg?: number;
+    selectedBg?: number;
+}
+/** Default header foreground color */
+declare const DEFAULT_HEADER_FG = 4294967295;
+/** Default header background color */
+declare const DEFAULT_HEADER_BG = 858993663;
+/** Default cell foreground color */
+declare const DEFAULT_CELL_FG = 3435973887;
+/** Default cell background color */
+declare const DEFAULT_CELL_BG = 255;
+/** Default border foreground color */
+declare const DEFAULT_BORDER_FG = 1717987071;
+/** Default border background color */
+declare const DEFAULT_BORDER_BG = 255;
+/**
+ * Table component store using SoA (Structure of Arrays) for performance.
+ *
+ * Stores table grid metadata.
+ *
+ * @example
+ * ```typescript
+ * import { Table, attachTableBehavior, setData } from 'blecsd';
+ *
+ * attachTableBehavior(world, eid);
+ * setData(world, eid, [
+ *   ['Name', 'Age'],
+ *   ['Alice', '30'],
+ * ]);
+ * ```
+ */
+declare const Table: {
+    /** Number of data rows (excluding headers) */
+    rowCount: Uint32Array<ArrayBuffer>;
+    /** Number of columns */
+    colCount: Uint16Array<ArrayBuffer>;
+    /** Number of header rows */
+    headerRows: Uint8Array<ArrayBuffer>;
+    /** Cell padding (spaces) */
+    pad: Uint8Array<ArrayBuffer>;
+    /** Whether to render cell borders (0 = no, 1 = yes) */
+    cellBorders: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Store for table component data.
+ */
+declare const tableStore: TableStore;
+/**
+ * Attaches table behavior to an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Table options
+ *
+ * @example
+ * ```typescript
+ * import { attachTableBehavior } from 'blecsd';
+ *
+ * attachTableBehavior(world, eid, {
+ *   headerRows: 1,
+ *   pad: 1,
+ *   cellBorders: true,
+ * });
+ * ```
+ */
+declare function attachTableBehavior(_world: World, eid: Entity, options?: {
+    headerRows?: number;
+    pad?: number;
+    cellBorders?: boolean;
+}): void;
+/**
+ * Checks if an entity is a table.
+ *
+ * @param _world - The ECS world (unused, kept for API consistency)
+ * @param eid - The entity ID
+ * @returns true if entity is a table
+ */
+declare function isTable(_world: World, eid: Entity): boolean;
+/**
+ * Detaches table behavior from an entity.
+ *
+ * @param _world - The ECS world
+ * @param eid - The entity ID
+ */
+declare function detachTableBehavior(_world: World, eid: Entity): void;
+/**
+ * Sets the table data.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param rows - Array of row arrays (string[][] or TableCell[][])
+ *
+ * @example
+ * ```typescript
+ * // With string arrays
+ * setData(world, eid, [
+ *   ['Name', 'Age', 'City'],
+ *   ['Alice', '30', 'NYC'],
+ *   ['Bob', '25', 'LA'],
+ * ]);
+ *
+ * // With TableCell objects
+ * setData(world, eid, [
+ *   [{ value: 'Name', fg: 0xffffffff }, { value: 'Age' }, { value: 'City' }],
+ *   [{ value: 'Alice' }, { value: '30' }, { value: 'NYC' }],
+ * ]);
+ * ```
+ */
+declare function setData(world: World, eid: Entity, rows: ReadonlyArray<ReadonlyArray<string | TableCell>>): void;
+/**
+ * Gets the table data.
+ *
+ * @param eid - The entity ID
+ * @returns Table data as array of rows
+ */
+declare function getData(eid: Entity): TableData;
+/**
+ * Gets the table data as a string array.
+ *
+ * @param eid - The entity ID
+ * @returns Table data as string[][]
+ */
+declare function getDataAsStrings(eid: Entity): string[][];
+/**
+ * Sets a single cell value.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param row - Row index (0-based)
+ * @param col - Column index (0-based)
+ * @param value - Cell value (string or TableCell)
+ * @returns true if cell was set successfully
+ *
+ * @example
+ * ```typescript
+ * setCell(world, eid, 1, 2, 'Updated value');
+ * setCell(world, eid, 1, 2, { value: 'Styled', fg: 0xff0000ff });
+ * ```
+ */
+declare function setCell(world: World, eid: Entity, row: number, col: number, value: string | TableCell): boolean;
+/**
+ * Gets a single cell value.
+ *
+ * @param eid - The entity ID
+ * @param row - Row index (0-based)
+ * @param col - Column index (0-based)
+ * @returns Cell data or undefined if out of bounds
+ */
+declare function getCell(eid: Entity, row: number, col: number): TableCell | undefined;
+/**
+ * Gets a cell's string value.
+ *
+ * @param eid - The entity ID
+ * @param row - Row index (0-based)
+ * @param col - Column index (0-based)
+ * @returns Cell value string or undefined if out of bounds
+ */
+declare function getCellValue(eid: Entity, row: number, col: number): string | undefined;
+/**
+ * Gets a specific row.
+ *
+ * @param eid - The entity ID
+ * @param row - Row index (0-based)
+ * @returns Row data or undefined if out of bounds
+ */
+declare function getRow(eid: Entity, row: number): TableRow | undefined;
+/**
+ * Gets a specific column.
+ *
+ * @param eid - The entity ID
+ * @param col - Column index (0-based)
+ * @returns Column data as array of cells
+ */
+declare function getColumn(eid: Entity, col: number): readonly TableCell[];
+/**
+ * Gets the number of rows.
+ *
+ * @param eid - The entity ID
+ * @returns Number of rows
+ */
+declare function getRowCount(eid: Entity): number;
+/**
+ * Gets the number of columns.
+ *
+ * @param eid - The entity ID
+ * @returns Number of columns
+ */
+declare function getColCount(eid: Entity): number;
+/**
+ * Appends a row to the table.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param row - Row data
+ */
+declare function appendRow(world: World, eid: Entity, row: ReadonlyArray<string | TableCell>): void;
+/**
+ * Inserts a row at a specific index.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param index - Row index to insert at
+ * @param row - Row data
+ */
+declare function insertRow(world: World, eid: Entity, index: number, row: ReadonlyArray<string | TableCell>): void;
+/**
+ * Removes a row from the table.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param index - Row index to remove
+ * @returns The removed row or undefined
+ */
+declare function removeRow(world: World, eid: Entity, index: number): TableRow | undefined;
+/**
+ * Clears all table data.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ */
+declare function clearData(world: World, eid: Entity): void;
+/**
+ * Sets table headers using column configuration.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param columns - Column configuration
+ *
+ * @example
+ * ```typescript
+ * setHeaders(world, eid, [
+ *   { header: 'Name', width: 20, align: 'left' },
+ *   { header: 'Age', width: 5, align: 'right' },
+ *   { header: 'City', width: 15, align: 'left' },
+ * ]);
+ * ```
+ */
+declare function setHeaders(world: World, eid: Entity, columns: readonly TableColumn[]): void;
+/**
+ * Gets the column configuration.
+ *
+ * @param eid - The entity ID
+ * @returns Column configuration
+ */
+declare function getColumns(eid: Entity): readonly TableColumn[];
+/**
+ * Gets the header row(s).
+ *
+ * @param eid - The entity ID
+ * @returns Header row data
+ */
+declare function getHeaderRows(eid: Entity): readonly TableRow[];
+/**
+ * Gets the data rows (excluding headers).
+ *
+ * @param eid - The entity ID
+ * @returns Data rows
+ */
+declare function getDataRows(eid: Entity): readonly TableRow[];
+/**
+ * Sets the number of header rows.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param count - Number of header rows (0-255)
+ */
+declare function setHeaderRowCount(world: World, eid: Entity, count: number): void;
+/**
+ * Gets the number of header rows.
+ *
+ * @param eid - The entity ID
+ * @returns Number of header rows
+ */
+declare function getHeaderRowCount(eid: Entity): number;
+/**
+ * Sets the table display configuration.
+ *
+ * @param eid - The entity ID
+ * @param options - Display options
+ */
+declare function setTableDisplay(eid: Entity, options: TableDisplayOptions): void;
+/**
+ * Gets the table display configuration.
+ *
+ * @param eid - The entity ID
+ * @returns Display configuration
+ */
+declare function getTableDisplay(eid: Entity): TableDisplay;
+/**
+ * Clears the table display configuration.
+ *
+ * @param eid - The entity ID
+ */
+declare function clearTableDisplay(eid: Entity): void;
+/**
+ * Gets the cell padding.
+ *
+ * @param eid - The entity ID
+ * @returns Cell padding (spaces)
+ */
+declare function getCellPadding(eid: Entity): number;
+/**
+ * Sets the cell padding.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param padding - Cell padding (0-255)
+ */
+declare function setCellPadding(world: World, eid: Entity, padding: number): void;
+/**
+ * Checks if cell borders are enabled.
+ *
+ * @param eid - The entity ID
+ * @returns true if cell borders are enabled
+ */
+declare function hasCellBorders(eid: Entity): boolean;
+/**
+ * Sets whether cell borders are enabled.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param enabled - Whether to show cell borders
+ */
+declare function setCellBorders(world: World, eid: Entity, enabled: boolean): void;
+declare function calculateColumnWidths(eid: Entity, maxTotalWidth?: number): number[];
+declare function renderTableLines(eid: Entity, width: number): string[];
+/**
+ * Resets the table store. Used for testing.
+ */
+declare function resetTableStore(): void;
+
+/**
+ * TerminalBuffer Component
+ *
+ * ECS component for terminal emulator buffers. Stores a 2D grid of cells
+ * with per-cell styling, cursor state, and scrollback history.
+ *
+ * @module components/terminalBuffer
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from 'blecsd';
+ * import {
+ *   setTerminalBuffer,
+ *   writeToTerminal,
+ *   getTerminalState,
+ *   clearTerminal,
+ * } from 'blecsd/components';
+ *
+ * const world = createWorld();
+ * const eid = addEntity(world);
+ *
+ * // Initialize a terminal buffer
+ * setTerminalBuffer(world, eid, { width: 80, height: 24 });
+ *
+ * // Write ANSI content
+ * writeToTerminal(world, eid, '\x1b[31mHello\x1b[0m World');
+ *
+ * // Get current state
+ * const state = getTerminalState(eid);
+ * console.log(state?.cursorX, state?.cursorY);
+ *
+ * // Clear the terminal
+ * clearTerminal(world, eid);
+ * ```
+ */
+
+/** Default terminal width in columns */
+declare const DEFAULT_TERMINAL_WIDTH = 80;
+/** Default terminal height in rows */
+declare const DEFAULT_TERMINAL_HEIGHT = 24;
+/** Default scrollback lines */
+declare const DEFAULT_SCROLLBACK_LINES = 1000;
+/**
+ * TerminalBuffer component for scalar state.
+ * Complex state (cells, scrollback, parser state) is stored in a Map.
+ */
+declare const TerminalBuffer: {
+    /** Tag indicating this is a terminal buffer (1 = yes) */
+    isTerminal: Uint8Array<ArrayBuffer>;
+    /** Terminal width in columns */
+    width: Uint16Array<ArrayBuffer>;
+    /** Terminal height in rows */
+    height: Uint16Array<ArrayBuffer>;
+    /** Cursor X position (column) */
+    cursorX: Uint16Array<ArrayBuffer>;
+    /** Cursor Y position (row) */
+    cursorY: Uint16Array<ArrayBuffer>;
+    /** Cursor visible flag (1 = visible) */
+    cursorVisible: Uint8Array<ArrayBuffer>;
+    /** Scroll offset from top (for viewing history) */
+    scrollOffset: Uint32Array<ArrayBuffer>;
+    /** Alternate screen buffer active (1 = yes) */
+    altScreenActive: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Terminal state stored in a Map for complex data.
+ */
+interface TerminalState {
+    /** Cell buffer (2D grid in row-major order) */
+    readonly buffer: ScreenBufferData;
+    /** Scrollback history */
+    readonly scrollback: ScrollbackBuffer;
+    /** Current text attributes for new characters */
+    currentAttr: Attribute;
+    /** Partial escape sequence buffer */
+    escapeBuffer: string;
+    /** Whether we're in the middle of parsing an escape sequence */
+    inEscape: boolean;
+    /** Saved cursor position X */
+    savedCursorX: number;
+    /** Saved cursor position Y */
+    savedCursorY: number;
+    /** Saved attributes */
+    savedAttr: Attribute;
+    /** Alternate screen buffer (for full-screen apps) */
+    altBuffer: ScreenBufferData | null;
+    /** Cursor shape: 'block' | 'underline' | 'bar' */
+    cursorShape: CursorShape;
+    /** Cursor blink enabled */
+    cursorBlink: boolean;
+}
+/**
+ * Cursor shape types.
+ */
+type CursorShape = 'block' | 'underline' | 'bar';
+/**
+ * Terminal buffer configuration schema.
+ */
+declare const TerminalBufferConfigSchema: z.ZodObject<{
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    scrollbackLines: z.ZodDefault<z.ZodNumber>;
+    cursorVisible: z.ZodDefault<z.ZodBoolean>;
+    cursorShape: z.ZodDefault<z.ZodEnum<{
+        underline: "underline";
+        block: "block";
+        bar: "bar";
+    }>>;
+    cursorBlink: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Terminal buffer configuration type.
+ */
+type TerminalBufferConfig = z.input<typeof TerminalBufferConfigSchema>;
+/**
+ * Sets up a terminal buffer on an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param config - Terminal buffer configuration
+ *
+ * @example
+ * ```typescript
+ * setTerminalBuffer(world, eid, {
+ *   width: 80,
+ *   height: 24,
+ *   scrollbackLines: 1000,
+ * });
+ * ```
+ */
+declare function setTerminalBuffer(world: World, eid: Entity, config?: TerminalBufferConfig): void;
+/**
+ * Checks if an entity has a terminal buffer.
+ *
+ * @param eid - Entity ID
+ * @returns true if the entity has a terminal buffer
+ */
+declare function hasTerminalBuffer(eid: Entity): boolean;
+/**
+ * Gets the terminal state for an entity.
+ *
+ * @param eid - Entity ID
+ * @returns Terminal state or undefined
+ */
+declare function getTerminalState(eid: Entity): TerminalState | undefined;
+/**
+ * Gets terminal buffer data (scalar values).
+ *
+ * @param eid - Entity ID
+ * @returns Terminal buffer data
+ */
+declare function getTerminalBuffer(eid: Entity): {
+    width: number;
+    height: number;
+    cursorX: number;
+    cursorY: number;
+    cursorVisible: boolean;
+    scrollOffset: number;
+} | undefined;
+/**
+ * Writes a character to the terminal at the current cursor position.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param char - Character to write
+ */
+declare function writeChar(world: World, eid: Entity, char: string): void;
+/**
+ * Writes a string to the terminal (processes escape sequences).
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param data - String to write
+ */
+declare function writeToTerminal(world: World, eid: Entity, data: string): void;
+/**
+ * Clears the terminal buffer.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ */
+declare function clearTerminal(world: World, eid: Entity): void;
+/**
+ * Resets the terminal to initial state.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ */
+declare function resetTerminal(world: World, eid: Entity): void;
+/**
+ * Sets cursor position.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param x - Column (0-indexed)
+ * @param y - Row (0-indexed)
+ */
+declare function setCursorPosition(world: World, eid: Entity, x: number, y: number): void;
+/**
+ * Sets cursor visibility.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param visible - Cursor visibility
+ */
+declare function setCursorVisible(world: World, eid: Entity, visible: boolean): void;
+/**
+ * Scrolls the terminal view up.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param lines - Number of lines to scroll
+ */
+declare function scrollTerminalUp(world: World, eid: Entity, lines: number): void;
+/**
+ * Scrolls the terminal view down.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param lines - Number of lines to scroll
+ */
+declare function scrollTerminalDown(world: World, eid: Entity, lines: number): void;
+/**
+ * Scrolls to the top of history.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ */
+declare function scrollTerminalToTop(world: World, eid: Entity): void;
+/**
+ * Scrolls to the bottom (current view).
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ */
+declare function scrollTerminalToBottom(world: World, eid: Entity): void;
+/**
+ * Resizes the terminal buffer.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity ID
+ * @param width - New width in columns
+ * @param height - New height in rows
+ */
+declare function resizeTerminalBuffer(world: World, eid: Entity, width: number, height: number): void;
+/**
+ * Removes a terminal buffer from an entity.
+ *
+ * @param eid - Entity ID
+ */
+declare function removeTerminalBuffer(eid: Entity): void;
+/**
+ * Renders terminal buffer to an ANSI string (for display).
+ *
+ * @param eid - Entity ID
+ * @returns ANSI string representation of the terminal
+ */
+declare function renderTerminalToAnsi(eid: Entity): string;
+/**
+ * Gets the cells for rendering.
+ *
+ * @param eid - Entity ID
+ * @returns Readonly array of cells
+ */
+declare function getTerminalCells(eid: Entity): readonly Cell[] | undefined;
+/**
+ * Resets the terminal buffer store (for testing).
+ * @internal
+ */
+declare function resetTerminalBufferStore(): void;
+
+/**
+ * VirtualViewport Component for Viewport Windowing
+ *
+ * ECS component that tracks which portion of a large dataset is currently visible.
+ * Works with VirtualizedLineStore for text, or any other indexed content.
+ *
+ * @module components/virtualViewport
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setVirtualViewport, scrollToLine, getVisibleRange } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * // Configure viewport for a list with 1000 items
+ * setVirtualViewport(world, entity, {
+ *   totalLineCount: 1000,
+ *   visibleLineCount: 25,
+ *   overscanBefore: 5,
+ *   overscanAfter: 5,
+ * });
+ *
+ * // Scroll to line 500
+ * scrollToLine(world, entity, 500);
+ *
+ * // Get visible range (includes overscan)
+ * const range = getVisibleRange(world, entity);
+ * // range = { start: 495, end: 530 }
+ * ```
+ */
+
+/**
+ * Schema for VirtualViewport configuration options.
+ *
+ * @example
+ * ```typescript
+ * import { VirtualViewportOptionsSchema } from 'blecsd';
+ *
+ * const options = VirtualViewportOptionsSchema.parse({
+ *   totalLineCount: 10000,
+ *   visibleLineCount: 25,
+ *   overscanBefore: 5,
+ * });
+ * ```
+ */
+declare const VirtualViewportOptionsSchema: z.ZodObject<{
+    firstVisibleLine: z.ZodOptional<z.ZodNumber>;
+    visibleLineCount: z.ZodOptional<z.ZodNumber>;
+    totalLineCount: z.ZodOptional<z.ZodNumber>;
+    overscanBefore: z.ZodOptional<z.ZodNumber>;
+    overscanAfter: z.ZodOptional<z.ZodNumber>;
+    estimatedLineHeight: z.ZodOptional<z.ZodNumber>;
+    isVariableHeight: z.ZodOptional<z.ZodBoolean>;
+    selectedLine: z.ZodOptional<z.ZodNumber>;
+    cursorLine: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Schema for visible range output.
+ */
+declare const VisibleRangeSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    visibleStart: z.ZodNumber;
+    visibleEnd: z.ZodNumber;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Schema for scroll info output.
+ */
+declare const ScrollInfoSchema: z.ZodObject<{
+    currentLine: z.ZodNumber;
+    totalLines: z.ZodNumber;
+    viewportSize: z.ZodNumber;
+    maxScrollLine: z.ZodNumber;
+    scrollPercent: z.ZodNumber;
+    atTop: z.ZodBoolean;
+    atBottom: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * VirtualViewport component store using SoA (Structure of Arrays).
+ *
+ * Tracks viewport windowing for virtualized content rendering.
+ * Only the visible portion (plus overscan) should be rendered.
+ */
+declare const VirtualViewport: {
+    /** First visible line index in the viewport */
+    firstVisibleLine: Uint32Array<ArrayBuffer>;
+    /** Number of lines visible in the viewport */
+    visibleLineCount: Uint32Array<ArrayBuffer>;
+    /** Total number of lines in the content */
+    totalLineCount: Uint32Array<ArrayBuffer>;
+    /** Extra lines to render above viewport for smooth scrolling */
+    overscanBefore: Uint8Array<ArrayBuffer>;
+    /** Extra lines to render below viewport for smooth scrolling */
+    overscanAfter: Uint8Array<ArrayBuffer>;
+    /** Estimated height of each line in rows (for variable height estimation) */
+    estimatedLineHeight: Uint8Array<ArrayBuffer>;
+    /** Whether lines have variable height (0=fixed, 1=variable) */
+    isVariableHeight: Uint8Array<ArrayBuffer>;
+    /** Whether viewport needs re-render (dirty flag) */
+    isDirty: Uint8Array<ArrayBuffer>;
+    /** Selected line index (-1 = none) using Int32 to allow -1 */
+    selectedLine: Int32Array<ArrayBuffer>;
+    /** Cursor line for interactive lists (-1 = none) */
+    cursorLine: Int32Array<ArrayBuffer>;
+};
+/**
+ * Configuration options for VirtualViewport.
+ */
+interface VirtualViewportOptions {
+    /** First visible line index */
+    firstVisibleLine?: number;
+    /** Number of visible lines */
+    visibleLineCount?: number;
+    /** Total line count in content */
+    totalLineCount?: number;
+    /** Overscan lines before viewport */
+    overscanBefore?: number;
+    /** Overscan lines after viewport */
+    overscanAfter?: number;
+    /** Estimated line height (for variable height) */
+    estimatedLineHeight?: number;
+    /** Whether lines have variable height */
+    isVariableHeight?: boolean;
+    /** Selected line index */
+    selectedLine?: number;
+    /** Cursor line index */
+    cursorLine?: number;
+}
+/**
+ * Visible range including overscan.
+ */
+interface VisibleRange {
+    /** Start line index (with overscan) */
+    readonly start: number;
+    /** End line index (exclusive, with overscan) */
+    readonly end: number;
+    /** First actually visible line (without overscan) */
+    readonly visibleStart: number;
+    /** Last actually visible line (exclusive, without overscan) */
+    readonly visibleEnd: number;
+    /** Total lines in range */
+    readonly count: number;
+}
+/**
+ * Full viewport data.
+ */
+interface VirtualViewportData {
+    readonly firstVisibleLine: number;
+    readonly visibleLineCount: number;
+    readonly totalLineCount: number;
+    readonly overscanBefore: number;
+    readonly overscanAfter: number;
+    readonly estimatedLineHeight: number;
+    readonly isVariableHeight: boolean;
+    readonly isDirty: boolean;
+    readonly selectedLine: number;
+    readonly cursorLine: number;
+}
+/**
+ * Scroll position info.
+ */
+interface ScrollInfo {
+    /** Current line */
+    readonly currentLine: number;
+    /** Total lines */
+    readonly totalLines: number;
+    /** Viewport size */
+    readonly viewportSize: number;
+    /** Maximum scrollable line */
+    readonly maxScrollLine: number;
+    /** Scroll percentage (0-100) */
+    readonly scrollPercent: number;
+    /** Whether at top */
+    readonly atTop: boolean;
+    /** Whether at bottom */
+    readonly atBottom: boolean;
+}
+/**
+ * Sets up a VirtualViewport on an entity.
+ * Input is validated against VirtualViewportOptionsSchema.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Viewport configuration
+ * @returns The entity ID for chaining
+ * @throws {z.ZodError} If options are invalid
+ *
+ * @example
+ * ```typescript
+ * setVirtualViewport(world, entity, {
+ *   totalLineCount: 10000,
+ *   visibleLineCount: 25,
+ * });
+ * ```
+ */
+declare function setVirtualViewport(world: World, eid: Entity, options: VirtualViewportOptions): Entity;
+/**
+ * Gets VirtualViewport data for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Viewport data or undefined if no component
+ */
+declare function getVirtualViewport(world: World, eid: Entity): VirtualViewportData | undefined;
+/**
+ * Checks if entity has VirtualViewport.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if has component
+ */
+declare function hasVirtualViewport(world: World, eid: Entity): boolean;
+/**
+ * Sets the first visible line (viewport start).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Line index to scroll to
+ * @returns The entity ID for chaining
+ */
+declare function setViewportStart(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Gets the visible range including overscan.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Visible range or undefined if no component
+ *
+ * @example
+ * ```typescript
+ * const range = getVisibleRange(world, entity);
+ * // Render lines from range.start to range.end
+ * const lines = getLineRange(store, range.start, range.end);
+ * ```
+ */
+declare function getVisibleRange(world: World, eid: Entity): VisibleRange | undefined;
+/**
+ * Checks if a line is currently visible (in viewport, not just overscan).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Line index to check
+ * @returns true if line is visible
+ */
+declare function isLineVisible(world: World, eid: Entity, lineIndex: number): boolean;
+/**
+ * Checks if a line is in the render range (visible + overscan).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Line index to check
+ * @returns true if line should be rendered
+ */
+declare function isLineInRenderRange(world: World, eid: Entity, lineIndex: number): boolean;
+/**
+ * Scrolls to a specific line, centering it if possible.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Target line index
+ * @returns The entity ID for chaining
+ */
+declare function scrollToLine(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Scrolls by a number of lines.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param delta - Lines to scroll (positive = down, negative = up)
+ * @returns The entity ID for chaining
+ */
+declare function scrollByLines(world: World, eid: Entity, delta: number): Entity;
+/**
+ * Scrolls by pages.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param pages - Pages to scroll (positive = down, negative = up)
+ * @returns The entity ID for chaining
+ */
+declare function scrollByPages(world: World, eid: Entity, pages: number): Entity;
+/**
+ * Scrolls to the top.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function scrollToTop(world: World, eid: Entity): Entity;
+/**
+ * Scrolls to the bottom.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function scrollToBottom(world: World, eid: Entity): Entity;
+/**
+ * Gets scroll information.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Scroll info or undefined if no component
+ */
+declare function getScrollInfo(world: World, eid: Entity): ScrollInfo | undefined;
+/**
+ * Updates the total line count (when content changes).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param totalLines - New total line count
+ * @returns The entity ID for chaining
+ */
+declare function setTotalLineCount(world: World, eid: Entity, totalLines: number): Entity;
+/**
+ * Updates the viewport size (when container resizes).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param visibleLines - New visible line count
+ * @returns The entity ID for chaining
+ */
+declare function setVisibleLineCount(world: World, eid: Entity, visibleLines: number): Entity;
+/**
+ * Sets overscan values.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param before - Lines to render before viewport
+ * @param after - Lines to render after viewport
+ * @returns The entity ID for chaining
+ */
+declare function setOverscan(world: World, eid: Entity, before: number, after: number): Entity;
+/**
+ * Sets the selected line.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Selected line (-1 for none)
+ * @returns The entity ID for chaining
+ */
+declare function setSelectedLine(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Gets the selected line.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Selected line index or -1 if none
+ */
+declare function getSelectedLine(world: World, eid: Entity): number;
+/**
+ * Sets the cursor line (for keyboard navigation).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Cursor line (-1 for none)
+ * @returns The entity ID for chaining
+ */
+declare function setCursorLine(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Gets the cursor line.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Cursor line index or -1 if none
+ */
+declare function getCursorLine(world: World, eid: Entity): number;
+/**
+ * Moves cursor up/down and auto-scrolls to keep it visible.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param delta - Lines to move (negative = up, positive = down)
+ * @returns The entity ID for chaining
+ */
+declare function moveCursor(world: World, eid: Entity, delta: number): Entity;
+/**
+ * Ensures the cursor is visible, scrolling if needed.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function ensureCursorVisible(world: World, eid: Entity): Entity;
+/**
+ * Checks if viewport needs re-render.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if dirty
+ */
+declare function isViewportDirty(world: World, eid: Entity): boolean;
+/**
+ * Clears the dirty flag after rendering.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function clearViewportDirty(world: World, eid: Entity): Entity;
+/**
+ * Forces viewport to be dirty (triggers re-render).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function invalidateViewport(world: World, eid: Entity): Entity;
+
+export { type ScrollInfo as $, type ScrollPercentage as A, type ScrollPosition as B, type CellAlign as C, DEFAULT_CELL_BG as D, Scrollable as E, type ScrollableData as F, type ScrollableOptions as G, ScrollbarVisibility as H, type TableCell as I, type TableColumn as J, type TableData as K, LIST_STATE_MACHINE_CONFIG as L, type TableDisplay as M, type TableDisplayOptions as N, type TableRow as O, type TableStore as P, TerminalBuffer as Q, type TerminalBufferConfig as R, ScrollInfoSchema as S, Table as T, TerminalBufferConfigSchema as U, type CursorShape as V, type TerminalState as W, VirtualViewport as X, type VirtualViewportData as Y, type VirtualViewportOptions as Z, VirtualViewportOptionsSchema as _, DEFAULT_CELL_FG as a, getTerminalBuffer as a$, type VisibleRange as a0, VisibleRangeSchema as a1, activateSelected as a2, addItem as a3, appendItems as a4, appendRow as a5, appendToSearchQuery as a6, attachListBehavior as a7, attachTableBehavior as a8, backspaceSearchQuery as a9, getColumn as aA, getColumns as aB, getCursorLine as aC, getData as aD, getDataAsStrings as aE, getDataRows as aF, getFirstVisible as aG, getHeaderRowCount as aH, getHeaderRows as aI, getItem as aJ, getItemCount as aK, getItems as aL, getLazyLoadCallback as aM, getListDisplay as aN, getListSearchQuery as aO, getSelectedIndex as aP, getListState as aQ, getLoadingPlaceholder as aR, getRow as aS, getRowCount as aT, getScroll as aU, getScrollInfo$1 as aV, getScrollPercentage as aW, getScrollable as aX, getSelectedItem as aY, getSelectedLine as aZ, getTableDisplay as a_, blurList as aa, calculateColumnWidths as ab, canScroll as ac, checkNeedsLoad as ad, clearData as ae, clearItems as af, clearLazyLoadCallback as ag, clearListCallbacks as ah, clearListDisplay as ai, clearSelection as aj, clearSearchQuery as ak, clearTableDisplay as al, clearTerminal as am, clearViewportDirty as an, detachTableBehavior as ao, disableList as ap, enableList as aq, endListSearch as ar, ensureCursorVisible as as, ensureVisible as at, findAndSelectByText as au, findNextMatch as av, focusList as aw, getCellPadding as ax, getCellValue as ay, getColCount as az, DEFAULT_DISABLED_FG as b, selectByValue as b$, getTerminalCells as b0, getTerminalState as b1, getTotalCount as b2, getScrollInfo as b3, getVirtualViewport as b4, getVisibleCount as b5, getVisibleItems as b6, getVisibleRange as b7, handleListKeyPress as b8, hasCellBorders as b9, onListSearchChange as bA, onListSelect as bB, removeItem as bC, removeRow as bD, removeTerminalBuffer as bE, renderListItems as bF, renderTableLines as bG, renderTerminalToAnsi as bH, resetListStore as bI, resetTableStore as bJ, resetTerminal as bK, resetTerminalBufferStore as bL, resizeTerminalBuffer as bM, scrollBy as bN, scrollByLines as bO, scrollByPages as bP, scrollPage as bQ, scrollTerminalDown as bR, scrollTerminalToBottom as bS, scrollTerminalToTop as bT, scrollTerminalUp as bU, scrollTo as bV, scrollToBottom$1 as bW, scrollToLine as bX, scrollToTop$1 as bY, scrollToBottom as bZ, scrollToTop as b_, hasScrollable as ba, hasTerminalBuffer as bb, hasVirtualViewport as bc, insertRow as bd, invalidateViewport as be, isAtBottom as bf, isAtTop as bg, isLineInRenderRange as bh, isLineVisible as bi, isList as bj, isListDisabled as bk, isListFocused as bl, isListInState as bm, isListInteractive as bn, isListKeysEnabled as bo, isListLoading as bp, isListMouseEnabled as bq, isListSearchEnabled as br, isListSearching as bs, isTable as bt, isViewportDirty as bu, listStore as bv, loadItems as bw, moveCursor as bx, onListActivate as by, onListScroll as bz, DEFAULT_HEADER_BG as c, selectFirst as c0, selectLast as c1, selectNext as c2, selectPrev as c3, sendListEvent as c4, setCellBorders as c5, setCellPadding as c6, setCursorLine as c7, setCursorPosition as c8, setData as c9, setVisibleCount as cA, setVisibleLineCount as cB, startListSearch as cC, tableStore as cD, updateItem as cE, writeToTerminal as cF, type StateMachineConfig as cG, type StateMachine as cH, getCell as cI, setCell as cJ, setCursorVisible as cK, writeChar as cL, setFirstVisible as ca, setHeaderRowCount as cb, setHeaders as cc, setItems as cd, setLazyLoadCallback as ce, setListDisplay as cf, setListInteractive as cg, setListKeys as ch, setListLoading as ci, setListMouse as cj, setListSearchEnabled as ck, setListSearchQuery as cl, setSelectedIndex as cm, setLoadingPlaceholder as cn, setOverscan as co, setScroll as cp, setScrollSize as cq, setScrollable as cr, setScrollbarVisibility as cs, setSelectedLine as ct, setTableDisplay as cu, setTerminalBuffer as cv, setTotalCount as cw, setTotalLineCount as cx, setViewportStart as cy, setVirtualViewport as cz, DEFAULT_HEADER_FG as d, DEFAULT_ITEM_BG as e, DEFAULT_ITEM_FG as f, DEFAULT_SCROLLBACK_LINES as g, DEFAULT_SELECTED_BG as h, DEFAULT_SELECTED_FG as i, DEFAULT_SELECTED_PREFIX as j, DEFAULT_BORDER_BG as k, DEFAULT_BORDER_FG as l, DEFAULT_TERMINAL_HEIGHT as m, DEFAULT_TERMINAL_WIDTH as n, DEFAULT_UNSELECTED_PREFIX as o, type ListAction as p, type ListDisplay as q, type ListDisplayOptions as r, type ListEvent as s, type ListItem as t, type ListLazyLoadCallback as u, type ListScrollCallback as v, type ListScrollInfo as w, type ListSelectCallback as x, type ListState as y, type ListStore as z };