@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/ink/parse-keypress.d.ts

@@ -0,0 +1,22 @@
+import { Buffer } from "node:buffer";
+export declare const nonAlphanumericKeys: string[];
+type ParsedKey = {
+    capsLock?: boolean;
+    code?: string;
+    ctrl: boolean;
+    eventType?: "press" | "repeat" | "release";
+    hyper?: boolean;
+    isKittyProtocol?: boolean;
+    isPrintable?: boolean;
+    meta: boolean;
+    name: string;
+    numLock?: boolean;
+    option: boolean;
+    raw: string | undefined;
+    sequence: string;
+    shift: boolean;
+    super?: boolean;
+    text?: string;
+};
+declare const parseKeypress: (s?: Buffer | string) => ParsedKey;
+export default parseKeypress;

package/dist/ink/reconciler.d.ts

@@ -0,0 +1,3 @@
+import createReconciler from "react-reconciler";
+declare const reconcilerInstance: ReturnType<typeof createReconciler>;
+export default reconcilerInstance;

package/dist/ink/region.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Region-based hierarchical output model.
+ *
+ * A Region represents a rectangular area of terminal output with its own
+ * line buffer, scroll state, and child regions. Regions form a tree that
+ * is composited into the final screen buffer via flattenRegion().
+ *
+ * This enables:
+ * - Incremental rendering (only changed regions are re-composited)
+ * - Render caching (cachedRender stores a Region for unchanged subtrees)
+ * - Dirty tracking (terminal buffer only writes changed lines)
+ *
+ * Ported from jacob314/ink (Google LLC, Apache-2.0).
+ */
+import type { StyledLine } from "./styled-line.d.ts";
+export type Region = {
+    backgroundColor?: string;
+    borderBottom?: number;
+    borderTop?: number;
+    cachedStickyHeaders?: StickyHeader[];
+    /** Child regions (nested content areas) */
+    children: Region[];
+    /** Cursor position within this region */
+    cursorPosition?: {
+        col: number;
+        row: number;
+    };
+    height: number;
+    /** Unique identifier for this region (used for dirty tracking) */
+    id: number | string;
+    isHorizontallyScrollable?: boolean;
+    /** Whether this region supports scrolling */
+    isScrollable: boolean;
+    isVerticallyScrollable?: boolean;
+    /** Content buffer — StyledLine per row, relative to (0,0) of this region */
+    readonly lines: ReadonlyArray<StyledLine>;
+    marginBottom?: number;
+    marginRight?: number;
+    /** DOM node reference for debugging/caching */
+    nodeId?: number;
+    opaque?: boolean;
+    /** Layout properties */
+    overflowToBackbuffer?: boolean;
+    scrollbarThumbColor?: string;
+    scrollbarVisible?: boolean;
+    scrollHeight?: number;
+    scrollLeft?: number;
+    /** Scroll state */
+    scrollTop?: number;
+    scrollWidth?: number;
+    /** Selectable text spans for text selection */
+    selectableSpans: SelectableSpan[];
+    selectableText?: string;
+    /** Whether the scrollback position is stable */
+    stableScrollback?: boolean;
+    /** Sticky headers for this region */
+    stickyHeaders: StickyHeader[];
+    /** Trimmed output (trailing spaces removed) for final rendering */
+    readonly styledOutput: ReadonlyArray<StyledLine>;
+    /** Dimensions */
+    width: number;
+    /** Position relative to parent region */
+    x: number;
+    y: number;
+};
+export type SelectableSpan = {
+    endX: number;
+    startX: number;
+    text: string;
+    y: number;
+};
+export type StickyHeader = {
+    /** Lines in the natural (scrolling) position */
+    lines: ReadonlyArray<StyledLine>;
+    /** Height of the header in lines */
+    maxHeaderHeight: number;
+    /** Natural row offset relative to content start */
+    naturalRow: number;
+    /** Node ID for identification */
+    nodeId: number;
+    /** Lines in the stuck (fixed) position */
+    stuckLines?: ReadonlyArray<StyledLine>;
+    /** Stuck X position relative to region */
+    x: number;
+    /** Stuck Y position relative to region */
+    y: number;
+};
+export type RegionNode = {
+    children: RegionNode[];
+    id: number | string;
+};
+/**
+ * Compare two region trees for structural equality (same IDs in same order).
+ */
+export declare const treesEqual: (a: RegionNode, b: RegionNode) => boolean;
+/**
+ * Extract selectable text from a list of selectable spans.
+ */
+export declare const extractSelectableText: (spans: ReadonlyArray<SelectableSpan>) => string;

package/dist/ink/render-background.d.ts

@@ -0,0 +1,4 @@
+import type { DOMNode } from "./dom.d.ts";
+import type Output from "./output.d.ts";
+declare const renderBackground: (x: number, y: number, node: DOMNode, output: Output) => void;
+export default renderBackground;

package/dist/ink/render-border.d.ts

@@ -0,0 +1,4 @@
+import type { DOMNode } from "./dom.d.ts";
+import type Output from "./output.d.ts";
+declare const renderBorder: (x: number, y: number, node: DOMNode, output: Output) => void;
+export default renderBorder;

package/dist/ink/render-node-to-output.d.ts

@@ -0,0 +1,38 @@
+import type { DOMElement, DOMNode } from "./dom.d.ts";
+import Output from "./output.d.ts";
+export type OutputTransformer = (s: string, index: number) => string;
+export type CursorOutputPosition = {
+    x: number;
+    y: number;
+};
+export type RenderState = {
+    cursorPosition: CursorOutputPosition | undefined;
+    cursorRequested: boolean;
+    lastTextWriteEnd?: CursorOutputPosition;
+};
+export declare const renderNodeToScreenReaderOutput: (node: DOMElement, options?: {
+    parentRole?: string;
+    skipStaticElements?: boolean;
+}) => string;
+declare const renderNodeToOutput: (node: DOMElement, output: Output, options: {
+    absoluteOffsetX?: number;
+    absoluteOffsetY?: number;
+    offsetX?: number;
+    offsetY?: number;
+    renderState?: RenderState;
+    selectionMap?: Map<DOMNode, {
+        end: number;
+        start: number;
+    }>;
+    skipStaticElements: boolean;
+    transformers?: OutputTransformer[];
+}) => void;
+export default renderNodeToOutput;
+/**
+ * Render a DOM subtree into a cached Region.
+ * Used by StaticRender to pre-render content once and cache it.
+ */
+export declare const renderToStatic: (node: DOMElement, options?: {
+    skipStaticElements?: boolean;
+    trackSelection?: boolean;
+}) => void;

package/dist/ink/render-scrollbar.d.ts

@@ -0,0 +1,9 @@
+import type { ScrollbarBoundingBox } from "./measure-element.d.ts";
+import type Output from "./output.d.ts";
+export type RenderScrollbarOptions = {
+    axis: "horizontal" | "vertical";
+    color?: string;
+    layout: ScrollbarBoundingBox;
+    output: Output;
+};
+export declare const renderScrollbar: ({ axis, color, layout, output }: RenderScrollbarOptions) => void;

package/dist/ink/render-sticky.d.ts

@@ -0,0 +1,44 @@
+import type { DOMElement } from "./dom.d.ts";
+import type Output from "./output.d.ts";
+import type { OutputTransformer } from "./render-node-to-output.d.ts";
+export type StickyNodeInfo = {
+    node: DOMElement;
+    type: "top" | "bottom";
+};
+/**
+ * Factory function type for creating Output instances.
+ * Passed as a parameter to avoid circular dependency between render-sticky and output.
+ */
+export type OutputFactory = (options: {
+    height: number;
+    width: number;
+}) => Output;
+/**
+ * Walk the DOM tree under `node` to find all sticky descendants.
+ * Stops at scroll boundaries (nested scrollable containers own their sticky nodes).
+ */
+export declare const getStickyDescendants: (node: DOMElement, result?: StickyNodeInfo[]) => StickyNodeInfo[];
+/**
+ * Identify which sticky nodes are currently active (should be pinned)
+ * based on the scroll position and viewport.
+ */
+export declare const identifyActiveStickyNodes: (stickyNodes: StickyNodeInfo[], node: DOMElement, scrollTop: number, viewportBottom: number) => {
+    nextStickyNodeInfo?: StickyNodeInfo;
+    stickyNode: DOMElement;
+    type: "top" | "bottom";
+}[];
+/**
+ * Render active sticky headers and write them to the output at their stuck positions.
+ * Called during the rendering of a scrollable container.
+ * @param createOutput Factory function for creating Output instances (avoids circular imports).
+ */
+export declare const renderActiveStickyNodes: (activeStickyNodes: {
+    nextStickyNodeInfo?: StickyNodeInfo;
+    stickyNode: DOMElement;
+    type: "top" | "bottom";
+}[], node: DOMElement, output: Output, createOutput: OutputFactory, options: {
+    newTransformers: OutputTransformer[];
+    skipStaticElements: boolean;
+    x: number;
+    y: number;
+}) => void;

package/dist/ink/render-to-string.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from "react";
+export type RenderToStringOptions = {
+    /**
+     * Width of the virtual terminal in columns.
+     * @default 80
+     */
+    columns?: number;
+};
+/**
+ * Render a React element to a string synchronously. Unlike `render()`, this function does not write to stdout, does not set up any terminal event listeners, and returns the rendered output as a string.
+ *
+ * Useful for generating documentation, writing output to files, testing, or any scenario where you need the rendered output as a string without starting a persistent terminal application.
+ *
+ *Notes:**
+ *
+ * - Terminal-specific hooks (`useInput`, `useStdin`, `useStdout`, `useStderr`, `useApp`, `useFocus`, `useFocusManager`) return default no-op values since there is no terminal session. They will not throw, but they will not function as in a live terminal.
+ * - `useEffect` callbacks will execute during rendering (due to synchronous rendering mode), but state updates they trigger will not affect the returned output, which reflects the initial render.
+ * - `useLayoutEffect` callbacks fire synchronously during commit, so state updates they trigger **will** be reflected in the output.
+- The `<Static>` component is supported — its output is prepended to the dynamic output.
+- If a component throws during rendering, the error is propagated to the caller after cleanup.
+ 
+@example
+```
+import {renderToString, Text, Box} from 'ink';
+ 
+const output = renderToString(
+    <Box padding={1}>
+        <Text color="green">Hello World</Text>
+    </Box>,
+    {columns: 40}
+);
+ 
+console.log(output);
+```
+ */
+declare const renderToString: (node: ReactNode, options?: RenderToStringOptions) => string;
+export default renderToString;

package/dist/ink/render.d.ts

@@ -0,0 +1,191 @@
+import type { ReactNode } from "react";
+import type { DOMElement } from "./dom.d.ts";
+import type { RenderMetrics } from "./ink/ink.d.ts";
+import Ink from "./ink/ink.d.ts";
+import type { KittyKeyboardOptions } from "./kitty-keyboard.d.ts";
+export type RenderOptions = {
+    /**
+     * Render the app in the terminal's alternate screen buffer. When enabled, the app renders on a separate screen, and the original terminal content is restored when the app exits. This is the same mechanism used by programs like vim, htop, and less.
+     *
+     * Note: The terminal's scrollback buffer is not available while in the alternate screen. This is standard terminal behavior; programs like vim use the alternate screen specifically to avoid polluting the user's scrollback history.
+     *
+     * Note: Ink intentionally treats alternate-screen teardown output as disposable. It does not preserve or replay teardown-time frames, hook writes, or `console.*` output after restoring the primary screen.
+     *
+     * Only works in interactive mode. Ignored when `interactive` is `false` or in a non-interactive environment (CI, piped stdout).
+     *
+     *Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+     * @default false
+     */
+    alternateScreen?: boolean;
+    /**
+     * Enable React Concurrent Rendering mode.
+     *
+     * When enabled:
+     * - Suspense boundaries work correctly with async data
+     * - `useTransition` and `useDeferredValue` are fully functional
+     * - Updates can be interrupted for higher priority work
+     *
+     *Note: Concurrent mode changes the timing of renders. Some tests may need to use `act()` to properly await updates. Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change the rendering mode or create a fresh instance.
+     * @default false
+     */
+    concurrent?: boolean;
+    /**
+     * If true, each update will be rendered as separate output, without replacing the previous one.
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Configure whether Ink should listen for Ctrl+C keyboard input and exit the app. This is needed in case `process.stdin` is in raw mode, because then Ctrl+C is ignored by default and the process is expected to handle it manually.
+     * @default true
+     */
+    exitOnCtrlC?: boolean;
+    /**
+     * Enable incremental rendering mode which only updates changed lines instead of redrawing the entire output.
+     *This can reduce flickering and improve performance for frequently updating UIs.
+     * @default false
+     */
+    incrementalRendering?: boolean;
+    /**
+     * Override automatic interactive mode detection.
+     *
+     * By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
+     *
+     * When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
+     *
+     * Set to `false` to force non-interactive mode or `true` to force interactive mode when the automatic detection doesn't suit your use case.
+     *
+     *Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+     * @default true (false if in CI or `stdout.isTTY` is falsy)
+     */
+    interactive?: boolean;
+    /**
+     * Enable screen reader support. See https://github.com/vadimdemedes/ink/blob/master/readme.md#screen-reader-support
+     * @default process.env['INK_SCREEN_READER'] === 'true'
+     */
+    isScreenReaderEnabled?: boolean;
+    /**
+     * Configure kitty keyboard protocol support for enhanced keyboard input.
+     * Enables additional modifiers (super, hyper, capsLock, numLock) and
+     *disambiguated key events in terminals that support the protocol.
+     * @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+     */
+    kittyKeyboard?: KittyKeyboardOptions;
+    /**
+     * Maximum frames per second for render updates.
+     * This controls how frequently the UI can update to prevent excessive re-rendering.
+     *Higher values allow more frequent updates but may impact performance.
+     * @default 30
+     */
+    maxFps?: number;
+    /**
+     * Runs the given callback after each render and re-render with render metrics.
+     *
+     * Note: this callback runs after Ink commits a frame, but it does not wait for `stdout`/`stderr` stream callbacks.
+     * To run code after output is flushed, use `waitUntilRenderFlush()`.
+     */
+    onRender?: (metrics: RenderMetrics) => void;
+    /**
+     * Patch console methods to ensure console output doesn't mix with Ink's output.
+     *
+     *Note: Once unmount starts, Ink restores the native console before React cleanup runs. Teardown-time `console.*` output then follows the normal console behavior instead of being rerouted through Ink.
+     * @default true
+     */
+    patchConsole?: boolean;
+    /**
+     * If true, Ink defers frame output until after React's commit phase completes,
+     * ensuring `useLayoutEffect` hooks run before the frame is written to the terminal.
+     *
+     * This eliminates the one-frame flicker when components measure layout
+     * (e.g., scroll position, element size) in `useLayoutEffect` and adjust state.
+     *
+     * **Warning:** Incompatible with the `<Static>` component, which relies on
+     * immediate render timing to append output.
+     * @default false
+     */
+    standardReactLayoutTiming?: boolean;
+    /**
+     * Error stream.
+     * @default process.stderr
+     */
+    stderr?: NodeJS.WriteStream;
+    /**
+     * Input stream where app will listen for input.
+     * @default process.stdin
+     */
+    stdin?: NodeJS.ReadStream;
+    /**
+     * Output stream where the app will be rendered.
+     * @default process.stdout
+     */
+    stdout?: NodeJS.WriteStream;
+    /**
+     * Use the native Rust cell-diff renderer for terminal output.
+     * Produces a Uint32Array buffer that the Rust renderer diffs cell-by-cell,
+     * generating minimal ANSI escape sequences. Reduces GC pressure and
+     * improves rendering performance for complex UIs.
+     *
+     * Falls back to string-based rendering if native bindings are not available.
+     * @default false
+     */
+    useNativeRenderer?: boolean;
+};
+export type Instance = {
+    /**
+     * Unmount the current app and remove the internal Ink instance for this stdout.
+     *
+     * This is mostly useful for advanced cases where you need `render()` to create a fresh instance for the same stream without leaving terminal state such as the alternate screen behind.
+     */
+    cleanup: () => void;
+    /**
+     * Clear output.
+     */
+    clear: () => void;
+    /**
+     * Replace the previous root node with a new one or update props of the current root node.
+     */
+    rerender: Ink["render"];
+    /**
+     * The root DOM element of the rendered tree.
+     * Useful for programmatic DOM inspection and advanced measurement.
+     */
+    rootNode: DOMElement;
+    /**
+     * Manually unmount the whole Ink app.
+     */
+    unmount: Ink["unmount"];
+    /**
+     * Returns a promise that settles when the app is unmounted.
+     *
+     * It resolves with the value passed to `exit(value)` and rejects with the error passed to `exit(error)`.
+     *When `unmount()` is called manually, it settles after unmount-related stdout writes complete.
+     * @example
+     * ```jsx
+     * const {unmount, waitUntilExit} = render(<MyApp />);
+     *
+     * setTimeout(unmount, 1000);
+     *
+     * await waitUntilExit(); // resolves after `unmount()` is called
+     * ```
+     */
+    waitUntilExit: Ink["waitUntilExit"];
+    /**
+     * Returns a promise that settles after pending render output is flushed to stdout.
+     *
+     *This can be used after `rerender()` when you need to run code only after the frame is written.
+     * @example
+     * ```jsx
+     * const {rerender, waitUntilRenderFlush} = render(<MyApp step="loading" />);
+     *
+     * rerender(<MyApp step="ready" />);
+     * await waitUntilRenderFlush(); // output for "ready" is flushed
+     *
+     * runNextCommand();
+     * ```
+     */
+    waitUntilRenderFlush: Ink["waitUntilRenderFlush"];
+};
+/**
+ * Mount a component and render the output.
+ */
+declare const render: (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Instance;
+export default render;

package/dist/ink/renderer.d.ts

@@ -0,0 +1,17 @@
+import type { DOMElement } from "./dom.d.ts";
+import type { CursorPosition } from "./log-update.d.ts";
+import type { Selection } from "./selection.d.ts";
+type Result = {
+    cursorPosition: CursorPosition | undefined;
+    cursorRequested: boolean;
+    output: string;
+    outputBuffer?: Uint32Array;
+    outputHeight: number;
+    outputWidth?: number;
+    staticOutput: string;
+};
+declare const renderer: (node: DOMElement, isScreenReaderEnabled: boolean, options?: {
+    selection?: Selection;
+    useNativeRenderer?: boolean;
+}) => Result;
+export default renderer;

package/dist/ink/resize-observer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ResizeObserver API for terminal UI elements.
+ *
+ * Mirrors the browser ResizeObserver API, allowing components to react
+ * to size changes of DOM elements after layout computation.
+ *
+ * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+ */
+import type { DOMElement } from "./dom.d.ts";
+export type ResizeObserverCallback = (entries: ResizeObserverEntry[], observer: ResizeObserver) => void;
+export declare class ResizeObserverEntry {
+    readonly target: DOMElement;
+    readonly contentRect: Readonly<{
+        height: number;
+        width: number;
+    }>;
+    constructor(target: DOMElement, contentRect: Readonly<{
+        height: number;
+        width: number;
+    }>);
+}
+declare class ResizeObserver {
+    private readonly callback;
+    private readonly observedElements;
+    constructor(callback: ResizeObserverCallback);
+    observe(element: DOMElement): void;
+    unobserve(element: DOMElement): void;
+    disconnect(): void;
+    /**
+     * Internal method called by the layout engine after computing layout.
+     */
+    internalTrigger(entries: ResizeObserverEntry[]): void;
+}
+/**
+ * Measure a node and collect resize observer entries for it.
+ * Used by both the main render loop and static render processing.
+ */
+export declare function measureAndExtractObservers(node: DOMElement, observerEntries: Map<ResizeObserver, ResizeObserverEntry[]>, forceCache?: boolean): void;
+/**
+ * Traverse a node tree, measure all nodes, and trigger resize observers.
+ * Skips into static/cached subtrees to avoid double-counting.
+ */
+export declare function triggerResizeObservers(node: DOMElement, forceCache?: boolean): void;
+export default ResizeObserver;

package/dist/ink/sanitize-ansi.d.ts

@@ -0,0 +1,2 @@
+declare const sanitizeAnsi: (text: string) => string;
+export default sanitizeAnsi;

package/dist/ink/scroll.d.ts

@@ -0,0 +1,23 @@
+import type { DOMElement } from "./dom.d.ts";
+export type ScrollState = {
+    actualScrollHeight: number;
+    clientHeight: number;
+    clientWidth: number;
+    scrollHeight: number;
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+};
+export declare const getScrollHeight: (node: DOMElement) => number;
+export declare const getScrollWidth: (node: DOMElement) => number;
+export declare const calculateScroll: (node: DOMElement) => void;
+/**
+ * Get the effective scroll top position from the pre-computed scroll state.
+ * Falls back to computing from style if scroll state hasn't been calculated yet.
+ */
+export declare const getScrollTop: (node: DOMElement) => number;
+/**
+ * Get the effective scroll left position from the pre-computed scroll state.
+ * Falls back to computing from style if scroll state hasn't been calculated yet.
+ */
+export declare const getScrollLeft: (node: DOMElement) => number;

package/dist/ink/selection.d.ts

@@ -0,0 +1,70 @@
+/**
+ * DOM-like Selection and Range API for terminal text selection.
+ *
+ * Provides browser-like Selection/Range classes that operate on the Ink DOM tree,
+ * enabling text selection highlighting and copy-to-clipboard functionality.
+ *
+ * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+ */
+import type { DOMNode } from "./dom.d.ts";
+import type { StyledLine } from "./styled-line.d.ts";
+/**
+ * Compare the document position of two points in the DOM tree.
+ * Returns -1 if A is before B, 0 if equal, 1 if A is after B.
+ */
+export declare const comparePoints: (nodeA: DOMNode, offsetA: number, nodeB: DOMNode, offsetB: number) => number;
+/**
+ * A Range represents a contiguous portion of the DOM tree.
+ * Modeled after the browser's Range API.
+ */
+export declare class Range {
+    startContainer: DOMNode | undefined;
+    startOffset: number;
+    endContainer: DOMNode | undefined;
+    endOffset: number;
+    collapsed: boolean;
+    commonAncestorContainer: DOMNode | undefined;
+    setStart(node: DOMNode, offset: number): void;
+    setEnd(node: DOMNode, offset: number): void;
+    collapse(toStart: boolean): void;
+    selectNode(node: DOMNode): void;
+    selectNodeContents(node: DOMNode): void;
+    toString(): string;
+    private updateCollapsed;
+    private updateCommonAncestor;
+}
+/**
+ * Manages multiple Range objects and provides high-level selection operations.
+ * Modeled after the browser's Selection API.
+ */
+export declare class Selection {
+    anchorNode: DOMNode | undefined;
+    anchorOffset: number;
+    focusNode: DOMNode | undefined;
+    focusOffset: number;
+    isCollapsed: boolean;
+    rangeCount: number;
+    private ranges;
+    private readonly listeners;
+    onChange(listener: () => void): () => void;
+    toString(): string;
+    getRangeAt(index: number): Range;
+    addRange(range: Range): void;
+    removeRange(range: Range): void;
+    removeAllRanges(): void;
+    collapse(node: DOMNode, offset: number): void;
+    containsNode(node: DOMNode, allowPartialContainment?: boolean): boolean;
+    private clearState;
+    private notifyChange;
+}
+/**
+ * Apply selection highlighting to a range of characters in a StyledLine.
+ *
+ * Characters whose index falls within [start, end) of the selection range
+ * get the INVERSE style flag applied. Returns a new StyledLine with the
+ * selection highlighting — the original is not mutated.
+ */
+export declare const applySelectionToStyledLine: (line: StyledLine, range: {
+    end: number;
+    start: number;
+}) => StyledLine;

package/dist/ink/squash-text-nodes.d.ts

@@ -0,0 +1,18 @@
+import type { DOMElement, DOMNode } from "./dom.d.ts";
+export type CharOffsetRange = {
+    end: number;
+    start: number;
+};
+export type CharOffsetMap = Map<DOMNode, CharOffsetRange>;
+declare const squashTextNodes: (node: DOMElement) => string;
+export default squashTextNodes;
+/**
+ * Squash text nodes while building a character offset map.
+ * Each DOM node is mapped to its start/end character offsets in the resulting string.
+ * Used for selection text extraction and cursor position calculation.
+ *
+ * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+ */
+export declare const squashTextNodesWithMap: (node: DOMElement, map: CharOffsetMap, offsetRef: {
+    current: number;
+}) => string;

package/dist/ink/style-flags.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bitmask constants for text formatting flags used by StyledLine.
+ *
+ * These map 1:1 to SGR (Select Graphic Rendition) attributes and are stored
+ * in the `formatFlags` field of StyleSpan objects. The FULL_WIDTH_MASK is
+ * also used in StyledLine.charData entries (bit 30 / 0x40000000 of number[]).
+ *
+ * Ported from jacob314/ink (Google LLC, Apache-2.0).
+ */
+export declare const BOLD_MASK: number;
+export declare const DIM_MASK: number;
+export declare const ITALIC_MASK: number;
+export declare const UNDERLINE_MASK: number;
+export declare const STRIKETHROUGH_MASK: number;
+export declare const INVERSE_MASK: number;
+export declare const HIDDEN_MASK: number;
+export declare const FULL_WIDTH_MASK: number;