@cjhyy/code-shell 0.2.0 → 0.5.0-rc.1

package/dist/render/screen.d.ts

@@ -1,269 +0,0 @@
-import { type AnsiCode } from '@alcalzone/ansi-tokenize';
-import { type Point, type Rectangle, type Size } from './layout/geometry.js';
-export declare class CharPool {
-    private strings;
-    private stringMap;
-    private ascii;
-    intern(char: string): number;
-    get(index: number): string;
-}
-export declare class HyperlinkPool {
-    private strings;
-    private stringMap;
-    intern(hyperlink: string | undefined): number;
-    get(id: number): string | undefined;
-}
-export declare class StylePool {
-    private ids;
-    private styles;
-    private transitionCache;
-    readonly none: number;
-    constructor();
-    /**
-     * Intern a style and return its ID. Bit 0 of the ID encodes whether the
-     * style has a visible effect on space characters (background, inverse,
-     * underline, etc.). Foreground-only styles get even IDs; styles visible
-     * on spaces get odd IDs. This lets the renderer skip invisible spaces
-     * with a single bitmask check on the packed word.
-     */
-    intern(styles: AnsiCode[]): number;
-    /** Recover styles from an encoded ID. Strips the bit-0 flag via >>> 1. */
-    get(id: number): AnsiCode[];
-    /**
-     * Returns the pre-serialized ANSI string to transition from one style to
-     * another. Cached by (fromId, toId) — zero allocations after first call
-     * for a given pair.
-     */
-    transition(fromId: number, toId: number): string;
-    /**
-     * Intern a style that is `base + inverse`. Cached by base ID so
-     * repeated calls for the same underlying style don't re-scan the
-     * AnsiCode[] array. Used by the selection overlay.
-     */
-    private inverseCache;
-    withInverse(baseId: number): number;
-    /** Inverse + bold + yellow-bg-via-fg-swap for the CURRENT search match.
-     *  OTHER matches are plain inverse — bg inherits from the theme. Current
-     *  gets a distinct yellow bg (via fg-then-inverse swap) plus bold weight
-     *  so it stands out in a sea of inverse. Underline was too subtle. Zero
-     *  reflow risk: all pure SGR overlays, per-cell, post-layout. The yellow
-     *  overrides any existing fg (syntax highlighting) on those cells — fine,
-     *  the "you are here" signal IS the point, syntax color can yield. */
-    private currentMatchCache;
-    withCurrentMatch(baseId: number): number;
-    /**
-     * Selection overlay: REPLACE the cell's background with a solid color
-     * while preserving its foreground (color, bold, italic, dim, underline).
-     * Matches native terminal selection — a dedicated bg color, not SGR-7
-     * inverse. Inverse swaps fg/bg per-cell, which fragments visually over
-     * syntax-highlighted text (every fg color becomes a different bg stripe).
-     *
-     * Strips any existing bg (endCode 49m — REPLACES, so diff-added green
-     * etc. don't bleed through) and any existing inverse (endCode 27m —
-     * inverse on top of a solid bg would re-swap and look wrong).
-     *
-     * bg is set via setSelectionBg(); null → fallback to withInverse() so the
-     * overlay still works before theme wiring sets a color (tests, first frame).
-     * Cache is keyed by baseId only — setSelectionBg() clears it on change.
-     */
-    private selectionBgCode;
-    private selectionBgCache;
-    setSelectionBg(bg: AnsiCode | null): void;
-    withSelectionBg(baseId: number): number;
-}
-/**
- * Cell width classification for handling double-wide characters (CJK, emoji,
- * etc.)
- *
- * We use explicit spacer cells rather than inferring width at render time. This
- * makes the data structure self-describing and simplifies cursor positioning
- * logic.
- *
- * @see https://mitchellh.com/writing/grapheme-clusters-in-terminals
- */
-export declare const enum CellWidth {
-    Narrow = 0,
-    Wide = 1,
-    SpacerTail = 2,
-    SpacerHead = 3
-}
-export type Hyperlink = string | undefined;
-/**
- * Cell is a view type returned by cellAt(). Cells are stored as packed typed
- * arrays internally to avoid GC pressure from allocating objects per cell.
- */
-export type Cell = {
-    char: string;
-    styleId: number;
-    width: CellWidth;
-    hyperlink: Hyperlink;
-};
-/**
- * Screen uses a packed Int32Array instead of Cell objects to eliminate GC
- * pressure. For a 200x120 screen, this avoids allocating 24,000 objects.
- *
- * Cell data is stored as 2 Int32s per cell in a single contiguous array:
- *   word0: charId (full 32 bits — index into CharPool)
- *   word1: styleId[31:17] | hyperlinkId[16:2] | width[1:0]
- *
- * This layout halves memory accesses in diffEach (2 int loads vs 4) and
- * enables future SIMD comparison via Bun.indexOfFirstDifference.
- */
-export type Screen = Size & {
-    cells: Int32Array;
-    cells64: BigInt64Array;
-    charPool: CharPool;
-    hyperlinkPool: HyperlinkPool;
-    emptyStyleId: number;
-    /**
-     * Bounding box of cells that were written to (not blitted) during rendering.
-     * Used by diff() to limit iteration to only the region that could have changed.
-     */
-    damage: Rectangle | undefined;
-    /**
-     * Per-cell noSelect bitmap — 1 byte per cell, 1 = exclude from text
-     * selection (copy + highlight). Used by <NoSelect> to mark gutters
-     * (line numbers, diff sigils) so click-drag over a diff yields clean
-     * copyable code. Fully reset each frame in resetScreen; blitRegion
-     * copies it alongside cells so the blit optimization preserves marks.
-     */
-    noSelect: Uint8Array;
-    /**
-     * Per-ROW soft-wrap continuation marker. softWrap[r]=N>0 means row r
-     * is a word-wrap continuation of row r-1 (the `\n` before it was
-     * inserted by wrapAnsi, not in the source), and row r-1's written
-     * content ends at absolute column N (exclusive — cells [0..N) are the
-     * fragment, past N is unwritten padding). 0 means row r is NOT a
-     * continuation (hard newline or first row). Selection copy checks
-     * softWrap[r]>0 to join row r onto row r-1 without a newline, and
-     * reads softWrap[r+1] to know row r's content end when row r+1
-     * continues from it. The content-end column is needed because an
-     * unwritten cell and a written-unstyled-space are indistinguishable in
-     * the packed typed array (both all-zero) — without it we'd either drop
-     * the word-separator space (trim) or include trailing padding (no
-     * trim). This encoding (continuation-on-self, prev-content-end-here)
-     * is chosen so shiftRows preserves the is-continuation semantics: when
-     * row r scrolls off the top and row r+1 shifts to row r, sw[r] gets
-     * old sw[r+1] — which correctly says the new row r is a continuation
-     * of what's now in scrolledOffAbove. Reset each frame; copied by
-     * blitRegion/shiftRows.
-     */
-    softWrap: Int32Array;
-};
-export declare function isEmptyCellAt(screen: Screen, x: number, y: number): boolean;
-/**
- * Check if a Cell (view object) represents an empty cell.
- */
-export declare function isCellEmpty(screen: Screen, cell: Cell): boolean;
-export declare function createScreen(width: number, height: number, styles: StylePool, charPool: CharPool, hyperlinkPool: HyperlinkPool): Screen;
-/**
- * Reset an existing screen for reuse, avoiding allocation of new typed arrays.
- * Resizes if needed and clears all cells to empty/unwritten state.
- *
- * For double-buffering, this allows swapping between front and back buffers
- * without allocating new Screen objects each frame.
- */
-export declare function resetScreen(screen: Screen, width: number, height: number): void;
-/**
- * Re-intern a screen's char and hyperlink IDs into new pools.
- * Used for generational pool reset — after migrating, the screen's
- * typed arrays contain valid IDs for the new pools, and the old pools
- * can be GC'd.
- *
- * O(width * height) but only called occasionally (e.g., between conversation turns).
- */
-export declare function migrateScreenPools(screen: Screen, charPool: CharPool, hyperlinkPool: HyperlinkPool): void;
-/**
- * Get a Cell view at the given position. Returns a new object each call -
- * this is intentional as cells are stored packed, not as objects.
- */
-export declare function cellAt(screen: Screen, x: number, y: number): Cell | undefined;
-/**
- * Get a Cell view by pre-computed array index. Skips bounds checks and
- * index computation — caller must ensure index is valid.
- */
-export declare function cellAtIndex(screen: Screen, index: number): Cell;
-/**
- * Get a Cell at the given index, or undefined if it has no visible content.
- * Returns undefined for spacer cells (charId 1), empty unstyled spaces, and
- * fg-only styled spaces that match lastRenderedStyleId (cursor-forward
- * produces an identical visual result, avoiding a Cell allocation).
- *
- * @param lastRenderedStyleId - styleId of the last rendered cell on this
- *   line, or -1 if none yet.
- */
-export declare function visibleCellAtIndex(cells: Int32Array, charPool: CharPool, hyperlinkPool: HyperlinkPool, index: number, lastRenderedStyleId: number): Cell | undefined;
-export declare function charInCellAt(screen: Screen, x: number, y: number): string | undefined;
-/**
- * Set a cell, optionally creating a spacer for wide characters.
- *
- * Wide characters (CJK, emoji) occupy 2 cells in the buffer:
- * 1. First cell: Contains the actual character with width = Wide
- * 2. Second cell: Spacer cell with width = SpacerTail (empty, not rendered)
- *
- * If the cell has width = Wide, this function automatically creates the
- * corresponding SpacerTail in the next column. This two-cell model keeps
- * the buffer aligned to visual columns, making cursor positioning
- * straightforward.
- *
- * TODO: When soft-wrapping is implemented, SpacerHead cells will be explicitly
- * placed by the wrapping logic at line-end positions where wide characters
- * wrap to the next line. This function doesn't need to handle SpacerHead
- * automatically - it will be set directly by the wrapping code.
- */
-export declare function setCellAt(screen: Screen, x: number, y: number, cell: Cell): void;
-/**
- * Replace the styleId of a cell in-place without disturbing char, width,
- * or hyperlink. Preserves empty cells as-is (char stays ' '). Tracks damage
- * for the cell so diffEach picks up the change.
- */
-export declare function setCellStyleId(screen: Screen, x: number, y: number, styleId: number): void;
-/**
- * Bulk-copy a rectangular region from src to dst using TypedArray.set().
- * Single cells.set() call per row (or one call for contiguous blocks).
- * Damage is computed once for the whole region.
- *
- * Clamps negative regionX/regionY to 0 (matching clearRegion) — absolute-
- * positioned overlays in tiny terminals can compute negative screen coords.
- * maxX/maxY should already be clamped to both screen bounds by the caller.
- */
-export declare function blitRegion(dst: Screen, src: Screen, regionX: number, regionY: number, maxX: number, maxY: number): void;
-/**
- * Bulk-clear a rectangular region of the screen.
- * Uses BigInt64Array.fill() for fast row clears.
- * Handles wide character boundary cleanup at region edges.
- */
-export declare function clearRegion(screen: Screen, regionX: number, regionY: number, regionWidth: number, regionHeight: number): void;
-/**
- * Shift full-width rows within [top, bottom] (inclusive, 0-indexed) by n.
- * n > 0 shifts UP (simulating CSI n S); n < 0 shifts DOWN (CSI n T).
- * Vacated rows are cleared. Does NOT update damage. Both cells and the
- * noSelect bitmap are shifted so text-selection markers stay aligned when
- * this is applied to next.screen during scroll fast path.
- */
-export declare function shiftRows(screen: Screen, top: number, bottom: number, n: number): void;
-export declare const OSC8_PREFIX = "\u001B]8;";
-export declare function extractHyperlinkFromStyles(styles: AnsiCode[]): Hyperlink | null;
-export declare function filterOutHyperlinkStyles(styles: AnsiCode[]): AnsiCode[];
-/**
- * Returns an array of all changes between two screens. Used by tests.
- * Production code should use diffEach() to avoid allocations.
- */
-export declare function diff(prev: Screen, next: Screen): [point: Point, removed: Cell | undefined, added: Cell | undefined][];
-type DiffCallback = (x: number, y: number, removed: Cell | undefined, added: Cell | undefined) => boolean | void;
-/**
- * Like diff(), but calls a callback for each change instead of building an array.
- * Reuses two Cell objects to avoid per-change allocations. The callback must not
- * retain references to the Cell objects — their contents are overwritten each call.
- *
- * Returns true if the callback ever returned true (early exit signal).
- */
-export declare function diffEach(prev: Screen, next: Screen, cb: DiffCallback): boolean;
-/**
- * Mark a rectangular region as noSelect (exclude from text selection).
- * Clamps to screen bounds. Called from output.ts when a <NoSelect> box
- * renders. No damage tracking — noSelect doesn't affect terminal output,
- * only getSelectedText/applySelectionOverlay which read it directly.
- */
-export declare function markNoSelectRegion(screen: Screen, x: number, y: number, width: number, height: number): void;
-export {};

package/dist/render/searchHighlight.d.ts

@@ -1,20 +0,0 @@
-import { type Screen, type StylePool } from './screen.js';
-/**
- * Highlight all visible occurrences of `query` in the screen buffer by
- * inverting cell styles (SGR 7). Post-render, same damage-tracking machinery
- * as applySelectionOverlay — the diff picks up highlighted cells as ordinary
- * changes, LogUpdate stays a pure diff engine.
- *
- * Case-insensitive. Handles wide characters (CJK, emoji) by building a
- * col-of-char map per row — the Nth character isn't at col N when wide chars
- * are present (each occupies 2 cells: head + SpacerTail).
- *
- * This ONLY inverts — there is no "current match" logic here. The yellow
- * current-match overlay is handled separately by applyPositionedHighlight
- * (render-to-screen.ts), which writes on top using positions scanned from
- * the target message's DOM subtree.
- *
- * Returns true if any match was highlighted (damage gate — caller forces
- * full-frame damage when true).
- */
-export declare function applySearchHighlight(screen: Screen, query: string, stylePool: StylePool): boolean;

package/dist/render/selection.d.ts

@@ -1,229 +0,0 @@
-/**
- * Text selection state for fullscreen mode.
- *
- * Tracks a linear selection in screen-buffer coordinates (0-indexed col/row).
- * Selection is line-based: cells from (startCol, startRow) through
- * (endCol, endRow) inclusive, wrapping across line boundaries. This matches
- * terminal-native selection behavior (not rectangular/block).
- *
- * The selection is stored as ANCHOR (where the drag started) + FOCUS (where
- * the cursor is now). The rendered highlight normalizes to start ≤ end.
- */
-import type { Screen, StylePool } from './screen.js';
-type Point = {
-    col: number;
-    row: number;
-};
-export type SelectionState = {
-    /** Where the mouse-down occurred. Null when no selection. */
-    anchor: Point | null;
-    /** Current drag position (updated on mouse-move while dragging). */
-    focus: Point | null;
-    /** True between mouse-down and mouse-up. */
-    isDragging: boolean;
-    /** For word/line mode: the initial word/line bounds from the first
-     *  multi-click. Drag extends from this span to the word/line at the
-     *  current mouse position so the original word/line stays selected
-     *  even when dragging backward past it. Null ⇔ char mode. The kind
-     *  tells extendSelection whether to snap to word or line boundaries. */
-    anchorSpan: {
-        lo: Point;
-        hi: Point;
-        kind: 'word' | 'line';
-    } | null;
-    /** Text from rows that scrolled out ABOVE the viewport during
-     *  drag-to-scroll. The screen buffer only holds the current viewport,
-     *  so without this accumulator, dragging down past the bottom edge
-     *  loses the top of the selection once the anchor clamps. Prepended
-     *  to the on-screen text by getSelectedText. Reset on start/clear. */
-    scrolledOffAbove: string[];
-    /** Symmetric: rows scrolled out BELOW when dragging up. Appended. */
-    scrolledOffBelow: string[];
-    /** Soft-wrap bits parallel to scrolledOffAbove — true means the row
-     *  is a continuation of the one before it (the `\n` was inserted by
-     *  word-wrap, not in the source). Captured alongside the text at
-     *  scroll time since the screen's softWrap bitmap shifts with content.
-     *  getSelectedText uses these to join wrapped rows back into logical
-     *  lines. */
-    scrolledOffAboveSW: boolean[];
-    /** Parallel to scrolledOffBelow. */
-    scrolledOffBelowSW: boolean[];
-    /** Pre-clamp anchor row. Set when shiftSelection clamps anchor so a
-     *  reverse scroll can restore the true position and pop accumulators.
-     *  Without this, PgDn (clamps anchor) → PgUp leaves anchor at the wrong
-     *  row AND scrolledOffAbove stale — highlight ≠ copy. Undefined when
-     *  anchor is in-bounds (no clamp debt). Cleared on start/clear. */
-    virtualAnchorRow?: number;
-    /** Same for focus. */
-    virtualFocusRow?: number;
-    /** True if the mouse-down that started this selection had the alt
-     *  modifier set (SGR button bit 0x08). On macOS xterm.js this is a
-     *  signal that VS Code's macOptionClickForcesSelection is OFF — if it
-     *  were on, xterm.js would have consumed the event for native selection
-     *  and we'd never receive it. Used by the footer to show the right hint. */
-    lastPressHadAlt: boolean;
-};
-export declare function createSelectionState(): SelectionState;
-export declare function startSelection(s: SelectionState, col: number, row: number): void;
-export declare function updateSelection(s: SelectionState, col: number, row: number): void;
-export declare function finishSelection(s: SelectionState): void;
-export declare function clearSelection(s: SelectionState): void;
-/**
- * Select the word at (col, row) by scanning the screen buffer for the
- * bounds of the same-class character run. Mutates the selection in place.
- * No-op if the click is out of bounds or lands on a noSelect cell.
- * Sets isDragging=true and anchorSpan so a subsequent drag extends the
- * selection word-by-word (native macOS behavior).
- */
-export declare function selectWordAt(s: SelectionState, screen: Screen, col: number, row: number): void;
-/**
- * Scan the screen buffer for a plain-text URL at (col, row). Mirrors the
- * terminal's native Cmd+Click URL detection, which fullscreen mode's mouse
- * tracking intercepts. Called from getHyperlinkAt as a fallback when the
- * cell has no OSC 8 hyperlink.
- */
-export declare function findPlainTextUrlAt(screen: Screen, col: number, row: number): string | undefined;
-/**
- * Select the entire row. Sets isDragging=true and anchorSpan so a
- * subsequent drag extends the selection line-by-line. The anchor/focus
- * span from col 0 to width-1; getSelectedText handles noSelect skipping
- * and trailing-whitespace trimming so the copied text is just the visible
- * line content.
- */
-export declare function selectLineAt(s: SelectionState, screen: Screen, row: number): void;
-/**
- * Extend a word/line-mode selection to the word/line at (col, row). The
- * anchor span (the original multi-clicked word/line) stays selected; the
- * selection grows from that span to the word/line at the current mouse
- * position. Word mode falls back to the raw cell when the mouse is over a
- * noSelect cell or out of bounds, so dragging into gutters still extends.
- */
-export declare function extendSelection(s: SelectionState, screen: Screen, col: number, row: number): void;
-/** Semantic keyboard focus moves. See moveSelectionFocus in ink.tsx for
- *  how screen bounds + row-wrap are applied. */
-export type FocusMove = 'left' | 'right' | 'up' | 'down' | 'lineStart' | 'lineEnd';
-/**
- * Set focus to (col, row) for keyboard selection extension (shift+arrow).
- * Anchor stays fixed; selection grows or shrinks depending on where focus
- * moves relative to anchor. Drops to char mode (clears anchorSpan) —
- * native macOS does this too: shift+arrow after a double-click word-select
- * extends char-by-char from the word edge, not word-by-word. Scrolled-off
- * accumulators are preserved: keyboard-extending a drag-scrolled selection
- * keeps the off-screen rows. Caller supplies coords already clamped/wrapped.
- */
-export declare function moveFocus(s: SelectionState, col: number, row: number): void;
-/**
- * Shift anchor AND focus by dRow, clamped to [minRow, maxRow]. Used for
- * keyboard scroll (PgUp/PgDn/ctrl+u/d/b/f): the whole selection must track
- * the content, unlike drag-to-scroll where focus stays at the mouse. Any
- * point that hits a clamp bound gets its col reset to the full-width edge —
- * its original content scrolled off-screen and was captured by
- * captureScrolledRows, so the col constraint was already consumed. Keeping
- * it would truncate the NEW content now at that screen row. Clamp col is 0
- * for dRow<0 (scrolling down, top leaves, 'above' semantics) or width-1 for
- * dRow>0 (scrolling up, bottom leaves, 'below' semantics).
- *
- * If both ends overshoot the SAME viewport edge (select text → Home/End/g/G
- * jumps far enough that both are out of view), clear — otherwise both clamp
- * to the same corner cell and a ghost 1-cell highlight lingers, and
- * getSelectedText returns one unrelated char from that corner. Symmetric
- * with shiftSelectionForFollow's top-edge check, but bidirectional: keyboard
- * scroll can jump either way.
- */
-export declare function shiftSelection(s: SelectionState, dRow: number, minRow: number, maxRow: number, width: number): void;
-/**
- * Shift the anchor row by dRow, clamped to [minRow, maxRow]. Used during
- * drag-to-scroll: when the ScrollBox scrolls by N rows, the content that
- * was under the anchor is now at a different viewport row, so the anchor
- * must follow it. Focus is left unchanged (it stays at the mouse position).
- */
-export declare function shiftAnchor(s: SelectionState, dRow: number, minRow: number, maxRow: number): void;
-/**
- * Shift the whole selection (anchor + focus + anchorSpan) by dRow, clamped
- * to [minRow, maxRow]. Used when sticky/auto-follow scrolls the ScrollBox
- * while a selection is active — native terminal behavior is for the
- * highlight to walk up the screen with the text (not stay at the same
- * screen position).
- *
- * Differs from shiftAnchor: during drag-to-scroll, focus tracks the live
- * mouse position and only anchor follows the text. During streaming-follow,
- * the selection is text-anchored at both ends — both must move. The
- * isDragging check in ink.tsx picks which shift to apply.
- *
- * If both ends would shift strictly BELOW minRow (unclamped), the selected
- * text has scrolled entirely off the top. Clear it — otherwise a single
- * inverted cell lingers at the viewport top as a ghost (native terminals
- * drop the selection when it leaves scrollback). Landing AT minRow is
- * still valid: that cell holds the correct text. Returns true if the
- * selection was cleared so the caller can notify React-land subscribers
- * (useHasSelection) — the caller is inside onRender so it can't use
- * notifySelectionChange (recursion), must fire listeners directly.
- */
-export declare function shiftSelectionForFollow(s: SelectionState, dRow: number, minRow: number, maxRow: number): boolean;
-export declare function hasSelection(s: SelectionState): boolean;
-/**
- * Normalized selection bounds: start is always before end in reading order.
- * Returns null if no active selection.
- */
-export declare function selectionBounds(s: SelectionState): {
-    start: {
-        col: number;
-        row: number;
-    };
-    end: {
-        col: number;
-        row: number;
-    };
-} | null;
-/**
- * Check if a cell at (col, row) is within the current selection range.
- * Used by the renderer to apply inverse style.
- */
-export declare function isCellSelected(s: SelectionState, col: number, row: number): boolean;
-/**
- * Extract text from the screen buffer within the selection range.
- * Rows are joined with newlines unless the screen's softWrap bitmap
- * marks a row as a word-wrap continuation — those rows are concatenated
- * onto the previous row so the copied text matches the logical source
- * line, not the visual wrapped layout. Trailing whitespace on the last
- * fragment of each logical line is trimmed. Wide-char spacer cells are
- * skipped. Rows that scrolled out of the viewport during drag-to-scroll
- * are joined back in from the scrolledOffAbove/Below accumulators along
- * with their captured softWrap bits.
- */
-export declare function getSelectedText(s: SelectionState, screen: Screen): string;
-/**
- * Capture text from rows about to scroll out of the viewport during
- * drag-to-scroll, BEFORE scrollBy overwrites them. Only the rows that
- * intersect the selection are captured, using the selection's col bounds
- * for the anchor-side boundary row. After capturing the anchor row, the
- * anchor.col AND anchorSpan cols are reset to the full-width boundary so
- * subsequent captures and the final getSelectedText don't re-apply a stale
- * col constraint to content that's no longer under the original anchor.
- * Both span cols are reset (not just the near side): after a blocked
- * reversal the drag can flip direction, and extendSelection then reads the
- * OPPOSITE span side — which would otherwise still hold the original word
- * boundary and truncate one subsequently-captured row.
- *
- * side='above': rows scrolling out the top (dragging down, anchor=start).
- * side='below': rows scrolling out the bottom (dragging up, anchor=end).
- */
-export declare function captureScrolledRows(s: SelectionState, screen: Screen, firstRow: number, lastRow: number, side: 'above' | 'below'): void;
-/**
- * Apply the selection overlay directly to the screen buffer by changing
- * the style of every cell in the selection range. Called after the
- * renderer produces the Frame but before the diff — the normal diffEach
- * then picks up the restyled cells as ordinary changes, so LogUpdate
- * stays a pure diff engine with no selection awareness.
- *
- * Uses a SOLID selection background (theme-provided via StylePool.
- * setSelectionBg) that REPLACES each cell's bg while PRESERVING its fg —
- * matches native terminal selection. Previously SGR-7 inverse (swapped
- * fg/bg per cell), which fragmented badly over syntax-highlighted text:
- * every distinct fg color became a different bg stripe.
- *
- * Uses StylePool caches so on drag the only work per cell is a Map
- * lookup + packed-int write.
- */
-export declare function applySelectionOverlay(screen: Screen, selection: SelectionState, stylePool: StylePool): void;
-export {};

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

@@ -1,22 +0,0 @@
-import type { DOMElement } from './dom.js';
-import type { TextStyles } from './styles.js';
-/**
- * A segment of text with its associated styles.
- * Used for structured rendering without ANSI string transforms.
- */
-export type StyledSegment = {
-    text: string;
-    styles: TextStyles;
-    hyperlink?: string;
-};
-/**
- * Squash text nodes into styled segments, propagating styles down through the tree.
- * This allows structured styling without relying on ANSI string transforms.
- */
-export declare function squashTextNodesToSegments(node: DOMElement, inheritedStyles?: TextStyles, inheritedHyperlink?: string, out?: StyledSegment[]): StyledSegment[];
-/**
- * Squash text nodes into a plain string (without styles).
- * Used for text measurement in layout calculations.
- */
-declare function squashTextNodes(node: DOMElement): string;
-export default squashTextNodes;

package/dist/render/stringWidth.d.ts

@@ -1 +0,0 @@
-export declare const stringWidth: (str: string) => number;