ink-prompt 0.2.2 → 0.2.4

package/README.md

@@ -46,7 +46,7 @@ render(<App />);
 | `onBoundaryArrow` | `(direction: 'up' \| 'down' \| 'left' \| 'right') => void` | | Called when arrow key reaches a boundary |
 | `undoDebounceMs` | `number` | `200` | Milliseconds of inactivity to commit undo batch (`0` = disable) |
 | `pasteThreshold` | `number` | | Max paste length before text is replaced by a placeholder |
-| `formatPastePlaceholder` | `(id: number) => string` | | Custom placeholder display format |
+| `formatPastePlaceholder` | `(displayNumber: number) => string` | | Custom placeholder display format (1-based) |
 | `enableImagePaste` | `boolean` | `false` | Enables image-aware Ctrl+V handling |
 | `images` | `ImageRef[]` | | Controlled image state for pasted images |
 | `onImagesChange` | `(images: ImageRef[]) => void` | | Called when images change |
@@ -77,7 +77,7 @@ replace the pasted content with a compact placeholder for cleaner display.
 <MultilineInput
   onSubmit={(value) => console.log(value)}
   pasteThreshold={200}            // Text >200 chars becomes a placeholder
-  formatPastePlaceholder={(id) => `[Pasted block #${id}]`}  // Optional formatter
+  formatPastePlaceholder={(n) => `[Pasted block #${n}]`}  // Optional formatter
 />
 ```
 

package/dist/components/MultilineInput/AtomicBlocks.d.ts

@@ -1,25 +1,15 @@
-import type { PlaceholderInfo } from './types.js';
-export type AtomicBlock = {
-    kind: 'sentinel';
+import type { BlockEntry, BlockKind } from './BlockTypes.js';
+export interface AtomicBlock {
+    kind: BlockKind;
     id: string;
-    displayNumber: number;
     start: number;
     end: number;
     displayWidth: number;
     displayText: string;
-} | {
-    kind: 'placeholder';
-    id: number;
-    start: number;
-    end: number;
-    displayWidth: number;
-    displayText: string;
-};
-export type Placeholders = Map<number, PlaceholderInfo> | undefined;
-export declare function findAtomicBlocks(line: string, placeholders?: Placeholders): AtomicBlock[];
-/** Block that strictly contains offset (offset > start && offset < end) — cursor is in the interior. */
-export declare function findAtomicBlockSpanning(line: string, offset: number, placeholders?: Placeholders): AtomicBlock | null;
-/** Block whose end === offset (the block immediately to the left of the cursor). */
-export declare function findAtomicBlockBefore(line: string, offset: number, placeholders?: Placeholders): AtomicBlock | null;
-/** Block whose start === offset (the block immediately to the right of the cursor). */
-export declare function findAtomicBlockAfter(line: string, offset: number, placeholders?: Placeholders): AtomicBlock | null;
+    dim: boolean;
+}
+export type BlockEntries = Map<string, BlockEntry> | undefined;
+export declare function findAtomicBlocks(line: string, entries?: BlockEntries): AtomicBlock[];
+export declare function findAtomicBlockSpanning(line: string, offset: number, entries?: BlockEntries): AtomicBlock | null;
+export declare function findAtomicBlockBefore(line: string, offset: number, entries?: BlockEntries): AtomicBlock | null;
+export declare function findAtomicBlockAfter(line: string, offset: number, entries?: BlockEntries): AtomicBlock | null;

package/dist/components/MultilineInput/AtomicBlocks.js

@@ -1,58 +1,49 @@
-import { parseSentinels, getPlaceholderText } from './ImageSentinel.js';
-import { MARKER_REGEX } from './Placeholder.js';
-export function findAtomicBlocks(line, placeholders) {
-    const blocks = [];
-    for (const s of parseSentinels(line)) {
-        const displayText = getPlaceholderText(s.displayNumber);
-        blocks.push({
-            kind: 'sentinel',
-            id: s.id,
-            displayNumber: s.displayNumber,
-            start: s.start,
-            end: s.end,
-            displayWidth: displayText.length,
-            displayText,
-        });
-    }
-    if (placeholders && placeholders.size > 0) {
-        MARKER_REGEX.lastIndex = 0;
-        let m;
-        while ((m = MARKER_REGEX.exec(line)) !== null) {
-            const id = Number(m[1]);
-            const info = placeholders.get(id);
-            const displayText = info ? info.displayText : '';
-            blocks.push({
-                kind: 'placeholder',
-                id,
-                start: m.index,
-                end: m.index + m[0].length,
-                displayWidth: displayText.length,
-                displayText,
-            });
+import { parseBlockMarkers } from './BlockMarker.js';
+function getDisplayInfo(marker, entries) {
+    if (entries) {
+        const entry = entries.get(marker.id);
+        if (entry && entry.kind === 'paste') {
+            return { displayWidth: entry.displayText.length, displayText: entry.displayText };
         }
     }
-    blocks.sort((a, b) => a.start - b.start);
-    return blocks;
+    if (marker.kind === 'p') {
+        const text = `[Paste text #${marker.displayNumber}]`;
+        return { displayWidth: text.length, displayText: text };
+    }
+    const text = `[Pasted Image #${marker.displayNumber}]`;
+    return { displayWidth: text.length, displayText: text };
+}
+export function findAtomicBlocks(line, entries) {
+    const markers = parseBlockMarkers(line);
+    return markers.map((m) => {
+        const { displayWidth, displayText } = getDisplayInfo(m, entries);
+        return {
+            kind: m.kind === 'p' ? 'paste' : 'image',
+            id: m.id,
+            start: m.start,
+            end: m.end,
+            displayWidth,
+            displayText,
+            dim: m.kind === 'i',
+        };
+    });
 }
-/** Block that strictly contains offset (offset > start && offset < end) — cursor is in the interior. */
-export function findAtomicBlockSpanning(line, offset, placeholders) {
-    for (const b of findAtomicBlocks(line, placeholders)) {
+export function findAtomicBlockSpanning(line, offset, entries) {
+    for (const b of findAtomicBlocks(line, entries)) {
         if (offset > b.start && offset < b.end)
             return b;
     }
     return null;
 }
-/** Block whose end === offset (the block immediately to the left of the cursor). */
-export function findAtomicBlockBefore(line, offset, placeholders) {
-    for (const b of findAtomicBlocks(line, placeholders)) {
+export function findAtomicBlockBefore(line, offset, entries) {
+    for (const b of findAtomicBlocks(line, entries)) {
         if (b.end === offset)
             return b;
     }
     return null;
 }
-/** Block whose start === offset (the block immediately to the right of the cursor). */
-export function findAtomicBlockAfter(line, offset, placeholders) {
-    for (const b of findAtomicBlocks(line, placeholders)) {
+export function findAtomicBlockAfter(line, offset, entries) {
+    for (const b of findAtomicBlocks(line, entries)) {
         if (b.start === offset)
             return b;
     }

package/dist/components/MultilineInput/BlockMarker.d.ts

@@ -0,0 +1,19 @@
+export declare const BLOCK_OPEN = "\uE000";
+export declare const BLOCK_CLOSE = "\uE001";
+export type BlockMarkerKind = 'p' | 'i';
+export interface BlockMarkerInfo {
+    kind: BlockMarkerKind;
+    id: string;
+    displayNumber: number;
+    start: number;
+    end: number;
+}
+export declare function generateBlockId(): string;
+export declare function createBlockMarker(kind: BlockMarkerKind, id: string, displayNumber: number): string;
+export declare function parseBlockMarkers(text: string): BlockMarkerInfo[];
+export declare function findBlockMarkerAt(text: string, offset: number): BlockMarkerInfo | null;
+export declare function findBlockMarkerBefore(text: string, offset: number): BlockMarkerInfo | null;
+export declare function findBlockMarkerAfter(text: string, offset: number): BlockMarkerInfo | null;
+export declare function removeBlockMarker(text: string, offset: number): string;
+export declare function blockMarkerVisualWidth(displayNumber: number): number;
+export declare function getBlockPlaceholderText(kind: BlockMarkerKind, displayNumber: number): string;

package/dist/components/MultilineInput/BlockMarker.js

@@ -0,0 +1,83 @@
+export const BLOCK_OPEN = '\uE000';
+export const BLOCK_CLOSE = '\uE001';
+export function generateBlockId() {
+    return Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 6);
+}
+export function createBlockMarker(kind, id, displayNumber) {
+    return `${BLOCK_OPEN}${kind}:${id}:${displayNumber}${BLOCK_CLOSE}`;
+}
+export function parseBlockMarkers(text) {
+    const result = [];
+    let i = 0;
+    while (i < text.length) {
+        const openIdx = text.indexOf(BLOCK_OPEN, i);
+        if (openIdx === -1)
+            break;
+        const closeIdx = text.indexOf(BLOCK_CLOSE, openIdx + 1);
+        if (closeIdx === -1)
+            break;
+        const raw = text.substring(openIdx + 1, closeIdx);
+        const kindChar = raw[0];
+        if (kindChar !== 'p' && kindChar !== 'i') {
+            i = closeIdx + 1;
+            continue;
+        }
+        const rest = raw.substring(2);
+        const colonIdx = rest.lastIndexOf(':');
+        if (colonIdx === -1) {
+            i = closeIdx + 1;
+            continue;
+        }
+        const id = rest.substring(0, colonIdx);
+        const displayNumber = parseInt(rest.substring(colonIdx + 1), 10);
+        if (isNaN(displayNumber)) {
+            i = closeIdx + 1;
+            continue;
+        }
+        result.push({
+            kind: kindChar,
+            id,
+            displayNumber,
+            start: openIdx,
+            end: closeIdx + 1,
+        });
+        i = closeIdx + 1;
+    }
+    return result;
+}
+export function findBlockMarkerAt(text, offset) {
+    for (const m of parseBlockMarkers(text)) {
+        if (offset > m.start && offset < m.end)
+            return m;
+    }
+    return null;
+}
+export function findBlockMarkerBefore(text, offset) {
+    for (const m of parseBlockMarkers(text)) {
+        if (m.end === offset)
+            return m;
+    }
+    return null;
+}
+export function findBlockMarkerAfter(text, offset) {
+    for (const m of parseBlockMarkers(text)) {
+        if (m.start === offset)
+            return m;
+    }
+    return null;
+}
+export function removeBlockMarker(text, offset) {
+    const marker = findBlockMarkerAt(text, offset);
+    if (!marker)
+        return text;
+    return text.slice(0, marker.start) + text.slice(marker.end);
+}
+export function blockMarkerVisualWidth(displayNumber) {
+    return getBlockPlaceholderText('i', displayNumber).length;
+}
+export function getBlockPlaceholderText(kind, displayNumber) {
+    if (kind === 'i') {
+        return `[Pasted Image #${displayNumber}]`;
+    }
+    return `[Paste text #${displayNumber}]`;
+}

package/dist/components/MultilineInput/BlockRegistry.d.ts

@@ -0,0 +1,39 @@
+import type { BlockEntry, BlockState } from './BlockTypes.js';
+import { type BlockMarkerKind } from './BlockMarker.js';
+import type { ImageRef } from './ImageTypes.js';
+export declare function createBlockState(): BlockState;
+export declare function createPasteBlockEntry(state: BlockState, originalText: string, displayText: string): {
+    id: string;
+    marker: string;
+    state: BlockState;
+};
+export declare function createImageBlockEntry(state: BlockState, imageRef: ImageRef, id?: string): {
+    id: string;
+    marker: string;
+    state: BlockState;
+};
+export declare function removeBlock(state: BlockState, id: string): BlockState;
+export declare function getBlock(state: BlockState, id: string): BlockEntry | undefined;
+export declare function getDisplayLine(line: string, entries: Map<string, BlockEntry>): string;
+export declare function getValue(lines: string[], entries: Map<string, BlockEntry>): string;
+export declare function bufferColToDisplayCol(line: string, column: number, entries: Map<string, BlockEntry>): number;
+export declare function displayColToBufferCol(line: string, displayColumn: number, entries: Map<string, BlockEntry>): number;
+export declare function getExpandedLineLength(line: string, entries: Map<string, BlockEntry>): number;
+export declare function getValueCursorOffset(lines: string[], cursor: {
+    line: number;
+    column: number;
+}, entries: Map<string, BlockEntry>): number;
+export declare function getCursorFromValueOffset(lines: string[], offset: number, entries: Map<string, BlockEntry>): {
+    line: number;
+    column: number;
+};
+export declare function getDisplayWidthForMarker(m: {
+    kind: BlockMarkerKind;
+    id: string;
+    displayNumber: number;
+}, entries: Map<string, BlockEntry>): number;
+export declare function getDisplayTextForMarker(m: {
+    kind: BlockMarkerKind;
+    id: string;
+    displayNumber: number;
+}, entries: Map<string, BlockEntry>): string;

package/dist/components/MultilineInput/BlockRegistry.js

@@ -0,0 +1,236 @@
+import { createBlockMarker, generateBlockId, parseBlockMarkers, } from './BlockMarker.js';
+export function createBlockState() {
+    return { entries: new Map(), nextPasteNumber: 1, nextImageNumber: 1 };
+}
+export function createPasteBlockEntry(state, originalText, displayText) {
+    const id = generateBlockId();
+    const displayNumber = state.nextPasteNumber;
+    const marker = createBlockMarker('p', id, displayNumber);
+    const newEntries = new Map(state.entries);
+    newEntries.set(id, { kind: 'paste', id, displayNumber, originalText, displayText });
+    return {
+        id,
+        marker,
+        state: { entries: newEntries, nextPasteNumber: displayNumber + 1, nextImageNumber: state.nextImageNumber },
+    };
+}
+export function createImageBlockEntry(state, imageRef, id) {
+    const blockId = id || imageRef.id;
+    const displayNumber = imageRef.displayNumber;
+    const marker = createBlockMarker('i', blockId, displayNumber);
+    const newEntries = new Map(state.entries);
+    newEntries.set(blockId, {
+        kind: 'image',
+        id: blockId,
+        displayNumber,
+        data: imageRef.data,
+        mimeType: imageRef.mimeType,
+        byteSize: imageRef.byteSize,
+    });
+    return {
+        id: blockId,
+        marker,
+        state: {
+            entries: newEntries,
+            nextPasteNumber: state.nextPasteNumber,
+            nextImageNumber: Math.max(state.nextImageNumber, displayNumber + 1),
+        },
+    };
+}
+export function removeBlock(state, id) {
+    const newEntries = new Map(state.entries);
+    newEntries.delete(id);
+    return { ...state, entries: newEntries };
+}
+export function getBlock(state, id) {
+    return state.entries.get(id);
+}
+export function getDisplayLine(line, entries) {
+    const markers = parseBlockMarkers(line);
+    if (markers.length === 0)
+        return line;
+    let result = '';
+    let lastEnd = 0;
+    for (const m of markers) {
+        result += line.slice(lastEnd, m.start);
+        const entry = entries.get(m.id);
+        if (entry && entry.kind === 'paste') {
+            result += entry.displayText;
+        }
+        else {
+            result += m.kind === 'i' ? `[Pasted Image #${m.displayNumber}]` : `[Paste text #${m.displayNumber}]`;
+        }
+        lastEnd = m.end;
+    }
+    result += line.slice(lastEnd);
+    return result;
+}
+export function getValue(lines, entries) {
+    return lines.map((line) => {
+        const markers = parseBlockMarkers(line);
+        if (markers.length === 0)
+            return line;
+        let result = '';
+        let lastEnd = 0;
+        for (const m of markers) {
+            result += line.slice(lastEnd, m.start);
+            const entry = entries.get(m.id);
+            if (entry && entry.kind === 'paste') {
+                result += entry.originalText;
+            }
+            else {
+                result += line.slice(m.start, m.end);
+            }
+            lastEnd = m.end;
+        }
+        result += line.slice(lastEnd);
+        return result;
+    }).join('\n');
+}
+export function bufferColToDisplayCol(line, column, entries) {
+    if (entries.size === 0)
+        return column;
+    let displayCol = 0;
+    let lastEnd = 0;
+    const markers = parseBlockMarkers(line);
+    for (const m of markers) {
+        if (column <= m.start) {
+            return displayCol + (column - lastEnd);
+        }
+        displayCol += m.start - lastEnd;
+        const entry = entries.get(m.id);
+        const displayLen = entry && entry.kind === 'paste' ? entry.displayText.length : `[Pasted Image #${m.displayNumber}]`.length;
+        if (column <= m.end) {
+            return displayCol + displayLen;
+        }
+        displayCol += displayLen;
+        lastEnd = m.end;
+    }
+    return displayCol + (column - lastEnd);
+}
+export function displayColToBufferCol(line, displayColumn, entries) {
+    if (entries.size === 0)
+        return displayColumn;
+    let bufPos = 0;
+    let dispPos = 0;
+    const markers = parseBlockMarkers(line);
+    for (const m of markers) {
+        const textLen = m.start - bufPos;
+        if (displayColumn <= dispPos + textLen) {
+            return bufPos + (displayColumn - dispPos);
+        }
+        dispPos += textLen;
+        bufPos = m.start;
+        const entry = entries.get(m.id);
+        const displayLen = entry && entry.kind === 'paste' ? entry.displayText.length : `[Pasted Image #${m.displayNumber}]`.length;
+        if (displayColumn <= dispPos + displayLen) {
+            return m.end;
+        }
+        dispPos += displayLen;
+        bufPos = m.end;
+    }
+    return bufPos + (displayColumn - dispPos);
+}
+export function getExpandedLineLength(line, entries) {
+    let len = 0;
+    let lastEnd = 0;
+    const markers = parseBlockMarkers(line);
+    for (const m of markers) {
+        len += m.start - lastEnd;
+        const entry = entries.get(m.id);
+        if (entry && entry.kind === 'paste') {
+            len += entry.originalText.length;
+        }
+        else {
+            len += m.end - m.start;
+        }
+        lastEnd = m.end;
+    }
+    len += line.length - lastEnd;
+    return len;
+}
+export function getValueCursorOffset(lines, cursor, entries) {
+    let offset = 0;
+    for (let i = 0; i < cursor.line; i++) {
+        offset += getExpandedLineLength(lines[i], entries) + 1;
+    }
+    const line = lines[cursor.line];
+    let bufPos = 0;
+    const markers = parseBlockMarkers(line);
+    for (const m of markers) {
+        if (cursor.column <= m.start) {
+            offset += cursor.column - bufPos;
+            return offset;
+        }
+        offset += m.start - bufPos;
+        const entry = entries.get(m.id);
+        if (entry && entry.kind === 'paste') {
+            offset += entry.originalText.length;
+        }
+        else {
+            offset += m.end - m.start;
+        }
+        bufPos = m.end;
+        if (cursor.column <= m.end) {
+            return offset;
+        }
+    }
+    offset += cursor.column - bufPos;
+    return offset;
+}
+export function getCursorFromValueOffset(lines, offset, entries) {
+    let currentOffset = 0;
+    const lineCount = lines.length;
+    for (let i = 0; i < lineCount; i++) {
+        const lineLen = getExpandedLineLength(lines[i], entries);
+        if (i === lineCount - 1) {
+            if (offset <= currentOffset + lineLen) {
+                const colInExpanded = offset - currentOffset;
+                return { line: i, column: valueOffsetToBufferColumn(lines[i], colInExpanded, entries) };
+            }
+            return { line: i, column: lines[i].length };
+        }
+        if (offset <= currentOffset + lineLen) {
+            const colInExpanded = offset - currentOffset;
+            return { line: i, column: valueOffsetToBufferColumn(lines[i], colInExpanded, entries) };
+        }
+        currentOffset += lineLen + 1;
+    }
+    const lastIdx = lines.length - 1;
+    return { line: lastIdx, column: lines[lastIdx].length };
+}
+function valueOffsetToBufferColumn(line, offsetInExpanded, entries) {
+    let bufPos = 0;
+    let expandedPos = 0;
+    const markers = parseBlockMarkers(line);
+    for (const m of markers) {
+        const textLen = m.start - bufPos;
+        if (offsetInExpanded <= expandedPos + textLen) {
+            return bufPos + (offsetInExpanded - expandedPos);
+        }
+        expandedPos += textLen;
+        bufPos = m.start;
+        const entry = entries.get(m.id);
+        const originalLen = entry && entry.kind === 'paste' ? entry.originalText.length : (m.end - m.start);
+        if (offsetInExpanded <= expandedPos + originalLen) {
+            return m.end;
+        }
+        expandedPos += originalLen;
+        bufPos = m.end;
+    }
+    return bufPos + (offsetInExpanded - expandedPos);
+}
+export function getDisplayWidthForMarker(m, entries) {
+    const entry = entries.get(m.id);
+    if (entry && entry.kind === 'paste') {
+        return entry.displayText.length;
+    }
+    return `[Pasted Image #${m.displayNumber}]`.length;
+}
+export function getDisplayTextForMarker(m, entries) {
+    const entry = entries.get(m.id);
+    if (entry && entry.kind === 'paste') {
+        return entry.displayText;
+    }
+    return `[Pasted Image #${m.displayNumber}]`;
+}

package/dist/components/MultilineInput/BlockTypes.d.ts

@@ -0,0 +1,22 @@
+export type BlockKind = 'paste' | 'image';
+export interface PasteBlockEntry {
+    kind: 'paste';
+    id: string;
+    displayNumber: number;
+    originalText: string;
+    displayText: string;
+}
+export interface ImageBlockEntry {
+    kind: 'image';
+    id: string;
+    displayNumber: number;
+    data: string;
+    mimeType: string;
+    byteSize: number;
+}
+export type BlockEntry = PasteBlockEntry | ImageBlockEntry;
+export interface BlockState {
+    entries: Map<string, BlockEntry>;
+    nextPasteNumber: number;
+    nextImageNumber: number;
+}

package/dist/components/MultilineInput/ImageTypes.d.ts

@@ -6,5 +6,3 @@ export interface ImageRef {
     displayNumber: number;
 }
 export type PasteErrorReason = 'clipboard-timeout' | 'clipboard-read-error' | 'clipboard-unsupported-type' | 'image-too-large' | 'too-many-images' | 'clipboard-empty';
-export declare const SENTINEL_OPEN = "\uE000";
-export declare const SENTINEL_CLOSE = "\uE001";

package/dist/components/MultilineInput/ImageTypes.js

@@ -1,2 +1 @@
-export const SENTINEL_OPEN = '\uE000';
-export const SENTINEL_CLOSE = '\uE001';
+export {};

package/dist/components/MultilineInput/ImageValidator.js

@@ -1,4 +1,4 @@
-import { generateImageId } from './ImageSentinel.js';
+import { generateBlockId as generateImageId } from './BlockMarker.js';
 const MAGIC_BYTES = [
     { mimeType: 'image/png', magic: [0x89, 0x50, 0x4e, 0x47] },
     { mimeType: 'image/jpeg', magic: [0xff, 0xd8, 0xff] },

package/dist/components/MultilineInput/KeyHandler.d.ts

@@ -1,6 +1,6 @@
 import { type Key, type Buffer, type Cursor } from './types.js';
 import { type UseTextInputResult } from './useTextInput.js';
-export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'cursor' | 'cursorOffset' | 'setCursorOffset' | 'buffer' | 'placeholderState' | 'insertImage' | 'images' | 'getImages' | 'setImages'> {
+export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'cursor' | 'cursorOffset' | 'setCursorOffset' | 'buffer' | 'blockState' | 'insertImage' | 'images' | 'getImages' | 'setImages'> {
     submit: () => void;
     onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
     paste?: () => void;

package/dist/components/MultilineInput/TextBuffer.d.ts

@@ -1,5 +1,5 @@
 import type { Buffer, Cursor, Direction } from './types.js';
-import { type Placeholders } from './AtomicBlocks.js';
+import { type BlockEntries } from './AtomicBlocks.js';
 /**
  * Create a new buffer from optional initial text
  */
@@ -15,14 +15,14 @@ export declare function insertText(buffer: Buffer, cursor: Cursor, text: string)
 /**
  * Delete character before cursor (backspace)
  */
-export declare function deleteChar(buffer: Buffer, cursor: Cursor, placeholders?: Placeholders): {
+export declare function deleteChar(buffer: Buffer, cursor: Cursor, entries?: BlockEntries): {
     buffer: Buffer;
     cursor: Cursor;
 };
 /**
  * Delete character after cursor (forward delete / Delete key)
  */
-export declare function deleteCharForward(buffer: Buffer, cursor: Cursor, placeholders?: Placeholders): {
+export declare function deleteCharForward(buffer: Buffer, cursor: Cursor, entries?: BlockEntries): {
     buffer: Buffer;
     cursor: Cursor;
 };
@@ -33,39 +33,13 @@ export declare function insertNewLine(buffer: Buffer, cursor: Cursor): {
     buffer: Buffer;
     cursor: Cursor;
 };
-/**
- * Information about a visual row within a wrapped line.
- */
 interface VisualRowInfo {
-    /** Starting offset in the buffer line */
     start: number;
-    /** Length of this visual row */
     length: number;
 }
-/**
- * Break a line into visual rows using word-aware wrapping.
- * Words are kept intact when possible, breaking at spaces.
- * Long words that exceed width are hard-wrapped.
- * Sentinel blocks are atomic: never split, and occupy visual width
- * equal to their placeholder text length.
- */
-export declare function getVisualRows(line: string, width: number, placeholders?: Placeholders): VisualRowInfo[];
-/**
- * Move cursor in specified direction with bounds checking.
- * When width is provided, up/down movement is based on visual lines (accounting for wrapping).
- * When width is not provided, up/down movement is based on buffer lines.
- */
-export declare function moveCursor(buffer: Buffer, cursor: Cursor, direction: Direction, width?: number, placeholders?: Placeholders): Cursor;
-/**
- * Get the full text content from buffer (lines joined with newlines)
- */
+export declare function getVisualRows(line: string, width: number, entries?: BlockEntries): VisualRowInfo[];
+export declare function moveCursor(buffer: Buffer, cursor: Cursor, direction: Direction, width?: number, entries?: BlockEntries): Cursor;
 export declare function getTextContent(buffer: Buffer): string;
-/**
- * Get the flat offset (index) from a cursor position.
- */
 export declare function getOffset(buffer: Buffer, cursor: Cursor): number;
-/**
- * Get the cursor position from a flat offset.
- */
 export declare function getCursor(buffer: Buffer, offset: number): Cursor;
 export {};