@aigne/cli 1.60.0-beta → 1.74.0-beta

package/dist/ui/utils/text-buffer.cjs

@@ -0,0 +1,865 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_text_utils = require('./text-utils.cjs');
+let react = require("react");
+
+//#region src/ui/utils/text-buffer.ts
+/**
+* @license
+* Copyright 2025 Google LLC
+* SPDX-License-Identifier: Apache-2.0
+*/
+function isWordChar(ch) {
+	if (ch === void 0) return false;
+	return !/[\s,.;!?]/.test(ch);
+}
+const isWordCharStrict = (char) => /[\w\p{L}\p{N}]/u.test(char);
+const isWhitespace = (char) => /\s/.test(char);
+const isCombiningMark = (char) => /\p{M}/u.test(char);
+const isWordCharWithCombining = (char) => isWordCharStrict(char) || isCombiningMark(char);
+const getCharScript = (char) => {
+	if (/[\p{Script=Latin}]/u.test(char)) return "latin";
+	if (/[\p{Script=Han}]/u.test(char)) return "han";
+	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";
+};
+const isDifferentScript = (char1, char2) => {
+	if (!isWordCharStrict(char1) || !isWordCharStrict(char2)) return false;
+	return getCharScript(char1) !== getCharScript(char2);
+};
+const findNextWordStartInLine = (line, col) => {
+	const chars = require_text_utils.toCodePoints(line);
+	let i = col;
+	if (i >= chars.length) return null;
+	const currentChar = chars[i];
+	if (isWordCharStrict(currentChar)) while (i < chars.length && isWordCharWithCombining(chars[i])) {
+		if (i + 1 < chars.length && isWordCharStrict(chars[i + 1]) && isDifferentScript(chars[i], chars[i + 1])) {
+			i++;
+			break;
+		}
+		i++;
+	}
+	else if (!isWhitespace(currentChar)) while (i < chars.length && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) i++;
+	while (i < chars.length && isWhitespace(chars[i])) i++;
+	return i < chars.length ? i : null;
+};
+const findPrevWordStartInLine = (line, col) => {
+	const chars = require_text_utils.toCodePoints(line);
+	let i = col;
+	if (i <= 0) return null;
+	i--;
+	while (i >= 0 && isWhitespace(chars[i])) i--;
+	if (i < 0) return null;
+	if (isWordCharStrict(chars[i])) {
+		while (i >= 0 && isWordCharStrict(chars[i])) {
+			if (i - 1 >= 0 && isWordCharStrict(chars[i - 1]) && isDifferentScript(chars[i], chars[i - 1])) return i;
+			i--;
+		}
+		return i + 1;
+	} else {
+		while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) i--;
+		return i + 1;
+	}
+};
+const replaceRangeInternal = (state, startRow, startCol, endRow, endCol, text) => {
+	const currentLine = (row) => state.lines[row] || "";
+	const currentLineLen = (row) => require_text_utils.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;
+	const newLines = [...state.lines];
+	const sCol = clamp(startCol, 0, currentLineLen(startRow));
+	const eCol = clamp(endCol, 0, currentLineLen(endRow));
+	const prefix = require_text_utils.cpSlice(currentLine(startRow), 0, sCol);
+	const suffix = require_text_utils.cpSlice(currentLine(endRow), eCol);
+	const replacementParts = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+	const firstLine = prefix + replacementParts[0];
+	if (replacementParts.length === 1) newLines.splice(startRow, endRow - startRow + 1, firstLine + suffix);
+	else {
+		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) + require_text_utils.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, require_text_utils.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 = require_text_utils.cpLen(initialLines[row]);
+		const totalCharsInLineAndNewline = lineLength + (row < initialLines.length - 1 ? 1 : 0);
+		if (remainingChars <= lineLength) return [row, remainingChars];
+		remainingChars -= totalCharsInLineAndNewline;
+		row++;
+	}
+	if (initialLines.length > 0) {
+		const lastRow = initialLines.length - 1;
+		return [lastRow, require_text_utils.cpLen(initialLines[lastRow])];
+	}
+	return [0, 0];
+}
+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 = require_text_utils.cpLen(line);
+		const lineLengthWithNewline = lineLength + (i < lines.length - 1 ? 1 : 0);
+		if (offset <= currentOffset + lineLength) {
+			row = i;
+			col = offset - currentOffset;
+			return [row, col];
+		} else if (offset <= currentOffset + lineLengthWithNewline) {
+			row = i;
+			col = lineLength;
+			if (offset === currentOffset + lineLengthWithNewline && i < lines.length - 1) return [i + 1, 0];
+			return [row, col];
+		}
+		currentOffset += lineLengthWithNewline;
+	}
+	if (lines.length > 0) {
+		row = lines.length - 1;
+		col = require_text_utils.cpLen(lines[row]);
+	} else {
+		row = 0;
+		col = 0;
+	}
+	return [row, col];
+}
+function calculateLayout(logicalLines, viewportWidth) {
+	const visualLines = [];
+	const logicalToVisualMap = [];
+	const visualToLogicalMap = [];
+	logicalLines.forEach((logLine, logIndex) => {
+		logicalToVisualMap[logIndex] = [];
+		if (logLine.length === 0) {
+			logicalToVisualMap[logIndex].push([visualLines.length, 0]);
+			visualToLogicalMap.push([logIndex, 0]);
+			visualLines.push("");
+		} else {
+			let currentPosInLogLine = 0;
+			const codePointsInLogLine = require_text_utils.toCodePoints(logLine);
+			while (currentPosInLogLine < codePointsInLogLine.length) {
+				let currentChunk = "";
+				let currentChunkVisualWidth = 0;
+				let numCodePointsInChunk = 0;
+				let lastWordBreakPoint = -1;
+				let numCodePointsAtLastWordBreak = 0;
+				for (let i = currentPosInLogLine; i < codePointsInLogLine.length; i++) {
+					const char = codePointsInLogLine[i];
+					const charVisualWidth = require_text_utils.getCachedStringWidth(char);
+					if (currentChunkVisualWidth + charVisualWidth > viewportWidth) {
+						if (lastWordBreakPoint !== -1 && numCodePointsAtLastWordBreak > 0 && currentPosInLogLine + numCodePointsAtLastWordBreak < i) {
+							currentChunk = codePointsInLogLine.slice(currentPosInLogLine, currentPosInLogLine + numCodePointsAtLastWordBreak).join("");
+							numCodePointsInChunk = numCodePointsAtLastWordBreak;
+						} else if (numCodePointsInChunk === 0 && charVisualWidth > viewportWidth) {
+							currentChunk = char;
+							numCodePointsInChunk = 1;
+						} else if (numCodePointsInChunk === 0 && charVisualWidth <= viewportWidth) {}
+						break;
+					}
+					currentChunk += char;
+					currentChunkVisualWidth += charVisualWidth;
+					numCodePointsInChunk++;
+					if (char === " ") {
+						lastWordBreakPoint = i;
+						numCodePointsAtLastWordBreak = numCodePointsInChunk - 1;
+					}
+				}
+				if (numCodePointsInChunk === 0 && currentPosInLogLine < codePointsInLogLine.length) {
+					currentChunk = codePointsInLogLine[currentPosInLogLine];
+					numCodePointsInChunk = 1;
+				}
+				if (numCodePointsInChunk === 0 && currentPosInLogLine < codePointsInLogLine.length) {
+					currentChunk = codePointsInLogLine[currentPosInLogLine];
+					numCodePointsInChunk = 1;
+				}
+				logicalToVisualMap[logIndex].push([visualLines.length, currentPosInLogLine]);
+				visualToLogicalMap.push([logIndex, currentPosInLogLine]);
+				visualLines.push(currentChunk);
+				const logicalStartOfThisChunk = currentPosInLogLine;
+				currentPosInLogLine += numCodePointsInChunk;
+				if (logicalStartOfThisChunk + numCodePointsInChunk < codePointsInLogLine.length && currentPosInLogLine < codePointsInLogLine.length && codePointsInLogLine[currentPosInLogLine] === " ") currentPosInLogLine++;
+			}
+		}
+	});
+	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]);
+		}
+	}
+	return {
+		visualLines,
+		logicalToVisualMap,
+		visualToLogicalMap
+	};
+}
+function calculateVisualCursorFromLayout(layout, logicalCursor) {
+	const { logicalToVisualMap, visualLines } = layout;
+	const [logicalRow, logicalCol] = logicalCursor;
+	const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
+	if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) return [0, 0];
+	let targetSegmentIndex = segmentsForLogicalLine.findIndex(([, startColInLogical$1], index) => {
+		const nextStartColInLogical = index + 1 < segmentsForLogicalLine.length ? segmentsForLogicalLine[index + 1][1] : Infinity;
+		return logicalCol >= startColInLogical$1 && logicalCol < nextStartColInLogical;
+	});
+	if (targetSegmentIndex === -1) if (logicalCol === 0) targetSegmentIndex = 0;
+	else targetSegmentIndex = segmentsForLogicalLine.length - 1;
+	const [visualRow, startColInLogical] = segmentsForLogicalLine[targetSegmentIndex];
+	const visualCol = logicalCol - startColInLogical;
+	return [visualRow, Math.min(visualCol, require_text_utils.cpLen(visualLines[visualRow] ?? ""))];
+}
+const historyLimit = 100;
+const pushUndo = (currentState) => {
+	const snapshot = {
+		lines: [...currentState.lines],
+		cursorRow: currentState.cursorRow,
+		cursorCol: currentState.cursorCol
+	};
+	const newStack = [...currentState.undoStack, snapshot];
+	if (newStack.length > historyLimit) newStack.shift();
+	return {
+		...currentState,
+		undoStack: newStack,
+		redoStack: []
+	};
+};
+function textBufferReducerLogic(state, action) {
+	const pushUndoLocal = pushUndo;
+	const currentLine = (r) => state.lines[r] ?? "";
+	const currentLineLen = (r) => require_text_utils.cpLen(currentLine(r));
+	switch (action.type) {
+		case "set_text": {
+			let nextState = state;
+			if (action.pushToUndo !== false) nextState = pushUndoLocal(state);
+			const newContentLines = action.payload.replace(/\r\n?/g, "\n").split("\n");
+			const lines = newContentLines.length === 0 ? [""] : newContentLines;
+			const lastNewLineIndex = lines.length - 1;
+			return {
+				...nextState,
+				lines,
+				cursorRow: lastNewLineIndex,
+				cursorCol: require_text_utils.cpLen(lines[lastNewLineIndex] ?? ""),
+				preferredCol: null
+			};
+		}
+		case "insert": {
+			const nextState = pushUndoLocal(state);
+			const newLines = [...nextState.lines];
+			let newCursorRow = nextState.cursorRow;
+			let newCursorCol = nextState.cursorCol;
+			const currentLine$1 = (r) => newLines[r] ?? "";
+			const parts = require_text_utils.stripUnsafeCharacters(action.payload.replace(/\r\n/g, "\n").replace(/\r/g, "\n")).split("\n");
+			const lineContent = currentLine$1(newCursorRow);
+			const before = require_text_utils.cpSlice(lineContent, 0, newCursorCol);
+			const after = require_text_utils.cpSlice(lineContent, newCursorCol);
+			if (parts.length > 1) {
+				newLines[newCursorRow] = before + parts[0];
+				const remainingParts = parts.slice(1);
+				const lastPartOriginal = remainingParts.pop() ?? "";
+				newLines.splice(newCursorRow + 1, 0, ...remainingParts);
+				newLines.splice(newCursorRow + parts.length - 1, 0, lastPartOriginal + after);
+				newCursorRow = newCursorRow + parts.length - 1;
+				newCursorCol = require_text_utils.cpLen(lastPartOriginal);
+			} else {
+				newLines[newCursorRow] = before + parts[0] + after;
+				newCursorCol = require_text_utils.cpLen(before) + require_text_utils.cpLen(parts[0]);
+			}
+			return {
+				...nextState,
+				lines: newLines,
+				cursorRow: newCursorRow,
+				cursorCol: newCursorCol,
+				preferredCol: null
+			};
+		}
+		case "backspace": {
+			const nextState = pushUndoLocal(state);
+			const newLines = [...nextState.lines];
+			let newCursorRow = nextState.cursorRow;
+			let newCursorCol = nextState.cursorCol;
+			const currentLine$1 = (r) => newLines[r] ?? "";
+			if (newCursorCol === 0 && newCursorRow === 0) return state;
+			if (newCursorCol > 0) {
+				const lineContent = currentLine$1(newCursorRow);
+				newLines[newCursorRow] = require_text_utils.cpSlice(lineContent, 0, newCursorCol - 1) + require_text_utils.cpSlice(lineContent, newCursorCol);
+				newCursorCol--;
+			} else if (newCursorRow > 0) {
+				const prevLineContent = currentLine$1(newCursorRow - 1);
+				const currentLineContentVal = currentLine$1(newCursorRow);
+				const newCol = require_text_utils.cpLen(prevLineContent);
+				newLines[newCursorRow - 1] = prevLineContent + currentLineContentVal;
+				newLines.splice(newCursorRow, 1);
+				newCursorRow--;
+				newCursorCol = newCol;
+			}
+			return {
+				...nextState,
+				lines: newLines,
+				cursorRow: newCursorRow,
+				cursorCol: newCursorCol,
+				preferredCol: null
+			};
+		}
+		case "set_viewport": {
+			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;
+			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 = require_text_utils.cpLen(visualLines[newVisualRow] ?? "");
+				switch (dir) {
+					case "left":
+						newPreferredCol = null;
+						if (newVisualCol > 0) newVisualCol--;
+						else if (newVisualRow > 0) {
+							newVisualRow--;
+							newVisualCol = require_text_utils.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, require_text_utils.cpLen(visualLines[newVisualRow] ?? ""));
+						}
+						break;
+					case "down":
+						if (newVisualRow < visualLines.length - 1) {
+							if (newPreferredCol === null) newPreferredCol = newVisualCol;
+							newVisualRow++;
+							newVisualCol = clamp(newPreferredCol, 0, require_text_utils.cpLen(visualLines[newVisualRow] ?? ""));
+						}
+						break;
+					case "home":
+						newPreferredCol = null;
+						newVisualCol = 0;
+						break;
+					case "end":
+						newPreferredCol = null;
+						newVisualCol = currentVisLineLen;
+						break;
+					default: {
+						const exhaustiveCheck = dir;
+						console.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
+						return state;
+					}
+				}
+				if (visualToLogicalMap[newVisualRow]) {
+					const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
+					return {
+						...state,
+						cursorRow: logRow,
+						cursorCol: clamp(logStartCol + newVisualCol, 0, require_text_utils.cpLen(lines[logRow] ?? "")),
+						preferredCol: newPreferredCol
+					};
+				}
+				return state;
+			}
+			switch (dir) {
+				case "wordLeft": {
+					if (cursorCol === 0 && cursorRow === 0) return state;
+					let newCursorRow = cursorRow;
+					let newCursorCol = cursorCol;
+					if (cursorCol === 0) {
+						newCursorRow--;
+						newCursorCol = require_text_utils.cpLen(lines[newCursorRow] ?? "");
+					} else {
+						const lineContent = lines[cursorRow];
+						const arr = require_text_utils.toCodePoints(lineContent);
+						let start = cursorCol;
+						let onlySpaces = true;
+						for (let i = 0; i < start; i++) if (isWordChar(arr[i])) {
+							onlySpaces = false;
+							break;
+						}
+						if (onlySpaces && start > 0) start--;
+						else {
+							while (start > 0 && !isWordChar(arr[start - 1])) start--;
+							while (start > 0 && isWordChar(arr[start - 1])) start--;
+						}
+						newCursorCol = start;
+					}
+					return {
+						...state,
+						cursorRow: newCursorRow,
+						cursorCol: newCursorCol,
+						preferredCol: null
+					};
+				}
+				case "wordRight": {
+					if (cursorRow === lines.length - 1 && cursorCol === require_text_utils.cpLen(lines[cursorRow] ?? "")) return state;
+					let newCursorRow = cursorRow;
+					let newCursorCol = cursorCol;
+					const arr = require_text_utils.toCodePoints(lines[cursorRow] ?? "");
+					if (cursorCol >= arr.length) {
+						newCursorRow++;
+						newCursorCol = 0;
+					} else {
+						let end = cursorCol;
+						while (end < arr.length && !isWordChar(arr[end])) end++;
+						while (end < arr.length && isWordChar(arr[end])) end++;
+						newCursorCol = end;
+					}
+					return {
+						...state,
+						cursorRow: newCursorRow,
+						cursorCol: newCursorCol,
+						preferredCol: null
+					};
+				}
+				default: return state;
+			}
+		}
+		case "set_cursor": return {
+			...state,
+			...action.payload
+		};
+		case "delete": {
+			const { cursorRow, cursorCol, lines } = state;
+			const lineContent = currentLine(cursorRow);
+			if (cursorCol < currentLineLen(cursorRow)) {
+				const nextState = pushUndoLocal(state);
+				const newLines = [...nextState.lines];
+				newLines[cursorRow] = require_text_utils.cpSlice(lineContent, 0, cursorCol) + require_text_utils.cpSlice(lineContent, cursorCol + 1);
+				return {
+					...nextState,
+					lines: newLines,
+					preferredCol: null
+				};
+			} else if (cursorRow < lines.length - 1) {
+				const nextState = pushUndoLocal(state);
+				const nextLineContent = currentLine(cursorRow + 1);
+				const newLines = [...nextState.lines];
+				newLines[cursorRow] = lineContent + nextLineContent;
+				newLines.splice(cursorRow + 1, 1);
+				return {
+					...nextState,
+					lines: newLines,
+					preferredCol: null
+				};
+			}
+			return state;
+		}
+		case "delete_word_left": {
+			const { cursorRow, cursorCol } = state;
+			if (cursorCol === 0 && cursorRow === 0) return state;
+			const nextState = pushUndoLocal(state);
+			const newLines = [...nextState.lines];
+			let newCursorRow = cursorRow;
+			let newCursorCol = cursorCol;
+			if (newCursorCol > 0) {
+				const lineContent = currentLine(newCursorRow);
+				const prevWordStart = findPrevWordStartInLine(lineContent, newCursorCol);
+				const start = prevWordStart === null ? 0 : prevWordStart;
+				newLines[newCursorRow] = require_text_utils.cpSlice(lineContent, 0, start) + require_text_utils.cpSlice(lineContent, newCursorCol);
+				newCursorCol = start;
+			} else {
+				const prevLineContent = currentLine(cursorRow - 1);
+				const currentLineContentVal = currentLine(cursorRow);
+				const newCol = require_text_utils.cpLen(prevLineContent);
+				newLines[cursorRow - 1] = prevLineContent + currentLineContentVal;
+				newLines.splice(cursorRow, 1);
+				newCursorRow--;
+				newCursorCol = newCol;
+			}
+			return {
+				...nextState,
+				lines: newLines,
+				cursorRow: newCursorRow,
+				cursorCol: newCursorCol,
+				preferredCol: null
+			};
+		}
+		case "delete_word_right": {
+			const { cursorRow, cursorCol, lines } = state;
+			const lineContent = currentLine(cursorRow);
+			const lineLen = require_text_utils.cpLen(lineContent);
+			if (cursorCol >= lineLen && cursorRow === lines.length - 1) return state;
+			const nextState = pushUndoLocal(state);
+			const newLines = [...nextState.lines];
+			if (cursorCol >= lineLen) {
+				newLines[cursorRow] = lineContent + currentLine(cursorRow + 1);
+				newLines.splice(cursorRow + 1, 1);
+			} else {
+				const nextWordStart = findNextWordStartInLine(lineContent, cursorCol);
+				const end = nextWordStart === null ? lineLen : nextWordStart;
+				newLines[cursorRow] = require_text_utils.cpSlice(lineContent, 0, cursorCol) + require_text_utils.cpSlice(lineContent, end);
+			}
+			return {
+				...nextState,
+				lines: newLines,
+				preferredCol: null
+			};
+		}
+		case "kill_line_right": {
+			const { cursorRow, cursorCol, lines } = state;
+			const lineContent = currentLine(cursorRow);
+			if (cursorCol < currentLineLen(cursorRow)) {
+				const nextState = pushUndoLocal(state);
+				const newLines = [...nextState.lines];
+				newLines[cursorRow] = require_text_utils.cpSlice(lineContent, 0, cursorCol);
+				return {
+					...nextState,
+					lines: newLines
+				};
+			} else if (cursorRow < lines.length - 1) {
+				const nextState = pushUndoLocal(state);
+				const nextLineContent = currentLine(cursorRow + 1);
+				const newLines = [...nextState.lines];
+				newLines[cursorRow] = lineContent + nextLineContent;
+				newLines.splice(cursorRow + 1, 1);
+				return {
+					...nextState,
+					lines: newLines,
+					preferredCol: null
+				};
+			}
+			return state;
+		}
+		case "kill_line_left": {
+			const { cursorRow, cursorCol } = state;
+			if (cursorCol > 0) {
+				const nextState = pushUndoLocal(state);
+				const lineContent = currentLine(cursorRow);
+				const newLines = [...nextState.lines];
+				newLines[cursorRow] = require_text_utils.cpSlice(lineContent, cursorCol);
+				return {
+					...nextState,
+					lines: newLines,
+					cursorCol: 0,
+					preferredCol: null
+				};
+			}
+			return state;
+		}
+		case "undo": {
+			const stateToRestore = state.undoStack[state.undoStack.length - 1];
+			if (!stateToRestore) return state;
+			const currentSnapshot = {
+				lines: [...state.lines],
+				cursorRow: state.cursorRow,
+				cursorCol: state.cursorCol
+			};
+			return {
+				...state,
+				...stateToRestore,
+				undoStack: state.undoStack.slice(0, -1),
+				redoStack: [...state.redoStack, currentSnapshot]
+			};
+		}
+		case "redo": {
+			const stateToRestore = state.redoStack[state.redoStack.length - 1];
+			if (!stateToRestore) return state;
+			const currentSnapshot = {
+				lines: [...state.lines],
+				cursorRow: state.cursorRow,
+				cursorCol: state.cursorCol
+			};
+			return {
+				...state,
+				...stateToRestore,
+				redoStack: state.redoStack.slice(0, -1),
+				undoStack: [...state.undoStack, currentSnapshot]
+			};
+		}
+		case "replace_range": {
+			const { startRow, startCol, endRow, endCol, text } = action.payload;
+			return replaceRangeInternal(pushUndoLocal(state), startRow, startCol, endRow, endCol, text);
+		}
+		case "move_to_offset": {
+			const { offset } = action.payload;
+			const [newRow, newCol] = offsetToLogicalPos(state.lines.join("\n"), offset);
+			return {
+				...state,
+				cursorRow: newRow,
+				cursorCol: newCol,
+				preferredCol: null
+			};
+		}
+		case "create_undo_snapshot": return pushUndoLocal(state);
+		default: {
+			const exhaustiveCheck = action;
+			console.error(`Unknown action encountered: ${exhaustiveCheck}`);
+			return state;
+		}
+	}
+}
+function textBufferReducer(state, action) {
+	const newState = textBufferReducerLogic(state, action);
+	if (newState.lines !== state.lines || newState.viewportWidth !== state.viewportWidth) return {
+		...newState,
+		visualLayout: calculateLayout(newState.lines, newState.viewportWidth)
+	};
+	return newState;
+}
+function useTextBuffer({ initialText = "", initialCursorOffset = 0, viewport, onChange, isValidPath, shellModeActive = false }) {
+	const [state, dispatch] = (0, react.useReducer)(textBufferReducer, (0, react.useMemo)(() => {
+		const lines$1 = initialText.split("\n");
+		const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(lines$1.length === 0 ? [""] : lines$1, initialCursorOffset);
+		const visualLayout$1 = calculateLayout(lines$1.length === 0 ? [""] : lines$1, viewport.width);
+		return {
+			lines: lines$1.length === 0 ? [""] : lines$1,
+			cursorRow: initialCursorRow,
+			cursorCol: initialCursorCol,
+			preferredCol: null,
+			undoStack: [],
+			redoStack: [],
+			clipboard: null,
+			selectionAnchor: null,
+			viewportWidth: viewport.width,
+			viewportHeight: viewport.height,
+			visualLayout: visualLayout$1
+		};
+	}, [
+		initialText,
+		initialCursorOffset,
+		viewport.width,
+		viewport.height
+	]));
+	const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout } = state;
+	const text = (0, react.useMemo)(() => lines.join("\n"), [lines]);
+	const visualCursor = (0, react.useMemo)(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [
+		visualLayout,
+		cursorRow,
+		cursorCol
+	]);
+	const { visualLines, visualToLogicalMap } = visualLayout;
+	const [visualScrollRow, setVisualScrollRow] = (0, react.useState)(0);
+	(0, react.useEffect)(() => {
+		if (onChange) onChange(text);
+	}, [text, onChange]);
+	(0, react.useEffect)(() => {
+		dispatch({
+			type: "set_viewport",
+			payload: {
+				width: viewport.width,
+				height: viewport.height
+			}
+		});
+	}, [viewport.width, viewport.height]);
+	(0, react.useEffect)(() => {
+		const { height } = viewport;
+		const totalVisualLines = visualLines.length;
+		const maxScrollStart = Math.max(0, totalVisualLines - height);
+		let newVisualScrollRow = visualScrollRow;
+		if (visualCursor[0] < visualScrollRow) newVisualScrollRow = visualCursor[0];
+		else if (visualCursor[0] >= visualScrollRow + height) newVisualScrollRow = visualCursor[0] - height + 1;
+		newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart);
+		if (newVisualScrollRow !== visualScrollRow) setVisualScrollRow(newVisualScrollRow);
+	}, [
+		visualCursor,
+		visualScrollRow,
+		viewport,
+		visualLines.length
+	]);
+	const insert = (0, react.useCallback)((ch, { paste = false } = {}) => {
+		if (/[\n\r]/.test(ch)) {
+			dispatch({
+				type: "insert",
+				payload: ch
+			});
+			return;
+		}
+		if (ch.length >= 3 && !shellModeActive && paste) {
+			let potentialPath = ch.trim();
+			const quoteMatch = potentialPath.match(/^'(.*)'$/);
+			if (quoteMatch) potentialPath = quoteMatch[1];
+			potentialPath = potentialPath.trim();
+			if (isValidPath(potentialPath)) ch = `@${potentialPath} `;
+		}
+		let currentText = "";
+		for (const char of require_text_utils.toCodePoints(ch)) if (char.codePointAt(0) === 127) {
+			if (currentText.length > 0) {
+				dispatch({
+					type: "insert",
+					payload: currentText
+				});
+				currentText = "";
+			}
+			dispatch({ type: "backspace" });
+		} else currentText += char;
+		if (currentText.length > 0) dispatch({
+			type: "insert",
+			payload: currentText
+		});
+	}, [isValidPath, shellModeActive]);
+	const newline = (0, react.useCallback)(() => {
+		dispatch({
+			type: "insert",
+			payload: "\n"
+		});
+	}, []);
+	const backspace = (0, react.useCallback)(() => {
+		dispatch({ type: "backspace" });
+	}, []);
+	const del = (0, react.useCallback)(() => {
+		dispatch({ type: "delete" });
+	}, []);
+	const move = (0, react.useCallback)((dir) => {
+		dispatch({
+			type: "move",
+			payload: { dir }
+		});
+	}, [dispatch]);
+	const undo = (0, react.useCallback)(() => {
+		dispatch({ type: "undo" });
+	}, []);
+	const redo = (0, react.useCallback)(() => {
+		dispatch({ type: "redo" });
+	}, []);
+	const setText = (0, react.useCallback)((newText) => {
+		dispatch({
+			type: "set_text",
+			payload: newText
+		});
+	}, []);
+	const deleteWordLeft = (0, react.useCallback)(() => {
+		dispatch({ type: "delete_word_left" });
+	}, []);
+	const deleteWordRight = (0, react.useCallback)(() => {
+		dispatch({ type: "delete_word_right" });
+	}, []);
+	const killLineRight = (0, react.useCallback)(() => {
+		dispatch({ type: "kill_line_right" });
+	}, []);
+	const killLineLeft = (0, react.useCallback)(() => {
+		dispatch({ type: "kill_line_left" });
+	}, []);
+	const handleInput = (0, react.useCallback)((key) => {
+		const { sequence: input } = key;
+		if (key.paste) {
+			insert(input, { paste: key.paste });
+			return;
+		}
+		if (key.name === "return" || input === "\r" || input === "\n" || input === "\\\r") newline();
+		else if (key.name === "left" && !key.meta && !key.ctrl) move("left");
+		else if (key.ctrl && key.name === "b") move("left");
+		else if (key.name === "right" && !key.meta && !key.ctrl) move("right");
+		else if (key.ctrl && key.name === "f") move("right");
+		else if (key.name === "up") move("up");
+		else if (key.name === "down") move("down");
+		else if ((key.ctrl || key.meta) && key.name === "left") move("wordLeft");
+		else if (key.meta && key.name === "b") move("wordLeft");
+		else if ((key.ctrl || key.meta) && key.name === "right") move("wordRight");
+		else if (key.meta && key.name === "f") move("wordRight");
+		else if (key.name === "home") move("home");
+		else if (key.ctrl && key.name === "a") move("home");
+		else if (key.name === "end") move("end");
+		else if (key.ctrl && key.name === "e") move("end");
+		else if (key.ctrl && key.name === "w") deleteWordLeft();
+		else if ((key.meta || key.ctrl) && (key.name === "backspace" || input === "")) deleteWordLeft();
+		else if ((key.meta || key.ctrl) && key.name === "delete") deleteWordRight();
+		else if (key.name === "backspace" || input === "" || key.ctrl && key.name === "h") backspace();
+		else if (key.name === "delete" || key.ctrl && key.name === "d") del();
+		else if (key.ctrl && !key.shift && key.name === "z") undo();
+		else if (key.ctrl && key.shift && key.name === "z") redo();
+		else if (input && !key.ctrl && !key.meta) insert(input, { paste: key.paste });
+	}, [
+		newline,
+		move,
+		deleteWordLeft,
+		deleteWordRight,
+		backspace,
+		del,
+		insert,
+		undo,
+		redo
+	]);
+	const renderedVisualLines = (0, react.useMemo)(() => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height), [
+		visualLines,
+		visualScrollRow,
+		viewport.height
+	]);
+	return (0, react.useMemo)(() => ({
+		lines,
+		text,
+		cursor: [cursorRow, cursorCol],
+		preferredCol,
+		selectionAnchor,
+		allVisualLines: visualLines,
+		viewportVisualLines: renderedVisualLines,
+		visualCursor,
+		visualScrollRow,
+		visualToLogicalMap,
+		setText,
+		insert,
+		newline,
+		backspace,
+		del,
+		move,
+		undo,
+		redo,
+		deleteWordLeft,
+		deleteWordRight,
+		killLineRight,
+		killLineLeft,
+		handleInput
+	}), [
+		lines,
+		text,
+		cursorRow,
+		cursorCol,
+		preferredCol,
+		selectionAnchor,
+		visualLines,
+		renderedVisualLines,
+		visualCursor,
+		visualScrollRow,
+		setText,
+		insert,
+		newline,
+		backspace,
+		del,
+		move,
+		undo,
+		redo,
+		deleteWordLeft,
+		deleteWordRight,
+		killLineRight,
+		killLineLeft,
+		handleInput,
+		visualToLogicalMap
+	]);
+}
+
+//#endregion
+exports.useTextBuffer = useTextBuffer;