@workclaw/openclaw-workclaw 1.0.337 → 1.0.339

package/dist/node_modules/.pnpm/@earendil-works_pi-tui@0.75.4/node_modules/@earendil-works/pi-tui/dist/components/editor.js

@@ -0,0 +1,1614 @@
+import { getKeybindings } from "../keybindings.js";
+import { decodePrintableKey, matchesKey } from "../keys.js";
+import { KillRing } from "../kill-ring.js";
+import { CURSOR_MARKER } from "../tui.js";
+import { UndoStack } from "../undo-stack.js";
+import { visibleWidth, truncateToWidth, isWhitespaceChar, isPunctuationChar, getSegmenter } from "../utils.js";
+import { SelectList } from "./select-list.js";
+const baseSegmenter = getSegmenter();
+const PASTE_MARKER_REGEX = /\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]/g;
+const PASTE_MARKER_SINGLE = /^\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]$/;
+function isPasteMarker(segment) {
+  return segment.length >= 10 && PASTE_MARKER_SINGLE.test(segment);
+}
+function segmentWithMarkers(text, validIds) {
+  if (validIds.size === 0 || !text.includes("[paste #")) {
+    return baseSegmenter.segment(text);
+  }
+  const markers = [];
+  for (const m of text.matchAll(PASTE_MARKER_REGEX)) {
+    const id = Number.parseInt(m[1], 10);
+    if (!validIds.has(id))
+      continue;
+    markers.push({ start: m.index, end: m.index + m[0].length });
+  }
+  if (markers.length === 0) {
+    return baseSegmenter.segment(text);
+  }
+  const baseSegments = baseSegmenter.segment(text);
+  const result = [];
+  let markerIdx = 0;
+  for (const seg of baseSegments) {
+    while (markerIdx < markers.length && markers[markerIdx].end <= seg.index) {
+      markerIdx++;
+    }
+    const marker = markerIdx < markers.length ? markers[markerIdx] : null;
+    if (marker && seg.index >= marker.start && seg.index < marker.end) {
+      if (seg.index === marker.start) {
+        const markerText = text.slice(marker.start, marker.end);
+        result.push({
+          segment: markerText,
+          index: marker.start,
+          input: text
+        });
+      }
+    } else {
+      result.push(seg);
+    }
+  }
+  return result;
+}
+function wordWrapLine(line, maxWidth, preSegmented) {
+  if (!line || maxWidth <= 0) {
+    return [{ text: "", startIndex: 0, endIndex: 0 }];
+  }
+  const lineWidth = visibleWidth(line);
+  if (lineWidth <= maxWidth) {
+    return [{ text: line, startIndex: 0, endIndex: line.length }];
+  }
+  const chunks = [];
+  const segments = preSegmented ?? [...baseSegmenter.segment(line)];
+  let currentWidth = 0;
+  let chunkStart = 0;
+  let wrapOppIndex = -1;
+  let wrapOppWidth = 0;
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const grapheme = seg.segment;
+    const gWidth = visibleWidth(grapheme);
+    const charIndex = seg.index;
+    const isWs = !isPasteMarker(grapheme) && isWhitespaceChar(grapheme);
+    if (currentWidth + gWidth > maxWidth) {
+      if (wrapOppIndex >= 0 && currentWidth - wrapOppWidth + gWidth <= maxWidth) {
+        chunks.push({ text: line.slice(chunkStart, wrapOppIndex), startIndex: chunkStart, endIndex: wrapOppIndex });
+        chunkStart = wrapOppIndex;
+        currentWidth -= wrapOppWidth;
+      } else if (chunkStart < charIndex) {
+        chunks.push({ text: line.slice(chunkStart, charIndex), startIndex: chunkStart, endIndex: charIndex });
+        chunkStart = charIndex;
+        currentWidth = 0;
+      }
+      wrapOppIndex = -1;
+    }
+    if (gWidth > maxWidth) {
+      const subChunks = wordWrapLine(grapheme, maxWidth);
+      for (let j = 0; j < subChunks.length - 1; j++) {
+        const sc = subChunks[j];
+        chunks.push({ text: sc.text, startIndex: charIndex + sc.startIndex, endIndex: charIndex + sc.endIndex });
+      }
+      const last = subChunks[subChunks.length - 1];
+      chunkStart = charIndex + last.startIndex;
+      currentWidth = visibleWidth(last.text);
+      wrapOppIndex = -1;
+      continue;
+    }
+    currentWidth += gWidth;
+    const next = segments[i + 1];
+    if (isWs && next && (isPasteMarker(next.segment) || !isWhitespaceChar(next.segment))) {
+      wrapOppIndex = next.index;
+      wrapOppWidth = currentWidth;
+    }
+  }
+  chunks.push({ text: line.slice(chunkStart), startIndex: chunkStart, endIndex: line.length });
+  return chunks;
+}
+const SLASH_COMMAND_SELECT_LIST_LAYOUT = {
+  minPrimaryColumnWidth: 12,
+  maxPrimaryColumnWidth: 32
+};
+const ATTACHMENT_AUTOCOMPLETE_DEBOUNCE_MS = 20;
+class Editor {
+  state = {
+    lines: [""],
+    cursorLine: 0,
+    cursorCol: 0
+  };
+  /** Focusable interface - set by TUI when focus changes */
+  focused = false;
+  tui;
+  theme;
+  paddingX = 0;
+  // Store last render width for cursor navigation
+  lastWidth = 80;
+  // Vertical scrolling support
+  scrollOffset = 0;
+  // Border color (can be changed dynamically)
+  borderColor;
+  // Autocomplete support
+  autocompleteProvider;
+  autocompleteList;
+  autocompleteState = null;
+  autocompletePrefix = "";
+  autocompleteMaxVisible = 5;
+  autocompleteAbort;
+  autocompleteDebounceTimer;
+  autocompleteRequestTask = Promise.resolve();
+  autocompleteStartToken = 0;
+  autocompleteRequestId = 0;
+  // Paste tracking for large pastes
+  pastes = /* @__PURE__ */ new Map();
+  pasteCounter = 0;
+  // Bracketed paste mode buffering
+  pasteBuffer = "";
+  isInPaste = false;
+  // Prompt history for up/down navigation
+  history = [];
+  historyIndex = -1;
+  // -1 = not browsing, 0 = most recent, 1 = older, etc.
+  // Kill ring for Emacs-style kill/yank operations
+  killRing = new KillRing();
+  lastAction = null;
+  // Character jump mode
+  jumpMode = null;
+  // Preferred visual column for vertical cursor movement (sticky column)
+  preferredVisualCol = null;
+  // When the cursor is snapped to the start of an atomic segment, e.g. a
+  // paste marker, cursorCol no longer reflects where the cursor would have
+  // landed. This field stores the pre-snap cursorCol so that the next
+  // vertical move can resolve it to a visual column on whatever VL it belongs
+  // to.
+  snappedFromCursorCol = null;
+  // Undo support
+  undoStack = new UndoStack();
+  onSubmit;
+  onChange;
+  disableSubmit = false;
+  constructor(tui, theme, options = {}) {
+    this.tui = tui;
+    this.theme = theme;
+    this.borderColor = theme.borderColor;
+    const paddingX = options.paddingX ?? 0;
+    this.paddingX = Number.isFinite(paddingX) ? Math.max(0, Math.floor(paddingX)) : 0;
+    const maxVisible = options.autocompleteMaxVisible ?? 5;
+    this.autocompleteMaxVisible = Number.isFinite(maxVisible) ? Math.max(3, Math.min(20, Math.floor(maxVisible))) : 5;
+  }
+  /** Set of currently valid paste IDs, for marker-aware segmentation. */
+  validPasteIds() {
+    return new Set(this.pastes.keys());
+  }
+  /** Segment text with paste-marker awareness, only merging markers with valid IDs. */
+  segment(text) {
+    return segmentWithMarkers(text, this.validPasteIds());
+  }
+  getPaddingX() {
+    return this.paddingX;
+  }
+  setPaddingX(padding) {
+    const newPadding = Number.isFinite(padding) ? Math.max(0, Math.floor(padding)) : 0;
+    if (this.paddingX !== newPadding) {
+      this.paddingX = newPadding;
+      this.tui.requestRender();
+    }
+  }
+  getAutocompleteMaxVisible() {
+    return this.autocompleteMaxVisible;
+  }
+  setAutocompleteMaxVisible(maxVisible) {
+    const newMaxVisible = Number.isFinite(maxVisible) ? Math.max(3, Math.min(20, Math.floor(maxVisible))) : 5;
+    if (this.autocompleteMaxVisible !== newMaxVisible) {
+      this.autocompleteMaxVisible = newMaxVisible;
+      this.tui.requestRender();
+    }
+  }
+  setAutocompleteProvider(provider) {
+    this.cancelAutocomplete();
+    this.autocompleteProvider = provider;
+  }
+  /**
+   * Add a prompt to history for up/down arrow navigation.
+   * Called after successful submission.
+   */
+  addToHistory(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+      return;
+    if (this.history.length > 0 && this.history[0] === trimmed)
+      return;
+    this.history.unshift(trimmed);
+    if (this.history.length > 100) {
+      this.history.pop();
+    }
+  }
+  isEditorEmpty() {
+    return this.state.lines.length === 1 && this.state.lines[0] === "";
+  }
+  isOnFirstVisualLine() {
+    const visualLines = this.buildVisualLineMap(this.lastWidth);
+    const currentVisualLine = this.findCurrentVisualLine(visualLines);
+    return currentVisualLine === 0;
+  }
+  isOnLastVisualLine() {
+    const visualLines = this.buildVisualLineMap(this.lastWidth);
+    const currentVisualLine = this.findCurrentVisualLine(visualLines);
+    return currentVisualLine === visualLines.length - 1;
+  }
+  navigateHistory(direction) {
+    this.lastAction = null;
+    if (this.history.length === 0)
+      return;
+    const newIndex = this.historyIndex - direction;
+    if (newIndex < -1 || newIndex >= this.history.length)
+      return;
+    if (this.historyIndex === -1 && newIndex >= 0) {
+      this.pushUndoSnapshot();
+    }
+    this.historyIndex = newIndex;
+    if (this.historyIndex === -1) {
+      this.setTextInternal("");
+    } else {
+      this.setTextInternal(this.history[this.historyIndex] || "");
+    }
+  }
+  /** Internal setText that doesn't reset history state - used by navigateHistory */
+  setTextInternal(text) {
+    const lines = text.split("\n");
+    this.state.lines = lines.length === 0 ? [""] : lines;
+    this.state.cursorLine = this.state.lines.length - 1;
+    this.setCursorCol(this.state.lines[this.state.cursorLine]?.length || 0);
+    this.scrollOffset = 0;
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  invalidate() {
+  }
+  render(width) {
+    const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
+    const paddingX = Math.min(this.paddingX, maxPadding);
+    const contentWidth = Math.max(1, width - paddingX * 2);
+    const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
+    this.lastWidth = layoutWidth;
+    const horizontal = this.borderColor("─");
+    const layoutLines = this.layoutText(layoutWidth);
+    const terminalRows = this.tui.terminal.rows;
+    const maxVisibleLines = Math.max(5, Math.floor(terminalRows * 0.3));
+    let cursorLineIndex = layoutLines.findIndex((line) => line.hasCursor);
+    if (cursorLineIndex === -1)
+      cursorLineIndex = 0;
+    if (cursorLineIndex < this.scrollOffset) {
+      this.scrollOffset = cursorLineIndex;
+    } else if (cursorLineIndex >= this.scrollOffset + maxVisibleLines) {
+      this.scrollOffset = cursorLineIndex - maxVisibleLines + 1;
+    }
+    const maxScrollOffset = Math.max(0, layoutLines.length - maxVisibleLines);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxScrollOffset));
+    const visibleLines = layoutLines.slice(this.scrollOffset, this.scrollOffset + maxVisibleLines);
+    const result = [];
+    const leftPadding = " ".repeat(paddingX);
+    const rightPadding = leftPadding;
+    if (this.scrollOffset > 0) {
+      const indicator = `─── ↑ ${this.scrollOffset} more `;
+      const remaining = width - visibleWidth(indicator);
+      if (remaining >= 0) {
+        result.push(this.borderColor(indicator + "─".repeat(remaining)));
+      } else {
+        result.push(this.borderColor(truncateToWidth(indicator, width)));
+      }
+    } else {
+      result.push(horizontal.repeat(width));
+    }
+    const emitCursorMarker = this.focused && !this.autocompleteState;
+    for (const layoutLine of visibleLines) {
+      let displayText = layoutLine.text;
+      let lineVisibleWidth = visibleWidth(layoutLine.text);
+      let cursorInPadding = false;
+      if (layoutLine.hasCursor && layoutLine.cursorPos !== void 0) {
+        const before = displayText.slice(0, layoutLine.cursorPos);
+        const after = displayText.slice(layoutLine.cursorPos);
+        const marker = emitCursorMarker ? CURSOR_MARKER : "";
+        if (after.length > 0) {
+          const afterGraphemes = [...this.segment(after)];
+          const firstGrapheme = afterGraphemes[0]?.segment || "";
+          const restAfter = after.slice(firstGrapheme.length);
+          const cursor = `\x1B[7m${firstGrapheme}\x1B[0m`;
+          displayText = before + marker + cursor + restAfter;
+        } else {
+          const cursor = "\x1B[7m \x1B[0m";
+          displayText = before + marker + cursor;
+          lineVisibleWidth = lineVisibleWidth + 1;
+          if (lineVisibleWidth > contentWidth && paddingX > 0) {
+            cursorInPadding = true;
+          }
+        }
+      }
+      const padding = " ".repeat(Math.max(0, contentWidth - lineVisibleWidth));
+      const lineRightPadding = cursorInPadding ? rightPadding.slice(1) : rightPadding;
+      result.push(`${leftPadding}${displayText}${padding}${lineRightPadding}`);
+    }
+    const linesBelow = layoutLines.length - (this.scrollOffset + visibleLines.length);
+    if (linesBelow > 0) {
+      const indicator = `─── ↓ ${linesBelow} more `;
+      const remaining = width - visibleWidth(indicator);
+      result.push(this.borderColor(indicator + "─".repeat(Math.max(0, remaining))));
+    } else {
+      result.push(horizontal.repeat(width));
+    }
+    if (this.autocompleteState && this.autocompleteList) {
+      const autocompleteResult = this.autocompleteList.render(contentWidth);
+      for (const line of autocompleteResult) {
+        const lineWidth = visibleWidth(line);
+        const linePadding = " ".repeat(Math.max(0, contentWidth - lineWidth));
+        result.push(`${leftPadding}${line}${linePadding}${rightPadding}`);
+      }
+    }
+    return result;
+  }
+  handleInput(data) {
+    const kb = getKeybindings();
+    if (this.jumpMode !== null) {
+      if (kb.matches(data, "tui.editor.jumpForward") || kb.matches(data, "tui.editor.jumpBackward")) {
+        this.jumpMode = null;
+        return;
+      }
+      const printable2 = decodePrintableKey(data) ?? (data.charCodeAt(0) >= 32 ? data : void 0);
+      if (printable2 !== void 0) {
+        const direction = this.jumpMode;
+        this.jumpMode = null;
+        this.jumpToChar(printable2, direction);
+        return;
+      }
+      this.jumpMode = null;
+    }
+    if (data.includes("\x1B[200~")) {
+      this.isInPaste = true;
+      this.pasteBuffer = "";
+      data = data.replace("\x1B[200~", "");
+    }
+    if (this.isInPaste) {
+      this.pasteBuffer += data;
+      const endIndex = this.pasteBuffer.indexOf("\x1B[201~");
+      if (endIndex !== -1) {
+        const pasteContent = this.pasteBuffer.substring(0, endIndex);
+        if (pasteContent.length > 0) {
+          this.handlePaste(pasteContent);
+        }
+        this.isInPaste = false;
+        const remaining = this.pasteBuffer.substring(endIndex + 6);
+        this.pasteBuffer = "";
+        if (remaining.length > 0) {
+          this.handleInput(remaining);
+        }
+        return;
+      }
+      return;
+    }
+    if (kb.matches(data, "tui.input.copy")) {
+      return;
+    }
+    if (kb.matches(data, "tui.editor.undo")) {
+      this.undo();
+      return;
+    }
+    if (this.autocompleteState && this.autocompleteList) {
+      if (kb.matches(data, "tui.select.cancel")) {
+        this.cancelAutocomplete();
+        return;
+      }
+      if (kb.matches(data, "tui.select.up") || kb.matches(data, "tui.select.down")) {
+        this.autocompleteList.handleInput(data);
+        return;
+      }
+      if (kb.matches(data, "tui.input.tab")) {
+        const selected = this.autocompleteList.getSelectedItem();
+        if (selected && this.autocompleteProvider) {
+          this.pushUndoSnapshot();
+          this.lastAction = null;
+          const result = this.autocompleteProvider.applyCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol, selected, this.autocompletePrefix);
+          this.state.lines = result.lines;
+          this.state.cursorLine = result.cursorLine;
+          this.setCursorCol(result.cursorCol);
+          this.cancelAutocomplete();
+          if (this.onChange)
+            this.onChange(this.getText());
+        }
+        return;
+      }
+      if (kb.matches(data, "tui.select.confirm")) {
+        const selected = this.autocompleteList.getSelectedItem();
+        if (selected && this.autocompleteProvider) {
+          this.pushUndoSnapshot();
+          this.lastAction = null;
+          const result = this.autocompleteProvider.applyCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol, selected, this.autocompletePrefix);
+          this.state.lines = result.lines;
+          this.state.cursorLine = result.cursorLine;
+          this.setCursorCol(result.cursorCol);
+          if (this.autocompletePrefix.startsWith("/")) {
+            this.cancelAutocomplete();
+          } else {
+            this.cancelAutocomplete();
+            if (this.onChange)
+              this.onChange(this.getText());
+            return;
+          }
+        }
+      }
+    }
+    if (kb.matches(data, "tui.input.tab") && !this.autocompleteState) {
+      this.handleTabCompletion();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.deleteToLineEnd")) {
+      this.deleteToEndOfLine();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.deleteToLineStart")) {
+      this.deleteToStartOfLine();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.deleteWordBackward")) {
+      this.deleteWordBackwards();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.deleteWordForward")) {
+      this.deleteWordForward();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.deleteCharBackward") || matchesKey(data, "shift+backspace")) {
+      this.handleBackspace();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.deleteCharForward") || matchesKey(data, "shift+delete")) {
+      this.handleForwardDelete();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.yank")) {
+      this.yank();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.yankPop")) {
+      this.yankPop();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorLineStart")) {
+      this.moveToLineStart();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorLineEnd")) {
+      this.moveToLineEnd();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorWordLeft")) {
+      this.moveWordBackwards();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorWordRight")) {
+      this.moveWordForwards();
+      return;
+    }
+    if (kb.matches(data, "tui.input.newLine") || data.charCodeAt(0) === 10 && data.length > 1 || data === "\x1B\r" || data === "\x1B[13;2~" || data.length > 1 && data.includes("\x1B") && data.includes("\r") || data === "\n" && data.length === 1) {
+      if (this.shouldSubmitOnBackslashEnter(data, kb)) {
+        this.handleBackspace();
+        this.submitValue();
+        return;
+      }
+      this.addNewLine();
+      return;
+    }
+    if (kb.matches(data, "tui.input.submit")) {
+      if (this.disableSubmit)
+        return;
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      if (this.state.cursorCol > 0 && currentLine[this.state.cursorCol - 1] === "\\") {
+        this.handleBackspace();
+        this.addNewLine();
+        return;
+      }
+      this.submitValue();
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorUp")) {
+      if (this.isEditorEmpty()) {
+        this.navigateHistory(-1);
+      } else if (this.historyIndex > -1 && this.isOnFirstVisualLine()) {
+        this.navigateHistory(-1);
+      } else if (this.isOnFirstVisualLine()) {
+        this.moveToLineStart();
+      } else {
+        this.moveCursor(-1, 0);
+      }
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorDown")) {
+      if (this.historyIndex > -1 && this.isOnLastVisualLine()) {
+        this.navigateHistory(1);
+      } else if (this.isOnLastVisualLine()) {
+        this.moveToLineEnd();
+      } else {
+        this.moveCursor(1, 0);
+      }
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorRight")) {
+      this.moveCursor(0, 1);
+      return;
+    }
+    if (kb.matches(data, "tui.editor.cursorLeft")) {
+      this.moveCursor(0, -1);
+      return;
+    }
+    if (kb.matches(data, "tui.editor.pageUp")) {
+      this.pageScroll(-1);
+      return;
+    }
+    if (kb.matches(data, "tui.editor.pageDown")) {
+      this.pageScroll(1);
+      return;
+    }
+    if (kb.matches(data, "tui.editor.jumpForward")) {
+      this.jumpMode = "forward";
+      return;
+    }
+    if (kb.matches(data, "tui.editor.jumpBackward")) {
+      this.jumpMode = "backward";
+      return;
+    }
+    if (matchesKey(data, "shift+space")) {
+      this.insertCharacter(" ");
+      return;
+    }
+    const printable = decodePrintableKey(data);
+    if (printable !== void 0) {
+      this.insertCharacter(printable);
+      return;
+    }
+    if (data.charCodeAt(0) >= 32) {
+      this.insertCharacter(data);
+    }
+  }
+  layoutText(contentWidth) {
+    const layoutLines = [];
+    if (this.state.lines.length === 0 || this.state.lines.length === 1 && this.state.lines[0] === "") {
+      layoutLines.push({
+        text: "",
+        hasCursor: true,
+        cursorPos: 0
+      });
+      return layoutLines;
+    }
+    for (let i = 0; i < this.state.lines.length; i++) {
+      const line = this.state.lines[i] || "";
+      const isCurrentLine = i === this.state.cursorLine;
+      const lineVisibleWidth = visibleWidth(line);
+      if (lineVisibleWidth <= contentWidth) {
+        if (isCurrentLine) {
+          layoutLines.push({
+            text: line,
+            hasCursor: true,
+            cursorPos: this.state.cursorCol
+          });
+        } else {
+          layoutLines.push({
+            text: line,
+            hasCursor: false
+          });
+        }
+      } else {
+        const chunks = wordWrapLine(line, contentWidth, [...this.segment(line)]);
+        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+          const chunk = chunks[chunkIndex];
+          if (!chunk)
+            continue;
+          const cursorPos = this.state.cursorCol;
+          const isLastChunk = chunkIndex === chunks.length - 1;
+          let hasCursorInChunk = false;
+          let adjustedCursorPos = 0;
+          if (isCurrentLine) {
+            if (isLastChunk) {
+              hasCursorInChunk = cursorPos >= chunk.startIndex;
+              adjustedCursorPos = cursorPos - chunk.startIndex;
+            } else {
+              hasCursorInChunk = cursorPos >= chunk.startIndex && cursorPos < chunk.endIndex;
+              if (hasCursorInChunk) {
+                adjustedCursorPos = cursorPos - chunk.startIndex;
+                if (adjustedCursorPos > chunk.text.length) {
+                  adjustedCursorPos = chunk.text.length;
+                }
+              }
+            }
+          }
+          if (hasCursorInChunk) {
+            layoutLines.push({
+              text: chunk.text,
+              hasCursor: true,
+              cursorPos: adjustedCursorPos
+            });
+          } else {
+            layoutLines.push({
+              text: chunk.text,
+              hasCursor: false
+            });
+          }
+        }
+      }
+    }
+    return layoutLines;
+  }
+  getText() {
+    return this.state.lines.join("\n");
+  }
+  expandPasteMarkers(text) {
+    let result = text;
+    for (const [pasteId, pasteContent] of this.pastes) {
+      const markerRegex = new RegExp(`\\[paste #${pasteId}( (\\+\\d+ lines|\\d+ chars))?\\]`, "g");
+      result = result.replace(markerRegex, () => pasteContent);
+    }
+    return result;
+  }
+  /**
+   * Get text with paste markers expanded to their actual content.
+   * Use this when you need the full content (e.g., for external editor).
+   */
+  getExpandedText() {
+    return this.expandPasteMarkers(this.state.lines.join("\n"));
+  }
+  getLines() {
+    return [...this.state.lines];
+  }
+  getCursor() {
+    return { line: this.state.cursorLine, col: this.state.cursorCol };
+  }
+  setText(text) {
+    this.cancelAutocomplete();
+    this.lastAction = null;
+    this.historyIndex = -1;
+    const normalized = this.normalizeText(text);
+    if (this.getText() !== normalized) {
+      this.pushUndoSnapshot();
+    }
+    this.setTextInternal(normalized);
+  }
+  /**
+   * Insert text at the current cursor position.
+   * Used for programmatic insertion (e.g., clipboard image markers).
+   * This is atomic for undo - single undo restores entire pre-insert state.
+   */
+  insertTextAtCursor(text) {
+    if (!text)
+      return;
+    this.cancelAutocomplete();
+    this.pushUndoSnapshot();
+    this.lastAction = null;
+    this.historyIndex = -1;
+    this.insertTextAtCursorInternal(text);
+  }
+  /**
+   * Normalize text for editor storage:
+   * - Normalize line endings (\r\n and \r -> \n)
+   * - Expand tabs to 4 spaces
+   */
+  normalizeText(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "    ");
+  }
+  /**
+   * Internal text insertion at cursor. Handles single and multi-line text.
+   * Does not push undo snapshots or trigger autocomplete - caller is responsible.
+   * Normalizes line endings and calls onChange once at the end.
+   */
+  insertTextAtCursorInternal(text) {
+    if (!text)
+      return;
+    const normalized = this.normalizeText(text);
+    const insertedLines = normalized.split("\n");
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    const beforeCursor = currentLine.slice(0, this.state.cursorCol);
+    const afterCursor = currentLine.slice(this.state.cursorCol);
+    if (insertedLines.length === 1) {
+      this.state.lines[this.state.cursorLine] = beforeCursor + normalized + afterCursor;
+      this.setCursorCol(this.state.cursorCol + normalized.length);
+    } else {
+      this.state.lines = [
+        // All lines before current line
+        ...this.state.lines.slice(0, this.state.cursorLine),
+        // The first inserted line merged with text before cursor
+        beforeCursor + insertedLines[0],
+        // All middle inserted lines
+        ...insertedLines.slice(1, -1),
+        // The last inserted line with text after cursor
+        insertedLines[insertedLines.length - 1] + afterCursor,
+        // All lines after current line
+        ...this.state.lines.slice(this.state.cursorLine + 1)
+      ];
+      this.state.cursorLine += insertedLines.length - 1;
+      this.setCursorCol((insertedLines[insertedLines.length - 1] || "").length);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  // All the editor methods from before...
+  insertCharacter(char, skipUndoCoalescing) {
+    this.historyIndex = -1;
+    if (!skipUndoCoalescing) {
+      if (isWhitespaceChar(char) || this.lastAction !== "type-word") {
+        this.pushUndoSnapshot();
+      }
+      this.lastAction = "type-word";
+    }
+    const line = this.state.lines[this.state.cursorLine] || "";
+    const before = line.slice(0, this.state.cursorCol);
+    const after = line.slice(this.state.cursorCol);
+    this.state.lines[this.state.cursorLine] = before + char + after;
+    this.setCursorCol(this.state.cursorCol + char.length);
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+    if (!this.autocompleteState) {
+      if (char === "/" && this.isAtStartOfMessage()) {
+        this.tryTriggerAutocomplete();
+      } else if (char === "@" || char === "#") {
+        const currentLine = this.state.lines[this.state.cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
+        const charBeforeSymbol = textBeforeCursor[textBeforeCursor.length - 2];
+        if (textBeforeCursor.length === 1 || charBeforeSymbol === " " || charBeforeSymbol === "	") {
+          this.tryTriggerAutocomplete();
+        }
+      } else if (/[a-zA-Z0-9.\-_]/.test(char)) {
+        const currentLine = this.state.lines[this.state.cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
+        if (this.isInSlashCommandContext(textBeforeCursor)) {
+          this.tryTriggerAutocomplete();
+        } else if (textBeforeCursor.match(/(?:^|[\s])[@#][^\s]*$/)) {
+          this.tryTriggerAutocomplete();
+        }
+      }
+    } else {
+      this.updateAutocomplete();
+    }
+  }
+  handlePaste(pastedText) {
+    this.cancelAutocomplete();
+    this.historyIndex = -1;
+    this.lastAction = null;
+    this.pushUndoSnapshot();
+    const decodedText = pastedText.replace(/\x1b\[(\d+);5u/g, (match, code) => {
+      const cp = Number(code);
+      if (cp >= 97 && cp <= 122)
+        return String.fromCharCode(cp - 96);
+      if (cp >= 65 && cp <= 90)
+        return String.fromCharCode(cp - 64);
+      return match;
+    });
+    const cleanText = this.normalizeText(decodedText);
+    let filteredText = cleanText.split("").filter((char) => char === "\n" || char.charCodeAt(0) >= 32).join("");
+    if (/^[/~.]/.test(filteredText)) {
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      const charBeforeCursor = this.state.cursorCol > 0 ? currentLine[this.state.cursorCol - 1] : "";
+      if (charBeforeCursor && /\w/.test(charBeforeCursor)) {
+        filteredText = ` ${filteredText}`;
+      }
+    }
+    const pastedLines = filteredText.split("\n");
+    const totalChars = filteredText.length;
+    if (pastedLines.length > 10 || totalChars > 1e3) {
+      this.pasteCounter++;
+      const pasteId = this.pasteCounter;
+      this.pastes.set(pasteId, filteredText);
+      const marker = pastedLines.length > 10 ? `[paste #${pasteId} +${pastedLines.length} lines]` : `[paste #${pasteId} ${totalChars} chars]`;
+      this.insertTextAtCursorInternal(marker);
+      return;
+    }
+    if (pastedLines.length === 1) {
+      this.insertTextAtCursorInternal(filteredText);
+      return;
+    }
+    this.insertTextAtCursorInternal(filteredText);
+  }
+  addNewLine() {
+    this.cancelAutocomplete();
+    this.historyIndex = -1;
+    this.lastAction = null;
+    this.pushUndoSnapshot();
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    const before = currentLine.slice(0, this.state.cursorCol);
+    const after = currentLine.slice(this.state.cursorCol);
+    this.state.lines[this.state.cursorLine] = before;
+    this.state.lines.splice(this.state.cursorLine + 1, 0, after);
+    this.state.cursorLine++;
+    this.setCursorCol(0);
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  shouldSubmitOnBackslashEnter(data, kb) {
+    if (this.disableSubmit)
+      return false;
+    if (!matchesKey(data, "enter"))
+      return false;
+    const submitKeys = kb.getKeys("tui.input.submit");
+    const hasShiftEnter = submitKeys.includes("shift+enter") || submitKeys.includes("shift+return");
+    if (!hasShiftEnter)
+      return false;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    return this.state.cursorCol > 0 && currentLine[this.state.cursorCol - 1] === "\\";
+  }
+  submitValue() {
+    this.cancelAutocomplete();
+    const result = this.expandPasteMarkers(this.state.lines.join("\n")).trim();
+    this.state = { lines: [""], cursorLine: 0, cursorCol: 0 };
+    this.pastes.clear();
+    this.pasteCounter = 0;
+    this.historyIndex = -1;
+    this.scrollOffset = 0;
+    this.undoStack.clear();
+    this.lastAction = null;
+    if (this.onChange)
+      this.onChange("");
+    if (this.onSubmit)
+      this.onSubmit(result);
+  }
+  handleBackspace() {
+    this.historyIndex = -1;
+    this.lastAction = null;
+    if (this.state.cursorCol > 0) {
+      this.pushUndoSnapshot();
+      const line = this.state.lines[this.state.cursorLine] || "";
+      const beforeCursor = line.slice(0, this.state.cursorCol);
+      const graphemes = [...this.segment(beforeCursor)];
+      const lastGrapheme = graphemes[graphemes.length - 1];
+      const graphemeLength = lastGrapheme ? lastGrapheme.segment.length : 1;
+      const before = line.slice(0, this.state.cursorCol - graphemeLength);
+      const after = line.slice(this.state.cursorCol);
+      this.state.lines[this.state.cursorLine] = before + after;
+      this.setCursorCol(this.state.cursorCol - graphemeLength);
+    } else if (this.state.cursorLine > 0) {
+      this.pushUndoSnapshot();
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      const previousLine = this.state.lines[this.state.cursorLine - 1] || "";
+      this.state.lines[this.state.cursorLine - 1] = previousLine + currentLine;
+      this.state.lines.splice(this.state.cursorLine, 1);
+      this.state.cursorLine--;
+      this.setCursorCol(previousLine.length);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+    if (this.autocompleteState) {
+      this.updateAutocomplete();
+    } else {
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
+      if (this.isInSlashCommandContext(textBeforeCursor)) {
+        this.tryTriggerAutocomplete();
+      } else if (textBeforeCursor.match(/(?:^|[\s])[@#][^\s]*$/)) {
+        this.tryTriggerAutocomplete();
+      }
+    }
+  }
+  /**
+   * Set cursor column and clear preferredVisualCol.
+   * Use this for all non-vertical cursor movements to reset sticky column behavior.
+   */
+  setCursorCol(col) {
+    this.state.cursorCol = col;
+    this.preferredVisualCol = null;
+    this.snappedFromCursorCol = null;
+  }
+  /**
+   * Move cursor to a target visual line, applying sticky column logic.
+   * Shared by moveCursor() and pageScroll().
+   */
+  moveToVisualLine(visualLines, currentVisualLine, targetVisualLine) {
+    const currentVL = visualLines[currentVisualLine];
+    const targetVL = visualLines[targetVisualLine];
+    if (!(currentVL && targetVL))
+      return;
+    let currentVisualCol;
+    if (this.snappedFromCursorCol !== null) {
+      const vlIndex = this.findVisualLineAt(visualLines, currentVL.logicalLine, this.snappedFromCursorCol);
+      currentVisualCol = this.snappedFromCursorCol - visualLines[vlIndex].startCol;
+    } else {
+      currentVisualCol = this.state.cursorCol - currentVL.startCol;
+    }
+    const isLastSourceSegment = currentVisualLine === visualLines.length - 1 || visualLines[currentVisualLine + 1]?.logicalLine !== currentVL.logicalLine;
+    const sourceMaxVisualCol = isLastSourceSegment ? currentVL.length : Math.max(0, currentVL.length - 1);
+    const isLastTargetSegment = targetVisualLine === visualLines.length - 1 || visualLines[targetVisualLine + 1]?.logicalLine !== targetVL.logicalLine;
+    const targetMaxVisualCol = isLastTargetSegment ? targetVL.length : Math.max(0, targetVL.length - 1);
+    const moveToVisualCol = this.computeVerticalMoveColumn(currentVisualCol, sourceMaxVisualCol, targetMaxVisualCol);
+    this.state.cursorLine = targetVL.logicalLine;
+    const targetCol = targetVL.startCol + moveToVisualCol;
+    const logicalLine = this.state.lines[targetVL.logicalLine] || "";
+    this.state.cursorCol = Math.min(targetCol, logicalLine.length);
+    const segments = [...this.segment(logicalLine)];
+    for (const seg of segments) {
+      if (seg.index > this.state.cursorCol)
+        break;
+      if (seg.segment.length <= 1)
+        continue;
+      if (this.state.cursorCol < seg.index + seg.segment.length) {
+        const isContinuation = seg.index < targetVL.startCol;
+        const isMovingDown = targetVisualLine > currentVisualLine;
+        if (isContinuation && isMovingDown) {
+          const segEnd = seg.index + seg.segment.length;
+          let next = targetVisualLine + 1;
+          while (next < visualLines.length && visualLines[next].logicalLine === targetVL.logicalLine && visualLines[next].startCol < segEnd) {
+            next++;
+          }
+          if (next < visualLines.length) {
+            this.moveToVisualLine(visualLines, currentVisualLine, next);
+            return;
+          }
+        }
+        this.snappedFromCursorCol = this.state.cursorCol;
+        this.state.cursorCol = seg.index;
+        return;
+      }
+    }
+    this.snappedFromCursorCol = null;
+  }
+  /**
+   * Compute the target visual column for vertical cursor movement.
+   * Implements the sticky column decision table:
+   *
+   * | P | S | T | U | Scenario                                             | Set Preferred | Move To     |
+   * |---|---|---|---| ---------------------------------------------------- |---------------|-------------|
+   * | 0 | * | 0 | - | Start nav, target fits                               | null          | current     |
+   * | 0 | * | 1 | - | Start nav, target shorter                            | current       | target end  |
+   * | 1 | 0 | 0 | 0 | Clamped, target fits preferred                       | null          | preferred   |
+   * | 1 | 0 | 0 | 1 | Clamped, target longer but still can't fit preferred | keep          | target end  |
+   * | 1 | 0 | 1 | - | Clamped, target even shorter                         | keep          | target end  |
+   * | 1 | 1 | 0 | - | Rewrapped, target fits current                       | null          | current     |
+   * | 1 | 1 | 1 | - | Rewrapped, target shorter than current               | current       | target end  |
+   *
+   * Where:
+   * - P = preferred col is set
+   * - S = cursor in middle of source line (not clamped to end)
+   * - T = target line shorter than current visual col
+   * - U = target line shorter than preferred col
+   */
+  computeVerticalMoveColumn(currentVisualCol, sourceMaxVisualCol, targetMaxVisualCol) {
+    const hasPreferred = this.preferredVisualCol !== null;
+    const cursorInMiddle = currentVisualCol < sourceMaxVisualCol;
+    const targetTooShort = targetMaxVisualCol < currentVisualCol;
+    if (!hasPreferred || cursorInMiddle) {
+      if (targetTooShort) {
+        this.preferredVisualCol = currentVisualCol;
+        return targetMaxVisualCol;
+      }
+      this.preferredVisualCol = null;
+      return currentVisualCol;
+    }
+    const targetCantFitPreferred = targetMaxVisualCol < this.preferredVisualCol;
+    if (targetTooShort || targetCantFitPreferred) {
+      return targetMaxVisualCol;
+    }
+    const result = this.preferredVisualCol;
+    this.preferredVisualCol = null;
+    return result;
+  }
+  moveToLineStart() {
+    this.lastAction = null;
+    this.setCursorCol(0);
+  }
+  moveToLineEnd() {
+    this.lastAction = null;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    this.setCursorCol(currentLine.length);
+  }
+  deleteToStartOfLine() {
+    this.historyIndex = -1;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    if (this.state.cursorCol > 0) {
+      this.pushUndoSnapshot();
+      const deletedText = currentLine.slice(0, this.state.cursorCol);
+      this.killRing.push(deletedText, { prepend: true, accumulate: this.lastAction === "kill" });
+      this.lastAction = "kill";
+      this.state.lines[this.state.cursorLine] = currentLine.slice(this.state.cursorCol);
+      this.setCursorCol(0);
+    } else if (this.state.cursorLine > 0) {
+      this.pushUndoSnapshot();
+      this.killRing.push("\n", { prepend: true, accumulate: this.lastAction === "kill" });
+      this.lastAction = "kill";
+      const previousLine = this.state.lines[this.state.cursorLine - 1] || "";
+      this.state.lines[this.state.cursorLine - 1] = previousLine + currentLine;
+      this.state.lines.splice(this.state.cursorLine, 1);
+      this.state.cursorLine--;
+      this.setCursorCol(previousLine.length);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  deleteToEndOfLine() {
+    this.historyIndex = -1;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    if (this.state.cursorCol < currentLine.length) {
+      this.pushUndoSnapshot();
+      const deletedText = currentLine.slice(this.state.cursorCol);
+      this.killRing.push(deletedText, { prepend: false, accumulate: this.lastAction === "kill" });
+      this.lastAction = "kill";
+      this.state.lines[this.state.cursorLine] = currentLine.slice(0, this.state.cursorCol);
+    } else if (this.state.cursorLine < this.state.lines.length - 1) {
+      this.pushUndoSnapshot();
+      this.killRing.push("\n", { prepend: false, accumulate: this.lastAction === "kill" });
+      this.lastAction = "kill";
+      const nextLine = this.state.lines[this.state.cursorLine + 1] || "";
+      this.state.lines[this.state.cursorLine] = currentLine + nextLine;
+      this.state.lines.splice(this.state.cursorLine + 1, 1);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  deleteWordBackwards() {
+    this.historyIndex = -1;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    if (this.state.cursorCol === 0) {
+      if (this.state.cursorLine > 0) {
+        this.pushUndoSnapshot();
+        this.killRing.push("\n", { prepend: true, accumulate: this.lastAction === "kill" });
+        this.lastAction = "kill";
+        const previousLine = this.state.lines[this.state.cursorLine - 1] || "";
+        this.state.lines[this.state.cursorLine - 1] = previousLine + currentLine;
+        this.state.lines.splice(this.state.cursorLine, 1);
+        this.state.cursorLine--;
+        this.setCursorCol(previousLine.length);
+      }
+    } else {
+      this.pushUndoSnapshot();
+      const wasKill = this.lastAction === "kill";
+      const oldCursorCol = this.state.cursorCol;
+      this.moveWordBackwards();
+      const deleteFrom = this.state.cursorCol;
+      this.setCursorCol(oldCursorCol);
+      const deletedText = currentLine.slice(deleteFrom, this.state.cursorCol);
+      this.killRing.push(deletedText, { prepend: true, accumulate: wasKill });
+      this.lastAction = "kill";
+      this.state.lines[this.state.cursorLine] = currentLine.slice(0, deleteFrom) + currentLine.slice(this.state.cursorCol);
+      this.setCursorCol(deleteFrom);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  deleteWordForward() {
+    this.historyIndex = -1;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    if (this.state.cursorCol >= currentLine.length) {
+      if (this.state.cursorLine < this.state.lines.length - 1) {
+        this.pushUndoSnapshot();
+        this.killRing.push("\n", { prepend: false, accumulate: this.lastAction === "kill" });
+        this.lastAction = "kill";
+        const nextLine = this.state.lines[this.state.cursorLine + 1] || "";
+        this.state.lines[this.state.cursorLine] = currentLine + nextLine;
+        this.state.lines.splice(this.state.cursorLine + 1, 1);
+      }
+    } else {
+      this.pushUndoSnapshot();
+      const wasKill = this.lastAction === "kill";
+      const oldCursorCol = this.state.cursorCol;
+      this.moveWordForwards();
+      const deleteTo = this.state.cursorCol;
+      this.setCursorCol(oldCursorCol);
+      const deletedText = currentLine.slice(this.state.cursorCol, deleteTo);
+      this.killRing.push(deletedText, { prepend: false, accumulate: wasKill });
+      this.lastAction = "kill";
+      this.state.lines[this.state.cursorLine] = currentLine.slice(0, this.state.cursorCol) + currentLine.slice(deleteTo);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  handleForwardDelete() {
+    this.historyIndex = -1;
+    this.lastAction = null;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    if (this.state.cursorCol < currentLine.length) {
+      this.pushUndoSnapshot();
+      const afterCursor = currentLine.slice(this.state.cursorCol);
+      const graphemes = [...this.segment(afterCursor)];
+      const firstGrapheme = graphemes[0];
+      const graphemeLength = firstGrapheme ? firstGrapheme.segment.length : 1;
+      const before = currentLine.slice(0, this.state.cursorCol);
+      const after = currentLine.slice(this.state.cursorCol + graphemeLength);
+      this.state.lines[this.state.cursorLine] = before + after;
+    } else if (this.state.cursorLine < this.state.lines.length - 1) {
+      this.pushUndoSnapshot();
+      const nextLine = this.state.lines[this.state.cursorLine + 1] || "";
+      this.state.lines[this.state.cursorLine] = currentLine + nextLine;
+      this.state.lines.splice(this.state.cursorLine + 1, 1);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+    if (this.autocompleteState) {
+      this.updateAutocomplete();
+    } else {
+      const currentLine2 = this.state.lines[this.state.cursorLine] || "";
+      const textBeforeCursor = currentLine2.slice(0, this.state.cursorCol);
+      if (this.isInSlashCommandContext(textBeforeCursor)) {
+        this.tryTriggerAutocomplete();
+      } else if (textBeforeCursor.match(/(?:^|[\s])[@#][^\s]*$/)) {
+        this.tryTriggerAutocomplete();
+      }
+    }
+  }
+  /**
+   * Build a mapping from visual lines to logical positions.
+   * Returns an array where each element represents a visual line with:
+   * - logicalLine: index into this.state.lines
+   * - startCol: starting column in the logical line
+   * - length: length of this visual line segment
+   */
+  buildVisualLineMap(width) {
+    const visualLines = [];
+    for (let i = 0; i < this.state.lines.length; i++) {
+      const line = this.state.lines[i] || "";
+      const lineVisWidth = visibleWidth(line);
+      if (line.length === 0) {
+        visualLines.push({ logicalLine: i, startCol: 0, length: 0 });
+      } else if (lineVisWidth <= width) {
+        visualLines.push({ logicalLine: i, startCol: 0, length: line.length });
+      } else {
+        const chunks = wordWrapLine(line, width, [...this.segment(line)]);
+        for (const chunk of chunks) {
+          visualLines.push({
+            logicalLine: i,
+            startCol: chunk.startIndex,
+            length: chunk.endIndex - chunk.startIndex
+          });
+        }
+      }
+    }
+    return visualLines;
+  }
+  /**
+   * Find the visual line index that contains the given logical position.
+   */
+  findVisualLineAt(visualLines, line, col) {
+    for (let i = 0; i < visualLines.length; i++) {
+      const vl = visualLines[i];
+      if (!vl || vl.logicalLine !== line)
+        continue;
+      const offset = col - vl.startCol;
+      const isLastSegmentOfLine = i === visualLines.length - 1 || visualLines[i + 1]?.logicalLine !== vl.logicalLine;
+      if (offset >= 0 && (offset < vl.length || isLastSegmentOfLine && offset === vl.length)) {
+        return i;
+      }
+    }
+    return visualLines.length - 1;
+  }
+  /**
+   * Find the visual line index for the current cursor position.
+   */
+  findCurrentVisualLine(visualLines) {
+    return this.findVisualLineAt(visualLines, this.state.cursorLine, this.state.cursorCol);
+  }
+  moveCursor(deltaLine, deltaCol) {
+    this.lastAction = null;
+    const visualLines = this.buildVisualLineMap(this.lastWidth);
+    const currentVisualLine = this.findCurrentVisualLine(visualLines);
+    if (deltaLine !== 0) {
+      const targetVisualLine = currentVisualLine + deltaLine;
+      if (targetVisualLine >= 0 && targetVisualLine < visualLines.length) {
+        this.moveToVisualLine(visualLines, currentVisualLine, targetVisualLine);
+      }
+    }
+    if (deltaCol !== 0) {
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      if (deltaCol > 0) {
+        if (this.state.cursorCol < currentLine.length) {
+          const afterCursor = currentLine.slice(this.state.cursorCol);
+          const graphemes = [...this.segment(afterCursor)];
+          const firstGrapheme = graphemes[0];
+          this.setCursorCol(this.state.cursorCol + (firstGrapheme ? firstGrapheme.segment.length : 1));
+        } else if (this.state.cursorLine < this.state.lines.length - 1) {
+          this.state.cursorLine++;
+          this.setCursorCol(0);
+        } else {
+          const currentVL = visualLines[currentVisualLine];
+          if (currentVL) {
+            this.preferredVisualCol = this.state.cursorCol - currentVL.startCol;
+          }
+        }
+      } else {
+        if (this.state.cursorCol > 0) {
+          const beforeCursor = currentLine.slice(0, this.state.cursorCol);
+          const graphemes = [...this.segment(beforeCursor)];
+          const lastGrapheme = graphemes[graphemes.length - 1];
+          this.setCursorCol(this.state.cursorCol - (lastGrapheme ? lastGrapheme.segment.length : 1));
+        } else if (this.state.cursorLine > 0) {
+          this.state.cursorLine--;
+          const prevLine = this.state.lines[this.state.cursorLine] || "";
+          this.setCursorCol(prevLine.length);
+        }
+      }
+    }
+  }
+  /**
+   * Scroll by a page (direction: -1 for up, 1 for down).
+   * Moves cursor by the page size while keeping it in bounds.
+   */
+  pageScroll(direction) {
+    this.lastAction = null;
+    const terminalRows = this.tui.terminal.rows;
+    const pageSize = Math.max(5, Math.floor(terminalRows * 0.3));
+    const visualLines = this.buildVisualLineMap(this.lastWidth);
+    const currentVisualLine = this.findCurrentVisualLine(visualLines);
+    const targetVisualLine = Math.max(0, Math.min(visualLines.length - 1, currentVisualLine + direction * pageSize));
+    this.moveToVisualLine(visualLines, currentVisualLine, targetVisualLine);
+  }
+  moveWordBackwards() {
+    this.lastAction = null;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    if (this.state.cursorCol === 0) {
+      if (this.state.cursorLine > 0) {
+        this.state.cursorLine--;
+        const prevLine = this.state.lines[this.state.cursorLine] || "";
+        this.setCursorCol(prevLine.length);
+      }
+      return;
+    }
+    const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
+    const graphemes = [...this.segment(textBeforeCursor)];
+    let newCol = this.state.cursorCol;
+    while (graphemes.length > 0 && !isPasteMarker(graphemes[graphemes.length - 1]?.segment || "") && isWhitespaceChar(graphemes[graphemes.length - 1]?.segment || "")) {
+      newCol -= graphemes.pop()?.segment.length || 0;
+    }
+    if (graphemes.length > 0) {
+      const lastGrapheme = graphemes[graphemes.length - 1]?.segment || "";
+      if (isPasteMarker(lastGrapheme)) {
+        newCol -= graphemes.pop()?.segment.length || 0;
+      } else if (isPunctuationChar(lastGrapheme)) {
+        while (graphemes.length > 0 && isPunctuationChar(graphemes[graphemes.length - 1]?.segment || "") && !isPasteMarker(graphemes[graphemes.length - 1]?.segment || "")) {
+          newCol -= graphemes.pop()?.segment.length || 0;
+        }
+      } else {
+        while (graphemes.length > 0 && !isWhitespaceChar(graphemes[graphemes.length - 1]?.segment || "") && !isPunctuationChar(graphemes[graphemes.length - 1]?.segment || "") && !isPasteMarker(graphemes[graphemes.length - 1]?.segment || "")) {
+          newCol -= graphemes.pop()?.segment.length || 0;
+        }
+      }
+    }
+    this.setCursorCol(newCol);
+  }
+  /**
+   * Yank (paste) the most recent kill ring entry at cursor position.
+   */
+  yank() {
+    if (this.killRing.length === 0)
+      return;
+    this.pushUndoSnapshot();
+    const text = this.killRing.peek();
+    this.insertYankedText(text);
+    this.lastAction = "yank";
+  }
+  /**
+   * Cycle through kill ring (only works immediately after yank or yank-pop).
+   * Replaces the last yanked text with the previous entry in the ring.
+   */
+  yankPop() {
+    if (this.lastAction !== "yank" || this.killRing.length <= 1)
+      return;
+    this.pushUndoSnapshot();
+    this.deleteYankedText();
+    this.killRing.rotate();
+    const text = this.killRing.peek();
+    this.insertYankedText(text);
+    this.lastAction = "yank";
+  }
+  /**
+   * Insert text at cursor position (used by yank operations).
+   */
+  insertYankedText(text) {
+    this.historyIndex = -1;
+    const lines = text.split("\n");
+    if (lines.length === 1) {
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      const before = currentLine.slice(0, this.state.cursorCol);
+      const after = currentLine.slice(this.state.cursorCol);
+      this.state.lines[this.state.cursorLine] = before + text + after;
+      this.setCursorCol(this.state.cursorCol + text.length);
+    } else {
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      const before = currentLine.slice(0, this.state.cursorCol);
+      const after = currentLine.slice(this.state.cursorCol);
+      this.state.lines[this.state.cursorLine] = before + (lines[0] || "");
+      for (let i = 1; i < lines.length - 1; i++) {
+        this.state.lines.splice(this.state.cursorLine + i, 0, lines[i] || "");
+      }
+      const lastLineIndex = this.state.cursorLine + lines.length - 1;
+      this.state.lines.splice(lastLineIndex, 0, (lines[lines.length - 1] || "") + after);
+      this.state.cursorLine = lastLineIndex;
+      this.setCursorCol((lines[lines.length - 1] || "").length);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  /**
+   * Delete the previously yanked text (used by yank-pop).
+   * The yanked text is derived from killRing[end] since it hasn't been rotated yet.
+   */
+  deleteYankedText() {
+    const yankedText = this.killRing.peek();
+    if (!yankedText)
+      return;
+    const yankLines = yankedText.split("\n");
+    if (yankLines.length === 1) {
+      const currentLine = this.state.lines[this.state.cursorLine] || "";
+      const deleteLen = yankedText.length;
+      const before = currentLine.slice(0, this.state.cursorCol - deleteLen);
+      const after = currentLine.slice(this.state.cursorCol);
+      this.state.lines[this.state.cursorLine] = before + after;
+      this.setCursorCol(this.state.cursorCol - deleteLen);
+    } else {
+      const startLine = this.state.cursorLine - (yankLines.length - 1);
+      const startCol = (this.state.lines[startLine] || "").length - (yankLines[0] || "").length;
+      const afterCursor = (this.state.lines[this.state.cursorLine] || "").slice(this.state.cursorCol);
+      const beforeYank = (this.state.lines[startLine] || "").slice(0, startCol);
+      this.state.lines.splice(startLine, yankLines.length, beforeYank + afterCursor);
+      this.state.cursorLine = startLine;
+      this.setCursorCol(startCol);
+    }
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  pushUndoSnapshot() {
+    this.undoStack.push(this.state);
+  }
+  undo() {
+    this.historyIndex = -1;
+    const snapshot = this.undoStack.pop();
+    if (!snapshot)
+      return;
+    Object.assign(this.state, snapshot);
+    this.lastAction = null;
+    this.preferredVisualCol = null;
+    if (this.onChange) {
+      this.onChange(this.getText());
+    }
+  }
+  /**
+   * Jump to the first occurrence of a character in the specified direction.
+   * Multi-line search. Case-sensitive. Skips the current cursor position.
+   */
+  jumpToChar(char, direction) {
+    this.lastAction = null;
+    const isForward = direction === "forward";
+    const lines = this.state.lines;
+    const end = isForward ? lines.length : -1;
+    const step = isForward ? 1 : -1;
+    for (let lineIdx = this.state.cursorLine; lineIdx !== end; lineIdx += step) {
+      const line = lines[lineIdx] || "";
+      const isCurrentLine = lineIdx === this.state.cursorLine;
+      const searchFrom = isCurrentLine ? isForward ? this.state.cursorCol + 1 : this.state.cursorCol - 1 : void 0;
+      const idx = isForward ? line.indexOf(char, searchFrom) : line.lastIndexOf(char, searchFrom);
+      if (idx !== -1) {
+        this.state.cursorLine = lineIdx;
+        this.setCursorCol(idx);
+        return;
+      }
+    }
+  }
+  moveWordForwards() {
+    this.lastAction = null;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    if (this.state.cursorCol >= currentLine.length) {
+      if (this.state.cursorLine < this.state.lines.length - 1) {
+        this.state.cursorLine++;
+        this.setCursorCol(0);
+      }
+      return;
+    }
+    const textAfterCursor = currentLine.slice(this.state.cursorCol);
+    const segments = this.segment(textAfterCursor);
+    const iterator = segments[Symbol.iterator]();
+    let next = iterator.next();
+    let newCol = this.state.cursorCol;
+    while (!next.done && !isPasteMarker(next.value.segment) && isWhitespaceChar(next.value.segment)) {
+      newCol += next.value.segment.length;
+      next = iterator.next();
+    }
+    if (!next.done) {
+      const firstGrapheme = next.value.segment;
+      if (isPasteMarker(firstGrapheme)) {
+        newCol += firstGrapheme.length;
+      } else if (isPunctuationChar(firstGrapheme)) {
+        while (!next.done && isPunctuationChar(next.value.segment) && !isPasteMarker(next.value.segment)) {
+          newCol += next.value.segment.length;
+          next = iterator.next();
+        }
+      } else {
+        while (!next.done && !isWhitespaceChar(next.value.segment) && !isPunctuationChar(next.value.segment) && !isPasteMarker(next.value.segment)) {
+          newCol += next.value.segment.length;
+          next = iterator.next();
+        }
+      }
+    }
+    this.setCursorCol(newCol);
+  }
+  // Slash menu only allowed on the first line of the editor
+  isSlashMenuAllowed() {
+    return this.state.cursorLine === 0;
+  }
+  // Helper method to check if cursor is at start of message (for slash command detection)
+  isAtStartOfMessage() {
+    if (!this.isSlashMenuAllowed())
+      return false;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    const beforeCursor = currentLine.slice(0, this.state.cursorCol);
+    return beforeCursor.trim() === "" || beforeCursor.trim() === "/";
+  }
+  isInSlashCommandContext(textBeforeCursor) {
+    return this.isSlashMenuAllowed() && textBeforeCursor.trimStart().startsWith("/");
+  }
+  // Autocomplete methods
+  /**
+   * Find the best autocomplete item index for the given prefix.
+   * Returns -1 if no match is found.
+   *
+   * Match priority:
+   * 1. Exact match (prefix === item.value) -> always selected
+   * 2. Prefix match -> first item whose value starts with prefix
+   * 3. No match -> -1 (keep default highlight)
+   *
+   * Matching is case-sensitive and checks item.value only.
+   */
+  getBestAutocompleteMatchIndex(items, prefix) {
+    if (!prefix)
+      return -1;
+    let firstPrefixIndex = -1;
+    for (let i = 0; i < items.length; i++) {
+      const value = items[i].value;
+      if (value === prefix) {
+        return i;
+      }
+      if (firstPrefixIndex === -1 && value.startsWith(prefix)) {
+        firstPrefixIndex = i;
+      }
+    }
+    return firstPrefixIndex;
+  }
+  createAutocompleteList(prefix, items) {
+    const layout = prefix.startsWith("/") ? SLASH_COMMAND_SELECT_LIST_LAYOUT : void 0;
+    return new SelectList(items, this.autocompleteMaxVisible, this.theme.selectList, layout);
+  }
+  tryTriggerAutocomplete(explicitTab = false) {
+    this.requestAutocomplete({ force: false, explicitTab });
+  }
+  handleTabCompletion() {
+    if (!this.autocompleteProvider)
+      return;
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    const beforeCursor = currentLine.slice(0, this.state.cursorCol);
+    if (this.isInSlashCommandContext(beforeCursor) && !beforeCursor.trimStart().includes(" ")) {
+      this.handleSlashCommandCompletion();
+    } else {
+      this.forceFileAutocomplete(true);
+    }
+  }
+  handleSlashCommandCompletion() {
+    this.requestAutocomplete({ force: false, explicitTab: true });
+  }
+  forceFileAutocomplete(explicitTab = false) {
+    this.requestAutocomplete({ force: true, explicitTab });
+  }
+  requestAutocomplete(options) {
+    if (!this.autocompleteProvider)
+      return;
+    if (options.force) {
+      const shouldTrigger = !this.autocompleteProvider.shouldTriggerFileCompletion || this.autocompleteProvider.shouldTriggerFileCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol);
+      if (!shouldTrigger) {
+        return;
+      }
+    }
+    this.cancelAutocompleteRequest();
+    const startToken = ++this.autocompleteStartToken;
+    const debounceMs = this.getAutocompleteDebounceMs(options);
+    if (debounceMs > 0) {
+      this.autocompleteDebounceTimer = setTimeout(() => {
+        this.autocompleteDebounceTimer = void 0;
+        void this.startAutocompleteRequest(startToken, options);
+      }, debounceMs);
+      return;
+    }
+    void this.startAutocompleteRequest(startToken, options);
+  }
+  async startAutocompleteRequest(startToken, options) {
+    const previousTask = this.autocompleteRequestTask;
+    this.autocompleteRequestTask = (async () => {
+      await previousTask;
+      if (startToken !== this.autocompleteStartToken || !this.autocompleteProvider) {
+        return;
+      }
+      const controller = new AbortController();
+      this.autocompleteAbort = controller;
+      const requestId = ++this.autocompleteRequestId;
+      const snapshotText = this.getText();
+      const snapshotLine = this.state.cursorLine;
+      const snapshotCol = this.state.cursorCol;
+      await this.runAutocompleteRequest(requestId, controller, snapshotText, snapshotLine, snapshotCol, options);
+    })();
+    await this.autocompleteRequestTask;
+  }
+  getAutocompleteDebounceMs(options) {
+    if (options.explicitTab || options.force) {
+      return 0;
+    }
+    const currentLine = this.state.lines[this.state.cursorLine] || "";
+    const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
+    const isSymbolAutocompleteContext = /(?:^|[ \t])(?:@(?:"[^"]*|[^\s]*)|#[^\s]*)$/.test(textBeforeCursor);
+    return isSymbolAutocompleteContext ? ATTACHMENT_AUTOCOMPLETE_DEBOUNCE_MS : 0;
+  }
+  async runAutocompleteRequest(requestId, controller, snapshotText, snapshotLine, snapshotCol, options) {
+    if (!this.autocompleteProvider)
+      return;
+    const suggestions = await this.autocompleteProvider.getSuggestions(this.state.lines, this.state.cursorLine, this.state.cursorCol, { signal: controller.signal, force: options.force });
+    if (!this.isAutocompleteRequestCurrent(requestId, controller, snapshotText, snapshotLine, snapshotCol)) {
+      return;
+    }
+    this.autocompleteAbort = void 0;
+    if (!suggestions || !Array.isArray(suggestions.items) || suggestions.items.length === 0) {
+      this.cancelAutocomplete();
+      this.tui.requestRender();
+      return;
+    }
+    if (options.force && options.explicitTab && suggestions.items.length === 1) {
+      const item = suggestions.items[0];
+      this.pushUndoSnapshot();
+      this.lastAction = null;
+      const result = this.autocompleteProvider.applyCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol, item, suggestions.prefix);
+      this.state.lines = result.lines;
+      this.state.cursorLine = result.cursorLine;
+      this.setCursorCol(result.cursorCol);
+      if (this.onChange)
+        this.onChange(this.getText());
+      this.tui.requestRender();
+      return;
+    }
+    this.applyAutocompleteSuggestions(suggestions, options.force ? "force" : "regular");
+    this.tui.requestRender();
+  }
+  isAutocompleteRequestCurrent(requestId, controller, snapshotText, snapshotLine, snapshotCol) {
+    return !controller.signal.aborted && requestId === this.autocompleteRequestId && this.getText() === snapshotText && this.state.cursorLine === snapshotLine && this.state.cursorCol === snapshotCol;
+  }
+  applyAutocompleteSuggestions(suggestions, state) {
+    this.autocompletePrefix = suggestions.prefix;
+    this.autocompleteList = this.createAutocompleteList(suggestions.prefix, suggestions.items);
+    const bestMatchIndex = this.getBestAutocompleteMatchIndex(suggestions.items, suggestions.prefix);
+    if (bestMatchIndex >= 0) {
+      this.autocompleteList.setSelectedIndex(bestMatchIndex);
+    }
+    this.autocompleteState = state;
+  }
+  cancelAutocompleteRequest() {
+    this.autocompleteStartToken += 1;
+    if (this.autocompleteDebounceTimer) {
+      clearTimeout(this.autocompleteDebounceTimer);
+      this.autocompleteDebounceTimer = void 0;
+    }
+    this.autocompleteAbort?.abort();
+    this.autocompleteAbort = void 0;
+  }
+  clearAutocompleteUi() {
+    this.autocompleteState = null;
+    this.autocompleteList = void 0;
+    this.autocompletePrefix = "";
+  }
+  cancelAutocomplete() {
+    this.cancelAutocompleteRequest();
+    this.clearAutocompleteUi();
+  }
+  isShowingAutocomplete() {
+    return this.autocompleteState !== null;
+  }
+  updateAutocomplete() {
+    if (!this.autocompleteState || !this.autocompleteProvider)
+      return;
+    this.requestAutocomplete({ force: this.autocompleteState === "force", explicitTab: false });
+  }
+}
+export {
+  Editor,
+  wordWrapLine
+};