@opentui/core 0.1.29 → 0.1.31

package/{index-bztetjc3.js → index-91qheh74.js}

@@ -2092,6 +2092,12 @@ var parseKeypress = (s = "", options = {}) => {
   } else if (!s) {
     s = "";
   }
+  if (/^\x1b\[<\d+;\d+;\d+[Mm]$/.test(s)) {
+    return null;
+  }
+  if (s.startsWith("\x1B[M") && s.length >= 6) {
+    return null;
+  }
   const key = {
     name: "",
     ctrl: false,
@@ -2110,11 +2116,14 @@ var parseKeypress = (s = "", options = {}) => {
       return kittyResult;
     }
   }
-  if (s === "\r") {
+  if (s === "\r" || s === "\x1B\r") {
     key.name = "return";
+    key.meta = s.length === 2;
   } else if (s === `
+` || s === `\x1B
 `) {
     key.name = "enter";
+    key.meta = s.length === 2;
   } else if (s === "\t") {
     key.name = "tab";
   } else if (s === "\b" || s === "\x1B\b" || s === "\x7F" || s === "\x1B\x7F") {
@@ -2277,6 +2286,9 @@ class KeyHandler extends EventEmitter {
         return;
       }
       const parsedKey = parseKeypress(key, { useKittyKeyboard: this.useKittyKeyboard });
+      if (!parsedKey) {
+        return;
+      }
       switch (parsedKey.eventType) {
         case "press":
           this.emit("keypress", new KeyEvent(parsedKey));
@@ -6204,6 +6216,680 @@ function getTreeSitterClient() {
     return client2;
   });
 }
+
+// src/lib/extmarks-history.ts
+class ExtmarksHistory {
+  undoStack = [];
+  redoStack = [];
+  saveSnapshot(extmarks, nextId) {
+    const snapshot = {
+      extmarks: new Map(Array.from(extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+      nextId
+    };
+    this.undoStack.push(snapshot);
+    this.redoStack = [];
+  }
+  undo() {
+    if (this.undoStack.length === 0)
+      return null;
+    return this.undoStack.pop();
+  }
+  redo() {
+    if (this.redoStack.length === 0)
+      return null;
+    return this.redoStack.pop();
+  }
+  pushRedo(snapshot) {
+    this.redoStack.push(snapshot);
+  }
+  pushUndo(snapshot) {
+    this.undoStack.push(snapshot);
+  }
+  clear() {
+    this.undoStack = [];
+    this.redoStack = [];
+  }
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+}
+
+// src/lib/extmarks.ts
+class ExtmarksController {
+  editBuffer;
+  editorView;
+  extmarks = new Map;
+  extmarksByTypeId = new Map;
+  metadata = new Map;
+  nextId = 1;
+  destroyed = false;
+  history = new ExtmarksHistory;
+  typeNameToId = new Map;
+  typeIdToName = new Map;
+  nextTypeId = 1;
+  originalMoveCursorLeft;
+  originalMoveCursorRight;
+  originalSetCursorByOffset;
+  originalMoveUpVisual;
+  originalMoveDownVisual;
+  originalDeleteCharBackward;
+  originalDeleteChar;
+  originalInsertText;
+  originalInsertChar;
+  originalDeleteRange;
+  originalSetText;
+  originalClear;
+  originalNewLine;
+  originalDeleteLine;
+  originalEditorViewDeleteSelectedText;
+  originalUndo;
+  originalRedo;
+  constructor(editBuffer, editorView) {
+    this.editBuffer = editBuffer;
+    this.editorView = editorView;
+    this.originalMoveCursorLeft = editBuffer.moveCursorLeft.bind(editBuffer);
+    this.originalMoveCursorRight = editBuffer.moveCursorRight.bind(editBuffer);
+    this.originalSetCursorByOffset = editBuffer.setCursorByOffset.bind(editBuffer);
+    this.originalMoveUpVisual = editorView.moveUpVisual.bind(editorView);
+    this.originalMoveDownVisual = editorView.moveDownVisual.bind(editorView);
+    this.originalDeleteCharBackward = editBuffer.deleteCharBackward.bind(editBuffer);
+    this.originalDeleteChar = editBuffer.deleteChar.bind(editBuffer);
+    this.originalInsertText = editBuffer.insertText.bind(editBuffer);
+    this.originalInsertChar = editBuffer.insertChar.bind(editBuffer);
+    this.originalDeleteRange = editBuffer.deleteRange.bind(editBuffer);
+    this.originalSetText = editBuffer.setText.bind(editBuffer);
+    this.originalClear = editBuffer.clear.bind(editBuffer);
+    this.originalNewLine = editBuffer.newLine.bind(editBuffer);
+    this.originalDeleteLine = editBuffer.deleteLine.bind(editBuffer);
+    this.originalEditorViewDeleteSelectedText = editorView.deleteSelectedText.bind(editorView);
+    this.originalUndo = editBuffer.undo.bind(editBuffer);
+    this.originalRedo = editBuffer.redo.bind(editBuffer);
+    this.wrapCursorMovement();
+    this.wrapDeletion();
+    this.wrapInsertion();
+    this.wrapEditorViewDeleteSelectedText();
+    this.wrapUndoRedo();
+    this.setupContentChangeListener();
+  }
+  wrapCursorMovement() {
+    this.editBuffer.moveCursorLeft = () => {
+      if (this.destroyed) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const targetOffset = currentOffset - 1;
+      if (targetOffset < 0) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset >= virtualExtmark.end) {
+        this.editBuffer.setCursorByOffset(virtualExtmark.start - 1);
+        return;
+      }
+      this.originalMoveCursorLeft();
+    };
+    this.editBuffer.moveCursorRight = () => {
+      if (this.destroyed) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const targetOffset = currentOffset + 1;
+      const textLength = this.editBuffer.getText().length;
+      if (targetOffset > textLength) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset <= virtualExtmark.start) {
+        this.editBuffer.setCursorByOffset(virtualExtmark.end);
+        return;
+      }
+      this.originalMoveCursorRight();
+    };
+    this.editorView.moveUpVisual = () => {
+      if (this.destroyed) {
+        this.originalMoveUpVisual();
+        return;
+      }
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveUpVisual();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalMoveUpVisual();
+      const newOffset = this.editorView.getVisualCursor().offset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(newOffset);
+      if (virtualExtmark) {
+        const distanceToStart = newOffset - virtualExtmark.start;
+        const distanceToEnd = virtualExtmark.end - newOffset;
+        if (distanceToStart < distanceToEnd) {
+          this.editorView.setCursorByOffset(virtualExtmark.start - 1);
+        } else {
+          this.editorView.setCursorByOffset(virtualExtmark.end);
+        }
+      }
+    };
+    this.editorView.moveDownVisual = () => {
+      if (this.destroyed) {
+        this.originalMoveDownVisual();
+        return;
+      }
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveDownVisual();
+        return;
+      }
+      this.originalMoveDownVisual();
+      const newOffset = this.editorView.getVisualCursor().offset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(newOffset);
+      if (virtualExtmark) {
+        const distanceToStart = newOffset - virtualExtmark.start;
+        const distanceToEnd = virtualExtmark.end - newOffset;
+        if (distanceToStart < distanceToEnd) {
+          this.editorView.setCursorByOffset(virtualExtmark.start - 1);
+        } else {
+          this.editorView.setCursorByOffset(virtualExtmark.end);
+        }
+      }
+    };
+    this.editBuffer.setCursorByOffset = (offset) => {
+      if (this.destroyed) {
+        this.originalSetCursorByOffset(offset);
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalSetCursorByOffset(offset);
+        return;
+      }
+      const movingForward = offset > currentOffset;
+      if (movingForward) {
+        const virtualExtmark = this.findVirtualExtmarkContaining(offset);
+        if (virtualExtmark && currentOffset <= virtualExtmark.start) {
+          this.originalSetCursorByOffset(virtualExtmark.end);
+          return;
+        }
+      } else {
+        for (const extmark of this.extmarks.values()) {
+          if (extmark.virtual && currentOffset >= extmark.end && offset < extmark.end && offset >= extmark.start) {
+            this.originalSetCursorByOffset(extmark.start - 1);
+            return;
+          }
+        }
+      }
+      this.originalSetCursorByOffset(offset);
+    };
+  }
+  wrapDeletion() {
+    this.editBuffer.deleteCharBackward = () => {
+      if (this.destroyed) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hadSelection = this.editorView.hasSelection();
+      if (currentOffset === 0) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      if (hadSelection) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      const targetOffset = currentOffset - 1;
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset === virtualExtmark.end) {
+        const startCursor = this.offsetToPosition(virtualExtmark.start);
+        const endCursor = this.offsetToPosition(virtualExtmark.end);
+        const deleteOffset = virtualExtmark.start;
+        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        this.deleteExtmarkById(virtualExtmark.id);
+        this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.updateHighlights();
+        return;
+      }
+      this.originalDeleteCharBackward();
+      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+    };
+    this.editBuffer.deleteChar = () => {
+      if (this.destroyed) {
+        this.originalDeleteChar();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const textLength = this.editBuffer.getText().length;
+      const hadSelection = this.editorView.hasSelection();
+      if (currentOffset >= textLength) {
+        this.originalDeleteChar();
+        return;
+      }
+      if (hadSelection) {
+        this.originalDeleteChar();
+        return;
+      }
+      const targetOffset = currentOffset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset === virtualExtmark.start) {
+        const startCursor = this.offsetToPosition(virtualExtmark.start);
+        const endCursor = this.offsetToPosition(virtualExtmark.end);
+        const deleteOffset = virtualExtmark.start;
+        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        this.deleteExtmarkById(virtualExtmark.id);
+        this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.updateHighlights();
+        return;
+      }
+      this.originalDeleteChar();
+      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+    };
+    this.editBuffer.deleteRange = (startLine, startCol, endLine, endCol) => {
+      if (this.destroyed) {
+        this.originalDeleteRange(startLine, startCol, endLine, endCol);
+        return;
+      }
+      this.saveSnapshot();
+      const startOffset = this.positionToOffset(startLine, startCol);
+      const endOffset = this.positionToOffset(endLine, endCol);
+      const length = endOffset - startOffset;
+      this.originalDeleteRange(startLine, startCol, endLine, endCol);
+      this.adjustExtmarksAfterDeletion(startOffset, length);
+    };
+    this.editBuffer.deleteLine = () => {
+      if (this.destroyed) {
+        this.originalDeleteLine();
+        return;
+      }
+      this.saveSnapshot();
+      const text = this.editBuffer.getText();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      let lineStart = 0;
+      for (let i = currentOffset - 1;i >= 0; i--) {
+        if (text[i] === `
+`) {
+          lineStart = i + 1;
+          break;
+        }
+      }
+      let lineEnd = text.length;
+      for (let i = currentOffset;i < text.length; i++) {
+        if (text[i] === `
+`) {
+          lineEnd = i + 1;
+          break;
+        }
+      }
+      const deleteLength = lineEnd - lineStart;
+      this.originalDeleteLine();
+      this.adjustExtmarksAfterDeletion(lineStart, deleteLength);
+    };
+  }
+  wrapInsertion() {
+    this.editBuffer.insertText = (text) => {
+      if (this.destroyed) {
+        this.originalInsertText(text);
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalInsertText(text);
+      this.adjustExtmarksAfterInsertion(currentOffset, text.length);
+    };
+    this.editBuffer.insertChar = (char) => {
+      if (this.destroyed) {
+        this.originalInsertChar(char);
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalInsertChar(char);
+      this.adjustExtmarksAfterInsertion(currentOffset, 1);
+    };
+    this.editBuffer.setText = (text, opts) => {
+      if (this.destroyed) {
+        this.originalSetText(text, opts);
+        return;
+      }
+      if (opts?.history !== false) {
+        this.saveSnapshot();
+      }
+      this.clear();
+      this.originalSetText(text, opts);
+    };
+    this.editBuffer.clear = () => {
+      if (this.destroyed) {
+        this.originalClear();
+        return;
+      }
+      this.saveSnapshot();
+      this.clear();
+      this.originalClear();
+    };
+    this.editBuffer.newLine = () => {
+      if (this.destroyed) {
+        this.originalNewLine();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalNewLine();
+      this.adjustExtmarksAfterInsertion(currentOffset, 1);
+    };
+  }
+  wrapEditorViewDeleteSelectedText() {
+    this.editorView.deleteSelectedText = () => {
+      if (this.destroyed) {
+        this.originalEditorViewDeleteSelectedText();
+        return;
+      }
+      this.saveSnapshot();
+      const selection = this.editorView.getSelection();
+      if (!selection) {
+        this.originalEditorViewDeleteSelectedText();
+        return;
+      }
+      const deleteOffset = Math.min(selection.start, selection.end);
+      const deleteLength = Math.abs(selection.end - selection.start);
+      this.originalEditorViewDeleteSelectedText();
+      if (deleteLength > 0) {
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+      }
+    };
+  }
+  setupContentChangeListener() {
+    this.editBuffer.on("content-changed", () => {
+      if (this.destroyed)
+        return;
+      this.updateHighlights();
+    });
+  }
+  deleteExtmarkById(id) {
+    const extmark = this.extmarks.get(id);
+    if (extmark) {
+      this.extmarks.delete(id);
+      this.extmarksByTypeId.get(extmark.typeId)?.delete(id);
+      this.metadata.delete(id);
+    }
+  }
+  findVirtualExtmarkContaining(offset) {
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.virtual && offset >= extmark.start && offset < extmark.end) {
+        return extmark;
+      }
+    }
+    return null;
+  }
+  adjustExtmarksAfterInsertion(insertOffset, length) {
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.start >= insertOffset) {
+        extmark.start += length;
+        extmark.end += length;
+      } else if (extmark.end > insertOffset) {
+        extmark.end += length;
+      }
+    }
+    this.updateHighlights();
+  }
+  adjustExtmarksAfterDeletion(deleteOffset, length) {
+    const toDelete = [];
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.end <= deleteOffset) {
+        continue;
+      }
+      if (extmark.start >= deleteOffset + length) {
+        extmark.start -= length;
+        extmark.end -= length;
+      } else if (extmark.start >= deleteOffset && extmark.end <= deleteOffset + length) {
+        toDelete.push(extmark.id);
+      } else if (extmark.start < deleteOffset && extmark.end > deleteOffset + length) {
+        extmark.end -= length;
+      } else if (extmark.start < deleteOffset && extmark.end > deleteOffset) {
+        extmark.end -= Math.min(extmark.end, deleteOffset + length) - deleteOffset;
+      } else if (extmark.start < deleteOffset + length && extmark.end > deleteOffset + length) {
+        const overlap = deleteOffset + length - extmark.start;
+        extmark.start = deleteOffset;
+        extmark.end -= length;
+      }
+    }
+    for (const id of toDelete) {
+      this.deleteExtmarkById(id);
+    }
+    this.updateHighlights();
+  }
+  offsetToPosition(offset) {
+    const result = this.editBuffer.offsetToPosition(offset);
+    if (!result) {
+      return { row: 0, col: 0 };
+    }
+    return result;
+  }
+  positionToOffset(row, col) {
+    return this.editBuffer.positionToOffset(row, col);
+  }
+  updateHighlights() {
+    this.editBuffer.clearAllHighlights();
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.styleId !== undefined) {
+        const startWithoutNewlines = this.offsetToCharOffset(extmark.start);
+        const endWithoutNewlines = this.offsetToCharOffset(extmark.end);
+        this.editBuffer.addHighlightByCharRange({
+          start: startWithoutNewlines,
+          end: endWithoutNewlines,
+          styleId: extmark.styleId,
+          priority: extmark.priority ?? 0,
+          hlRef: extmark.id
+        });
+      }
+    }
+  }
+  offsetToCharOffset(offset) {
+    const text = this.editBuffer.getText();
+    let charOffset = 0;
+    for (let i = 0;i < offset && i < text.length; i++) {
+      if (text[i] !== `
+`) {
+        charOffset++;
+      }
+    }
+    return charOffset;
+  }
+  create(options) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const id = this.nextId++;
+    const typeId = options.typeId ?? 0;
+    const extmark = {
+      id,
+      start: options.start,
+      end: options.end,
+      virtual: options.virtual ?? false,
+      styleId: options.styleId,
+      priority: options.priority,
+      data: options.data,
+      typeId
+    };
+    this.extmarks.set(id, extmark);
+    if (!this.extmarksByTypeId.has(typeId)) {
+      this.extmarksByTypeId.set(typeId, new Set);
+    }
+    this.extmarksByTypeId.get(typeId).add(id);
+    if (options.metadata !== undefined) {
+      this.metadata.set(id, options.metadata);
+    }
+    this.updateHighlights();
+    return id;
+  }
+  delete(id) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const extmark = this.extmarks.get(id);
+    if (!extmark)
+      return false;
+    this.deleteExtmarkById(id);
+    this.updateHighlights();
+    return true;
+  }
+  get(id) {
+    if (this.destroyed)
+      return null;
+    return this.extmarks.get(id) ?? null;
+  }
+  getAll() {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values());
+  }
+  getVirtual() {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values()).filter((e) => e.virtual);
+  }
+  getAtOffset(offset) {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values()).filter((e) => offset >= e.start && offset < e.end);
+  }
+  getAllForTypeId(typeId) {
+    if (this.destroyed)
+      return [];
+    const ids = this.extmarksByTypeId.get(typeId);
+    if (!ids)
+      return [];
+    return Array.from(ids).map((id) => this.extmarks.get(id)).filter((e) => e !== undefined);
+  }
+  clear() {
+    if (this.destroyed)
+      return;
+    this.extmarks.clear();
+    this.extmarksByTypeId.clear();
+    this.metadata.clear();
+    this.updateHighlights();
+  }
+  saveSnapshot() {
+    this.history.saveSnapshot(this.extmarks, this.nextId);
+  }
+  restoreSnapshot(snapshot) {
+    this.extmarks = new Map(Array.from(snapshot.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }]));
+    this.nextId = snapshot.nextId;
+    this.updateHighlights();
+  }
+  wrapUndoRedo() {
+    this.editBuffer.undo = () => {
+      if (this.destroyed) {
+        return this.originalUndo();
+      }
+      if (!this.history.canUndo()) {
+        return this.originalUndo();
+      }
+      const currentSnapshot = {
+        extmarks: new Map(Array.from(this.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+        nextId: this.nextId
+      };
+      this.history.pushRedo(currentSnapshot);
+      const snapshot = this.history.undo();
+      this.restoreSnapshot(snapshot);
+      return this.originalUndo();
+    };
+    this.editBuffer.redo = () => {
+      if (this.destroyed) {
+        return this.originalRedo();
+      }
+      if (!this.history.canRedo()) {
+        return this.originalRedo();
+      }
+      const currentSnapshot = {
+        extmarks: new Map(Array.from(this.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+        nextId: this.nextId
+      };
+      this.history.pushUndo(currentSnapshot);
+      const snapshot = this.history.redo();
+      this.restoreSnapshot(snapshot);
+      return this.originalRedo();
+    };
+  }
+  registerType(typeName) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const existing = this.typeNameToId.get(typeName);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const typeId = this.nextTypeId++;
+    this.typeNameToId.set(typeName, typeId);
+    this.typeIdToName.set(typeId, typeName);
+    return typeId;
+  }
+  getTypeId(typeName) {
+    if (this.destroyed)
+      return null;
+    return this.typeNameToId.get(typeName) ?? null;
+  }
+  getTypeName(typeId) {
+    if (this.destroyed)
+      return null;
+    return this.typeIdToName.get(typeId) ?? null;
+  }
+  getMetadataFor(extmarkId) {
+    if (this.destroyed)
+      return;
+    return this.metadata.get(extmarkId);
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.editBuffer.moveCursorLeft = this.originalMoveCursorLeft;
+    this.editBuffer.moveCursorRight = this.originalMoveCursorRight;
+    this.editBuffer.setCursorByOffset = this.originalSetCursorByOffset;
+    this.editorView.moveUpVisual = this.originalMoveUpVisual;
+    this.editorView.moveDownVisual = this.originalMoveDownVisual;
+    this.editBuffer.deleteCharBackward = this.originalDeleteCharBackward;
+    this.editBuffer.deleteChar = this.originalDeleteChar;
+    this.editBuffer.insertText = this.originalInsertText;
+    this.editBuffer.insertChar = this.originalInsertChar;
+    this.editBuffer.deleteRange = this.originalDeleteRange;
+    this.editBuffer.setText = this.originalSetText;
+    this.editBuffer.clear = this.originalClear;
+    this.editBuffer.newLine = this.originalNewLine;
+    this.editBuffer.deleteLine = this.originalDeleteLine;
+    this.editorView.deleteSelectedText = this.originalEditorViewDeleteSelectedText;
+    this.editBuffer.undo = this.originalUndo;
+    this.editBuffer.redo = this.originalRedo;
+    this.extmarks.clear();
+    this.extmarksByTypeId.clear();
+    this.metadata.clear();
+    this.typeNameToId.clear();
+    this.typeIdToName.clear();
+    this.history.clear();
+    this.destroyed = true;
+  }
+}
+function createExtmarksController(editBuffer, editorView) {
+  return new ExtmarksController(editBuffer, editorView);
+}
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr3 } from "bun:ffi";
 import { existsSync as existsSync2 } from "fs";
@@ -7014,6 +7700,18 @@ var HighlightStruct = defineStruct([
   ["priority", "u8", { default: 0 }],
   ["hlRef", "u16", { default: 0 }]
 ]);
+var LogicalCursorStruct = defineStruct([
+  ["row", "u32"],
+  ["col", "u32"],
+  ["offset", "u32"]
+]);
+var VisualCursorStruct = defineStruct([
+  ["visualRow", "u32"],
+  ["visualCol", "u32"],
+  ["logicalRow", "u32"],
+  ["logicalCol", "u32"],
+  ["offset", "u32"]
+]);
 
 // src/zig.ts
 var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
@@ -7471,6 +8169,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    editorViewGetLineInfoDirect: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "u32"
+    },
+    editorViewGetLogicalLineInfoDirect: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "u32"
+    },
     createEditBuffer: {
       args: ["u8"],
       returns: "ptr"
@@ -7507,6 +8213,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
+    editBufferDeleteRange: {
+      args: ["ptr", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
     editBufferNewLine: {
       args: ["ptr"],
       returns: "void"
@@ -7548,7 +8258,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     editBufferGetCursorPosition: {
-      args: ["ptr", "ptr", "ptr", "ptr"],
+      args: ["ptr", "ptr"],
       returns: "void"
     },
     editBufferGetId: {
@@ -7583,14 +8293,34 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
-    editBufferSetPlaceholder: {
-      args: ["ptr", "ptr", "usize"],
+    editBufferClear: {
+      args: ["ptr"],
       returns: "void"
     },
-    editBufferSetPlaceholderColor: {
+    editBufferGetNextWordBoundary: {
       args: ["ptr", "ptr"],
       returns: "void"
     },
+    editBufferGetPrevWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferOffsetToPosition: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "bool"
+    },
+    editBufferPositionToOffset: {
+      args: ["ptr", "u32", "u32"],
+      returns: "u32"
+    },
+    editBufferGetLineStartOffset: {
+      args: ["ptr", "u32"],
+      returns: "u32"
+    },
     editorViewSetSelection: {
       args: ["ptr", "u32", "u32", "ptr", "ptr"],
       returns: "void"
@@ -7624,8 +8354,8 @@ function getOpenTUILib(libPath) {
       returns: "usize"
     },
     editorViewGetVisualCursor: {
-      args: ["ptr", "ptr", "ptr", "ptr", "ptr", "ptr"],
-      returns: "bool"
+      args: ["ptr", "ptr"],
+      returns: "void"
     },
     editorViewMoveUpVisual: {
       args: ["ptr"],
@@ -7643,6 +8373,22 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u32"],
       returns: "void"
     },
+    editorViewGetNextWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetPrevWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewSetPlaceholderStyledText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
     getArenaAllocatedBytes: {
       args: [],
       returns: "usize"
@@ -8392,6 +9138,34 @@ class FFIRenderLib {
     }
     return result;
   }
+  editorViewGetLineInfo(view) {
+    const lineCount = this.editorViewGetVirtualLineCount(view);
+    if (lineCount === 0) {
+      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
+    }
+    const lineStarts = new Uint32Array(lineCount);
+    const lineWidths = new Uint32Array(lineCount);
+    const maxLineWidth = this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr3(lineStarts), ptr3(lineWidths));
+    return {
+      maxLineWidth,
+      lineStarts: Array.from(lineStarts),
+      lineWidths: Array.from(lineWidths)
+    };
+  }
+  editorViewGetLogicalLineInfo(view) {
+    const lineCount = this.editorViewGetVirtualLineCount(view);
+    if (lineCount === 0) {
+      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
+    }
+    const lineStarts = new Uint32Array(lineCount);
+    const lineWidths = new Uint32Array(lineCount);
+    const maxLineWidth = this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr3(lineStarts), ptr3(lineWidths));
+    return {
+      maxLineWidth,
+      lineStarts: Array.from(lineStarts),
+      lineWidths: Array.from(lineWidths)
+    };
+  }
   createEditBuffer(widthMethod) {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
     const bufferPtr = this.opentui.symbols.createEditBuffer(widthMethodCode);
@@ -8431,6 +9205,9 @@ class FFIRenderLib {
   editBufferDeleteCharBackward(buffer) {
     this.opentui.symbols.editBufferDeleteCharBackward(buffer);
   }
+  editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol) {
+    this.opentui.symbols.editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol);
+  }
   editBufferNewLine(buffer) {
     this.opentui.symbols.editBufferNewLine(buffer);
   }
@@ -8462,15 +9239,9 @@ class FFIRenderLib {
     this.opentui.symbols.editBufferSetCursorByOffset(buffer, offset);
   }
   editBufferGetCursorPosition(buffer) {
-    const line = new Uint32Array(1);
-    const visualColumn = new Uint32Array(1);
-    const offset = new Uint32Array(1);
-    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr3(line), ptr3(visualColumn), ptr3(offset));
-    return {
-      line: line[0],
-      visualColumn: visualColumn[0],
-      offset: offset[0]
-    };
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetId(buffer) {
     return this.opentui.symbols.editBufferGetId(buffer);
@@ -8510,16 +9281,36 @@ class FFIRenderLib {
   editBufferClearHistory(buffer) {
     this.opentui.symbols.editBufferClearHistory(buffer);
   }
-  editBufferSetPlaceholder(buffer, text) {
-    if (text === null) {
-      this.opentui.symbols.editBufferSetPlaceholder(buffer, null, 0);
-    } else {
-      const textBytes = this.encoder.encode(text);
-      this.opentui.symbols.editBufferSetPlaceholder(buffer, textBytes, textBytes.length);
-    }
+  editBufferClear(buffer) {
+    this.opentui.symbols.editBufferClear(buffer);
+  }
+  editBufferGetNextWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferGetPrevWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
   }
-  editBufferSetPlaceholderColor(buffer, color) {
-    this.opentui.symbols.editBufferSetPlaceholderColor(buffer, color.buffer);
+  editBufferGetEOL(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetEOL(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferOffsetToPosition(buffer, offset) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr3(cursorBuffer));
+    if (!success)
+      return null;
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferPositionToOffset(buffer, row, col) {
+    return this.opentui.symbols.editBufferPositionToOffset(buffer, row, col);
+  }
+  editBufferGetLineStartOffset(buffer, row) {
+    return this.opentui.symbols.editBufferGetLineStartOffset(buffer, row);
   }
   editorViewSetSelection(view, start, end, bgColor, fgColor) {
     const bg2 = bgColor ? bgColor.buffer : null;
@@ -8569,22 +9360,9 @@ class FFIRenderLib {
     return outBuffer.slice(0, len);
   }
   editorViewGetVisualCursor(view) {
-    const visualRow = new Uint32Array(1);
-    const visualCol = new Uint32Array(1);
-    const logicalRow = new Uint32Array(1);
-    const logicalCol = new Uint32Array(1);
-    const offset = new Uint32Array(1);
-    const success = this.opentui.symbols.editorViewGetVisualCursor(view, ptr3(visualRow), ptr3(visualCol), ptr3(logicalRow), ptr3(logicalCol), ptr3(offset));
-    if (!success) {
-      return { visualRow: 0, visualCol: 0, logicalRow: 0, logicalCol: 0, offset: 0 };
-    }
-    return {
-      visualRow: visualRow[0],
-      visualCol: visualCol[0],
-      logicalRow: logicalRow[0],
-      logicalCol: logicalCol[0],
-      offset: offset[0]
-    };
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualCursor(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewMoveUpVisual(view) {
     this.opentui.symbols.editorViewMoveUpVisual(view);
@@ -8598,6 +9376,21 @@ class FFIRenderLib {
   editorViewSetCursorByOffset(view, offset) {
     this.opentui.symbols.editorViewSetCursorByOffset(view, offset);
   }
+  editorViewGetNextWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetPrevWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetEOL(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetEOL(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
   bufferPushScissorRect(buffer, x, y, width, height) {
     this.opentui.symbols.bufferPushScissorRect(buffer, x, y, width, height);
   }
@@ -8657,6 +9450,15 @@ class FFIRenderLib {
     const result = this.opentui.symbols.syntaxStyleGetStyleCount(style);
     return typeof result === "bigint" ? Number(result) : result;
   }
+  editorViewSetPlaceholderStyledText(view, chunks) {
+    const nonEmptyChunks = chunks.filter((c) => c.text.length > 0);
+    if (nonEmptyChunks.length === 0) {
+      this.opentui.symbols.editorViewSetPlaceholderStyledText(view, null, 0);
+      return;
+    }
+    const chunksBuffer = StyledChunkStruct.packList(nonEmptyChunks);
+    this.opentui.symbols.editorViewSetPlaceholderStyledText(view, ptr3(chunksBuffer), nonEmptyChunks.length);
+  }
   onNativeEvent(name, handler) {
     this._nativeEvents.on(name, handler);
   }
@@ -9119,9 +9921,9 @@ class Renderable extends BaseRenderable {
       }
     };
     this.pasteHandler = (event) => {
-      this._pasteListener?.call(this, event.text);
+      this._pasteListener?.call(this, event);
       if (!event.defaultPrevented && this.handlePaste) {
-        this.handlePaste(event.text);
+        this.handlePaste(event);
       }
     };
     this.ctx._internalKeyInput.onInternal("keypress", this.keypressHandler);
@@ -11188,7 +11990,7 @@ class CliRenderer extends EventEmitter8 {
   frameTimes = [];
   maxStatSamples = 300;
   postProcessFns = [];
-  backgroundColor = RGBA.fromHex("#000000");
+  backgroundColor = RGBA.fromInts(0, 0, 0, 0);
   waitingForPixelResolution = false;
   rendering = false;
   renderingNative = false;
@@ -11252,30 +12054,10 @@ class CliRenderer extends EventEmitter8 {
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   handleError = ((error) => {
-    this.stop();
-    this.destroy();
-    new Promise((resolve4) => {
-      setTimeout(() => {
-        resolve4(true);
-      }, 100);
-    }).then(() => {
-      this.realStdoutWrite.call(this.stdout, `
-`.repeat(this._terminalHeight));
-      this.realStdoutWrite.call(this.stdout, `
-=== FATAL ERROR OCCURRED ===
-`);
-      this.dumpOutputCache();
-      this.realStdoutWrite.call(this.stdout, `
-Error details:
-`);
-      this.realStdoutWrite.call(this.stdout, error.message || "unknown error");
-      this.realStdoutWrite.call(this.stdout, `
-`);
-      this.realStdoutWrite.call(this.stdout, error.stack || error.toString());
-      this.realStdoutWrite.call(this.stdout, `
-`);
-      process.exit(1);
-    });
+    console.error(error);
+    if (true) {
+      this.console.show();
+    }
   }).bind(this);
   dumpOutputCache(optionalMessage = "") {
     const cachedLogs = this.console.getCachedLogs();
@@ -11300,8 +12082,10 @@ Captured output:
   exitHandler = (() => {
     this.destroy();
     if (env.OTUI_DUMP_CAPTURES) {
-      this.dumpOutputCache(`=== CAPTURED OUTPUT ===
+      Bun.sleep(100).then(() => {
+        this.dumpOutputCache(`=== CAPTURED OUTPUT ===
 `);
+      });
     }
   }).bind(this);
   warningHandler = ((warning) => {
@@ -11818,7 +12602,7 @@ Captured output:
       this.renderOffset = height - this._splitHeight;
       this.width = width;
       this.height = this._splitHeight;
-      this.currentRenderBuffer.clear(RGBA.fromHex("#000000"));
+      this.currentRenderBuffer.clear(this.backgroundColor);
       this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
     } else {
       this.width = width;
@@ -12261,7 +13045,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=13370E63AB96DC2264756E2164756E21
-//# sourceMappingURL=index-bztetjc3.js.map
+//# debugId=6145BB5C85305CD464756E2164756E21
+//# sourceMappingURL=index-91qheh74.js.map