fss-link 1.2.1 → 1.2.3

package/dist/src/ui/components/shared/text-buffer.js

@@ -1,1533 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import stripAnsi from 'strip-ansi';
-import { stripVTControlCharacters } from 'util';
-import { spawnSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import pathMod from 'path';
-import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
-import stringWidth from 'string-width';
-import { unescapePath } from 'fss-link-core';
-import { toCodePoints, cpLen, cpSlice } from '../../utils/textUtils.js';
-import { handleVimAction } from './vim-buffer-actions.js';
-// Simple helper for word‑wise ops.
-function isWordChar(ch) {
-    if (ch === undefined) {
-        return false;
-    }
-    return !/[\s,.;!?]/.test(ch);
-}
-// Helper functions for line-based word navigation
-export const isWordCharStrict = (char) => /[\w\p{L}\p{N}]/u.test(char); // Matches a single character that is any Unicode letter, any Unicode number, or an underscore
-export const isWhitespace = (char) => /\s/.test(char);
-// Check if a character is a combining mark (only diacritics for now)
-export const isCombiningMark = (char) => /\p{M}/u.test(char);
-// Check if a character should be considered part of a word (including combining marks)
-export const isWordCharWithCombining = (char) => isWordCharStrict(char) || isCombiningMark(char);
-// Get the script of a character (simplified for common scripts)
-export const getCharScript = (char) => {
-    if (/[\p{Script=Latin}]/u.test(char))
-        return 'latin'; // All Latin script chars including diacritics
-    if (/[\p{Script=Han}]/u.test(char))
-        return 'han'; // Chinese
-    if (/[\p{Script=Arabic}]/u.test(char))
-        return 'arabic';
-    if (/[\p{Script=Hiragana}]/u.test(char))
-        return 'hiragana';
-    if (/[\p{Script=Katakana}]/u.test(char))
-        return 'katakana';
-    if (/[\p{Script=Cyrillic}]/u.test(char))
-        return 'cyrillic';
-    return 'other';
-};
-// Check if two characters are from different scripts (indicating word boundary)
-export const isDifferentScript = (char1, char2) => {
-    if (!isWordCharStrict(char1) || !isWordCharStrict(char2))
-        return false;
-    return getCharScript(char1) !== getCharScript(char2);
-};
-// Find next word start within a line, starting from col
-export const findNextWordStartInLine = (line, col) => {
-    const chars = toCodePoints(line);
-    let i = col;
-    if (i >= chars.length)
-        return null;
-    const currentChar = chars[i];
-    // Skip current word/sequence based on character type
-    if (isWordCharStrict(currentChar)) {
-        while (i < chars.length && isWordCharWithCombining(chars[i])) {
-            // Check for script boundary - if next character is from different script, stop here
-            if (i + 1 < chars.length &&
-                isWordCharStrict(chars[i + 1]) &&
-                isDifferentScript(chars[i], chars[i + 1])) {
-                i++; // Include current character
-                break; // Stop at script boundary
-            }
-            i++;
-        }
-    }
-    else if (!isWhitespace(currentChar)) {
-        while (i < chars.length &&
-            !isWordCharStrict(chars[i]) &&
-            !isWhitespace(chars[i])) {
-            i++;
-        }
-    }
-    // Skip whitespace
-    while (i < chars.length && isWhitespace(chars[i])) {
-        i++;
-    }
-    return i < chars.length ? i : null;
-};
-// Find previous word start within a line
-export const findPrevWordStartInLine = (line, col) => {
-    const chars = toCodePoints(line);
-    let i = col;
-    if (i <= 0)
-        return null;
-    i--;
-    // Skip whitespace moving backwards
-    while (i >= 0 && isWhitespace(chars[i])) {
-        i--;
-    }
-    if (i < 0)
-        return null;
-    if (isWordCharStrict(chars[i])) {
-        // We're in a word, move to its beginning
-        while (i >= 0 && isWordCharStrict(chars[i])) {
-            // Check for script boundary - if previous character is from different script, stop here
-            if (i - 1 >= 0 &&
-                isWordCharStrict(chars[i - 1]) &&
-                isDifferentScript(chars[i], chars[i - 1])) {
-                return i; // Return current position at script boundary
-            }
-            i--;
-        }
-        return i + 1;
-    }
-    else {
-        // We're in punctuation, move to its beginning
-        while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
-            i--;
-        }
-        return i + 1;
-    }
-};
-// Find word end within a line
-export const findWordEndInLine = (line, col) => {
-    const chars = toCodePoints(line);
-    let i = col;
-    // If we're already at the end of a word (including punctuation sequences), advance to next word
-    // This includes both regular word endings and script boundaries
-    const atEndOfWordChar = i < chars.length &&
-        isWordCharWithCombining(chars[i]) &&
-        (i + 1 >= chars.length ||
-            !isWordCharWithCombining(chars[i + 1]) ||
-            (isWordCharStrict(chars[i]) &&
-                i + 1 < chars.length &&
-                isWordCharStrict(chars[i + 1]) &&
-                isDifferentScript(chars[i], chars[i + 1])));
-    const atEndOfPunctuation = i < chars.length &&
-        !isWordCharWithCombining(chars[i]) &&
-        !isWhitespace(chars[i]) &&
-        (i + 1 >= chars.length ||
-            isWhitespace(chars[i + 1]) ||
-            isWordCharWithCombining(chars[i + 1]));
-    if (atEndOfWordChar || atEndOfPunctuation) {
-        // We're at the end of a word or punctuation sequence, move forward to find next word
-        i++;
-        // Skip whitespace to find next word or punctuation
-        while (i < chars.length && isWhitespace(chars[i])) {
-            i++;
-        }
-    }
-    // If we're not on a word character, find the next word or punctuation sequence
-    if (i < chars.length && !isWordCharWithCombining(chars[i])) {
-        // Skip whitespace to find next word or punctuation
-        while (i < chars.length && isWhitespace(chars[i])) {
-            i++;
-        }
-    }
-    // Move to end of current word (including combining marks, but stop at script boundaries)
-    let foundWord = false;
-    let lastBaseCharPos = -1;
-    if (i < chars.length && isWordCharWithCombining(chars[i])) {
-        // Handle word characters
-        while (i < chars.length && isWordCharWithCombining(chars[i])) {
-            foundWord = true;
-            // Track the position of the last base character (not combining mark)
-            if (isWordCharStrict(chars[i])) {
-                lastBaseCharPos = i;
-            }
-            // Check if next character is from a different script (word boundary)
-            if (i + 1 < chars.length &&
-                isWordCharStrict(chars[i + 1]) &&
-                isDifferentScript(chars[i], chars[i + 1])) {
-                i++; // Include current character
-                if (isWordCharStrict(chars[i - 1])) {
-                    lastBaseCharPos = i - 1;
-                }
-                break; // Stop at script boundary
-            }
-            i++;
-        }
-    }
-    else if (i < chars.length && !isWhitespace(chars[i])) {
-        // Handle punctuation sequences (like ████)
-        while (i < chars.length &&
-            !isWordCharStrict(chars[i]) &&
-            !isWhitespace(chars[i])) {
-            foundWord = true;
-            lastBaseCharPos = i;
-            i++;
-        }
-    }
-    // Only return a position if we actually found a word
-    // Return the position of the last base character, not combining marks
-    if (foundWord && lastBaseCharPos >= col) {
-        return lastBaseCharPos;
-    }
-    return null;
-};
-// Find next word across lines
-export const findNextWordAcrossLines = (lines, cursorRow, cursorCol, searchForWordStart) => {
-    // First try current line
-    const currentLine = lines[cursorRow] || '';
-    const colInCurrentLine = searchForWordStart
-        ? findNextWordStartInLine(currentLine, cursorCol)
-        : findWordEndInLine(currentLine, cursorCol);
-    if (colInCurrentLine !== null) {
-        return { row: cursorRow, col: colInCurrentLine };
-    }
-    // Search subsequent lines
-    for (let row = cursorRow + 1; row < lines.length; row++) {
-        const line = lines[row] || '';
-        const chars = toCodePoints(line);
-        // For empty lines, if we haven't found any words yet, return the empty line
-        if (chars.length === 0) {
-            // Check if there are any words in remaining lines
-            let hasWordsInLaterLines = false;
-            for (let laterRow = row + 1; laterRow < lines.length; laterRow++) {
-                const laterLine = lines[laterRow] || '';
-                const laterChars = toCodePoints(laterLine);
-                let firstNonWhitespace = 0;
-                while (firstNonWhitespace < laterChars.length &&
-                    isWhitespace(laterChars[firstNonWhitespace])) {
-                    firstNonWhitespace++;
-                }
-                if (firstNonWhitespace < laterChars.length) {
-                    hasWordsInLaterLines = true;
-                    break;
-                }
-            }
-            // If no words in later lines, return the empty line
-            if (!hasWordsInLaterLines) {
-                return { row, col: 0 };
-            }
-            continue;
-        }
-        // Find first non-whitespace
-        let firstNonWhitespace = 0;
-        while (firstNonWhitespace < chars.length &&
-            isWhitespace(chars[firstNonWhitespace])) {
-            firstNonWhitespace++;
-        }
-        if (firstNonWhitespace < chars.length) {
-            if (searchForWordStart) {
-                return { row, col: firstNonWhitespace };
-            }
-            else {
-                // For word end, find the end of the first word
-                const endCol = findWordEndInLine(line, firstNonWhitespace);
-                if (endCol !== null) {
-                    return { row, col: endCol };
-                }
-            }
-        }
-    }
-    return null;
-};
-// Find previous word across lines
-export const findPrevWordAcrossLines = (lines, cursorRow, cursorCol) => {
-    // First try current line
-    const currentLine = lines[cursorRow] || '';
-    const colInCurrentLine = findPrevWordStartInLine(currentLine, cursorCol);
-    if (colInCurrentLine !== null) {
-        return { row: cursorRow, col: colInCurrentLine };
-    }
-    // Search previous lines
-    for (let row = cursorRow - 1; row >= 0; row--) {
-        const line = lines[row] || '';
-        const chars = toCodePoints(line);
-        if (chars.length === 0)
-            continue;
-        // Find last word start
-        let lastWordStart = chars.length;
-        while (lastWordStart > 0 && isWhitespace(chars[lastWordStart - 1])) {
-            lastWordStart--;
-        }
-        if (lastWordStart > 0) {
-            // Find start of this word
-            const wordStart = findPrevWordStartInLine(line, lastWordStart);
-            if (wordStart !== null) {
-                return { row, col: wordStart };
-            }
-        }
-    }
-    return null;
-};
-// Helper functions for vim line operations
-export const getPositionFromOffsets = (startOffset, endOffset, lines) => {
-    let offset = 0;
-    let startRow = 0;
-    let startCol = 0;
-    let endRow = 0;
-    let endCol = 0;
-    // Find start position
-    for (let i = 0; i < lines.length; i++) {
-        const lineLength = lines[i].length + 1; // +1 for newline
-        if (offset + lineLength > startOffset) {
-            startRow = i;
-            startCol = startOffset - offset;
-            break;
-        }
-        offset += lineLength;
-    }
-    // Find end position
-    offset = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const lineLength = lines[i].length + (i < lines.length - 1 ? 1 : 0); // +1 for newline except last line
-        if (offset + lineLength >= endOffset) {
-            endRow = i;
-            endCol = endOffset - offset;
-            break;
-        }
-        offset += lineLength;
-    }
-    return { startRow, startCol, endRow, endCol };
-};
-export const getLineRangeOffsets = (startRow, lineCount, lines) => {
-    let startOffset = 0;
-    // Calculate start offset
-    for (let i = 0; i < startRow; i++) {
-        startOffset += lines[i].length + 1; // +1 for newline
-    }
-    // Calculate end offset
-    let endOffset = startOffset;
-    for (let i = 0; i < lineCount; i++) {
-        const lineIndex = startRow + i;
-        if (lineIndex < lines.length) {
-            endOffset += lines[lineIndex].length;
-            if (lineIndex < lines.length - 1) {
-                endOffset += 1; // +1 for newline
-            }
-        }
-    }
-    return { startOffset, endOffset };
-};
-export const replaceRangeInternal = (state, startRow, startCol, endRow, endCol, text) => {
-    const currentLine = (row) => state.lines[row] || '';
-    const currentLineLen = (row) => cpLen(currentLine(row));
-    const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
-    if (startRow > endRow ||
-        (startRow === endRow && startCol > endCol) ||
-        startRow < 0 ||
-        startCol < 0 ||
-        endRow >= state.lines.length ||
-        (endRow < state.lines.length && endCol > currentLineLen(endRow))) {
-        return state; // Invalid range
-    }
-    const newLines = [...state.lines];
-    const sCol = clamp(startCol, 0, currentLineLen(startRow));
-    const eCol = clamp(endCol, 0, currentLineLen(endRow));
-    const prefix = cpSlice(currentLine(startRow), 0, sCol);
-    const suffix = cpSlice(currentLine(endRow), eCol);
-    const normalisedReplacement = text
-        .replace(/\r\n/g, '\n')
-        .replace(/\r/g, '\n');
-    const replacementParts = normalisedReplacement.split('\n');
-    // The combined first line of the new text
-    const firstLine = prefix + replacementParts[0];
-    if (replacementParts.length === 1) {
-        // No newlines in replacement: combine prefix, replacement, and suffix on one line.
-        newLines.splice(startRow, endRow - startRow + 1, firstLine + suffix);
-    }
-    else {
-        // Newlines in replacement: create new lines.
-        const lastLine = replacementParts[replacementParts.length - 1] + suffix;
-        const middleLines = replacementParts.slice(1, -1);
-        newLines.splice(startRow, endRow - startRow + 1, firstLine, ...middleLines, lastLine);
-    }
-    const finalCursorRow = startRow + replacementParts.length - 1;
-    const finalCursorCol = (replacementParts.length > 1 ? 0 : sCol) +
-        cpLen(replacementParts[replacementParts.length - 1]);
-    return {
-        ...state,
-        lines: newLines,
-        cursorRow: Math.min(Math.max(finalCursorRow, 0), newLines.length - 1),
-        cursorCol: Math.max(0, Math.min(finalCursorCol, cpLen(newLines[finalCursorRow] || ''))),
-        preferredCol: null,
-    };
-};
-/**
- * Strip characters that can break terminal rendering.
- *
- * Uses Node.js built-in stripVTControlCharacters to handle VT sequences,
- * then filters remaining control characters that can disrupt display.
- *
- * Characters stripped:
- * - ANSI escape sequences (via strip-ansi)
- * - VT control sequences (via Node.js util.stripVTControlCharacters)
- * - C0 control chars (0x00-0x1F) except CR/LF which are handled elsewhere
- * - C1 control chars (0x80-0x9F) that can cause display issues
- *
- * Characters preserved:
- * - All printable Unicode including emojis
- * - DEL (0x7F) - handled functionally by applyOperations, not a display issue
- * - CR/LF (0x0D/0x0A) - needed for line breaks
- */
-function stripUnsafeCharacters(str) {
-    const strippedAnsi = stripAnsi(str);
-    const strippedVT = stripVTControlCharacters(strippedAnsi);
-    return toCodePoints(strippedVT)
-        .filter((char) => {
-        const code = char.codePointAt(0);
-        if (code === undefined)
-            return false;
-        // Preserve CR/LF for line handling
-        if (code === 0x0a || code === 0x0d)
-            return true;
-        // Remove C0 control chars (except CR/LF) that can break display
-        // Examples: BELL(0x07) makes noise, BS(0x08) moves cursor, VT(0x0B), FF(0x0C)
-        if (code >= 0x00 && code <= 0x1f)
-            return false;
-        // Remove C1 control chars (0x80-0x9F) - legacy 8-bit control codes
-        if (code >= 0x80 && code <= 0x9f)
-            return false;
-        // Preserve DEL (0x7F) - it's handled functionally by applyOperations as backspace
-        // and doesn't cause rendering issues when displayed
-        // Preserve all other characters including Unicode/emojis
-        return true;
-    })
-        .join('');
-}
-function clamp(v, min, max) {
-    return v < min ? min : v > max ? max : v;
-}
-function calculateInitialCursorPosition(initialLines, offset) {
-    let remainingChars = offset;
-    let row = 0;
-    while (row < initialLines.length) {
-        const lineLength = cpLen(initialLines[row]);
-        // Add 1 for the newline character (except for the last line)
-        const totalCharsInLineAndNewline = lineLength + (row < initialLines.length - 1 ? 1 : 0);
-        if (remainingChars <= lineLength) {
-            // Cursor is on this line
-            return [row, remainingChars];
-        }
-        remainingChars -= totalCharsInLineAndNewline;
-        row++;
-    }
-    // Offset is beyond the text, place cursor at the end of the last line
-    if (initialLines.length > 0) {
-        const lastRow = initialLines.length - 1;
-        return [lastRow, cpLen(initialLines[lastRow])];
-    }
-    return [0, 0]; // Default for empty text
-}
-export function offsetToLogicalPos(text, offset) {
-    let row = 0;
-    let col = 0;
-    let currentOffset = 0;
-    if (offset === 0)
-        return [0, 0];
-    const lines = text.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const lineLength = cpLen(line);
-        const lineLengthWithNewline = lineLength + (i < lines.length - 1 ? 1 : 0);
-        if (offset <= currentOffset + lineLength) {
-            // Check against lineLength first
-            row = i;
-            col = offset - currentOffset;
-            return [row, col];
-        }
-        else if (offset <= currentOffset + lineLengthWithNewline) {
-            // Check if offset is the newline itself
-            row = i;
-            col = lineLength; // Position cursor at the end of the current line content
-            // If the offset IS the newline, and it's not the last line, advance to next line, col 0
-            if (offset === currentOffset + lineLengthWithNewline &&
-                i < lines.length - 1) {
-                return [i + 1, 0];
-            }
-            return [row, col]; // Otherwise, it's at the end of the current line content
-        }
-        currentOffset += lineLengthWithNewline;
-    }
-    // If offset is beyond the text length, place cursor at the end of the last line
-    // or [0,0] if text is empty
-    if (lines.length > 0) {
-        row = lines.length - 1;
-        col = cpLen(lines[row]);
-    }
-    else {
-        row = 0;
-        col = 0;
-    }
-    return [row, col];
-}
-/**
- * Converts logical row/col position to absolute text offset
- * Inverse operation of offsetToLogicalPos
- */
-export function logicalPosToOffset(lines, row, col) {
-    let offset = 0;
-    // Clamp row to valid range
-    const actualRow = Math.min(row, lines.length - 1);
-    // Add lengths of all lines before the target row
-    for (let i = 0; i < actualRow; i++) {
-        offset += cpLen(lines[i]) + 1; // +1 for newline
-    }
-    // Add column offset within the target row
-    if (actualRow >= 0 && actualRow < lines.length) {
-        offset += Math.min(col, cpLen(lines[actualRow]));
-    }
-    return offset;
-}
-// Helper to calculate visual lines and map cursor positions
-function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
-    const visualLines = [];
-    const logicalToVisualMap = [];
-    const visualToLogicalMap = [];
-    let currentVisualCursor = [0, 0];
-    logicalLines.forEach((logLine, logIndex) => {
-        logicalToVisualMap[logIndex] = [];
-        if (logLine.length === 0) {
-            // Handle empty logical line
-            logicalToVisualMap[logIndex].push([visualLines.length, 0]);
-            visualToLogicalMap.push([logIndex, 0]);
-            visualLines.push('');
-            if (logIndex === logicalCursor[0] && logicalCursor[1] === 0) {
-                currentVisualCursor = [visualLines.length - 1, 0];
-            }
-        }
-        else {
-            // Non-empty logical line
-            let currentPosInLogLine = 0; // Tracks position within the current logical line (code point index)
-            const codePointsInLogLine = toCodePoints(logLine);
-            while (currentPosInLogLine < codePointsInLogLine.length) {
-                let currentChunk = '';
-                let currentChunkVisualWidth = 0;
-                let numCodePointsInChunk = 0;
-                let lastWordBreakPoint = -1; // Index in codePointsInLogLine for word break
-                let numCodePointsAtLastWordBreak = 0;
-                // Iterate through code points to build the current visual line (chunk)
-                for (let i = currentPosInLogLine; i < codePointsInLogLine.length; i++) {
-                    const char = codePointsInLogLine[i];
-                    const charVisualWidth = stringWidth(char);
-                    if (currentChunkVisualWidth + charVisualWidth > viewportWidth) {
-                        // Character would exceed viewport width
-                        if (lastWordBreakPoint !== -1 &&
-                            numCodePointsAtLastWordBreak > 0 &&
-                            currentPosInLogLine + numCodePointsAtLastWordBreak < i) {
-                            // We have a valid word break point to use, and it's not the start of the current segment
-                            currentChunk = codePointsInLogLine
-                                .slice(currentPosInLogLine, currentPosInLogLine + numCodePointsAtLastWordBreak)
-                                .join('');
-                            numCodePointsInChunk = numCodePointsAtLastWordBreak;
-                        }
-                        else {
-                            // No word break, or word break is at the start of this potential chunk, or word break leads to empty chunk.
-                            // Hard break: take characters up to viewportWidth, or just the current char if it alone is too wide.
-                            if (numCodePointsInChunk === 0 &&
-                                charVisualWidth > viewportWidth) {
-                                // Single character is wider than viewport, take it anyway
-                                currentChunk = char;
-                                numCodePointsInChunk = 1;
-                            }
-                            else if (numCodePointsInChunk === 0 &&
-                                charVisualWidth <= viewportWidth) {
-                                // This case should ideally be caught by the next iteration if the char fits.
-                                // If it doesn't fit (because currentChunkVisualWidth was already > 0 from a previous char that filled the line),
-                                // then numCodePointsInChunk would not be 0.
-                                // This branch means the current char *itself* doesn't fit an empty line, which is handled by the above.
-                                // If we are here, it means the loop should break and the current chunk (which is empty) is finalized.
-                            }
-                        }
-                        break; // Break from inner loop to finalize this chunk
-                    }
-                    currentChunk += char;
-                    currentChunkVisualWidth += charVisualWidth;
-                    numCodePointsInChunk++;
-                    // Check for word break opportunity (space)
-                    if (char === ' ') {
-                        lastWordBreakPoint = i; // Store code point index of the space
-                        // Store the state *before* adding the space, if we decide to break here.
-                        numCodePointsAtLastWordBreak = numCodePointsInChunk - 1; // Chars *before* the space
-                    }
-                }
-                // If the inner loop completed without breaking (i.e., remaining text fits)
-                // or if the loop broke but numCodePointsInChunk is still 0 (e.g. first char too wide for empty line)
-                if (numCodePointsInChunk === 0 &&
-                    currentPosInLogLine < codePointsInLogLine.length) {
-                    // This can happen if the very first character considered for a new visual line is wider than the viewport.
-                    // In this case, we take that single character.
-                    const firstChar = codePointsInLogLine[currentPosInLogLine];
-                    currentChunk = firstChar;
-                    numCodePointsInChunk = 1; // Ensure we advance
-                }
-                // If after everything, numCodePointsInChunk is still 0 but we haven't processed the whole logical line,
-                // it implies an issue, like viewportWidth being 0 or less. Avoid infinite loop.
-                if (numCodePointsInChunk === 0 &&
-                    currentPosInLogLine < codePointsInLogLine.length) {
-                    // Force advance by one character to prevent infinite loop if something went wrong
-                    currentChunk = codePointsInLogLine[currentPosInLogLine];
-                    numCodePointsInChunk = 1;
-                }
-                logicalToVisualMap[logIndex].push([
-                    visualLines.length,
-                    currentPosInLogLine,
-                ]);
-                visualToLogicalMap.push([logIndex, currentPosInLogLine]);
-                visualLines.push(currentChunk);
-                // Cursor mapping logic
-                // Note: currentPosInLogLine here is the start of the currentChunk within the logical line.
-                if (logIndex === logicalCursor[0]) {
-                    const cursorLogCol = logicalCursor[1]; // This is a code point index
-                    if (cursorLogCol >= currentPosInLogLine &&
-                        cursorLogCol < currentPosInLogLine + numCodePointsInChunk // Cursor is within this chunk
-                    ) {
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            cursorLogCol - currentPosInLogLine, // Visual col is also code point index within visual line
-                        ];
-                    }
-                    else if (cursorLogCol === currentPosInLogLine + numCodePointsInChunk &&
-                        numCodePointsInChunk > 0) {
-                        // Cursor is exactly at the end of this non-empty chunk
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            numCodePointsInChunk,
-                        ];
-                    }
-                }
-                const logicalStartOfThisChunk = currentPosInLogLine;
-                currentPosInLogLine += numCodePointsInChunk;
-                // If the chunk processed did not consume the entire logical line,
-                // and the character immediately following the chunk is a space,
-                // advance past this space as it acted as a delimiter for word wrapping.
-                if (logicalStartOfThisChunk + numCodePointsInChunk <
-                    codePointsInLogLine.length &&
-                    currentPosInLogLine < codePointsInLogLine.length && // Redundant if previous is true, but safe
-                    codePointsInLogLine[currentPosInLogLine] === ' ') {
-                    currentPosInLogLine++;
-                }
-            }
-            // After all chunks of a non-empty logical line are processed,
-            // if the cursor is at the very end of this logical line, update visual cursor.
-            if (logIndex === logicalCursor[0] &&
-                logicalCursor[1] === codePointsInLogLine.length // Cursor at end of logical line
-            ) {
-                const lastVisualLineIdx = visualLines.length - 1;
-                if (lastVisualLineIdx >= 0 &&
-                    visualLines[lastVisualLineIdx] !== undefined) {
-                    currentVisualCursor = [
-                        lastVisualLineIdx,
-                        cpLen(visualLines[lastVisualLineIdx]), // Cursor at end of last visual line for this logical line
-                    ];
-                }
-            }
-        }
-    });
-    // If the entire logical text was empty, ensure there's one empty visual line.
-    if (logicalLines.length === 0 ||
-        (logicalLines.length === 1 && logicalLines[0] === '')) {
-        if (visualLines.length === 0) {
-            visualLines.push('');
-            if (!logicalToVisualMap[0])
-                logicalToVisualMap[0] = [];
-            logicalToVisualMap[0].push([0, 0]);
-            visualToLogicalMap.push([0, 0]);
-        }
-        currentVisualCursor = [0, 0];
-    }
-    // Handle cursor at the very end of the text (after all processing)
-    // This case might be covered by the loop end condition now, but kept for safety.
-    else if (logicalCursor[0] === logicalLines.length - 1 &&
-        logicalCursor[1] === cpLen(logicalLines[logicalLines.length - 1]) &&
-        visualLines.length > 0) {
-        const lastVisLineIdx = visualLines.length - 1;
-        currentVisualCursor = [lastVisLineIdx, cpLen(visualLines[lastVisLineIdx])];
-    }
-    return {
-        visualLines,
-        visualCursor: currentVisualCursor,
-        logicalToVisualMap,
-        visualToLogicalMap,
-    };
-}
-const historyLimit = 100;
-export const pushUndo = (currentState) => {
-    const snapshot = {
-        lines: [...currentState.lines],
-        cursorRow: currentState.cursorRow,
-        cursorCol: currentState.cursorCol,
-    };
-    const newStack = [...currentState.undoStack, snapshot];
-    if (newStack.length > historyLimit) {
-        newStack.shift();
-    }
-    return { ...currentState, undoStack: newStack, redoStack: [] };
-};
-export function textBufferReducer(state, action) {
-    const pushUndoLocal = pushUndo;
-    const currentLine = (r) => state.lines[r] ?? '';
-    const currentLineLen = (r) => cpLen(currentLine(r));
-    switch (action.type) {
-        case 'set_text': {
-            let nextState = state;
-            if (action.pushToUndo !== false) {
-                nextState = pushUndoLocal(state);
-            }
-            const newContentLines = action.payload
-                .replace(/\r\n?/g, '\n')
-                .split('\n');
-            const lines = newContentLines.length === 0 ? [''] : newContentLines;
-            const lastNewLineIndex = lines.length - 1;
-            return {
-                ...nextState,
-                lines,
-                cursorRow: lastNewLineIndex,
-                cursorCol: cpLen(lines[lastNewLineIndex] ?? ''),
-                preferredCol: null,
-            };
-        }
-        case 'insert': {
-            const nextState = pushUndoLocal(state);
-            const newLines = [...nextState.lines];
-            let newCursorRow = nextState.cursorRow;
-            let newCursorCol = nextState.cursorCol;
-            const currentLine = (r) => newLines[r] ?? '';
-            const str = stripUnsafeCharacters(action.payload.replace(/\r\n/g, '\n').replace(/\r/g, '\n'));
-            const parts = str.split('\n');
-            const lineContent = currentLine(newCursorRow);
-            const before = cpSlice(lineContent, 0, newCursorCol);
-            const after = cpSlice(lineContent, newCursorCol);
-            if (parts.length > 1) {
-                newLines[newCursorRow] = before + parts[0];
-                const remainingParts = parts.slice(1);
-                const lastPartOriginal = remainingParts.pop() ?? '';
-                newLines.splice(newCursorRow + 1, 0, ...remainingParts);
-                newLines.splice(newCursorRow + parts.length - 1, 0, lastPartOriginal + after);
-                newCursorRow = newCursorRow + parts.length - 1;
-                newCursorCol = cpLen(lastPartOriginal);
-            }
-            else {
-                newLines[newCursorRow] = before + parts[0] + after;
-                newCursorCol = cpLen(before) + cpLen(parts[0]);
-            }
-            return {
-                ...nextState,
-                lines: newLines,
-                cursorRow: newCursorRow,
-                cursorCol: newCursorCol,
-                preferredCol: null,
-            };
-        }
-        case 'backspace': {
-            const nextState = pushUndoLocal(state);
-            const newLines = [...nextState.lines];
-            let newCursorRow = nextState.cursorRow;
-            let newCursorCol = nextState.cursorCol;
-            const currentLine = (r) => newLines[r] ?? '';
-            if (newCursorCol === 0 && newCursorRow === 0)
-                return state;
-            if (newCursorCol > 0) {
-                const lineContent = currentLine(newCursorRow);
-                newLines[newCursorRow] =
-                    cpSlice(lineContent, 0, newCursorCol - 1) +
-                        cpSlice(lineContent, newCursorCol);
-                newCursorCol--;
-            }
-            else if (newCursorRow > 0) {
-                const prevLineContent = currentLine(newCursorRow - 1);
-                const currentLineContentVal = currentLine(newCursorRow);
-                const newCol = cpLen(prevLineContent);
-                newLines[newCursorRow - 1] = prevLineContent + currentLineContentVal;
-                newLines.splice(newCursorRow, 1);
-                newCursorRow--;
-                newCursorCol = newCol;
-            }
-            return {
-                ...nextState,
-                lines: newLines,
-                cursorRow: newCursorRow,
-                cursorCol: newCursorCol,
-                preferredCol: null,
-            };
-        }
-        case 'set_viewport_width': {
-            if (action.payload === state.viewportWidth) {
-                return state;
-            }
-            return { ...state, viewportWidth: action.payload };
-        }
-        case 'move': {
-            const { dir } = action.payload;
-            const { lines, cursorRow, cursorCol, viewportWidth } = state;
-            const visualLayout = calculateVisualLayout(lines, [cursorRow, cursorCol], viewportWidth);
-            const { visualLines, visualCursor, visualToLogicalMap } = visualLayout;
-            let newVisualRow = visualCursor[0];
-            let newVisualCol = visualCursor[1];
-            let newPreferredCol = state.preferredCol;
-            const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
-            switch (dir) {
-                case 'left':
-                    newPreferredCol = null;
-                    if (newVisualCol > 0) {
-                        newVisualCol--;
-                    }
-                    else if (newVisualRow > 0) {
-                        newVisualRow--;
-                        newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
-                    }
-                    break;
-                case 'right':
-                    newPreferredCol = null;
-                    if (newVisualCol < currentVisLineLen) {
-                        newVisualCol++;
-                    }
-                    else if (newVisualRow < visualLines.length - 1) {
-                        newVisualRow++;
-                        newVisualCol = 0;
-                    }
-                    break;
-                case 'up':
-                    if (newVisualRow > 0) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow--;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'down':
-                    if (newVisualRow < visualLines.length - 1) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow++;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'home':
-                    newPreferredCol = null;
-                    newVisualCol = 0;
-                    break;
-                case 'end':
-                    newPreferredCol = null;
-                    newVisualCol = currentVisLineLen;
-                    break;
-                case 'wordLeft': {
-                    const { cursorRow, cursorCol, lines } = state;
-                    if (cursorCol === 0 && cursorRow === 0)
-                        return state;
-                    let newCursorRow = cursorRow;
-                    let newCursorCol = cursorCol;
-                    if (cursorCol === 0) {
-                        newCursorRow--;
-                        newCursorCol = cpLen(lines[newCursorRow] ?? '');
-                    }
-                    else {
-                        const lineContent = lines[cursorRow];
-                        const arr = toCodePoints(lineContent);
-                        let start = cursorCol;
-                        let onlySpaces = true;
-                        for (let i = 0; i < start; i++) {
-                            if (isWordChar(arr[i])) {
-                                onlySpaces = false;
-                                break;
-                            }
-                        }
-                        if (onlySpaces && start > 0) {
-                            start--;
-                        }
-                        else {
-                            while (start > 0 && !isWordChar(arr[start - 1]))
-                                start--;
-                            while (start > 0 && isWordChar(arr[start - 1]))
-                                start--;
-                        }
-                        newCursorCol = start;
-                    }
-                    return {
-                        ...state,
-                        cursorRow: newCursorRow,
-                        cursorCol: newCursorCol,
-                        preferredCol: null,
-                    };
-                }
-                case 'wordRight': {
-                    const { cursorRow, cursorCol, lines } = state;
-                    if (cursorRow === lines.length - 1 &&
-                        cursorCol === cpLen(lines[cursorRow] ?? '')) {
-                        return state;
-                    }
-                    let newCursorRow = cursorRow;
-                    let newCursorCol = cursorCol;
-                    const lineContent = lines[cursorRow] ?? '';
-                    const arr = toCodePoints(lineContent);
-                    if (cursorCol >= arr.length) {
-                        newCursorRow++;
-                        newCursorCol = 0;
-                    }
-                    else {
-                        let end = cursorCol;
-                        while (end < arr.length && !isWordChar(arr[end]))
-                            end++;
-                        while (end < arr.length && isWordChar(arr[end]))
-                            end++;
-                        newCursorCol = end;
-                    }
-                    return {
-                        ...state,
-                        cursorRow: newCursorRow,
-                        cursorCol: newCursorCol,
-                        preferredCol: null,
-                    };
-                }
-                default:
-                    break;
-            }
-            if (visualToLogicalMap[newVisualRow]) {
-                const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
-                return {
-                    ...state,
-                    cursorRow: logRow,
-                    cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(state.lines[logRow] ?? '')),
-                    preferredCol: newPreferredCol,
-                };
-            }
-            return state;
-        }
-        case 'delete': {
-            const { cursorRow, cursorCol, lines } = state;
-            const lineContent = currentLine(cursorRow);
-            if (cursorCol < currentLineLen(cursorRow)) {
-                const nextState = pushUndoLocal(state);
-                const newLines = [...nextState.lines];
-                newLines[cursorRow] =
-                    cpSlice(lineContent, 0, cursorCol) +
-                        cpSlice(lineContent, cursorCol + 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
-            }
-            else if (cursorRow < lines.length - 1) {
-                const nextState = pushUndoLocal(state);
-                const nextLineContent = currentLine(cursorRow + 1);
-                const newLines = [...nextState.lines];
-                newLines[cursorRow] = lineContent + nextLineContent;
-                newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
-            }
-            return state;
-        }
-        case 'delete_word_left': {
-            const { cursorRow, cursorCol } = state;
-            if (cursorCol === 0 && cursorRow === 0)
-                return state;
-            if (cursorCol === 0) {
-                // Act as a backspace
-                const nextState = pushUndoLocal(state);
-                const prevLineContent = currentLine(cursorRow - 1);
-                const currentLineContentVal = currentLine(cursorRow);
-                const newCol = cpLen(prevLineContent);
-                const newLines = [...nextState.lines];
-                newLines[cursorRow - 1] = prevLineContent + currentLineContentVal;
-                newLines.splice(cursorRow, 1);
-                return {
-                    ...nextState,
-                    lines: newLines,
-                    cursorRow: cursorRow - 1,
-                    cursorCol: newCol,
-                    preferredCol: null,
-                };
-            }
-            const nextState = pushUndoLocal(state);
-            const lineContent = currentLine(cursorRow);
-            const arr = toCodePoints(lineContent);
-            let start = cursorCol;
-            let onlySpaces = true;
-            for (let i = 0; i < start; i++) {
-                if (isWordChar(arr[i])) {
-                    onlySpaces = false;
-                    break;
-                }
-            }
-            if (onlySpaces && start > 0) {
-                start--;
-            }
-            else {
-                while (start > 0 && !isWordChar(arr[start - 1]))
-                    start--;
-                while (start > 0 && isWordChar(arr[start - 1]))
-                    start--;
-            }
-            const newLines = [...nextState.lines];
-            newLines[cursorRow] =
-                cpSlice(lineContent, 0, start) + cpSlice(lineContent, cursorCol);
-            return {
-                ...nextState,
-                lines: newLines,
-                cursorCol: start,
-                preferredCol: null,
-            };
-        }
-        case 'delete_word_right': {
-            const { cursorRow, cursorCol, lines } = state;
-            const lineContent = currentLine(cursorRow);
-            const arr = toCodePoints(lineContent);
-            if (cursorCol >= arr.length && cursorRow === lines.length - 1)
-                return state;
-            if (cursorCol >= arr.length) {
-                // Act as a delete
-                const nextState = pushUndoLocal(state);
-                const nextLineContent = currentLine(cursorRow + 1);
-                const newLines = [...nextState.lines];
-                newLines[cursorRow] = lineContent + nextLineContent;
-                newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
-            }
-            const nextState = pushUndoLocal(state);
-            let end = cursorCol;
-            while (end < arr.length && !isWordChar(arr[end]))
-                end++;
-            while (end < arr.length && isWordChar(arr[end]))
-                end++;
-            const newLines = [...nextState.lines];
-            newLines[cursorRow] =
-                cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
-            return { ...nextState, lines: newLines, preferredCol: null };
-        }
-        case 'kill_line_right': {
-            const { cursorRow, cursorCol, lines } = state;
-            const lineContent = currentLine(cursorRow);
-            if (cursorCol < currentLineLen(cursorRow)) {
-                const nextState = pushUndoLocal(state);
-                const newLines = [...nextState.lines];
-                newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
-                return { ...nextState, lines: newLines };
-            }
-            else if (cursorRow < lines.length - 1) {
-                // Act as a delete
-                const nextState = pushUndoLocal(state);
-                const nextLineContent = currentLine(cursorRow + 1);
-                const newLines = [...nextState.lines];
-                newLines[cursorRow] = lineContent + nextLineContent;
-                newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
-            }
-            return state;
-        }
-        case 'kill_line_left': {
-            const { cursorRow, cursorCol } = state;
-            if (cursorCol > 0) {
-                const nextState = pushUndoLocal(state);
-                const lineContent = currentLine(cursorRow);
-                const newLines = [...nextState.lines];
-                newLines[cursorRow] = cpSlice(lineContent, cursorCol);
-                return {
-                    ...nextState,
-                    lines: newLines,
-                    cursorCol: 0,
-                    preferredCol: null,
-                };
-            }
-            return state;
-        }
-        case 'undo': {
-            const stateToRestore = state.undoStack[state.undoStack.length - 1];
-            if (!stateToRestore)
-                return state;
-            const currentSnapshot = {
-                lines: [...state.lines],
-                cursorRow: state.cursorRow,
-                cursorCol: state.cursorCol,
-            };
-            return {
-                ...state,
-                ...stateToRestore,
-                undoStack: state.undoStack.slice(0, -1),
-                redoStack: [...state.redoStack, currentSnapshot],
-            };
-        }
-        case 'redo': {
-            const stateToRestore = state.redoStack[state.redoStack.length - 1];
-            if (!stateToRestore)
-                return state;
-            const currentSnapshot = {
-                lines: [...state.lines],
-                cursorRow: state.cursorRow,
-                cursorCol: state.cursorCol,
-            };
-            return {
-                ...state,
-                ...stateToRestore,
-                redoStack: state.redoStack.slice(0, -1),
-                undoStack: [...state.undoStack, currentSnapshot],
-            };
-        }
-        case 'replace_range': {
-            const { startRow, startCol, endRow, endCol, text } = action.payload;
-            const nextState = pushUndoLocal(state);
-            return replaceRangeInternal(nextState, startRow, startCol, endRow, endCol, text);
-        }
-        case 'move_to_offset': {
-            const { offset } = action.payload;
-            const [newRow, newCol] = offsetToLogicalPos(state.lines.join('\n'), offset);
-            return {
-                ...state,
-                cursorRow: newRow,
-                cursorCol: newCol,
-                preferredCol: null,
-            };
-        }
-        case 'create_undo_snapshot': {
-            return pushUndoLocal(state);
-        }
-        // Vim-specific operations
-        case 'vim_delete_word_forward':
-        case 'vim_delete_word_backward':
-        case 'vim_delete_word_end':
-        case 'vim_change_word_forward':
-        case 'vim_change_word_backward':
-        case 'vim_change_word_end':
-        case 'vim_delete_line':
-        case 'vim_change_line':
-        case 'vim_delete_to_end_of_line':
-        case 'vim_change_to_end_of_line':
-        case 'vim_change_movement':
-        case 'vim_move_left':
-        case 'vim_move_right':
-        case 'vim_move_up':
-        case 'vim_move_down':
-        case 'vim_move_word_forward':
-        case 'vim_move_word_backward':
-        case 'vim_move_word_end':
-        case 'vim_delete_char':
-        case 'vim_insert_at_cursor':
-        case 'vim_append_at_cursor':
-        case 'vim_open_line_below':
-        case 'vim_open_line_above':
-        case 'vim_append_at_line_end':
-        case 'vim_insert_at_line_start':
-        case 'vim_move_to_line_start':
-        case 'vim_move_to_line_end':
-        case 'vim_move_to_first_nonwhitespace':
-        case 'vim_move_to_first_line':
-        case 'vim_move_to_last_line':
-        case 'vim_move_to_line':
-        case 'vim_escape_insert_mode':
-            return handleVimAction(state, action);
-        default: {
-            const exhaustiveCheck = action;
-            console.error(`Unknown action encountered: ${exhaustiveCheck}`);
-            return state;
-        }
-    }
-}
-// --- End of reducer logic ---
-export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, isValidPath, shellModeActive = false, }) {
-    const initialState = useMemo(() => {
-        const lines = initialText.split('\n');
-        const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(lines.length === 0 ? [''] : lines, initialCursorOffset);
-        return {
-            lines: lines.length === 0 ? [''] : lines,
-            cursorRow: initialCursorRow,
-            cursorCol: initialCursorCol,
-            preferredCol: null,
-            undoStack: [],
-            redoStack: [],
-            clipboard: null,
-            selectionAnchor: null,
-            viewportWidth: viewport.width,
-        };
-    }, [initialText, initialCursorOffset, viewport.width]);
-    const [state, dispatch] = useReducer(textBufferReducer, initialState);
-    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor } = state;
-    const text = useMemo(() => lines.join('\n'), [lines]);
-    const visualLayout = useMemo(() => calculateVisualLayout(lines, [cursorRow, cursorCol], state.viewportWidth), [lines, cursorRow, cursorCol, state.viewportWidth]);
-    const { visualLines, visualCursor } = visualLayout;
-    const [visualScrollRow, setVisualScrollRow] = useState(0);
-    useEffect(() => {
-        if (onChange) {
-            onChange(text);
-        }
-    }, [text, onChange]);
-    useEffect(() => {
-        dispatch({ type: 'set_viewport_width', payload: viewport.width });
-    }, [viewport.width]);
-    // Update visual scroll (vertical)
-    useEffect(() => {
-        const { height } = viewport;
-        let newVisualScrollRow = visualScrollRow;
-        if (visualCursor[0] < visualScrollRow) {
-            newVisualScrollRow = visualCursor[0];
-        }
-        else if (visualCursor[0] >= visualScrollRow + height) {
-            newVisualScrollRow = visualCursor[0] - height + 1;
-        }
-        if (newVisualScrollRow !== visualScrollRow) {
-            setVisualScrollRow(newVisualScrollRow);
-        }
-    }, [visualCursor, visualScrollRow, viewport]);
-    const insert = useCallback((ch, { paste = false } = {}) => {
-        if (/[\n\r]/.test(ch)) {
-            dispatch({ type: 'insert', payload: ch });
-            return;
-        }
-        const minLengthToInferAsDragDrop = 3;
-        if (ch.length >= minLengthToInferAsDragDrop &&
-            !shellModeActive &&
-            paste) {
-            let potentialPath = ch.trim();
-            const quoteMatch = potentialPath.match(/^'(.*)'$/);
-            if (quoteMatch) {
-                potentialPath = quoteMatch[1];
-            }
-            potentialPath = potentialPath.trim();
-            if (isValidPath(unescapePath(potentialPath))) {
-                ch = `@${potentialPath} `;
-            }
-        }
-        let currentText = '';
-        for (const char of toCodePoints(ch)) {
-            if (char.codePointAt(0) === 127) {
-                if (currentText.length > 0) {
-                    dispatch({ type: 'insert', payload: currentText });
-                    currentText = '';
-                }
-                dispatch({ type: 'backspace' });
-            }
-            else {
-                currentText += char;
-            }
-        }
-        if (currentText.length > 0) {
-            dispatch({ type: 'insert', payload: currentText });
-        }
-    }, [isValidPath, shellModeActive]);
-    const newline = useCallback(() => {
-        dispatch({ type: 'insert', payload: '\n' });
-    }, []);
-    const backspace = useCallback(() => {
-        dispatch({ type: 'backspace' });
-    }, []);
-    const del = useCallback(() => {
-        dispatch({ type: 'delete' });
-    }, []);
-    const move = useCallback((dir) => {
-        dispatch({ type: 'move', payload: { dir } });
-    }, []);
-    const undo = useCallback(() => {
-        dispatch({ type: 'undo' });
-    }, []);
-    const redo = useCallback(() => {
-        dispatch({ type: 'redo' });
-    }, []);
-    const setText = useCallback((newText) => {
-        dispatch({ type: 'set_text', payload: newText });
-    }, []);
-    const deleteWordLeft = useCallback(() => {
-        dispatch({ type: 'delete_word_left' });
-    }, []);
-    const deleteWordRight = useCallback(() => {
-        dispatch({ type: 'delete_word_right' });
-    }, []);
-    const killLineRight = useCallback(() => {
-        dispatch({ type: 'kill_line_right' });
-    }, []);
-    const killLineLeft = useCallback(() => {
-        dispatch({ type: 'kill_line_left' });
-    }, []);
-    // Vim-specific operations
-    const vimDeleteWordForward = useCallback((count) => {
-        dispatch({ type: 'vim_delete_word_forward', payload: { count } });
-    }, []);
-    const vimDeleteWordBackward = useCallback((count) => {
-        dispatch({ type: 'vim_delete_word_backward', payload: { count } });
-    }, []);
-    const vimDeleteWordEnd = useCallback((count) => {
-        dispatch({ type: 'vim_delete_word_end', payload: { count } });
-    }, []);
-    const vimChangeWordForward = useCallback((count) => {
-        dispatch({ type: 'vim_change_word_forward', payload: { count } });
-    }, []);
-    const vimChangeWordBackward = useCallback((count) => {
-        dispatch({ type: 'vim_change_word_backward', payload: { count } });
-    }, []);
-    const vimChangeWordEnd = useCallback((count) => {
-        dispatch({ type: 'vim_change_word_end', payload: { count } });
-    }, []);
-    const vimDeleteLine = useCallback((count) => {
-        dispatch({ type: 'vim_delete_line', payload: { count } });
-    }, []);
-    const vimChangeLine = useCallback((count) => {
-        dispatch({ type: 'vim_change_line', payload: { count } });
-    }, []);
-    const vimDeleteToEndOfLine = useCallback(() => {
-        dispatch({ type: 'vim_delete_to_end_of_line' });
-    }, []);
-    const vimChangeToEndOfLine = useCallback(() => {
-        dispatch({ type: 'vim_change_to_end_of_line' });
-    }, []);
-    const vimChangeMovement = useCallback((movement, count) => {
-        dispatch({ type: 'vim_change_movement', payload: { movement, count } });
-    }, []);
-    // New vim navigation and operation methods
-    const vimMoveLeft = useCallback((count) => {
-        dispatch({ type: 'vim_move_left', payload: { count } });
-    }, []);
-    const vimMoveRight = useCallback((count) => {
-        dispatch({ type: 'vim_move_right', payload: { count } });
-    }, []);
-    const vimMoveUp = useCallback((count) => {
-        dispatch({ type: 'vim_move_up', payload: { count } });
-    }, []);
-    const vimMoveDown = useCallback((count) => {
-        dispatch({ type: 'vim_move_down', payload: { count } });
-    }, []);
-    const vimMoveWordForward = useCallback((count) => {
-        dispatch({ type: 'vim_move_word_forward', payload: { count } });
-    }, []);
-    const vimMoveWordBackward = useCallback((count) => {
-        dispatch({ type: 'vim_move_word_backward', payload: { count } });
-    }, []);
-    const vimMoveWordEnd = useCallback((count) => {
-        dispatch({ type: 'vim_move_word_end', payload: { count } });
-    }, []);
-    const vimDeleteChar = useCallback((count) => {
-        dispatch({ type: 'vim_delete_char', payload: { count } });
-    }, []);
-    const vimInsertAtCursor = useCallback(() => {
-        dispatch({ type: 'vim_insert_at_cursor' });
-    }, []);
-    const vimAppendAtCursor = useCallback(() => {
-        dispatch({ type: 'vim_append_at_cursor' });
-    }, []);
-    const vimOpenLineBelow = useCallback(() => {
-        dispatch({ type: 'vim_open_line_below' });
-    }, []);
-    const vimOpenLineAbove = useCallback(() => {
-        dispatch({ type: 'vim_open_line_above' });
-    }, []);
-    const vimAppendAtLineEnd = useCallback(() => {
-        dispatch({ type: 'vim_append_at_line_end' });
-    }, []);
-    const vimInsertAtLineStart = useCallback(() => {
-        dispatch({ type: 'vim_insert_at_line_start' });
-    }, []);
-    const vimMoveToLineStart = useCallback(() => {
-        dispatch({ type: 'vim_move_to_line_start' });
-    }, []);
-    const vimMoveToLineEnd = useCallback(() => {
-        dispatch({ type: 'vim_move_to_line_end' });
-    }, []);
-    const vimMoveToFirstNonWhitespace = useCallback(() => {
-        dispatch({ type: 'vim_move_to_first_nonwhitespace' });
-    }, []);
-    const vimMoveToFirstLine = useCallback(() => {
-        dispatch({ type: 'vim_move_to_first_line' });
-    }, []);
-    const vimMoveToLastLine = useCallback(() => {
-        dispatch({ type: 'vim_move_to_last_line' });
-    }, []);
-    const vimMoveToLine = useCallback((lineNumber) => {
-        dispatch({ type: 'vim_move_to_line', payload: { lineNumber } });
-    }, []);
-    const vimEscapeInsertMode = useCallback(() => {
-        dispatch({ type: 'vim_escape_insert_mode' });
-    }, []);
-    const openInExternalEditor = useCallback(async (opts = {}) => {
-        const editor = opts.editor ??
-            process.env['VISUAL'] ??
-            process.env['EDITOR'] ??
-            (process.platform === 'win32' ? 'notepad' : 'vi');
-        const tmpDir = fs.mkdtempSync(pathMod.join(os.tmpdir(), 'gemini-edit-'));
-        const filePath = pathMod.join(tmpDir, 'buffer.txt');
-        fs.writeFileSync(filePath, text, 'utf8');
-        dispatch({ type: 'create_undo_snapshot' });
-        const wasRaw = stdin?.isRaw ?? false;
-        try {
-            setRawMode?.(false);
-            const { status, error } = spawnSync(editor, [filePath], {
-                stdio: 'inherit',
-            });
-            if (error)
-                throw error;
-            if (typeof status === 'number' && status !== 0)
-                throw new Error(`External editor exited with status ${status}`);
-            let newText = fs.readFileSync(filePath, 'utf8');
-            newText = newText.replace(/\r\n?/g, '\n');
-            dispatch({ type: 'set_text', payload: newText, pushToUndo: false });
-        }
-        catch (err) {
-            console.error('[useTextBuffer] external editor error', err);
-        }
-        finally {
-            if (wasRaw)
-                setRawMode?.(true);
-            try {
-                fs.unlinkSync(filePath);
-            }
-            catch {
-                /* ignore */
-            }
-            try {
-                fs.rmdirSync(tmpDir);
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }, [text, stdin, setRawMode]);
-    const handleInput = useCallback((key) => {
-        const { sequence: input } = key;
-        if (key.paste) {
-            // Do not do any other processing on pastes so ensure we handle them
-            // before all other cases.
-            insert(input, { paste: key.paste });
-            return;
-        }
-        if (key.name === 'return' ||
-            input === '\r' ||
-            input === '\n' ||
-            input === '\\\r' // VSCode terminal represents shift + enter this way
-        )
-            newline();
-        else if (key.name === 'left' && !key.meta && !key.ctrl)
-            move('left');
-        else if (key.ctrl && key.name === 'b')
-            move('left');
-        else if (key.name === 'right' && !key.meta && !key.ctrl)
-            move('right');
-        else if (key.ctrl && key.name === 'f')
-            move('right');
-        else if (key.name === 'up')
-            move('up');
-        else if (key.name === 'down')
-            move('down');
-        else if ((key.ctrl || key.meta) && key.name === 'left')
-            move('wordLeft');
-        else if (key.meta && key.name === 'b')
-            move('wordLeft');
-        else if ((key.ctrl || key.meta) && key.name === 'right')
-            move('wordRight');
-        else if (key.meta && key.name === 'f')
-            move('wordRight');
-        else if (key.name === 'home')
-            move('home');
-        else if (key.ctrl && key.name === 'a')
-            move('home');
-        else if (key.name === 'end')
-            move('end');
-        else if (key.ctrl && key.name === 'e')
-            move('end');
-        else if (key.ctrl && key.name === 'w')
-            deleteWordLeft();
-        else if ((key.meta || key.ctrl) &&
-            (key.name === 'backspace' || input === '\x7f'))
-            deleteWordLeft();
-        else if ((key.meta || key.ctrl) && key.name === 'delete')
-            deleteWordRight();
-        else if (key.name === 'backspace' ||
-            input === '\x7f' ||
-            (key.ctrl && key.name === 'h'))
-            backspace();
-        else if (key.name === 'delete' || (key.ctrl && key.name === 'd'))
-            del();
-        else if (input && !key.ctrl && !key.meta) {
-            insert(input, { paste: key.paste });
-        }
-    }, [newline, move, deleteWordLeft, deleteWordRight, backspace, del, insert]);
-    const renderedVisualLines = useMemo(() => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height), [visualLines, visualScrollRow, viewport.height]);
-    const replaceRange = useCallback((startRow, startCol, endRow, endCol, text) => {
-        dispatch({
-            type: 'replace_range',
-            payload: { startRow, startCol, endRow, endCol, text },
-        });
-    }, []);
-    const replaceRangeByOffset = useCallback((startOffset, endOffset, replacementText) => {
-        const [startRow, startCol] = offsetToLogicalPos(text, startOffset);
-        const [endRow, endCol] = offsetToLogicalPos(text, endOffset);
-        replaceRange(startRow, startCol, endRow, endCol, replacementText);
-    }, [text, replaceRange]);
-    const moveToOffset = useCallback((offset) => {
-        dispatch({ type: 'move_to_offset', payload: { offset } });
-    }, []);
-    const returnValue = {
-        lines,
-        text,
-        cursor: [cursorRow, cursorCol],
-        preferredCol,
-        selectionAnchor,
-        allVisualLines: visualLines,
-        viewportVisualLines: renderedVisualLines,
-        visualCursor,
-        visualScrollRow,
-        setText,
-        insert,
-        newline,
-        backspace,
-        del,
-        move,
-        undo,
-        redo,
-        replaceRange,
-        replaceRangeByOffset,
-        moveToOffset,
-        deleteWordLeft,
-        deleteWordRight,
-        killLineRight,
-        killLineLeft,
-        handleInput,
-        openInExternalEditor,
-        // Vim-specific operations
-        vimDeleteWordForward,
-        vimDeleteWordBackward,
-        vimDeleteWordEnd,
-        vimChangeWordForward,
-        vimChangeWordBackward,
-        vimChangeWordEnd,
-        vimDeleteLine,
-        vimChangeLine,
-        vimDeleteToEndOfLine,
-        vimChangeToEndOfLine,
-        vimChangeMovement,
-        vimMoveLeft,
-        vimMoveRight,
-        vimMoveUp,
-        vimMoveDown,
-        vimMoveWordForward,
-        vimMoveWordBackward,
-        vimMoveWordEnd,
-        vimDeleteChar,
-        vimInsertAtCursor,
-        vimAppendAtCursor,
-        vimOpenLineBelow,
-        vimOpenLineAbove,
-        vimAppendAtLineEnd,
-        vimInsertAtLineStart,
-        vimMoveToLineStart,
-        vimMoveToLineEnd,
-        vimMoveToFirstNonWhitespace,
-        vimMoveToFirstLine,
-        vimMoveToLastLine,
-        vimMoveToLine,
-        vimEscapeInsertMode,
-    };
-    return returnValue;
-}
-//# sourceMappingURL=text-buffer.js.map