@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/utils/Cursor.js

@@ -0,0 +1,1229 @@
+import { stringWidth } from '../ink/stringWidth.js';
+import { wrapAnsi } from '../ink/wrapAnsi.js';
+import { firstGrapheme, getGraphemeSegmenter, getWordSegmenter, } from './intl.js';
+/**
+ * Kill ring for storing killed (cut) text that can be yanked (pasted) with Ctrl+Y.
+ * This is global state that shares one kill ring across all input fields.
+ *
+ * Consecutive kills accumulate in the kill ring until the user types some
+ * other key. Alt+Y cycles through previous kills after a yank.
+ */
+const KILL_RING_MAX_SIZE = 10;
+let killRing = [];
+let killRingIndex = 0;
+let lastActionWasKill = false;
+// Track yank state for yank-pop (alt-y)
+let lastYankStart = 0;
+let lastYankLength = 0;
+let lastActionWasYank = false;
+export function pushToKillRing(text, direction = 'append') {
+    if (text.length > 0) {
+        if (lastActionWasKill && killRing.length > 0) {
+            // Accumulate with the most recent kill
+            if (direction === 'prepend') {
+                killRing[0] = text + killRing[0];
+            }
+            else {
+                killRing[0] = killRing[0] + text;
+            }
+        }
+        else {
+            // Add new entry to front of ring
+            killRing.unshift(text);
+            if (killRing.length > KILL_RING_MAX_SIZE) {
+                killRing.pop();
+            }
+        }
+        lastActionWasKill = true;
+        // Reset yank state when killing new text
+        lastActionWasYank = false;
+    }
+}
+export function getLastKill() {
+    return killRing[0] ?? '';
+}
+export function getKillRingItem(index) {
+    if (killRing.length === 0)
+        return '';
+    const normalizedIndex = ((index % killRing.length) + killRing.length) % killRing.length;
+    return killRing[normalizedIndex] ?? '';
+}
+export function getKillRingSize() {
+    return killRing.length;
+}
+export function clearKillRing() {
+    killRing = [];
+    killRingIndex = 0;
+    lastActionWasKill = false;
+    lastActionWasYank = false;
+    lastYankStart = 0;
+    lastYankLength = 0;
+}
+export function resetKillAccumulation() {
+    lastActionWasKill = false;
+}
+// Yank tracking for yank-pop
+export function recordYank(start, length) {
+    lastYankStart = start;
+    lastYankLength = length;
+    lastActionWasYank = true;
+    killRingIndex = 0;
+}
+export function canYankPop() {
+    return lastActionWasYank && killRing.length > 1;
+}
+export function yankPop() {
+    if (!lastActionWasYank || killRing.length <= 1) {
+        return null;
+    }
+    // Cycle to next item in kill ring
+    killRingIndex = (killRingIndex + 1) % killRing.length;
+    const text = killRing[killRingIndex] ?? '';
+    return { text, start: lastYankStart, length: lastYankLength };
+}
+export function updateYankLength(length) {
+    lastYankLength = length;
+}
+export function resetYankState() {
+    lastActionWasYank = false;
+}
+/**
+ * Text Processing Flow for Unicode Normalization:
+ *
+ * User Input (raw text, potentially mixed NFD/NFC)
+ *     ↓
+ * MeasuredText (normalizes to NFC + builds grapheme info)
+ *     ↓
+ * All cursor operations use normalized text/offsets
+ *     ↓
+ * Display uses normalized text from wrappedLines
+ *
+ * This flow ensures consistent Unicode handling:
+ * - NFD/NFC normalization differences don't break cursor movement
+ * - Grapheme clusters (like 👨‍👩‍👧‍👦) are treated as single units
+ * - Display width calculations are accurate for CJK characters
+ *
+ * RULE: Once text enters MeasuredText, all operations
+ * work on the normalized version.
+ */
+// Pre-compiled regex patterns for Vim word detection (avoid creating in hot loops)
+export const VIM_WORD_CHAR_REGEX = /^[\p{L}\p{N}\p{M}_]$/u;
+export const WHITESPACE_REGEX = /\s/;
+// Exported helper functions for Vim character classification
+export const isVimWordChar = (ch) => VIM_WORD_CHAR_REGEX.test(ch);
+export const isVimWhitespace = (ch) => WHITESPACE_REGEX.test(ch);
+export const isVimPunctuation = (ch) => ch.length > 0 && !isVimWhitespace(ch) && !isVimWordChar(ch);
+export class Cursor {
+    measuredText;
+    selection;
+    offset;
+    constructor(measuredText, offset = 0, selection = 0) {
+        this.measuredText = measuredText;
+        this.selection = selection;
+        // it's ok for the cursor to be 1 char beyond the end of the string
+        this.offset = Math.max(0, Math.min(this.text.length, offset));
+    }
+    static fromText(text, columns, offset = 0, selection = 0) {
+        // make MeasuredText on less than columns width, to account for cursor
+        return new Cursor(new MeasuredText(text, columns - 1), offset, selection);
+    }
+    getViewportStartLine(maxVisibleLines) {
+        if (maxVisibleLines === undefined || maxVisibleLines <= 0)
+            return 0;
+        const { line } = this.getPosition();
+        const allLines = this.measuredText.getWrappedText();
+        if (allLines.length <= maxVisibleLines)
+            return 0;
+        const half = Math.floor(maxVisibleLines / 2);
+        let startLine = Math.max(0, line - half);
+        const endLine = Math.min(allLines.length, startLine + maxVisibleLines);
+        if (endLine - startLine < maxVisibleLines) {
+            startLine = Math.max(0, endLine - maxVisibleLines);
+        }
+        return startLine;
+    }
+    getViewportCharOffset(maxVisibleLines) {
+        const startLine = this.getViewportStartLine(maxVisibleLines);
+        if (startLine === 0)
+            return 0;
+        const wrappedLines = this.measuredText.getWrappedLines();
+        return wrappedLines[startLine]?.startOffset ?? 0;
+    }
+    getViewportCharEnd(maxVisibleLines) {
+        const startLine = this.getViewportStartLine(maxVisibleLines);
+        const allLines = this.measuredText.getWrappedLines();
+        if (maxVisibleLines === undefined || maxVisibleLines <= 0)
+            return this.text.length;
+        const endLine = Math.min(allLines.length, startLine + maxVisibleLines);
+        if (endLine >= allLines.length)
+            return this.text.length;
+        return allLines[endLine]?.startOffset ?? this.text.length;
+    }
+    render(cursorChar, mask, invert, ghostText, maxVisibleLines) {
+        const { line, column } = this.getPosition();
+        const allLines = this.measuredText.getWrappedText();
+        const startLine = this.getViewportStartLine(maxVisibleLines);
+        const endLine = maxVisibleLines !== undefined && maxVisibleLines > 0
+            ? Math.min(allLines.length, startLine + maxVisibleLines)
+            : allLines.length;
+        return allLines
+            .slice(startLine, endLine)
+            .map((text, i) => {
+            const currentLine = i + startLine;
+            let displayText = text;
+            if (mask) {
+                const graphemes = Array.from(getGraphemeSegmenter().segment(text));
+                if (currentLine === allLines.length - 1) {
+                    // Last line: mask all but the trailing 6 chars so the user can
+                    // confirm they pasted the right thing without exposing the full token
+                    const visibleCount = Math.min(6, graphemes.length);
+                    const maskCount = graphemes.length - visibleCount;
+                    const splitOffset = graphemes.length > visibleCount ? graphemes[maskCount].index : 0;
+                    displayText = mask.repeat(maskCount) + text.slice(splitOffset);
+                }
+                else {
+                    // Earlier wrapped lines: fully mask. Previously only the last line
+                    // was masked, leaking the start of the token on narrow terminals
+                    // where the pasted OAuth code wraps across multiple lines.
+                    displayText = mask.repeat(graphemes.length);
+                }
+            }
+            // looking for the line with the cursor
+            if (line !== currentLine)
+                return displayText.trimEnd();
+            // Split the line into before/at/after cursor in a single pass over the
+            // graphemes, accumulating display width until we reach the cursor column.
+            // This replaces a two-pass approach (displayWidthToStringIndex + a second
+            // segmenter pass) — the intermediate stringIndex from that approach is
+            // always a grapheme boundary, so the "cursor in the middle of a
+            // multi-codepoint character" branch was unreachable.
+            let beforeCursor = '';
+            let atCursor = cursorChar;
+            let afterCursor = '';
+            let currentWidth = 0;
+            let cursorFound = false;
+            for (const { segment } of getGraphemeSegmenter().segment(displayText)) {
+                if (cursorFound) {
+                    afterCursor += segment;
+                    continue;
+                }
+                const nextWidth = currentWidth + stringWidth(segment);
+                if (nextWidth > column) {
+                    atCursor = segment;
+                    cursorFound = true;
+                }
+                else {
+                    currentWidth = nextWidth;
+                    beforeCursor += segment;
+                }
+            }
+            // Only invert the cursor if we have a cursor character to show
+            // When ghost text is present and cursor is at end, show first ghost char in cursor
+            let renderedCursor;
+            let ghostSuffix = '';
+            if (ghostText &&
+                currentLine === allLines.length - 1 &&
+                this.isAtEnd() &&
+                ghostText.text.length > 0) {
+                // First ghost character goes in the inverted cursor (grapheme-safe)
+                const firstGhostChar = firstGrapheme(ghostText.text) || ghostText.text[0];
+                renderedCursor = cursorChar ? invert(firstGhostChar) : firstGhostChar;
+                // Rest of ghost text is dimmed after cursor
+                const ghostRest = ghostText.text.slice(firstGhostChar.length);
+                if (ghostRest.length > 0) {
+                    ghostSuffix = ghostText.dim(ghostRest);
+                }
+            }
+            else {
+                renderedCursor = cursorChar ? invert(atCursor) : atCursor;
+            }
+            return (beforeCursor + renderedCursor + ghostSuffix + afterCursor.trimEnd());
+        })
+            .join('\n');
+    }
+    left() {
+        if (this.offset === 0)
+            return this;
+        const chip = this.imageRefEndingAt(this.offset);
+        if (chip)
+            return new Cursor(this.measuredText, chip.start);
+        const prevOffset = this.measuredText.prevOffset(this.offset);
+        return new Cursor(this.measuredText, prevOffset);
+    }
+    right() {
+        if (this.offset >= this.text.length)
+            return this;
+        const chip = this.imageRefStartingAt(this.offset);
+        if (chip)
+            return new Cursor(this.measuredText, chip.end);
+        const nextOffset = this.measuredText.nextOffset(this.offset);
+        return new Cursor(this.measuredText, Math.min(nextOffset, this.text.length));
+    }
+    /**
+     * If an [Image #N] chip ends at `offset`, return its bounds. Used by left()
+     * to hop the cursor over the chip instead of stepping into it.
+     */
+    imageRefEndingAt(offset) {
+        const m = this.text.slice(0, offset).match(/\[Image #\d+\]$/);
+        return m ? { start: offset - m[0].length, end: offset } : null;
+    }
+    imageRefStartingAt(offset) {
+        const m = this.text.slice(offset).match(/^\[Image #\d+\]/);
+        return m ? { start: offset, end: offset + m[0].length } : null;
+    }
+    /**
+     * If offset lands strictly inside an [Image #N] chip, snap it to the given
+     * boundary. Used by word-movement methods so Ctrl+W / Alt+D never leave a
+     * partial chip.
+     */
+    snapOutOfImageRef(offset, toward) {
+        const re = /\[Image #\d+\]/g;
+        let m;
+        while ((m = re.exec(this.text)) !== null) {
+            const start = m.index;
+            const end = start + m[0].length;
+            if (offset > start && offset < end) {
+                return toward === 'start' ? start : end;
+            }
+        }
+        return offset;
+    }
+    up() {
+        const { line, column } = this.getPosition();
+        if (line === 0) {
+            return this;
+        }
+        const prevLine = this.measuredText.getWrappedText()[line - 1];
+        if (prevLine === undefined) {
+            return this;
+        }
+        const prevLineDisplayWidth = stringWidth(prevLine);
+        if (column > prevLineDisplayWidth) {
+            const newOffset = this.getOffset({
+                line: line - 1,
+                column: prevLineDisplayWidth,
+            });
+            return new Cursor(this.measuredText, newOffset, 0);
+        }
+        const newOffset = this.getOffset({ line: line - 1, column });
+        return new Cursor(this.measuredText, newOffset, 0);
+    }
+    down() {
+        const { line, column } = this.getPosition();
+        if (line >= this.measuredText.lineCount - 1) {
+            return this;
+        }
+        // If there is no next line, stay on the current line,
+        // and let the caller handle it (e.g. for prompt input,
+        // we move to the next history entry)
+        const nextLine = this.measuredText.getWrappedText()[line + 1];
+        if (nextLine === undefined) {
+            return this;
+        }
+        // If the current column is past the end of the next line,
+        // move to the end of the next line
+        const nextLineDisplayWidth = stringWidth(nextLine);
+        if (column > nextLineDisplayWidth) {
+            const newOffset = this.getOffset({
+                line: line + 1,
+                column: nextLineDisplayWidth,
+            });
+            return new Cursor(this.measuredText, newOffset, 0);
+        }
+        // Otherwise, move to the same column on the next line
+        const newOffset = this.getOffset({
+            line: line + 1,
+            column,
+        });
+        return new Cursor(this.measuredText, newOffset, 0);
+    }
+    /**
+     * Move to the start of the current line (column 0).
+     * This is the raw version used internally by startOfLine.
+     */
+    startOfCurrentLine() {
+        const { line } = this.getPosition();
+        return new Cursor(this.measuredText, this.getOffset({
+            line,
+            column: 0,
+        }), 0);
+    }
+    startOfLine() {
+        const { line, column } = this.getPosition();
+        // If already at start of line and not at first line, move to previous line
+        if (column === 0 && line > 0) {
+            return new Cursor(this.measuredText, this.getOffset({
+                line: line - 1,
+                column: 0,
+            }), 0);
+        }
+        return this.startOfCurrentLine();
+    }
+    firstNonBlankInLine() {
+        const { line } = this.getPosition();
+        const lineText = this.measuredText.getWrappedText()[line] || '';
+        const match = lineText.match(/^\s*\S/);
+        const column = match?.index ? match.index + match[0].length - 1 : 0;
+        const offset = this.getOffset({ line, column });
+        return new Cursor(this.measuredText, offset, 0);
+    }
+    endOfLine() {
+        const { line } = this.getPosition();
+        const column = this.measuredText.getLineLength(line);
+        const offset = this.getOffset({ line, column });
+        return new Cursor(this.measuredText, offset, 0);
+    }
+    // Helper methods for finding logical line boundaries
+    findLogicalLineStart(fromOffset = this.offset) {
+        const prevNewline = this.text.lastIndexOf('\n', fromOffset - 1);
+        return prevNewline === -1 ? 0 : prevNewline + 1;
+    }
+    findLogicalLineEnd(fromOffset = this.offset) {
+        const nextNewline = this.text.indexOf('\n', fromOffset);
+        return nextNewline === -1 ? this.text.length : nextNewline;
+    }
+    // Helper to get logical line bounds for current position
+    getLogicalLineBounds() {
+        return {
+            start: this.findLogicalLineStart(),
+            end: this.findLogicalLineEnd(),
+        };
+    }
+    // Helper to create cursor with preserved column, clamped to line length
+    // Snaps to grapheme boundary to avoid landing mid-grapheme
+    createCursorWithColumn(lineStart, lineEnd, targetColumn) {
+        const lineLength = lineEnd - lineStart;
+        const clampedColumn = Math.min(targetColumn, lineLength);
+        const rawOffset = lineStart + clampedColumn;
+        const offset = this.measuredText.snapToGraphemeBoundary(rawOffset);
+        return new Cursor(this.measuredText, offset, 0);
+    }
+    endOfLogicalLine() {
+        return new Cursor(this.measuredText, this.findLogicalLineEnd(), 0);
+    }
+    startOfLogicalLine() {
+        return new Cursor(this.measuredText, this.findLogicalLineStart(), 0);
+    }
+    firstNonBlankInLogicalLine() {
+        const { start, end } = this.getLogicalLineBounds();
+        const lineText = this.text.slice(start, end);
+        const match = lineText.match(/\S/);
+        const offset = start + (match?.index ?? 0);
+        return new Cursor(this.measuredText, offset, 0);
+    }
+    upLogicalLine() {
+        const { start: currentStart } = this.getLogicalLineBounds();
+        // At first line - stay at beginning
+        if (currentStart === 0) {
+            return new Cursor(this.measuredText, 0, 0);
+        }
+        // Calculate target column position
+        const currentColumn = this.offset - currentStart;
+        // Find previous line bounds
+        const prevLineEnd = currentStart - 1;
+        const prevLineStart = this.findLogicalLineStart(prevLineEnd);
+        return this.createCursorWithColumn(prevLineStart, prevLineEnd, currentColumn);
+    }
+    downLogicalLine() {
+        const { start: currentStart, end: currentEnd } = this.getLogicalLineBounds();
+        // At last line - stay at end
+        if (currentEnd >= this.text.length) {
+            return new Cursor(this.measuredText, this.text.length, 0);
+        }
+        // Calculate target column position
+        const currentColumn = this.offset - currentStart;
+        // Find next line bounds
+        const nextLineStart = currentEnd + 1;
+        const nextLineEnd = this.findLogicalLineEnd(nextLineStart);
+        return this.createCursorWithColumn(nextLineStart, nextLineEnd, currentColumn);
+    }
+    // Vim word vs WORD movements:
+    // - word (lowercase w/b/e): sequences of letters, digits, and underscores
+    // - WORD (uppercase W/B/E): sequences of non-whitespace characters
+    // For example, in "hello-world!", word movements see 3 words: "hello", "world", and nothing
+    // But WORD movements see 1 WORD: "hello-world!"
+    nextWord() {
+        if (this.isAtEnd()) {
+            return this;
+        }
+        // Use Intl.Segmenter for proper word boundary detection (including CJK)
+        const wordBoundaries = this.measuredText.getWordBoundaries();
+        // Find the next word start boundary after current position
+        for (const boundary of wordBoundaries) {
+            if (boundary.isWordLike && boundary.start > this.offset) {
+                return new Cursor(this.measuredText, boundary.start);
+            }
+        }
+        // If no next word found, go to end
+        return new Cursor(this.measuredText, this.text.length);
+    }
+    endOfWord() {
+        if (this.isAtEnd()) {
+            return this;
+        }
+        // Use Intl.Segmenter for proper word boundary detection (including CJK)
+        const wordBoundaries = this.measuredText.getWordBoundaries();
+        // Find the current word boundary we're in
+        for (const boundary of wordBoundaries) {
+            if (!boundary.isWordLike)
+                continue;
+            // If we're inside this word but NOT at the last character
+            if (this.offset >= boundary.start && this.offset < boundary.end - 1) {
+                // Move to end of this word (last character position)
+                return new Cursor(this.measuredText, boundary.end - 1);
+            }
+            // If we're at the last character of a word (end - 1), find the next word's end
+            if (this.offset === boundary.end - 1) {
+                // Find next word
+                for (const nextBoundary of wordBoundaries) {
+                    if (nextBoundary.isWordLike && nextBoundary.start > this.offset) {
+                        return new Cursor(this.measuredText, nextBoundary.end - 1);
+                    }
+                }
+                return this;
+            }
+        }
+        // If not in a word, find the next word and go to its end
+        for (const boundary of wordBoundaries) {
+            if (boundary.isWordLike && boundary.start > this.offset) {
+                return new Cursor(this.measuredText, boundary.end - 1);
+            }
+        }
+        return this;
+    }
+    prevWord() {
+        if (this.isAtStart()) {
+            return this;
+        }
+        // Use Intl.Segmenter for proper word boundary detection (including CJK)
+        const wordBoundaries = this.measuredText.getWordBoundaries();
+        // Find the previous word start boundary before current position
+        // We need to iterate in reverse to find the previous word
+        let prevWordStart = null;
+        for (const boundary of wordBoundaries) {
+            if (!boundary.isWordLike)
+                continue;
+            // If we're at or after the start of this word, but this word starts before us
+            if (boundary.start < this.offset) {
+                // If we're inside this word (not at the start), go to its start
+                if (this.offset > boundary.start && this.offset <= boundary.end) {
+                    return new Cursor(this.measuredText, boundary.start);
+                }
+                // Otherwise, remember this as a candidate for previous word
+                prevWordStart = boundary.start;
+            }
+        }
+        if (prevWordStart !== null) {
+            return new Cursor(this.measuredText, prevWordStart);
+        }
+        return new Cursor(this.measuredText, 0);
+    }
+    // Vim-specific word methods
+    // In Vim, a "word" is either:
+    // 1. A sequence of word characters (letters, digits, underscore) - including Unicode
+    // 2. A sequence of non-blank, non-word characters (punctuation/symbols)
+    nextVimWord() {
+        if (this.isAtEnd()) {
+            return this;
+        }
+        let pos = this.offset;
+        const advance = (p) => this.measuredText.nextOffset(p);
+        const currentGrapheme = this.graphemeAt(pos);
+        if (!currentGrapheme) {
+            return this;
+        }
+        if (isVimWordChar(currentGrapheme)) {
+            while (pos < this.text.length && isVimWordChar(this.graphemeAt(pos))) {
+                pos = advance(pos);
+            }
+        }
+        else if (isVimPunctuation(currentGrapheme)) {
+            while (pos < this.text.length && isVimPunctuation(this.graphemeAt(pos))) {
+                pos = advance(pos);
+            }
+        }
+        while (pos < this.text.length &&
+            WHITESPACE_REGEX.test(this.graphemeAt(pos))) {
+            pos = advance(pos);
+        }
+        return new Cursor(this.measuredText, pos);
+    }
+    endOfVimWord() {
+        if (this.isAtEnd()) {
+            return this;
+        }
+        const text = this.text;
+        let pos = this.offset;
+        const advance = (p) => this.measuredText.nextOffset(p);
+        if (this.graphemeAt(pos) === '') {
+            return this;
+        }
+        pos = advance(pos);
+        while (pos < text.length && WHITESPACE_REGEX.test(this.graphemeAt(pos))) {
+            pos = advance(pos);
+        }
+        if (pos >= text.length) {
+            return new Cursor(this.measuredText, text.length);
+        }
+        const charAtPos = this.graphemeAt(pos);
+        if (isVimWordChar(charAtPos)) {
+            while (pos < text.length) {
+                const nextPos = advance(pos);
+                if (nextPos >= text.length || !isVimWordChar(this.graphemeAt(nextPos)))
+                    break;
+                pos = nextPos;
+            }
+        }
+        else if (isVimPunctuation(charAtPos)) {
+            while (pos < text.length) {
+                const nextPos = advance(pos);
+                if (nextPos >= text.length ||
+                    !isVimPunctuation(this.graphemeAt(nextPos)))
+                    break;
+                pos = nextPos;
+            }
+        }
+        return new Cursor(this.measuredText, pos);
+    }
+    prevVimWord() {
+        if (this.isAtStart()) {
+            return this;
+        }
+        let pos = this.offset;
+        const retreat = (p) => this.measuredText.prevOffset(p);
+        pos = retreat(pos);
+        while (pos > 0 && WHITESPACE_REGEX.test(this.graphemeAt(pos))) {
+            pos = retreat(pos);
+        }
+        // At position 0 with whitespace means no previous word exists, go to start
+        if (pos === 0 && WHITESPACE_REGEX.test(this.graphemeAt(0))) {
+            return new Cursor(this.measuredText, 0);
+        }
+        const charAtPos = this.graphemeAt(pos);
+        if (isVimWordChar(charAtPos)) {
+            while (pos > 0) {
+                const prevPos = retreat(pos);
+                if (!isVimWordChar(this.graphemeAt(prevPos)))
+                    break;
+                pos = prevPos;
+            }
+        }
+        else if (isVimPunctuation(charAtPos)) {
+            while (pos > 0) {
+                const prevPos = retreat(pos);
+                if (!isVimPunctuation(this.graphemeAt(prevPos)))
+                    break;
+                pos = prevPos;
+            }
+        }
+        return new Cursor(this.measuredText, pos);
+    }
+    nextWORD() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let nextCursor = this;
+        // If we're on a non-whitespace character, move to the next whitespace
+        while (!nextCursor.isOverWhitespace() && !nextCursor.isAtEnd()) {
+            nextCursor = nextCursor.right();
+        }
+        // now move to the next non-whitespace character
+        while (nextCursor.isOverWhitespace() && !nextCursor.isAtEnd()) {
+            nextCursor = nextCursor.right();
+        }
+        return nextCursor;
+    }
+    endOfWORD() {
+        if (this.isAtEnd()) {
+            return this;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let cursor = this;
+        // Check if we're already at the end of a WORD
+        // (current character is non-whitespace, but next character is whitespace or we're at the end)
+        const atEndOfWORD = !cursor.isOverWhitespace() &&
+            (cursor.right().isOverWhitespace() || cursor.right().isAtEnd());
+        if (atEndOfWORD) {
+            // We're already at the end of a WORD, move to the next WORD
+            cursor = cursor.right();
+            return cursor.endOfWORD();
+        }
+        // If we're on a whitespace character, find the next WORD
+        if (cursor.isOverWhitespace()) {
+            cursor = cursor.nextWORD();
+        }
+        // Now move to the end of the current WORD
+        while (!cursor.right().isOverWhitespace() && !cursor.isAtEnd()) {
+            cursor = cursor.right();
+        }
+        return cursor;
+    }
+    prevWORD() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let cursor = this;
+        // if we are already at the beginning of a WORD, step off it
+        if (cursor.left().isOverWhitespace()) {
+            cursor = cursor.left();
+        }
+        // Move left over any whitespace characters
+        while (cursor.isOverWhitespace() && !cursor.isAtStart()) {
+            cursor = cursor.left();
+        }
+        // If we're over a non-whitespace character, move to the start of this WORD
+        if (!cursor.isOverWhitespace()) {
+            while (!cursor.left().isOverWhitespace() && !cursor.isAtStart()) {
+                cursor = cursor.left();
+            }
+        }
+        return cursor;
+    }
+    modifyText(end, insertString = '') {
+        const startOffset = this.offset;
+        const endOffset = end.offset;
+        const newText = this.text.slice(0, startOffset) +
+            insertString +
+            this.text.slice(endOffset);
+        return Cursor.fromText(newText, this.columns, startOffset + insertString.normalize('NFC').length);
+    }
+    insert(insertString) {
+        const newCursor = this.modifyText(this, insertString);
+        return newCursor;
+    }
+    del() {
+        if (this.isAtEnd()) {
+            return this;
+        }
+        return this.modifyText(this.right());
+    }
+    backspace() {
+        if (this.isAtStart()) {
+            return this;
+        }
+        return this.left().modifyText(this);
+    }
+    deleteToLineStart() {
+        // If cursor is right after a newline (at start of line), delete just that
+        // newline — symmetric with deleteToLineEnd's newline handling. This lets
+        // repeated ctrl+u clear across lines.
+        if (this.offset > 0 && this.text[this.offset - 1] === '\n') {
+            return { cursor: this.left().modifyText(this), killed: '\n' };
+        }
+        // Use startOfLine() so that at column 0 of a wrapped visual line,
+        // the cursor moves to the previous visual line's start instead of
+        // getting stuck.
+        const startCursor = this.startOfLine();
+        const killed = this.text.slice(startCursor.offset, this.offset);
+        return { cursor: startCursor.modifyText(this), killed };
+    }
+    deleteToLineEnd() {
+        // If cursor is on a newline character, delete just that character
+        if (this.text[this.offset] === '\n') {
+            return { cursor: this.modifyText(this.right()), killed: '\n' };
+        }
+        const endCursor = this.endOfLine();
+        const killed = this.text.slice(this.offset, endCursor.offset);
+        return { cursor: this.modifyText(endCursor), killed };
+    }
+    deleteToLogicalLineEnd() {
+        // If cursor is on a newline character, delete just that character
+        if (this.text[this.offset] === '\n') {
+            return this.modifyText(this.right());
+        }
+        return this.modifyText(this.endOfLogicalLine());
+    }
+    deleteWordBefore() {
+        if (this.isAtStart()) {
+            return { cursor: this, killed: '' };
+        }
+        const target = this.snapOutOfImageRef(this.prevWord().offset, 'start');
+        const prevWordCursor = new Cursor(this.measuredText, target);
+        const killed = this.text.slice(prevWordCursor.offset, this.offset);
+        return { cursor: prevWordCursor.modifyText(this), killed };
+    }
+    /**
+     * Deletes a token before the cursor if one exists.
+     * Supports pasted text refs: [Pasted text #1], [Pasted text #1 +10 lines],
+     * [...Truncated text #1 +10 lines...]
+     *
+     * Note: @mentions are NOT tokenized since users may want to correct typos
+     * in file paths. Use Ctrl/Cmd+backspace for word-deletion on mentions.
+     *
+     * Returns null if no token found at cursor position.
+     * Only triggers when cursor is at end of token (followed by whitespace or EOL).
+     */
+    deleteTokenBefore() {
+        // Cursor at chip.start is the "selected" state — backspace deletes the
+        // chip forward, not the char before it.
+        const chipAfter = this.imageRefStartingAt(this.offset);
+        if (chipAfter) {
+            const end = this.text[chipAfter.end] === ' ' ? chipAfter.end + 1 : chipAfter.end;
+            return this.modifyText(new Cursor(this.measuredText, end));
+        }
+        if (this.isAtStart()) {
+            return null;
+        }
+        // Only trigger if cursor is at a word boundary (whitespace or end of string after cursor)
+        const charAfter = this.text[this.offset];
+        if (charAfter !== undefined && !/\s/.test(charAfter)) {
+            return null;
+        }
+        const textBefore = this.text.slice(0, this.offset);
+        // Check for pasted/truncated text refs: [Pasted text #1] or [...Truncated text #1 +50 lines...]
+        const pasteMatch = textBefore.match(/(^|\s)\[(Pasted text #\d+(?: \+\d+ lines)?|Image #\d+|\.\.\.Truncated text #\d+ \+\d+ lines\.\.\.)\]$/);
+        if (pasteMatch) {
+            const matchStart = pasteMatch.index + pasteMatch[1].length;
+            return new Cursor(this.measuredText, matchStart).modifyText(this);
+        }
+        return null;
+    }
+    deleteWordAfter() {
+        if (this.isAtEnd()) {
+            return this;
+        }
+        const target = this.snapOutOfImageRef(this.nextWord().offset, 'end');
+        return this.modifyText(new Cursor(this.measuredText, target));
+    }
+    graphemeAt(pos) {
+        if (pos >= this.text.length)
+            return '';
+        const nextOff = this.measuredText.nextOffset(pos);
+        return this.text.slice(pos, nextOff);
+    }
+    isOverWhitespace() {
+        const currentChar = this.text[this.offset] ?? '';
+        return /\s/.test(currentChar);
+    }
+    equals(other) {
+        return (this.offset === other.offset && this.measuredText === other.measuredText);
+    }
+    isAtStart() {
+        return this.offset === 0;
+    }
+    isAtEnd() {
+        return this.offset >= this.text.length;
+    }
+    startOfFirstLine() {
+        // Go to the very beginning of the text (first character of first line)
+        return new Cursor(this.measuredText, 0, 0);
+    }
+    startOfLastLine() {
+        // Go to the beginning of the last line
+        const lastNewlineIndex = this.text.lastIndexOf('\n');
+        if (lastNewlineIndex === -1) {
+            // If there are no newlines, the text is a single line
+            return this.startOfLine();
+        }
+        // Position after the last newline character
+        return new Cursor(this.measuredText, lastNewlineIndex + 1, 0);
+    }
+    goToLine(lineNumber) {
+        // Go to the beginning of the specified logical line (1-indexed, like vim)
+        // Uses logical lines (separated by \n), not wrapped display lines
+        const lines = this.text.split('\n');
+        const targetLine = Math.min(Math.max(0, lineNumber - 1), lines.length - 1);
+        let offset = 0;
+        for (let i = 0; i < targetLine; i++) {
+            offset += (lines[i]?.length ?? 0) + 1; // +1 for newline
+        }
+        return new Cursor(this.measuredText, offset, 0);
+    }
+    endOfFile() {
+        return new Cursor(this.measuredText, this.text.length, 0);
+    }
+    get text() {
+        return this.measuredText.text;
+    }
+    get columns() {
+        return this.measuredText.columns + 1;
+    }
+    getPosition() {
+        return this.measuredText.getPositionFromOffset(this.offset);
+    }
+    getOffset(position) {
+        return this.measuredText.getOffsetFromPosition(position);
+    }
+    /**
+     * Find a character using vim f/F/t/T semantics.
+     *
+     * @param char - The character to find
+     * @param type - 'f' (forward to), 'F' (backward to), 't' (forward till), 'T' (backward till)
+     * @param count - Find the Nth occurrence
+     * @returns The target offset, or null if not found
+     */
+    findCharacter(char, type, count = 1) {
+        const text = this.text;
+        const forward = type === 'f' || type === 't';
+        const till = type === 't' || type === 'T';
+        let found = 0;
+        if (forward) {
+            let pos = this.measuredText.nextOffset(this.offset);
+            while (pos < text.length) {
+                const grapheme = this.graphemeAt(pos);
+                if (grapheme === char) {
+                    found++;
+                    if (found === count) {
+                        return till
+                            ? Math.max(this.offset, this.measuredText.prevOffset(pos))
+                            : pos;
+                    }
+                }
+                pos = this.measuredText.nextOffset(pos);
+            }
+        }
+        else {
+            if (this.offset === 0)
+                return null;
+            let pos = this.measuredText.prevOffset(this.offset);
+            while (pos >= 0) {
+                const grapheme = this.graphemeAt(pos);
+                if (grapheme === char) {
+                    found++;
+                    if (found === count) {
+                        return till
+                            ? Math.min(this.offset, this.measuredText.nextOffset(pos))
+                            : pos;
+                    }
+                }
+                if (pos === 0)
+                    break;
+                pos = this.measuredText.prevOffset(pos);
+            }
+        }
+        return null;
+    }
+}
+class WrappedLine {
+    text;
+    startOffset;
+    isPrecededByNewline;
+    endsWithNewline;
+    constructor(text, startOffset, isPrecededByNewline, endsWithNewline = false) {
+        this.text = text;
+        this.startOffset = startOffset;
+        this.isPrecededByNewline = isPrecededByNewline;
+        this.endsWithNewline = endsWithNewline;
+    }
+    equals(other) {
+        return this.text === other.text && this.startOffset === other.startOffset;
+    }
+    get length() {
+        return this.text.length + (this.endsWithNewline ? 1 : 0);
+    }
+}
+export class MeasuredText {
+    columns;
+    _wrappedLines;
+    text;
+    navigationCache;
+    graphemeBoundaries;
+    constructor(text, columns) {
+        this.columns = columns;
+        this.text = text.normalize('NFC');
+        this.navigationCache = new Map();
+    }
+    /**
+     * Lazily computes and caches wrapped lines.
+     * This expensive operation is deferred until actually needed.
+     */
+    get wrappedLines() {
+        if (!this._wrappedLines) {
+            this._wrappedLines = this.measureWrappedText();
+        }
+        return this._wrappedLines;
+    }
+    getGraphemeBoundaries() {
+        if (!this.graphemeBoundaries) {
+            this.graphemeBoundaries = [];
+            for (const { index } of getGraphemeSegmenter().segment(this.text)) {
+                this.graphemeBoundaries.push(index);
+            }
+            // Add the end of text as a boundary
+            this.graphemeBoundaries.push(this.text.length);
+        }
+        return this.graphemeBoundaries;
+    }
+    wordBoundariesCache;
+    /**
+     * Get word boundaries using Intl.Segmenter for proper Unicode word segmentation.
+     * This correctly handles CJK (Chinese, Japanese, Korean) text where each character
+     * is typically its own word, as well as scripts that use spaces between words.
+     */
+    getWordBoundaries() {
+        if (!this.wordBoundariesCache) {
+            this.wordBoundariesCache = [];
+            for (const segment of getWordSegmenter().segment(this.text)) {
+                this.wordBoundariesCache.push({
+                    start: segment.index,
+                    end: segment.index + segment.segment.length,
+                    isWordLike: segment.isWordLike ?? false,
+                });
+            }
+        }
+        return this.wordBoundariesCache;
+    }
+    /**
+     * Binary search for boundaries.
+     * @param boundaries: Sorted array of boundaries
+     * @param target: Target offset
+     * @param findNext: If true, finds first boundary > target. If false, finds last boundary < target.
+     * @returns The found boundary index, or appropriate default
+     */
+    binarySearchBoundary(boundaries, target, findNext) {
+        let left = 0;
+        let right = boundaries.length - 1;
+        let result = findNext ? this.text.length : 0;
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            const boundary = boundaries[mid];
+            if (boundary === undefined)
+                break;
+            if (findNext) {
+                if (boundary > target) {
+                    result = boundary;
+                    right = mid - 1;
+                }
+                else {
+                    left = mid + 1;
+                }
+            }
+            else {
+                if (boundary < target) {
+                    result = boundary;
+                    left = mid + 1;
+                }
+                else {
+                    right = mid - 1;
+                }
+            }
+        }
+        return result;
+    }
+    // Convert string index to display width
+    stringIndexToDisplayWidth(text, index) {
+        if (index <= 0)
+            return 0;
+        if (index >= text.length)
+            return stringWidth(text);
+        return stringWidth(text.substring(0, index));
+    }
+    // Convert display width to string index
+    displayWidthToStringIndex(text, targetWidth) {
+        if (targetWidth <= 0)
+            return 0;
+        if (!text)
+            return 0;
+        // If the text matches our text, use the precomputed graphemes
+        if (text === this.text) {
+            return this.offsetAtDisplayWidth(targetWidth);
+        }
+        // Otherwise compute on the fly
+        let currentWidth = 0;
+        let currentOffset = 0;
+        for (const { segment, index } of getGraphemeSegmenter().segment(text)) {
+            const segmentWidth = stringWidth(segment);
+            if (currentWidth + segmentWidth > targetWidth) {
+                break;
+            }
+            currentWidth += segmentWidth;
+            currentOffset = index + segment.length;
+        }
+        return currentOffset;
+    }
+    /**
+     * Find the string offset that corresponds to a target display width.
+     */
+    offsetAtDisplayWidth(targetWidth) {
+        if (targetWidth <= 0)
+            return 0;
+        let currentWidth = 0;
+        const boundaries = this.getGraphemeBoundaries();
+        // Iterate through grapheme boundaries
+        for (let i = 0; i < boundaries.length - 1; i++) {
+            const start = boundaries[i];
+            const end = boundaries[i + 1];
+            if (start === undefined || end === undefined)
+                continue;
+            const segment = this.text.substring(start, end);
+            const segmentWidth = stringWidth(segment);
+            if (currentWidth + segmentWidth > targetWidth) {
+                return start;
+            }
+            currentWidth += segmentWidth;
+        }
+        return this.text.length;
+    }
+    measureWrappedText() {
+        const wrappedText = wrapAnsi(this.text, this.columns, {
+            hard: true,
+            trim: false,
+        });
+        const wrappedLines = [];
+        let searchOffset = 0;
+        let lastNewLinePos = -1;
+        const lines = wrappedText.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const text = lines[i];
+            const isPrecededByNewline = (startOffset) => i === 0 || (startOffset > 0 && this.text[startOffset - 1] === '\n');
+            if (text.length === 0) {
+                // For blank lines, find the next newline character after the last one
+                lastNewLinePos = this.text.indexOf('\n', lastNewLinePos + 1);
+                if (lastNewLinePos !== -1) {
+                    const startOffset = lastNewLinePos;
+                    const endsWithNewline = true;
+                    wrappedLines.push(new WrappedLine(text, startOffset, isPrecededByNewline(startOffset), endsWithNewline));
+                }
+                else {
+                    // If we can't find another newline, this must be the end of text
+                    const startOffset = this.text.length;
+                    wrappedLines.push(new WrappedLine(text, startOffset, isPrecededByNewline(startOffset), false));
+                }
+            }
+            else {
+                // For non-blank lines, find the text in this.text
+                const startOffset = this.text.indexOf(text, searchOffset);
+                if (startOffset === -1) {
+                    throw new Error('Failed to find wrapped line in text');
+                }
+                searchOffset = startOffset + text.length;
+                // Check if this line ends with a newline in this.text
+                const potentialNewlinePos = startOffset + text.length;
+                const endsWithNewline = potentialNewlinePos < this.text.length &&
+                    this.text[potentialNewlinePos] === '\n';
+                if (endsWithNewline) {
+                    lastNewLinePos = potentialNewlinePos;
+                }
+                wrappedLines.push(new WrappedLine(text, startOffset, isPrecededByNewline(startOffset), endsWithNewline));
+            }
+        }
+        return wrappedLines;
+    }
+    getWrappedText() {
+        return this.wrappedLines.map(line => line.isPrecededByNewline ? line.text : line.text.trimStart());
+    }
+    getWrappedLines() {
+        return this.wrappedLines;
+    }
+    getLine(line) {
+        const lines = this.wrappedLines;
+        return lines[Math.max(0, Math.min(line, lines.length - 1))];
+    }
+    getOffsetFromPosition(position) {
+        const wrappedLine = this.getLine(position.line);
+        // Handle blank lines specially
+        if (wrappedLine.text.length === 0 && wrappedLine.endsWithNewline) {
+            return wrappedLine.startOffset;
+        }
+        // Account for leading whitespace
+        const leadingWhitespace = wrappedLine.isPrecededByNewline
+            ? 0
+            : wrappedLine.text.length - wrappedLine.text.trimStart().length;
+        // Convert display column to string index
+        const displayColumnWithLeading = position.column + leadingWhitespace;
+        const stringIndex = this.displayWidthToStringIndex(wrappedLine.text, displayColumnWithLeading);
+        // Calculate the actual offset
+        const offset = wrappedLine.startOffset + stringIndex;
+        // For normal lines
+        const lineEnd = wrappedLine.startOffset + wrappedLine.text.length;
+        // Don't allow going past the end of the current line into the next line
+        // unless we're at the very end of the text
+        let maxOffset = lineEnd;
+        const lineDisplayWidth = stringWidth(wrappedLine.text);
+        if (wrappedLine.endsWithNewline && position.column > lineDisplayWidth) {
+            // Allow positioning after the newline
+            maxOffset = lineEnd + 1;
+        }
+        return Math.min(offset, maxOffset);
+    }
+    getLineLength(line) {
+        const wrappedLine = this.getLine(line);
+        return stringWidth(wrappedLine.text);
+    }
+    getPositionFromOffset(offset) {
+        const lines = this.wrappedLines;
+        for (let line = 0; line < lines.length; line++) {
+            const currentLine = lines[line];
+            const nextLine = lines[line + 1];
+            if (offset >= currentLine.startOffset &&
+                (!nextLine || offset < nextLine.startOffset)) {
+                // Calculate string position within the line
+                const stringPosInLine = offset - currentLine.startOffset;
+                // Handle leading whitespace for wrapped lines
+                let displayColumn;
+                if (currentLine.isPrecededByNewline) {
+                    // For lines preceded by newline, calculate display width directly
+                    displayColumn = this.stringIndexToDisplayWidth(currentLine.text, stringPosInLine);
+                }
+                else {
+                    // For wrapped lines, we need to account for trimmed whitespace
+                    const leadingWhitespace = currentLine.text.length - currentLine.text.trimStart().length;
+                    if (stringPosInLine < leadingWhitespace) {
+                        // Cursor is in the trimmed whitespace area, position at start
+                        displayColumn = 0;
+                    }
+                    else {
+                        // Calculate display width from the trimmed text
+                        const trimmedText = currentLine.text.trimStart();
+                        const posInTrimmed = stringPosInLine - leadingWhitespace;
+                        displayColumn = this.stringIndexToDisplayWidth(trimmedText, posInTrimmed);
+                    }
+                }
+                return {
+                    line,
+                    column: Math.max(0, displayColumn),
+                };
+            }
+        }
+        // If we're past the last character, return the end of the last line
+        const line = lines.length - 1;
+        const lastLine = this.wrappedLines[line];
+        return {
+            line,
+            column: stringWidth(lastLine.text),
+        };
+    }
+    get lineCount() {
+        return this.wrappedLines.length;
+    }
+    withCache(key, compute) {
+        const cached = this.navigationCache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const result = compute();
+        this.navigationCache.set(key, result);
+        return result;
+    }
+    nextOffset(offset) {
+        return this.withCache(`next:${offset}`, () => {
+            const boundaries = this.getGraphemeBoundaries();
+            return this.binarySearchBoundary(boundaries, offset, true);
+        });
+    }
+    prevOffset(offset) {
+        if (offset <= 0)
+            return 0;
+        return this.withCache(`prev:${offset}`, () => {
+            const boundaries = this.getGraphemeBoundaries();
+            return this.binarySearchBoundary(boundaries, offset, false);
+        });
+    }
+    /**
+     * Snap an arbitrary code-unit offset to the start of the containing grapheme.
+     * If offset is already on a boundary, returns it unchanged.
+     */
+    snapToGraphemeBoundary(offset) {
+        if (offset <= 0)
+            return 0;
+        if (offset >= this.text.length)
+            return this.text.length;
+        const boundaries = this.getGraphemeBoundaries();
+        // Binary search for largest boundary <= offset
+        let lo = 0;
+        let hi = boundaries.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (boundaries[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return boundaries[lo];
+    }
+}