@quantum-ai/gemini-cli 0.45.3

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

@@ -0,0 +1,2771 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import pathMod from 'node:path';
+import * as path from 'node:path';
+import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
+import { LRUCache } from 'mnemonist';
+import { coreEvents, debugLogger, getErrorMessage, unescapePath, } from '@quantum-ai/gemini-cli-core';
+import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, getCachedStringWidth, } from '../../utils/textUtils.js';
+import { parsePastedPaths } from '../../utils/clipboardUtils.js';
+import { Command } from '../../key/keyMatchers.js';
+import { handleVimAction } from './vim-buffer-actions.js';
+import { LRU_BUFFER_PERF_CACHE_LIMIT } from '../../constants.js';
+import { openFileInEditor } from '../../utils/editorUtils.js';
+import { useSettings } from '../../contexts/SettingsContext.js';
+import { useKeyMatchers } from '../../hooks/useKeyMatchers.js';
+export const LARGE_PASTE_LINE_THRESHOLD = 5;
+export const LARGE_PASTE_CHAR_THRESHOLD = 500;
+// Regex to match paste placeholders like [Pasted Text: 6 lines] or [Pasted Text: 501 chars #2]
+export const PASTED_TEXT_PLACEHOLDER_REGEX = /\[Pasted Text: \d+ (?:lines|chars)(?: #\d+)?\]/g;
+// Replace paste placeholder strings with their actual pasted content.
+export function expandPastePlaceholders(text, pastedContent) {
+    return text.replace(PASTED_TEXT_PLACEHOLDER_REGEX, (match) => pastedContent[match] || match);
+}
+// 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
+    let nextBaseCharIdx = i + 1;
+    while (nextBaseCharIdx < chars.length &&
+        isCombiningMark(chars[nextBaseCharIdx])) {
+        nextBaseCharIdx++;
+    }
+    const atEndOfWordChar = i < chars.length &&
+        isWordCharWithCombining(chars[i]) &&
+        (nextBaseCharIdx >= chars.length ||
+            !isWordCharStrict(chars[nextBaseCharIdx]) ||
+            (isWordCharStrict(chars[i]) &&
+                isDifferentScript(chars[i], chars[nextBaseCharIdx])));
+    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 any combining marks that belong to the word we just finished
+        while (i < chars.length && isCombiningMark(chars[i])) {
+            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 big word start within a line (W)
+export const findNextBigWordStartInLine = (line, col) => {
+    const chars = toCodePoints(line);
+    let i = col;
+    if (i >= chars.length)
+        return null;
+    // If currently on non-whitespace, skip it
+    if (!isWhitespace(chars[i])) {
+        while (i < chars.length && !isWhitespace(chars[i])) {
+            i++;
+        }
+    }
+    // Skip whitespace
+    while (i < chars.length && isWhitespace(chars[i])) {
+        i++;
+    }
+    return i < chars.length ? i : null;
+};
+// Find previous big word start within a line (B)
+export const findPrevBigWordStartInLine = (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;
+    // We're in a big word, move to its beginning
+    while (i >= 0 && !isWhitespace(chars[i])) {
+        i--;
+    }
+    return i + 1;
+};
+// Find big word end within a line (E)
+export const findBigWordEndInLine = (line, col) => {
+    const chars = toCodePoints(line);
+    let i = col;
+    // If we're already at the end of a big word, advance to next
+    const atEndOfBigWord = i < chars.length &&
+        !isWhitespace(chars[i]) &&
+        (i + 1 >= chars.length || isWhitespace(chars[i + 1]));
+    if (atEndOfBigWord) {
+        i++;
+    }
+    // Skip whitespace
+    while (i < chars.length && isWhitespace(chars[i])) {
+        i++;
+    }
+    // Move to end of current big word
+    if (i < chars.length && !isWhitespace(chars[i])) {
+        while (i < chars.length && !isWhitespace(chars[i])) {
+            i++;
+        }
+        return i - 1;
+    }
+    return null;
+};
+// Initialize segmenter for word boundary detection
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+function findPrevWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    // Convert cursorCol (CP index) to string index
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = 0;
+    for (const seg of segmenter.segment(line)) {
+        // We want the last word start strictly before the cursor.
+        // If we've reached or passed the cursor, we stop.
+        if (seg.index >= cursorIdx)
+            break;
+        if (seg.isWordLike) {
+            targetIdx = seg.index;
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
+function findNextWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = line.length;
+    for (const seg of segmenter.segment(line)) {
+        const segEnd = seg.index + seg.segment.length;
+        if (segEnd > cursorIdx) {
+            if (seg.isWordLike) {
+                targetIdx = segEnd;
+                break;
+            }
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
+// 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 };
+    }
+    let firstEmptyRow = null;
+    // 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, remember the first empty line
+        if (chars.length === 0) {
+            if (firstEmptyRow === null) {
+                firstEmptyRow = row;
+            }
+            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 };
+                }
+            }
+        }
+    }
+    // If no words in later lines, return the first empty line we found
+    if (firstEmptyRow !== null) {
+        return { row: firstEmptyRow, col: 0 };
+    }
+    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;
+};
+// Find next big word across lines
+export const findNextBigWordAcrossLines = (lines, cursorRow, cursorCol, searchForWordStart) => {
+    // First try current line
+    const currentLine = lines[cursorRow] || '';
+    const colInCurrentLine = searchForWordStart
+        ? findNextBigWordStartInLine(currentLine, cursorCol)
+        : findBigWordEndInLine(currentLine, cursorCol);
+    if (colInCurrentLine !== null) {
+        return { row: cursorRow, col: colInCurrentLine };
+    }
+    let firstEmptyRow = null;
+    // 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, remember the first empty line
+        if (chars.length === 0) {
+            if (firstEmptyRow === null) {
+                firstEmptyRow = row;
+            }
+            continue;
+        }
+        // Find first non-whitespace
+        let firstNonWhitespace = 0;
+        while (firstNonWhitespace < chars.length &&
+            isWhitespace(chars[firstNonWhitespace])) {
+            firstNonWhitespace++;
+        }
+        if (firstNonWhitespace < chars.length) {
+            // Found a non-whitespace character (start of a big word)
+            if (searchForWordStart) {
+                return { row, col: firstNonWhitespace };
+            }
+            else {
+                const endCol = findBigWordEndInLine(line, firstNonWhitespace);
+                if (endCol !== null) {
+                    return { row, col: endCol };
+                }
+            }
+        }
+    }
+    // If no words in later lines, return the first empty line we found
+    if (firstEmptyRow !== null) {
+        return { row: firstEmptyRow, col: 0 };
+    }
+    return null;
+};
+// Find previous big word across lines
+export const findPrevBigWordAcrossLines = (lines, cursorRow, cursorCol) => {
+    // First try current line
+    const currentLine = lines[cursorRow] || '';
+    const colInCurrentLine = findPrevBigWordStartInLine(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 big word start
+        let lastWordStart = chars.length;
+        while (lastWordStart > 0 && isWhitespace(chars[lastWordStart - 1])) {
+            lastWordStart--;
+        }
+        if (lastWordStart > 0) {
+            const wordStart = findPrevBigWordStartInLine(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,
+    };
+};
+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;
+}
+export const imagePathRegex = /@((?:\\.|[^\s\r\n\\])+?\.(?:png|jpg|jpeg|gif|webp|svg|bmp))\b/gi;
+export function getTransformedImagePath(filePath) {
+    const raw = filePath;
+    // Ignore leading @ when stripping directories, but keep it for simple '@file.png'
+    const withoutAt = raw.startsWith('@') ? raw.slice(1) : raw;
+    // Unescape the path to handle escaped spaces and other characters
+    const unescaped = unescapePath(withoutAt);
+    // Find last directory separator, supporting both POSIX and Windows styles
+    const lastSepIndex = Math.max(unescaped.lastIndexOf('/'), unescaped.lastIndexOf('\\'));
+    // If we saw a separator, take the segment after it; otherwise fall back to the unescaped string
+    const fileName = lastSepIndex >= 0 ? unescaped.slice(lastSepIndex + 1) : unescaped;
+    const extension = path.extname(fileName);
+    const baseName = path.basename(fileName, extension);
+    const maxBaseLength = 10;
+    const truncatedBase = baseName.length > maxBaseLength
+        ? `...${baseName.slice(-maxBaseLength)}`
+        : baseName;
+    return `[Image ${truncatedBase}${extension}]`;
+}
+const transformationsCache = new LRUCache(LRU_BUFFER_PERF_CACHE_LIMIT);
+export function calculateTransformationsForLine(line) {
+    const cached = transformationsCache.get(line);
+    if (cached) {
+        return cached;
+    }
+    const transformations = [];
+    // 1. Detect image paths
+    imagePathRegex.lastIndex = 0;
+    let match;
+    while ((match = imagePathRegex.exec(line)) !== null) {
+        const logicalText = match[0];
+        const logStart = cpLen(line.substring(0, match.index));
+        const logEnd = logStart + cpLen(logicalText);
+        transformations.push({
+            logStart,
+            logEnd,
+            logicalText,
+            collapsedText: getTransformedImagePath(logicalText),
+            type: 'image',
+        });
+    }
+    // 2. Detect paste placeholders
+    const pasteRegex = new RegExp(PASTED_TEXT_PLACEHOLDER_REGEX.source, 'g');
+    while ((match = pasteRegex.exec(line)) !== null) {
+        const logicalText = match[0];
+        const logStart = cpLen(line.substring(0, match.index));
+        const logEnd = logStart + cpLen(logicalText);
+        transformations.push({
+            logStart,
+            logEnd,
+            logicalText,
+            collapsedText: logicalText,
+            type: 'paste',
+            id: logicalText,
+        });
+    }
+    // Sort transformations by logStart to maintain consistency
+    transformations.sort((a, b) => a.logStart - b.logStart);
+    transformationsCache.set(line, transformations);
+    return transformations;
+}
+export function calculateTransformations(lines) {
+    return lines.map((ln) => calculateTransformationsForLine(ln));
+}
+export function getTransformUnderCursor(row, col, spansByLine, options = {}) {
+    const spans = spansByLine[row];
+    if (!spans || spans.length === 0)
+        return null;
+    for (const span of spans) {
+        if (col >= span.logStart &&
+            (options.includeEdge ? col <= span.logEnd : col < span.logEnd)) {
+            return span;
+        }
+        if (col < span.logStart)
+            break;
+    }
+    return null;
+}
+/**
+ * Check if a line index falls within an expanded paste region.
+ * Returns the paste placeholder ID if found, null otherwise.
+ */
+export function getExpandedPasteAtLine(lineIndex, expandedPaste) {
+    if (expandedPaste &&
+        lineIndex >= expandedPaste.startLine &&
+        lineIndex < expandedPaste.startLine + expandedPaste.lineCount) {
+        return expandedPaste.id;
+    }
+    return null;
+}
+/**
+ * Surgery for expanded paste regions when lines are added or removed.
+ * Adjusts startLine indices and detaches any region that is partially or fully deleted.
+ */
+export function shiftExpandedRegions(expandedPaste, changeStartLine, lineDelta, changeEndLine) {
+    if (!expandedPaste)
+        return { newInfo: null, isDetached: false };
+    const effectiveEndLine = changeEndLine ?? changeStartLine;
+    const infoEndLine = expandedPaste.startLine + expandedPaste.lineCount - 1;
+    // 1. Check for overlap/intersection with the changed range
+    const isOverlapping = changeStartLine <= infoEndLine &&
+        effectiveEndLine >= expandedPaste.startLine;
+    if (isOverlapping) {
+        // If the change is a deletion (lineDelta < 0) that touches this region, we detach.
+        // If it's an insertion, we only detach if it's a multi-line insertion (lineDelta > 0)
+        // that isn't at the very start of the region (which would shift it).
+        // Regular character typing (lineDelta === 0) does NOT detach.
+        if (lineDelta < 0 ||
+            (lineDelta > 0 &&
+                changeStartLine > expandedPaste.startLine &&
+                changeStartLine <= infoEndLine)) {
+            return { newInfo: null, isDetached: true };
+        }
+    }
+    // 2. Shift regions that start at or after the change point
+    if (expandedPaste.startLine >= changeStartLine) {
+        return {
+            newInfo: {
+                ...expandedPaste,
+                startLine: expandedPaste.startLine + lineDelta,
+            },
+            isDetached: false,
+        };
+    }
+    return { newInfo: expandedPaste, isDetached: false };
+}
+/**
+ * Detach any expanded paste region if the cursor is within it.
+ * This converts the expanded content to regular text that can no longer be collapsed.
+ * Returns the state unchanged if cursor is not in an expanded region.
+ */
+export function detachExpandedPaste(state) {
+    const expandedId = getExpandedPasteAtLine(state.cursorRow, state.expandedPaste);
+    if (!expandedId)
+        return state;
+    const { [expandedId]: _, ...newPastedContent } = state.pastedContent;
+    return {
+        ...state,
+        expandedPaste: null,
+        pastedContent: newPastedContent,
+    };
+}
+/**
+ * Find atomic placeholder at cursor for backspace (cursor at end).
+ * Checks all placeholder types in priority order.
+ */
+function findAtomicPlaceholderForBackspace(line, cursorCol, transformations) {
+    for (const transform of transformations) {
+        if (cursorCol === transform.logEnd) {
+            return {
+                start: transform.logStart,
+                end: transform.logEnd,
+                type: transform.type,
+                id: transform.id,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Find atomic placeholder at cursor for delete (cursor at start).
+ */
+function findAtomicPlaceholderForDelete(line, cursorCol, transformations) {
+    for (const transform of transformations) {
+        if (cursorCol === transform.logStart) {
+            return {
+                start: transform.logStart,
+                end: transform.logEnd,
+                type: transform.type,
+                id: transform.id,
+            };
+        }
+    }
+    return null;
+}
+export function calculateTransformedLine(logLine, logIndex, logicalCursor, transformations) {
+    let transformedLine = '';
+    const transformedToLogMap = [];
+    let lastLogPos = 0;
+    const cursorIsOnThisLine = logIndex === logicalCursor[0];
+    const cursorCol = logicalCursor[1];
+    for (const transform of transformations) {
+        const textBeforeTransformation = cpSlice(logLine, lastLogPos, transform.logStart);
+        transformedLine += textBeforeTransformation;
+        for (let i = 0; i < cpLen(textBeforeTransformation); i++) {
+            transformedToLogMap.push(lastLogPos + i);
+        }
+        const isExpanded = transform.type === 'image' &&
+            cursorIsOnThisLine &&
+            cursorCol >= transform.logStart &&
+            cursorCol <= transform.logEnd;
+        const transformedText = isExpanded
+            ? transform.logicalText
+            : transform.collapsedText;
+        transformedLine += transformedText;
+        // Map transformed characters back to logical characters
+        const transformedLen = cpLen(transformedText);
+        if (isExpanded) {
+            for (let i = 0; i < transformedLen; i++) {
+                transformedToLogMap.push(transform.logStart + i);
+            }
+        }
+        else {
+            // Collapsed: distribute transformed positions monotonically across the raw span.
+            // This preserves ordering across wrapped slices so logicalToVisualMap has
+            // increasing startColInLogical and visual cursor mapping remains consistent.
+            const logicalLength = Math.max(0, transform.logEnd - transform.logStart);
+            for (let i = 0; i < transformedLen; i++) {
+                // Map the i-th transformed code point into [logStart, logEnd)
+                const transformationToLogicalOffset = logicalLength === 0
+                    ? 0
+                    : Math.floor((i * logicalLength) / transformedLen);
+                const transformationToLogicalIndex = transform.logStart +
+                    Math.min(transformationToLogicalOffset, Math.max(logicalLength - 1, 0));
+                transformedToLogMap.push(transformationToLogicalIndex);
+            }
+        }
+        lastLogPos = transform.logEnd;
+    }
+    // Append text after last transform
+    const remainingUntransformedText = cpSlice(logLine, lastLogPos);
+    transformedLine += remainingUntransformedText;
+    for (let i = 0; i < cpLen(remainingUntransformedText); i++) {
+        transformedToLogMap.push(lastLogPos + i);
+    }
+    // For a cursor at the very end of the transformed line
+    transformedToLogMap.push(cpLen(logLine));
+    return { transformedLine, transformedToLogMap };
+}
+const lineLayoutCache = new LRUCache(LRU_BUFFER_PERF_CACHE_LIMIT);
+function getLineLayoutCacheKey(line, viewportWidth, isCursorOnLine, cursorCol) {
+    // Most lines (99.9% in a large buffer) are not cursor lines.
+    // We use a simpler key for them to reduce string allocation overhead.
+    if (!isCursorOnLine) {
+        return `${viewportWidth}:N:${line}`;
+    }
+    return `${viewportWidth}:C:${cursorCol}:${line}`;
+}
+// Calculates the visual wrapping of lines and the mapping between logical and visual coordinates.
+// This is an expensive operation and should be memoized.
+function calculateLayout(logicalLines, viewportWidth, logicalCursor) {
+    const visualLines = [];
+    const logicalToVisualMap = [];
+    const visualToLogicalMap = [];
+    const transformedToLogicalMaps = [];
+    const visualToTransformedMap = [];
+    logicalLines.forEach((logLine, logIndex) => {
+        logicalToVisualMap[logIndex] = [];
+        const isCursorOnLine = logIndex === logicalCursor[0];
+        const cacheKey = getLineLayoutCacheKey(logLine, viewportWidth, isCursorOnLine, logicalCursor[1]);
+        const cached = lineLayoutCache.get(cacheKey);
+        if (cached) {
+            const visualLineOffset = visualLines.length;
+            visualLines.push(...cached.visualLines);
+            cached.logicalToVisualMap.forEach(([relVisualIdx, logCol]) => {
+                logicalToVisualMap[logIndex].push([
+                    visualLineOffset + relVisualIdx,
+                    logCol,
+                ]);
+            });
+            cached.visualToLogicalMap.forEach(([, logCol]) => {
+                visualToLogicalMap.push([logIndex, logCol]);
+            });
+            transformedToLogicalMaps[logIndex] = cached.transformedToLogMap;
+            visualToTransformedMap.push(...cached.visualToTransformedMap);
+            return;
+        }
+        // Not in cache, calculate
+        const transformations = calculateTransformationsForLine(logLine);
+        const { transformedLine, transformedToLogMap } = calculateTransformedLine(logLine, logIndex, logicalCursor, transformations);
+        const lineVisualLines = [];
+        const lineLogicalToVisualMap = [];
+        const lineVisualToLogicalMap = [];
+        const lineVisualToTransformedMap = [];
+        if (transformedLine.length === 0) {
+            // Handle empty logical line
+            lineLogicalToVisualMap.push([0, 0]);
+            lineVisualToLogicalMap.push([logIndex, 0]);
+            lineVisualToTransformedMap.push(0);
+            lineVisualLines.push('');
+        }
+        else {
+            // Non-empty logical line
+            let currentPosInLogLine = 0; // Tracks position within the current logical line (code point index)
+            const codePointsInLogLine = toCodePoints(transformedLine);
+            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 = getCachedStringWidth(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;
+                            }
+                        }
+                        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 (numCodePointsInChunk === 0 &&
+                    currentPosInLogLine < codePointsInLogLine.length) {
+                    const firstChar = codePointsInLogLine[currentPosInLogLine];
+                    currentChunk = firstChar;
+                    numCodePointsInChunk = 1;
+                }
+                const logicalStartCol = transformedToLogMap[currentPosInLogLine] ?? 0;
+                lineLogicalToVisualMap.push([lineVisualLines.length, logicalStartCol]);
+                lineVisualToLogicalMap.push([logIndex, logicalStartCol]);
+                lineVisualToTransformedMap.push(currentPosInLogLine);
+                lineVisualLines.push(currentChunk);
+                const logicalStartOfThisChunk = currentPosInLogLine;
+                currentPosInLogLine += numCodePointsInChunk;
+                if (logicalStartOfThisChunk + numCodePointsInChunk <
+                    codePointsInLogLine.length &&
+                    currentPosInLogLine < codePointsInLogLine.length &&
+                    codePointsInLogLine[currentPosInLogLine] === ' ') {
+                    currentPosInLogLine++;
+                }
+            }
+        }
+        // Cache the result for this line
+        lineLayoutCache.set(cacheKey, {
+            visualLines: lineVisualLines,
+            logicalToVisualMap: lineLogicalToVisualMap,
+            visualToLogicalMap: lineVisualToLogicalMap,
+            transformedToLogMap,
+            visualToTransformedMap: lineVisualToTransformedMap,
+        });
+        const visualLineOffset = visualLines.length;
+        visualLines.push(...lineVisualLines);
+        lineLogicalToVisualMap.forEach(([relVisualIdx, logCol]) => {
+            logicalToVisualMap[logIndex].push([
+                visualLineOffset + relVisualIdx,
+                logCol,
+            ]);
+        });
+        lineVisualToLogicalMap.forEach(([, logCol]) => {
+            visualToLogicalMap.push([logIndex, logCol]);
+        });
+        transformedToLogicalMaps[logIndex] = transformedToLogMap;
+        visualToTransformedMap.push(...lineVisualToTransformedMap);
+    });
+    // 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]);
+            visualToTransformedMap.push(0);
+        }
+    }
+    return {
+        visualLines,
+        logicalToVisualMap,
+        visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+    };
+}
+// Calculates the visual cursor position based on a pre-calculated layout.
+// This is a lightweight operation.
+function calculateVisualCursorFromLayout(layout, logicalCursor) {
+    const { logicalToVisualMap, visualLines, transformedToLogicalMaps } = layout;
+    const [logicalRow, logicalCol] = logicalCursor;
+    const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
+    if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) {
+        // This can happen for an empty document.
+        return [0, 0];
+    }
+    // Find the segment where the logical column fits.
+    // The segments are sorted by startColInLogical.
+    let targetSegmentIndex = segmentsForLogicalLine.findIndex(([, startColInLogical], index) => {
+        const nextStartColInLogical = index + 1 < segmentsForLogicalLine.length
+            ? segmentsForLogicalLine[index + 1][1]
+            : Infinity;
+        return (logicalCol >= startColInLogical && logicalCol < nextStartColInLogical);
+    });
+    // If not found, it means the cursor is at the end of the logical line.
+    if (targetSegmentIndex === -1) {
+        if (logicalCol === 0) {
+            targetSegmentIndex = 0;
+        }
+        else {
+            targetSegmentIndex = segmentsForLogicalLine.length - 1;
+        }
+    }
+    const [visualRow, startColInLogical] = segmentsForLogicalLine[targetSegmentIndex];
+    // Find the coordinates in transformed space in order to conver to visual
+    const transformedToLogicalMap = transformedToLogicalMaps[logicalRow] ?? [];
+    let transformedCol = 0;
+    for (let i = 0; i < transformedToLogicalMap.length; i++) {
+        if (transformedToLogicalMap[i] > logicalCol) {
+            transformedCol = Math.max(0, i - 1);
+            break;
+        }
+        if (i === transformedToLogicalMap.length - 1) {
+            transformedCol = transformedToLogicalMap.length - 1;
+        }
+    }
+    let startColInTransformed = 0;
+    while (startColInTransformed < transformedToLogicalMap.length &&
+        transformedToLogicalMap[startColInTransformed] < startColInLogical) {
+        startColInTransformed++;
+    }
+    const clampedTransformedCol = Math.min(transformedCol, Math.max(0, transformedToLogicalMap.length - 1));
+    const visualCol = clampedTransformedCol - startColInTransformed;
+    const clampedVisualCol = Math.min(Math.max(visualCol, 0), cpLen(visualLines[visualRow] ?? ''));
+    return [visualRow, clampedVisualCol];
+}
+const historyLimit = 100;
+export const pushUndo = (currentState) => {
+    const snapshot = {
+        lines: [...currentState.lines],
+        cursorRow: currentState.cursorRow,
+        cursorCol: currentState.cursorCol,
+        pastedContent: { ...currentState.pastedContent },
+        expandedPaste: currentState.expandedPaste
+            ? { ...currentState.expandedPaste }
+            : null,
+    };
+    const newStack = [...currentState.undoStack, snapshot];
+    if (newStack.length > historyLimit) {
+        newStack.shift();
+    }
+    return { ...currentState, undoStack: newStack, redoStack: [] };
+};
+function generatePastedTextId(content, lineCount, pastedContent) {
+    const base = lineCount > LARGE_PASTE_LINE_THRESHOLD
+        ? `[Pasted Text: ${lineCount} lines]`
+        : `[Pasted Text: ${content.length} chars]`;
+    let id = base;
+    let suffix = 2;
+    while (pastedContent[id]) {
+        id = base.replace(']', ` #${suffix}]`);
+        suffix++;
+    }
+    return id;
+}
+function collectPlaceholderIdsFromLines(lines) {
+    const ids = new Set();
+    const pasteRegex = new RegExp(PASTED_TEXT_PLACEHOLDER_REGEX.source, 'g');
+    for (const line of lines) {
+        if (!line)
+            continue;
+        for (const match of line.matchAll(pasteRegex)) {
+            const placeholderId = match[0];
+            if (placeholderId) {
+                ids.add(placeholderId);
+            }
+        }
+    }
+    return ids;
+}
+function pruneOrphanedPastedContent(pastedContent, expandedPasteId, beforeChangedLines, allLines) {
+    if (Object.keys(pastedContent).length === 0)
+        return pastedContent;
+    const beforeIds = collectPlaceholderIdsFromLines(beforeChangedLines);
+    if (beforeIds.size === 0)
+        return pastedContent;
+    const afterIds = collectPlaceholderIdsFromLines(allLines);
+    const removedIds = [...beforeIds].filter((id) => !afterIds.has(id) && id !== expandedPasteId);
+    if (removedIds.length === 0)
+        return pastedContent;
+    const pruned = { ...pastedContent };
+    for (const id of removedIds) {
+        if (pruned[id]) {
+            delete pruned[id];
+        }
+    }
+    return pruned;
+}
+function textBufferReducerLogic(state, action, options = {}) {
+    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;
+            let newCursorRow;
+            let newCursorCol;
+            if (typeof action.cursorPosition === 'number') {
+                [newCursorRow, newCursorCol] = offsetToLogicalPos(action.payload, action.cursorPosition);
+            }
+            else if (action.cursorPosition === 'start') {
+                newCursorRow = 0;
+                newCursorCol = 0;
+            }
+            else {
+                // Default to 'end'
+                newCursorRow = lines.length - 1;
+                newCursorCol = cpLen(lines[newCursorRow] ?? '');
+            }
+            return {
+                ...nextState,
+                lines,
+                cursorRow: newCursorRow,
+                cursorCol: newCursorCol,
+                preferredCol: null,
+                pastedContent: action.payload === '' ? {} : nextState.pastedContent,
+            };
+        }
+        case 'insert': {
+            const nextState = detachExpandedPaste(pushUndoLocal(state));
+            const newLines = [...nextState.lines];
+            let newCursorRow = nextState.cursorRow;
+            let newCursorCol = nextState.cursorCol;
+            const currentLine = (r) => newLines[r] ?? '';
+            let payload = action.payload;
+            let newPastedContent = nextState.pastedContent;
+            if (action.isPaste) {
+                // Normalize line endings for pastes
+                payload = payload.replace(/\r\n|\r/g, '\n');
+                const lineCount = payload.split('\n').length;
+                if (lineCount > LARGE_PASTE_LINE_THRESHOLD ||
+                    payload.length > LARGE_PASTE_CHAR_THRESHOLD) {
+                    const id = generatePastedTextId(payload, lineCount, newPastedContent);
+                    newPastedContent = {
+                        ...newPastedContent,
+                        [id]: payload,
+                    };
+                    payload = id;
+                }
+            }
+            if (options.singleLine) {
+                payload = payload.replace(/[\r\n]/g, '');
+            }
+            if (options.inputFilter) {
+                payload = options.inputFilter(payload);
+            }
+            if (payload.length === 0) {
+                return state;
+            }
+            const str = stripUnsafeCharacters(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);
+            let lineDelta = 0;
+            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);
+                lineDelta = parts.length - 1;
+                newCursorRow = newCursorRow + parts.length - 1;
+                newCursorCol = cpLen(lastPartOriginal);
+            }
+            else {
+                newLines[newCursorRow] = before + parts[0] + after;
+                newCursorCol = cpLen(before) + cpLen(parts[0]);
+            }
+            const { newInfo: newExpandedPaste, isDetached } = shiftExpandedRegions(nextState.expandedPaste, nextState.cursorRow, lineDelta);
+            if (isDetached && newExpandedPaste === null && nextState.expandedPaste) {
+                delete newPastedContent[nextState.expandedPaste.id];
+            }
+            return {
+                ...nextState,
+                lines: newLines,
+                cursorRow: newCursorRow,
+                cursorCol: newCursorCol,
+                preferredCol: null,
+                pastedContent: newPastedContent,
+                expandedPaste: newExpandedPaste,
+            };
+        }
+        case 'add_pasted_content': {
+            const { id, text } = action.payload;
+            return {
+                ...state,
+                pastedContent: {
+                    ...state.pastedContent,
+                    [id]: text,
+                },
+            };
+        }
+        case 'backspace': {
+            const stateWithUndo = pushUndoLocal(state);
+            const currentState = detachExpandedPaste(stateWithUndo);
+            const { cursorRow, cursorCol, lines, transformationsByLine } = currentState;
+            // Early return if at start of buffer
+            if (cursorCol === 0 && cursorRow === 0)
+                return currentState;
+            // Check if cursor is at end of an atomic placeholder
+            const transformations = transformationsByLine[cursorRow] ?? [];
+            const placeholder = findAtomicPlaceholderForBackspace(lines[cursorRow], cursorCol, transformations);
+            if (placeholder) {
+                const nextState = currentState;
+                const newLines = [...nextState.lines];
+                newLines[cursorRow] =
+                    cpSlice(newLines[cursorRow], 0, placeholder.start) +
+                        cpSlice(newLines[cursorRow], placeholder.end);
+                // Recalculate transformations for the modified line
+                const newTransformations = [...nextState.transformationsByLine];
+                newTransformations[cursorRow] = calculateTransformationsForLine(newLines[cursorRow]);
+                // Clean up pastedContent if this was a paste placeholder
+                let newPastedContent = nextState.pastedContent;
+                if (placeholder.type === 'paste' && placeholder.id) {
+                    const { [placeholder.id]: _, ...remaining } = nextState.pastedContent;
+                    newPastedContent = remaining;
+                }
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    cursorCol: placeholder.start,
+                    preferredCol: null,
+                    transformationsByLine: newTransformations,
+                    pastedContent: newPastedContent,
+                };
+            }
+            // Standard backspace logic
+            const nextState = currentState;
+            const newLines = [...nextState.lines];
+            let newCursorRow = nextState.cursorRow;
+            let newCursorCol = nextState.cursorCol;
+            const currentLine = (r) => newLines[r] ?? '';
+            let lineDelta = 0;
+            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);
+                lineDelta = -1;
+                newCursorRow--;
+                newCursorCol = newCol;
+            }
+            const { newInfo: newExpandedPaste, isDetached } = shiftExpandedRegions(nextState.expandedPaste, nextState.cursorRow + lineDelta, // shift based on the line that was removed
+            lineDelta, nextState.cursorRow);
+            const newPastedContent = { ...nextState.pastedContent };
+            if (isDetached && nextState.expandedPaste) {
+                delete newPastedContent[nextState.expandedPaste.id];
+            }
+            return {
+                ...nextState,
+                lines: newLines,
+                cursorRow: newCursorRow,
+                cursorCol: newCursorCol,
+                preferredCol: null,
+                pastedContent: newPastedContent,
+                expandedPaste: newExpandedPaste,
+            };
+        }
+        case 'set_viewport': {
+            const { width, height } = action.payload;
+            if (width === state.viewportWidth && height === state.viewportHeight) {
+                return state;
+            }
+            return {
+                ...state,
+                viewportWidth: width,
+                viewportHeight: height,
+            };
+        }
+        case 'move': {
+            const { dir } = action.payload;
+            const { cursorRow, cursorCol, lines, visualLayout, preferredCol } = state;
+            // Visual movements
+            if (dir === 'left' ||
+                dir === 'right' ||
+                dir === 'up' ||
+                dir === 'down' ||
+                dir === 'home' ||
+                dir === 'end') {
+                const visualCursor = calculateVisualCursorFromLayout(visualLayout, [
+                    cursorRow,
+                    cursorCol,
+                ]);
+                const { visualLines, visualToLogicalMap } = visualLayout;
+                let newVisualRow = visualCursor[0];
+                let newVisualCol = visualCursor[1];
+                let newPreferredCol = 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;
+                    default: {
+                        const exhaustiveCheck = dir;
+                        debugLogger.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
+                        return state;
+                    }
+                }
+                if (visualToLogicalMap[newVisualRow]) {
+                    const [logRow, logicalStartCol] = visualToLogicalMap[newVisualRow];
+                    const transformedToLogicalMap = visualLayout.transformedToLogicalMaps?.[logRow] ?? [];
+                    let transformedStartCol = 0;
+                    while (transformedStartCol < transformedToLogicalMap.length &&
+                        transformedToLogicalMap[transformedStartCol] < logicalStartCol) {
+                        transformedStartCol++;
+                    }
+                    const clampedTransformedCol = Math.min(transformedStartCol + newVisualCol, Math.max(0, transformedToLogicalMap.length - 1));
+                    const newLogicalCol = transformedToLogicalMap[clampedTransformedCol] ??
+                        cpLen(lines[logRow] ?? '');
+                    return {
+                        ...state,
+                        cursorRow: logRow,
+                        cursorCol: newLogicalCol,
+                        preferredCol: newPreferredCol,
+                    };
+                }
+                return state;
+            }
+            // Logical movements
+            switch (dir) {
+                case 'wordLeft': {
+                    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];
+                        newCursorCol = findPrevWordBoundary(lineContent, cursorCol);
+                    }
+                    return {
+                        ...state,
+                        cursorRow: newCursorRow,
+                        cursorCol: newCursorCol,
+                        preferredCol: null,
+                    };
+                }
+                case 'wordRight': {
+                    const lineContent = lines[cursorRow] ?? '';
+                    if (cursorRow === lines.length - 1 &&
+                        cursorCol === cpLen(lineContent)) {
+                        return state;
+                    }
+                    let newCursorRow = cursorRow;
+                    let newCursorCol = cursorCol;
+                    const lineLen = cpLen(lineContent);
+                    if (cursorCol >= lineLen) {
+                        newCursorRow++;
+                        newCursorCol = 0;
+                    }
+                    else {
+                        newCursorCol = findNextWordBoundary(lineContent, cursorCol);
+                    }
+                    return {
+                        ...state,
+                        cursorRow: newCursorRow,
+                        cursorCol: newCursorCol,
+                        preferredCol: null,
+                    };
+                }
+                default:
+                    return state;
+            }
+        }
+        case 'set_cursor': {
+            return {
+                ...state,
+                ...action.payload,
+            };
+        }
+        case 'delete': {
+            const stateWithUndo = pushUndoLocal(state);
+            const currentState = detachExpandedPaste(stateWithUndo);
+            const { cursorRow, cursorCol, lines, transformationsByLine } = currentState;
+            // Check if cursor is at start of an atomic placeholder
+            const transformations = transformationsByLine[cursorRow] ?? [];
+            const placeholder = findAtomicPlaceholderForDelete(lines[cursorRow], cursorCol, transformations);
+            if (placeholder) {
+                const nextState = currentState;
+                const newLines = [...nextState.lines];
+                newLines[cursorRow] =
+                    cpSlice(newLines[cursorRow], 0, placeholder.start) +
+                        cpSlice(newLines[cursorRow], placeholder.end);
+                // Recalculate transformations for the modified line
+                const newTransformations = [...nextState.transformationsByLine];
+                newTransformations[cursorRow] = calculateTransformationsForLine(newLines[cursorRow]);
+                // Clean up pastedContent if this was a paste placeholder
+                let newPastedContent = nextState.pastedContent;
+                if (placeholder.type === 'paste' && placeholder.id) {
+                    const { [placeholder.id]: _, ...remaining } = nextState.pastedContent;
+                    newPastedContent = remaining;
+                }
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    // cursorCol stays the same
+                    preferredCol: null,
+                    transformationsByLine: newTransformations,
+                    pastedContent: newPastedContent,
+                };
+            }
+            // Standard delete logic
+            const lineContent = currentLine(cursorRow);
+            let lineDelta = 0;
+            const nextState = currentState;
+            const newLines = [...nextState.lines];
+            if (cursorCol < currentLineLen(cursorRow)) {
+                newLines[cursorRow] =
+                    cpSlice(lineContent, 0, cursorCol) +
+                        cpSlice(lineContent, cursorCol + 1);
+            }
+            else if (cursorRow < lines.length - 1) {
+                const nextLineContent = currentLine(cursorRow + 1);
+                newLines[cursorRow] = lineContent + nextLineContent;
+                newLines.splice(cursorRow + 1, 1);
+                lineDelta = -1;
+            }
+            else {
+                return currentState;
+            }
+            const { newInfo: newExpandedPaste, isDetached } = shiftExpandedRegions(nextState.expandedPaste, nextState.cursorRow, lineDelta, nextState.cursorRow + (lineDelta < 0 ? 1 : 0));
+            const newPastedContent = { ...nextState.pastedContent };
+            if (isDetached && nextState.expandedPaste) {
+                delete newPastedContent[nextState.expandedPaste.id];
+            }
+            return {
+                ...nextState,
+                lines: newLines,
+                preferredCol: null,
+                pastedContent: newPastedContent,
+                expandedPaste: newExpandedPaste,
+            };
+        }
+        case 'delete_word_left': {
+            const stateWithUndo = pushUndoLocal(state);
+            const currentState = detachExpandedPaste(stateWithUndo);
+            const { cursorRow, cursorCol } = currentState;
+            if (cursorCol === 0 && cursorRow === 0)
+                return currentState;
+            const nextState = currentState;
+            const newLines = [...nextState.lines];
+            let newCursorRow = cursorRow;
+            let newCursorCol = cursorCol;
+            let beforeChangedLines = [];
+            if (newCursorCol > 0) {
+                const lineContent = currentLine(newCursorRow);
+                beforeChangedLines = [lineContent];
+                const prevWordStart = findPrevWordStartInLine(lineContent, newCursorCol);
+                const start = prevWordStart === null ? 0 : prevWordStart;
+                newLines[newCursorRow] =
+                    cpSlice(lineContent, 0, start) + cpSlice(lineContent, newCursorCol);
+                newCursorCol = start;
+            }
+            else {
+                // Act as a backspace
+                const prevLineContent = currentLine(cursorRow - 1);
+                const currentLineContentVal = currentLine(cursorRow);
+                beforeChangedLines = [prevLineContent, currentLineContentVal];
+                const newCol = cpLen(prevLineContent);
+                newLines[cursorRow - 1] = prevLineContent + currentLineContentVal;
+                newLines.splice(cursorRow, 1);
+                newCursorRow--;
+                newCursorCol = newCol;
+            }
+            const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
+            return {
+                ...nextState,
+                lines: newLines,
+                cursorRow: newCursorRow,
+                cursorCol: newCursorCol,
+                preferredCol: null,
+                pastedContent: newPastedContent,
+            };
+        }
+        case 'delete_word_right': {
+            const stateWithUndo = pushUndoLocal(state);
+            const currentState = detachExpandedPaste(stateWithUndo);
+            const { cursorRow, cursorCol, lines } = currentState;
+            const lineContent = currentLine(cursorRow);
+            const lineLen = cpLen(lineContent);
+            if (cursorCol >= lineLen && cursorRow === lines.length - 1) {
+                return currentState;
+            }
+            const nextState = currentState;
+            const newLines = [...nextState.lines];
+            let beforeChangedLines = [];
+            if (cursorCol >= lineLen) {
+                // Act as a delete, joining with the next line
+                const nextLineContent = currentLine(cursorRow + 1);
+                beforeChangedLines = [lineContent, nextLineContent];
+                newLines[cursorRow] = lineContent + nextLineContent;
+                newLines.splice(cursorRow + 1, 1);
+            }
+            else {
+                beforeChangedLines = [lineContent];
+                const nextWordStart = findNextWordStartInLine(lineContent, cursorCol);
+                const end = nextWordStart === null ? lineLen : nextWordStart;
+                newLines[cursorRow] =
+                    cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
+            }
+            const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
+            return {
+                ...nextState,
+                lines: newLines,
+                preferredCol: null,
+                pastedContent: newPastedContent,
+            };
+        }
+        case 'kill_line_right': {
+            const stateWithUndo = pushUndoLocal(state);
+            const currentState = detachExpandedPaste(stateWithUndo);
+            const { cursorRow, cursorCol, lines } = currentState;
+            const lineContent = currentLine(cursorRow);
+            if (cursorCol < currentLineLen(cursorRow)) {
+                const nextState = currentState;
+                const newLines = [...nextState.lines];
+                const beforeChangedLines = [lineContent];
+                newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
+                const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                    pastedContent: newPastedContent,
+                };
+            }
+            else if (cursorRow < lines.length - 1) {
+                // Act as a delete
+                const nextState = currentState;
+                const nextLineContent = currentLine(cursorRow + 1);
+                const newLines = [...nextState.lines];
+                const beforeChangedLines = [lineContent, nextLineContent];
+                newLines[cursorRow] = lineContent + nextLineContent;
+                newLines.splice(cursorRow + 1, 1);
+                const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                    pastedContent: newPastedContent,
+                };
+            }
+            return currentState;
+        }
+        case 'kill_line_left': {
+            const stateWithUndo = pushUndoLocal(state);
+            const currentState = detachExpandedPaste(stateWithUndo);
+            const { cursorRow, cursorCol } = currentState;
+            if (cursorCol > 0) {
+                const nextState = currentState;
+                const lineContent = currentLine(cursorRow);
+                const newLines = [...nextState.lines];
+                const beforeChangedLines = [lineContent];
+                newLines[cursorRow] = cpSlice(lineContent, cursorCol);
+                const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    cursorCol: 0,
+                    preferredCol: null,
+                    pastedContent: newPastedContent,
+                };
+            }
+            return currentState;
+        }
+        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,
+                pastedContent: { ...state.pastedContent },
+                expandedPaste: state.expandedPaste ? { ...state.expandedPaste } : null,
+            };
+            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,
+                pastedContent: { ...state.pastedContent },
+                expandedPaste: state.expandedPaste ? { ...state.expandedPaste } : null,
+            };
+            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);
+            const newState = replaceRangeInternal(nextState, startRow, startCol, endRow, endCol, text);
+            const oldLineCount = endRow - startRow + 1;
+            const newLineCount = newState.lines.length - (nextState.lines.length - oldLineCount);
+            const lineDelta = newLineCount - oldLineCount;
+            const { newInfo: newExpandedPaste, isDetached } = shiftExpandedRegions(nextState.expandedPaste, startRow, lineDelta, endRow);
+            const newPastedContent = { ...newState.pastedContent };
+            if (isDetached && nextState.expandedPaste) {
+                delete newPastedContent[nextState.expandedPaste.id];
+            }
+            return {
+                ...newState,
+                pastedContent: newPastedContent,
+                expandedPaste: newExpandedPaste,
+            };
+        }
+        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_delete_big_word_forward':
+        case 'vim_delete_big_word_backward':
+        case 'vim_delete_big_word_end':
+        case 'vim_change_word_forward':
+        case 'vim_change_word_backward':
+        case 'vim_change_word_end':
+        case 'vim_change_big_word_forward':
+        case 'vim_change_big_word_backward':
+        case 'vim_change_big_word_end':
+        case 'vim_delete_line':
+        case 'vim_change_line':
+        case 'vim_delete_to_end_of_line':
+        case 'vim_delete_to_start_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_move_big_word_forward':
+        case 'vim_move_big_word_backward':
+        case 'vim_move_big_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':
+        case 'vim_delete_to_first_nonwhitespace':
+        case 'vim_change_to_start_of_line':
+        case 'vim_change_to_first_nonwhitespace':
+        case 'vim_delete_to_first_line':
+        case 'vim_delete_to_last_line':
+        case 'vim_delete_char_before':
+        case 'vim_toggle_case':
+        case 'vim_replace_char':
+        case 'vim_find_char_forward':
+        case 'vim_find_char_backward':
+        case 'vim_delete_to_char_forward':
+        case 'vim_delete_to_char_backward':
+        case 'vim_yank_line':
+        case 'vim_yank_word_forward':
+        case 'vim_yank_big_word_forward':
+        case 'vim_yank_word_end':
+        case 'vim_yank_big_word_end':
+        case 'vim_yank_to_end_of_line':
+        case 'vim_paste_after':
+        case 'vim_paste_before':
+            return handleVimAction(state, action);
+        case 'toggle_paste_expansion': {
+            const { id, row, col } = action.payload;
+            const expandedPaste = state.expandedPaste;
+            if (expandedPaste && expandedPaste.id === id) {
+                const nextState = pushUndoLocal(state);
+                // COLLAPSE: Restore original line with placeholder
+                const newLines = [...nextState.lines];
+                newLines.splice(expandedPaste.startLine, expandedPaste.lineCount, expandedPaste.prefix + id + expandedPaste.suffix);
+                // Move cursor to end of collapsed placeholder
+                const newCursorRow = expandedPaste.startLine;
+                const newCursorCol = cpLen(expandedPaste.prefix) + cpLen(id);
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    cursorRow: newCursorRow,
+                    cursorCol: newCursorCol,
+                    preferredCol: null,
+                    expandedPaste: null,
+                };
+            }
+            else {
+                // EXPAND: Replace placeholder with content
+                // Collapse any existing expanded paste first
+                let currentState = state;
+                let targetRow = row;
+                if (state.expandedPaste) {
+                    const existingInfo = state.expandedPaste;
+                    const lineDelta = 1 - existingInfo.lineCount;
+                    if (targetRow !== undefined && targetRow > existingInfo.startLine) {
+                        // If we collapsed something above our target, our target row shifted up
+                        targetRow += lineDelta;
+                    }
+                    currentState = textBufferReducerLogic(state, {
+                        type: 'toggle_paste_expansion',
+                        payload: {
+                            id: existingInfo.id,
+                            row: existingInfo.startLine,
+                            col: 0,
+                        },
+                    });
+                    // Update transformations because they are needed for finding the next placeholder
+                    currentState.transformationsByLine = calculateTransformations(currentState.lines);
+                }
+                const content = currentState.pastedContent[id];
+                if (!content)
+                    return currentState;
+                // Find line and position containing exactly this placeholder
+                let lineIndex = -1;
+                let placeholderStart = -1;
+                const tryFindOnLine = (idx) => {
+                    const transforms = currentState.transformationsByLine[idx] ?? [];
+                    // Precise match by col
+                    let transform = transforms.find((t) => t.type === 'paste' &&
+                        t.id === id &&
+                        col >= t.logStart &&
+                        col <= t.logEnd);
+                    if (!transform) {
+                        // Fallback to first match on line
+                        transform = transforms.find((t) => t.type === 'paste' && t.id === id);
+                    }
+                    if (transform) {
+                        lineIndex = idx;
+                        placeholderStart = transform.logStart;
+                        return true;
+                    }
+                    return false;
+                };
+                // Try provided row first for precise targeting
+                if (targetRow >= 0 && targetRow < currentState.lines.length) {
+                    tryFindOnLine(targetRow);
+                }
+                if (lineIndex === -1) {
+                    for (let i = 0; i < currentState.lines.length; i++) {
+                        if (tryFindOnLine(i))
+                            break;
+                    }
+                }
+                if (lineIndex === -1)
+                    return currentState;
+                const nextState = pushUndoLocal(currentState);
+                const line = nextState.lines[lineIndex];
+                const prefix = cpSlice(line, 0, placeholderStart);
+                const suffix = cpSlice(line, placeholderStart + cpLen(id));
+                // Split content into lines
+                const contentLines = content.split('\n');
+                const newLines = [...nextState.lines];
+                let expandedLines;
+                if (contentLines.length === 1) {
+                    // Single-line content
+                    expandedLines = [prefix + contentLines[0] + suffix];
+                }
+                else {
+                    // Multi-line content
+                    expandedLines = [
+                        prefix + contentLines[0],
+                        ...contentLines.slice(1, -1),
+                        contentLines[contentLines.length - 1] + suffix,
+                    ];
+                }
+                newLines.splice(lineIndex, 1, ...expandedLines);
+                // Move cursor to end of expanded content (before suffix)
+                const newCursorRow = lineIndex + expandedLines.length - 1;
+                const lastExpandedLine = expandedLines[expandedLines.length - 1];
+                const newCursorCol = cpLen(lastExpandedLine) - cpLen(suffix);
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    cursorRow: newCursorRow,
+                    cursorCol: newCursorCol,
+                    preferredCol: null,
+                    expandedPaste: {
+                        id,
+                        startLine: lineIndex,
+                        lineCount: expandedLines.length,
+                        prefix,
+                        suffix,
+                    },
+                };
+            }
+        }
+        default: {
+            const exhaustiveCheck = action;
+            debugLogger.error(`Unknown action encountered: ${exhaustiveCheck}`);
+            return state;
+        }
+    }
+}
+export function textBufferReducer(state, action, options = {}) {
+    const newState = textBufferReducerLogic(state, action, options);
+    const newTransformedLines = newState.lines !== state.lines
+        ? calculateTransformations(newState.lines)
+        : state.transformationsByLine;
+    const oldTransform = getTransformUnderCursor(state.cursorRow, state.cursorCol, state.transformationsByLine);
+    const newTransform = getTransformUnderCursor(newState.cursorRow, newState.cursorCol, newTransformedLines);
+    const oldInside = oldTransform !== null;
+    const newInside = newTransform !== null;
+    const movedBetweenTransforms = oldTransform !== newTransform &&
+        (oldTransform !== null || newTransform !== null);
+    if (newState.lines !== state.lines ||
+        newState.viewportWidth !== state.viewportWidth ||
+        oldInside !== newInside ||
+        movedBetweenTransforms) {
+        const shouldResetPreferred = oldInside !== newInside || movedBetweenTransforms;
+        return {
+            ...newState,
+            preferredCol: shouldResetPreferred ? null : newState.preferredCol,
+            visualLayout: calculateLayout(newState.lines, newState.viewportWidth, [
+                newState.cursorRow,
+                newState.cursorCol,
+            ]),
+            transformationsByLine: newTransformedLines,
+        };
+    }
+    return newState;
+}
+// --- End of reducer logic ---
+export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, escapePastedPaths = false, shellModeActive = false, inputFilter, singleLine = false, getPreferredEditor, }) {
+    const settings = useSettings();
+    const keyMatchers = useKeyMatchers();
+    const initialState = useMemo(() => {
+        const lines = initialText.split('\n');
+        const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(lines.length === 0 ? [''] : lines, initialCursorOffset);
+        const transformationsByLine = calculateTransformations(lines.length === 0 ? [''] : lines);
+        const visualLayout = calculateLayout(lines.length === 0 ? [''] : lines, viewport.width, [initialCursorRow, initialCursorCol]);
+        return {
+            lines: lines.length === 0 ? [''] : lines,
+            cursorRow: initialCursorRow,
+            cursorCol: initialCursorCol,
+            transformationsByLine,
+            preferredCol: null,
+            undoStack: [],
+            redoStack: [],
+            clipboard: null,
+            selectionAnchor: null,
+            viewportWidth: viewport.width,
+            viewportHeight: viewport.height,
+            visualLayout,
+            pastedContent: {},
+            expandedPaste: null,
+            yankRegister: null,
+        };
+    }, [initialText, initialCursorOffset, viewport.width, viewport.height]);
+    const [state, dispatch] = useReducer((s, a) => textBufferReducer(s, a, { inputFilter, singleLine }), initialState);
+    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, transformationsByLine, pastedContent, expandedPaste, undoStack, redoStack, } = state;
+    const text = useMemo(() => lines.join('\n'), [lines]);
+    const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
+    const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
+    const [scrollRowState, setScrollRowState] = useState(0);
+    const { height } = viewport;
+    const totalVisualLines = visualLines.length;
+    const maxScrollStart = Math.max(0, totalVisualLines - height);
+    let newVisualScrollRow = scrollRowState;
+    if (visualCursor[0] < scrollRowState) {
+        newVisualScrollRow = visualCursor[0];
+    }
+    else if (visualCursor[0] >= scrollRowState + height) {
+        newVisualScrollRow = visualCursor[0] - height + 1;
+    }
+    newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart);
+    if (newVisualScrollRow !== scrollRowState) {
+        setScrollRowState(newVisualScrollRow);
+    }
+    const actualScrollRowState = newVisualScrollRow;
+    useEffect(() => {
+        if (onChange) {
+            onChange(text);
+        }
+    }, [text, onChange]);
+    useEffect(() => {
+        dispatch({
+            type: 'set_viewport',
+            payload: { width: viewport.width, height: viewport.height },
+        });
+    }, [viewport.width, viewport.height]);
+    const insert = useCallback((ch, { paste = false } = {}) => {
+        if (typeof ch !== 'string') {
+            return;
+        }
+        let textToInsert = ch;
+        const minLengthToInferAsDragDrop = 3;
+        if (ch.length >= minLengthToInferAsDragDrop &&
+            !shellModeActive &&
+            paste &&
+            escapePastedPaths) {
+            const processed = parsePastedPaths(ch.trim());
+            if (processed) {
+                textToInsert = processed;
+            }
+        }
+        let currentText = '';
+        for (const char of toCodePoints(textToInsert)) {
+            if (char.codePointAt(0) === 127) {
+                if (currentText.length > 0) {
+                    dispatch({ type: 'insert', payload: currentText, isPaste: paste });
+                    currentText = '';
+                }
+                dispatch({ type: 'backspace' });
+            }
+            else {
+                currentText += char;
+            }
+        }
+        if (currentText.length > 0) {
+            dispatch({ type: 'insert', payload: currentText, isPaste: paste });
+        }
+    }, [shellModeActive, escapePastedPaths]);
+    const newline = useCallback(() => {
+        if (singleLine) {
+            return;
+        }
+        dispatch({ type: 'insert', payload: '\n' });
+    }, [singleLine]);
+    const backspace = useCallback(() => {
+        dispatch({ type: 'backspace' });
+    }, []);
+    const del = useCallback(() => {
+        dispatch({ type: 'delete' });
+    }, []);
+    const move = useCallback((dir) => {
+        dispatch({ type: 'move', payload: { dir } });
+    }, [dispatch]);
+    const undo = useCallback(() => {
+        dispatch({ type: 'undo' });
+    }, []);
+    const redo = useCallback(() => {
+        dispatch({ type: 'redo' });
+    }, []);
+    const setText = useCallback((newText, cursorPosition) => {
+        dispatch({ type: 'set_text', payload: newText, cursorPosition });
+    }, []);
+    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 vimDeleteBigWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_delete_big_word_forward', payload: { count } });
+    }, []);
+    const vimDeleteBigWordBackward = useCallback((count) => {
+        dispatch({ type: 'vim_delete_big_word_backward', payload: { count } });
+    }, []);
+    const vimDeleteBigWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_delete_big_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 vimChangeBigWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_change_big_word_forward', payload: { count } });
+    }, []);
+    const vimChangeBigWordBackward = useCallback((count) => {
+        dispatch({ type: 'vim_change_big_word_backward', payload: { count } });
+    }, []);
+    const vimChangeBigWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_change_big_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((count = 1) => {
+        dispatch({ type: 'vim_delete_to_end_of_line', payload: { count } });
+    }, []);
+    const vimDeleteToStartOfLine = useCallback(() => {
+        dispatch({ type: 'vim_delete_to_start_of_line' });
+    }, []);
+    const vimChangeToEndOfLine = useCallback((count = 1) => {
+        dispatch({ type: 'vim_change_to_end_of_line', payload: { count } });
+    }, []);
+    const vimDeleteToFirstNonWhitespace = useCallback(() => {
+        dispatch({ type: 'vim_delete_to_first_nonwhitespace' });
+    }, []);
+    const vimChangeToStartOfLine = useCallback(() => {
+        dispatch({ type: 'vim_change_to_start_of_line' });
+    }, []);
+    const vimChangeToFirstNonWhitespace = useCallback(() => {
+        dispatch({ type: 'vim_change_to_first_nonwhitespace' });
+    }, []);
+    const vimDeleteToFirstLine = useCallback((count) => {
+        dispatch({ type: 'vim_delete_to_first_line', payload: { count } });
+    }, []);
+    const vimDeleteToLastLine = useCallback((count) => {
+        dispatch({ type: 'vim_delete_to_last_line', payload: { count } });
+    }, []);
+    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 vimMoveBigWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_move_big_word_forward', payload: { count } });
+    }, []);
+    const vimMoveBigWordBackward = useCallback((count) => {
+        dispatch({ type: 'vim_move_big_word_backward', payload: { count } });
+    }, []);
+    const vimMoveBigWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_move_big_word_end', payload: { count } });
+    }, []);
+    const vimDeleteChar = useCallback((count) => {
+        dispatch({ type: 'vim_delete_char', payload: { count } });
+    }, []);
+    const vimDeleteCharBefore = useCallback((count) => {
+        dispatch({ type: 'vim_delete_char_before', payload: { count } });
+    }, []);
+    const vimToggleCase = useCallback((count) => {
+        dispatch({ type: 'vim_toggle_case', payload: { count } });
+    }, []);
+    const vimReplaceChar = useCallback((char, count) => {
+        dispatch({ type: 'vim_replace_char', payload: { char, count } });
+    }, []);
+    const vimFindCharForward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_find_char_forward',
+            payload: { char, count, till },
+        });
+    }, []);
+    const vimFindCharBackward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_find_char_backward',
+            payload: { char, count, till },
+        });
+    }, []);
+    const vimDeleteToCharForward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_delete_to_char_forward',
+            payload: { char, count, till },
+        });
+    }, []);
+    const vimDeleteToCharBackward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_delete_to_char_backward',
+            payload: { char, count, till },
+        });
+    }, []);
+    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 vimYankLine = useCallback((count) => {
+        dispatch({ type: 'vim_yank_line', payload: { count } });
+    }, []);
+    const vimYankWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_yank_word_forward', payload: { count } });
+    }, []);
+    const vimYankBigWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_yank_big_word_forward', payload: { count } });
+    }, []);
+    const vimYankWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_yank_word_end', payload: { count } });
+    }, []);
+    const vimYankBigWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_yank_big_word_end', payload: { count } });
+    }, []);
+    const vimYankToEndOfLine = useCallback((count) => {
+        dispatch({ type: 'vim_yank_to_end_of_line', payload: { count } });
+    }, []);
+    const vimPasteAfter = useCallback((count) => {
+        dispatch({ type: 'vim_paste_after', payload: { count } });
+    }, []);
+    const vimPasteBefore = useCallback((count) => {
+        dispatch({ type: 'vim_paste_before', payload: { count } });
+    }, []);
+    const openInExternalEditor = useCallback(async () => {
+        const tmpDir = fs.mkdtempSync(pathMod.join(os.tmpdir(), 'gemini-edit-'));
+        const filePath = pathMod.join(tmpDir, 'buffer.txt');
+        // Expand paste placeholders so user sees full content in editor
+        const expandedText = expandPastePlaceholders(text, pastedContent);
+        fs.writeFileSync(filePath, expandedText, 'utf8');
+        dispatch({ type: 'create_undo_snapshot' });
+        try {
+            await openFileInEditor(filePath, stdin, setRawMode, getPreferredEditor?.(), settings.merged.general.openEditorInNewWindow);
+            let newText = fs.readFileSync(filePath, 'utf8');
+            newText = newText.replace(/\r\n?/g, '\n');
+            // Attempt to re-collapse unchanged pasted content back into placeholders
+            const sortedPlaceholders = Object.entries(pastedContent).sort((a, b) => b[1].length - a[1].length);
+            for (const [id, content] of sortedPlaceholders) {
+                if (newText.includes(content)) {
+                    newText = newText.replace(content, id);
+                }
+            }
+            dispatch({ type: 'set_text', payload: newText, pushToUndo: false });
+        }
+        catch (err) {
+            coreEvents.emitFeedback('error', getErrorMessage(err), err);
+        }
+        finally {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                fs.rmdirSync(tmpDir);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }, [
+        text,
+        pastedContent,
+        stdin,
+        setRawMode,
+        getPreferredEditor,
+        settings.merged.general.openEditorInNewWindow,
+    ]);
+    const handleInput = useCallback((key) => {
+        const { sequence: input } = key;
+        if (key.name === 'paste') {
+            insert(input, { paste: true });
+            return true;
+        }
+        if (keyMatchers[Command.RETURN](key)) {
+            if (singleLine) {
+                return false;
+            }
+            newline();
+            return true;
+        }
+        if (keyMatchers[Command.NEWLINE](key)) {
+            if (singleLine) {
+                return false;
+            }
+            newline();
+            return true;
+        }
+        if (keyMatchers[Command.MOVE_LEFT](key)) {
+            if (cursorRow === 0 && cursorCol === 0)
+                return false;
+            move('left');
+            return true;
+        }
+        if (keyMatchers[Command.MOVE_RIGHT](key)) {
+            const lastLineIdx = lines.length - 1;
+            if (cursorRow === lastLineIdx &&
+                cursorCol === cpLen(lines[lastLineIdx] ?? '')) {
+                return false;
+            }
+            move('right');
+            return true;
+        }
+        if (keyMatchers[Command.MOVE_UP](key)) {
+            if (visualCursor[0] === 0)
+                return false;
+            move('up');
+            return true;
+        }
+        if (keyMatchers[Command.MOVE_DOWN](key)) {
+            if (visualCursor[0] === visualLines.length - 1)
+                return false;
+            move('down');
+            return true;
+        }
+        if (keyMatchers[Command.MOVE_WORD_LEFT](key)) {
+            move('wordLeft');
+            return true;
+        }
+        if (keyMatchers[Command.MOVE_WORD_RIGHT](key)) {
+            move('wordRight');
+            return true;
+        }
+        if (keyMatchers[Command.HOME](key)) {
+            move('home');
+            return true;
+        }
+        if (keyMatchers[Command.END](key)) {
+            move('end');
+            return true;
+        }
+        if (keyMatchers[Command.CLEAR_INPUT](key)) {
+            if (text.length > 0) {
+                setText('');
+                return true;
+            }
+            return false;
+        }
+        if (keyMatchers[Command.DELETE_WORD_BACKWARD](key)) {
+            deleteWordLeft();
+            return true;
+        }
+        if (keyMatchers[Command.DELETE_WORD_FORWARD](key)) {
+            deleteWordRight();
+            return true;
+        }
+        if (keyMatchers[Command.DELETE_CHAR_LEFT](key)) {
+            backspace();
+            return true;
+        }
+        if (keyMatchers[Command.DELETE_CHAR_RIGHT](key)) {
+            const lastLineIdx = lines.length - 1;
+            if (cursorRow === lastLineIdx &&
+                cursorCol === cpLen(lines[lastLineIdx] ?? '')) {
+                return false;
+            }
+            del();
+            return true;
+        }
+        if (keyMatchers[Command.UNDO](key)) {
+            if (undoStack.length === 0) {
+                return false;
+            }
+            undo();
+            return true;
+        }
+        if (keyMatchers[Command.REDO](key)) {
+            if (redoStack.length === 0) {
+                return false;
+            }
+            redo();
+            return true;
+        }
+        if (key.insertable) {
+            insert(input, { paste: false });
+            return true;
+        }
+        return false;
+    }, [
+        newline,
+        move,
+        deleteWordLeft,
+        deleteWordRight,
+        backspace,
+        del,
+        insert,
+        undo,
+        redo,
+        cursorRow,
+        cursorCol,
+        lines,
+        singleLine,
+        setText,
+        text,
+        visualCursor,
+        visualLines,
+        keyMatchers,
+        undoStack.length,
+        redoStack.length,
+    ]);
+    const visualScrollRow = useMemo(() => {
+        const totalVisualLines = visualLines.length;
+        return Math.min(actualScrollRowState, Math.max(0, totalVisualLines - viewport.height));
+    }, [visualLines.length, actualScrollRowState, viewport.height]);
+    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 moveToVisualPosition = useCallback((visRow, visCol) => {
+        const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
+        // Clamp visRow to valid range
+        const clampedVisRow = Math.max(0, Math.min(visRow, visualLines.length - 1));
+        const visualLine = visualLines[clampedVisRow] || '';
+        if (visualToLogicalMap[clampedVisRow]) {
+            const [logRow] = visualToLogicalMap[clampedVisRow];
+            const transformedToLogicalMap = transformedToLogicalMaps?.[logRow] ?? [];
+            // Where does this visual line begin within the transformed line?
+            const startColInTransformed = visualToTransformedMap?.[clampedVisRow] ?? 0;
+            // Handle wide characters: convert visual X position to character offset
+            const codePoints = toCodePoints(visualLine);
+            let currentVisX = 0;
+            let charOffset = 0;
+            for (const char of codePoints) {
+                const charWidth = getCachedStringWidth(char);
+                // If the click is within this character
+                if (visCol < currentVisX + charWidth) {
+                    // Check if we clicked the second half of a wide character
+                    if (charWidth > 1 && visCol >= currentVisX + charWidth / 2) {
+                        charOffset++;
+                    }
+                    break;
+                }
+                currentVisX += charWidth;
+                charOffset++;
+            }
+            // Clamp charOffset to length
+            charOffset = Math.min(charOffset, codePoints.length);
+            // Map character offset through transformations to get logical position
+            const transformedCol = Math.min(startColInTransformed + charOffset, Math.max(0, transformedToLogicalMap.length - 1));
+            const newCursorRow = logRow;
+            const newCursorCol = transformedToLogicalMap[transformedCol] ?? cpLen(lines[logRow] ?? '');
+            dispatch({
+                type: 'set_cursor',
+                payload: {
+                    cursorRow: newCursorRow,
+                    cursorCol: newCursorCol,
+                    preferredCol: charOffset,
+                },
+            });
+        }
+    }, [visualLayout, lines]);
+    const getLogicalPositionFromVisual = useCallback((visRow, visCol) => {
+        const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
+        // Clamp visRow to valid range
+        const clampedVisRow = Math.max(0, Math.min(visRow, visualLines.length - 1));
+        const visualLine = visualLines[clampedVisRow] || '';
+        if (!visualToLogicalMap[clampedVisRow]) {
+            return null;
+        }
+        const [logRow] = visualToLogicalMap[clampedVisRow];
+        const transformedToLogicalMap = transformedToLogicalMaps?.[logRow] ?? [];
+        // Where does this visual line begin within the transformed line?
+        const startColInTransformed = visualToTransformedMap?.[clampedVisRow] ?? 0;
+        // Handle wide characters: convert visual X position to character offset
+        const codePoints = toCodePoints(visualLine);
+        let currentVisX = 0;
+        let charOffset = 0;
+        for (const char of codePoints) {
+            const charWidth = getCachedStringWidth(char);
+            if (visCol < currentVisX + charWidth) {
+                if (charWidth > 1 && visCol >= currentVisX + charWidth / 2) {
+                    charOffset++;
+                }
+                break;
+            }
+            currentVisX += charWidth;
+            charOffset++;
+        }
+        charOffset = Math.min(charOffset, codePoints.length);
+        const transformedCol = Math.min(startColInTransformed + charOffset, Math.max(0, transformedToLogicalMap.length - 1));
+        const row = logRow;
+        const col = transformedToLogicalMap[transformedCol] ?? cpLen(lines[logRow] ?? '');
+        return { row, col };
+    }, [visualLayout, lines]);
+    const getOffset = useCallback(() => logicalPosToOffset(lines, cursorRow, cursorCol), [lines, cursorRow, cursorCol]);
+    const togglePasteExpansion = useCallback((id, row, col) => {
+        dispatch({ type: 'toggle_paste_expansion', payload: { id, row, col } });
+    }, []);
+    const getExpandedPasteAtLineCallback = useCallback((lineIndex) => getExpandedPasteAtLine(lineIndex, expandedPaste), [expandedPaste]);
+    const returnValue = useMemo(() => ({
+        lines,
+        text,
+        cursor: [cursorRow, cursorCol],
+        preferredCol,
+        selectionAnchor,
+        pastedContent,
+        allVisualLines: visualLines,
+        viewportVisualLines: renderedVisualLines,
+        visualCursor,
+        visualScrollRow,
+        viewportHeight: viewport.height,
+        visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+        transformationsByLine,
+        visualLayout,
+        setText,
+        insert,
+        newline,
+        backspace,
+        del,
+        move,
+        undo,
+        redo,
+        replaceRange,
+        replaceRangeByOffset,
+        moveToOffset,
+        getOffset,
+        moveToVisualPosition,
+        getLogicalPositionFromVisual,
+        getExpandedPasteAtLine: getExpandedPasteAtLineCallback,
+        togglePasteExpansion,
+        expandedPaste,
+        deleteWordLeft,
+        deleteWordRight,
+        killLineRight,
+        killLineLeft,
+        handleInput,
+        openInExternalEditor,
+        // Vim-specific operations
+        vimDeleteWordForward,
+        vimDeleteWordBackward,
+        vimDeleteWordEnd,
+        vimDeleteBigWordForward,
+        vimDeleteBigWordBackward,
+        vimDeleteBigWordEnd,
+        vimChangeWordForward,
+        vimChangeWordBackward,
+        vimChangeWordEnd,
+        vimChangeBigWordForward,
+        vimChangeBigWordBackward,
+        vimChangeBigWordEnd,
+        vimDeleteLine,
+        vimChangeLine,
+        vimDeleteToEndOfLine,
+        vimDeleteToStartOfLine,
+        vimChangeToEndOfLine,
+        vimDeleteToFirstNonWhitespace,
+        vimChangeToStartOfLine,
+        vimChangeToFirstNonWhitespace,
+        vimDeleteToFirstLine,
+        vimDeleteToLastLine,
+        vimChangeMovement,
+        vimMoveLeft,
+        vimMoveRight,
+        vimMoveUp,
+        vimMoveDown,
+        vimMoveWordForward,
+        vimMoveWordBackward,
+        vimMoveWordEnd,
+        vimMoveBigWordForward,
+        vimMoveBigWordBackward,
+        vimMoveBigWordEnd,
+        vimDeleteChar,
+        vimDeleteCharBefore,
+        vimToggleCase,
+        vimReplaceChar,
+        vimFindCharForward,
+        vimFindCharBackward,
+        vimDeleteToCharForward,
+        vimDeleteToCharBackward,
+        vimInsertAtCursor,
+        vimAppendAtCursor,
+        vimOpenLineBelow,
+        vimOpenLineAbove,
+        vimAppendAtLineEnd,
+        vimInsertAtLineStart,
+        vimMoveToLineStart,
+        vimMoveToLineEnd,
+        vimMoveToFirstNonWhitespace,
+        vimMoveToFirstLine,
+        vimMoveToLastLine,
+        vimMoveToLine,
+        vimEscapeInsertMode,
+        vimYankLine,
+        vimYankWordForward,
+        vimYankBigWordForward,
+        vimYankWordEnd,
+        vimYankBigWordEnd,
+        vimYankToEndOfLine,
+        vimPasteAfter,
+        vimPasteBefore,
+    }), [
+        lines,
+        text,
+        cursorRow,
+        cursorCol,
+        preferredCol,
+        selectionAnchor,
+        pastedContent,
+        visualLines,
+        renderedVisualLines,
+        visualCursor,
+        visualScrollRow,
+        viewport.height,
+        visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+        transformationsByLine,
+        visualLayout,
+        setText,
+        insert,
+        newline,
+        backspace,
+        del,
+        move,
+        undo,
+        redo,
+        replaceRange,
+        replaceRangeByOffset,
+        moveToOffset,
+        getOffset,
+        moveToVisualPosition,
+        getLogicalPositionFromVisual,
+        getExpandedPasteAtLineCallback,
+        togglePasteExpansion,
+        expandedPaste,
+        deleteWordLeft,
+        deleteWordRight,
+        killLineRight,
+        killLineLeft,
+        handleInput,
+        openInExternalEditor,
+        vimDeleteWordForward,
+        vimDeleteWordBackward,
+        vimDeleteWordEnd,
+        vimDeleteBigWordForward,
+        vimDeleteBigWordBackward,
+        vimDeleteBigWordEnd,
+        vimChangeWordForward,
+        vimChangeWordBackward,
+        vimChangeWordEnd,
+        vimChangeBigWordForward,
+        vimChangeBigWordBackward,
+        vimChangeBigWordEnd,
+        vimDeleteLine,
+        vimChangeLine,
+        vimDeleteToEndOfLine,
+        vimDeleteToStartOfLine,
+        vimChangeToEndOfLine,
+        vimDeleteToFirstNonWhitespace,
+        vimChangeToStartOfLine,
+        vimChangeToFirstNonWhitespace,
+        vimDeleteToFirstLine,
+        vimDeleteToLastLine,
+        vimChangeMovement,
+        vimMoveLeft,
+        vimMoveRight,
+        vimMoveUp,
+        vimMoveDown,
+        vimMoveWordForward,
+        vimMoveWordBackward,
+        vimMoveWordEnd,
+        vimMoveBigWordForward,
+        vimMoveBigWordBackward,
+        vimMoveBigWordEnd,
+        vimDeleteChar,
+        vimDeleteCharBefore,
+        vimToggleCase,
+        vimReplaceChar,
+        vimFindCharForward,
+        vimFindCharBackward,
+        vimDeleteToCharForward,
+        vimDeleteToCharBackward,
+        vimInsertAtCursor,
+        vimAppendAtCursor,
+        vimOpenLineBelow,
+        vimOpenLineAbove,
+        vimAppendAtLineEnd,
+        vimInsertAtLineStart,
+        vimMoveToLineStart,
+        vimMoveToLineEnd,
+        vimMoveToFirstNonWhitespace,
+        vimMoveToFirstLine,
+        vimMoveToLastLine,
+        vimMoveToLine,
+        vimEscapeInsertMode,
+        vimYankLine,
+        vimYankWordForward,
+        vimYankBigWordForward,
+        vimYankWordEnd,
+        vimYankBigWordEnd,
+        vimYankToEndOfLine,
+        vimPasteAfter,
+        vimPasteBefore,
+    ]);
+    return returnValue;
+}
+//# sourceMappingURL=text-buffer.js.map