@opentui/core 0.1.95 → 0.1.96

package/{index-wv534m5j.js → index-vy1rm1x3.js}

@@ -15974,245 +15974,777 @@ function delegate(mapping, vnode) {
   return vnode;
 }
 
-// src/console.ts
-import { EventEmitter as EventEmitter7 } from "events";
-import { Console } from "console";
-import fs from "fs";
-import path5 from "path";
-import util2 from "util";
-
-// src/lib/output.capture.ts
-import { Writable } from "stream";
+// src/edit-buffer.ts
 import { EventEmitter as EventEmitter6 } from "events";
 
-class Capture extends EventEmitter6 {
-  output = [];
-  constructor() {
+class EditBuffer extends EventEmitter6 {
+  static registry = new Map;
+  static nativeEventsSubscribed = false;
+  lib;
+  bufferPtr;
+  textBufferPtr;
+  id;
+  _destroyed = false;
+  _textBytes = [];
+  _singleTextBytes = null;
+  _singleTextMemId = null;
+  _syntaxStyle;
+  constructor(lib, ptr5) {
     super();
+    this.lib = lib;
+    this.bufferPtr = ptr5;
+    this.textBufferPtr = lib.editBufferGetTextBuffer(ptr5);
+    this.id = lib.editBufferGetId(ptr5);
+    EditBuffer.registry.set(this.id, this);
+    EditBuffer.subscribeToNativeEvents(lib);
   }
-  get size() {
-    return this.output.length;
+  static create(widthMethod) {
+    const lib = resolveRenderLib();
+    const ptr5 = lib.createEditBuffer(widthMethod);
+    return new EditBuffer(lib, ptr5);
   }
-  write(stream, data) {
-    this.output.push({ stream, output: data });
-    this.emit("write", stream, data);
+  static subscribeToNativeEvents(lib) {
+    if (EditBuffer.nativeEventsSubscribed)
+      return;
+    EditBuffer.nativeEventsSubscribed = true;
+    lib.onAnyNativeEvent((name, data) => {
+      const buffer = new Uint16Array(data);
+      if (name.startsWith("eb_") && buffer.length >= 1) {
+        const id = buffer[0];
+        const instance = EditBuffer.registry.get(id);
+        if (instance) {
+          const eventName = name.slice(3);
+          const eventData = data.slice(2);
+          instance.emit(eventName, eventData);
+        }
+      }
+    });
   }
-  claimOutput() {
-    const output = this.output.map((o) => o.output).join("");
-    this.clear();
-    return output;
+  guard() {
+    if (this._destroyed)
+      throw new Error("EditBuffer is destroyed");
   }
-  clear() {
-    this.output = [];
+  get ptr() {
+    this.guard();
+    return this.bufferPtr;
   }
-}
-
-class CapturedWritableStream extends Writable {
-  stream;
-  capture;
-  isTTY = true;
-  columns = process.stdout.columns || 80;
-  rows = process.stdout.rows || 24;
-  constructor(stream, capture) {
-    super();
-    this.stream = stream;
-    this.capture = capture;
+  setText(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    if (this._singleTextMemId !== null) {
+      this.lib.textBufferReplaceMemBuffer(this.textBufferPtr, this._singleTextMemId, textBytes, false);
+    } else {
+      this._singleTextMemId = this.lib.textBufferRegisterMemBuffer(this.textBufferPtr, textBytes, false);
+    }
+    this._singleTextBytes = textBytes;
+    this.lib.editBufferSetTextFromMem(this.bufferPtr, this._singleTextMemId);
   }
-  _write(chunk, encoding, callback) {
-    const data = chunk.toString();
-    this.capture.write(this.stream, data);
-    callback();
+  setTextOwned(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    this.lib.editBufferSetText(this.bufferPtr, textBytes);
   }
-  getColorDepth() {
-    return process.stdout.getColorDepth?.() || 8;
+  replaceText(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    this._textBytes.push(textBytes);
+    const memId = this.lib.textBufferRegisterMemBuffer(this.textBufferPtr, textBytes, false);
+    this.lib.editBufferReplaceTextFromMem(this.bufferPtr, memId);
   }
-}
-
-// src/lib/keymapping.ts
-var defaultKeyAliases = {
-  enter: "return",
-  esc: "escape"
-};
-function mergeKeyAliases(defaults, custom) {
-  return { ...defaults, ...custom };
-}
-function mergeKeyBindings(defaults, custom) {
-  const map = new Map;
-  for (const binding of defaults) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding);
+  replaceTextOwned(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    this.lib.editBufferReplaceText(this.bufferPtr, textBytes);
   }
-  for (const binding of custom) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding);
+  getLineCount() {
+    this.guard();
+    return this.lib.textBufferGetLineCount(this.textBufferPtr);
   }
-  return Array.from(map.values());
-}
-function getKeyBindingKey(binding) {
-  return `${binding.name}:${binding.ctrl ? 1 : 0}:${binding.shift ? 1 : 0}:${binding.meta ? 1 : 0}:${binding.super ? 1 : 0}`;
-}
-function buildKeyBindingsMap(bindings, aliasMap) {
-  const map = new Map;
-  const aliases = aliasMap || {};
-  for (const binding of bindings) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding.action);
+  getText() {
+    this.guard();
+    const maxSize = 1024 * 1024;
+    const textBytes = this.lib.editBufferGetText(this.bufferPtr, maxSize);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
   }
-  for (const binding of bindings) {
-    const normalizedName = aliases[binding.name] || binding.name;
-    if (normalizedName !== binding.name) {
-      const aliasedKey = getKeyBindingKey({ ...binding, name: normalizedName });
-      map.set(aliasedKey, binding.action);
-    }
+  insertChar(char) {
+    this.guard();
+    this.lib.editBufferInsertChar(this.bufferPtr, char);
   }
-  return map;
-}
-function keyBindingToString(binding) {
-  const parts = [];
-  if (binding.ctrl)
-    parts.push("ctrl");
-  if (binding.shift)
-    parts.push("shift");
-  if (binding.meta)
-    parts.push("meta");
-  if (binding.super)
-    parts.push("super");
-  parts.push(binding.name);
-  return parts.join("+");
-}
-
-// src/console.ts
-function getCallerInfo() {
-  const err = new Error;
-  const stackLines = err.stack?.split(`
-`).slice(5) || [];
-  if (!stackLines.length)
-    return null;
-  const callerLine = stackLines[0].trim();
-  const regex = /at\s+(?:([\w$.<>]+)\s+\()?((?:\/|[A-Za-z]:\\)[^:]+):(\d+):(\d+)\)?/;
-  const match = callerLine.match(regex);
-  if (!match)
-    return null;
-  const functionName = match[1] || "<anonymous>";
-  const fullPath = match[2];
-  const fileName = fullPath.split(/[\\/]/).pop() || "<unknown>";
-  const lineNumber = parseInt(match[3], 10) || 0;
-  const columnNumber = parseInt(match[4], 10) || 0;
-  return { functionName, fullPath, fileName, lineNumber, columnNumber };
-}
-var capture = singleton("ConsoleCapture", () => new Capture);
-registerEnvVar({
-  name: "OTUI_USE_CONSOLE",
-  description: "Whether to use the console. Will not capture console output if set to false.",
-  type: "boolean",
-  default: true
-});
-registerEnvVar({
-  name: "SHOW_CONSOLE",
-  description: "Show the console at startup if set to true.",
-  type: "boolean",
-  default: false
-});
-
-class TerminalConsoleCache extends EventEmitter7 {
-  _cachedLogs = [];
-  MAX_CACHE_SIZE = 1000;
-  _collectCallerInfo = false;
-  _cachingEnabled = true;
-  _originalConsole = null;
-  get cachedLogs() {
-    return this._cachedLogs;
+  insertText(text) {
+    this.guard();
+    this.lib.editBufferInsertText(this.bufferPtr, text);
   }
-  constructor() {
-    super();
+  deleteChar() {
+    this.guard();
+    this.lib.editBufferDeleteChar(this.bufferPtr);
   }
-  activate() {
-    if (!this._originalConsole) {
-      this._originalConsole = global.console;
-    }
-    this.setupConsoleCapture();
-    this.overrideConsoleMethods();
+  deleteCharBackward() {
+    this.guard();
+    this.lib.editBufferDeleteCharBackward(this.bufferPtr);
   }
-  setupConsoleCapture() {
-    if (!env.OTUI_USE_CONSOLE)
-      return;
-    const mockStdout = new CapturedWritableStream("stdout", capture);
-    const mockStderr = new CapturedWritableStream("stderr", capture);
-    global.console = new Console({
-      stdout: mockStdout,
-      stderr: mockStderr,
-      colorMode: true,
-      inspectOptions: {
-        compact: false,
-        breakLength: 80,
-        depth: 2
-      }
-    });
+  deleteRange(startLine, startCol, endLine, endCol) {
+    this.guard();
+    this.lib.editBufferDeleteRange(this.bufferPtr, startLine, startCol, endLine, endCol);
   }
-  overrideConsoleMethods() {
-    console.log = (...args) => {
-      this.appendToConsole("LOG" /* LOG */, ...args);
-    };
-    console.info = (...args) => {
-      this.appendToConsole("INFO" /* INFO */, ...args);
-    };
-    console.warn = (...args) => {
-      this.appendToConsole("WARN" /* WARN */, ...args);
-    };
-    console.error = (...args) => {
-      this.appendToConsole("ERROR" /* ERROR */, ...args);
-    };
-    console.debug = (...args) => {
-      this.appendToConsole("DEBUG" /* DEBUG */, ...args);
-    };
+  newLine() {
+    this.guard();
+    this.lib.editBufferNewLine(this.bufferPtr);
   }
-  setCollectCallerInfo(enabled) {
-    this._collectCallerInfo = enabled;
+  deleteLine() {
+    this.guard();
+    this.lib.editBufferDeleteLine(this.bufferPtr);
   }
-  clearConsole() {
-    this._cachedLogs = [];
+  moveCursorLeft() {
+    this.guard();
+    this.lib.editBufferMoveCursorLeft(this.bufferPtr);
   }
-  setCachingEnabled(enabled) {
-    this._cachingEnabled = enabled;
+  moveCursorRight() {
+    this.guard();
+    this.lib.editBufferMoveCursorRight(this.bufferPtr);
   }
-  deactivate() {
-    this.restoreOriginalConsole();
+  moveCursorUp() {
+    this.guard();
+    this.lib.editBufferMoveCursorUp(this.bufferPtr);
   }
-  restoreOriginalConsole() {
-    if (this._originalConsole) {
-      global.console = this._originalConsole;
-    }
+  moveCursorDown() {
+    this.guard();
+    this.lib.editBufferMoveCursorDown(this.bufferPtr);
   }
-  addLogEntry(level, ...args) {
-    const callerInfo = this._collectCallerInfo ? getCallerInfo() : null;
-    const logEntry = [new Date, level, args, callerInfo];
-    if (this._cachingEnabled) {
-      if (this._cachedLogs.length >= this.MAX_CACHE_SIZE) {
-        this._cachedLogs.shift();
-      }
-      this._cachedLogs.push(logEntry);
-    }
-    return logEntry;
+  gotoLine(line) {
+    this.guard();
+    this.lib.editBufferGotoLine(this.bufferPtr, line);
   }
-  appendToConsole(level, ...args) {
-    if (this._cachedLogs.length >= this.MAX_CACHE_SIZE) {
-      this._cachedLogs.shift();
-    }
-    const entry = this.addLogEntry(level, ...args);
-    this.emit("entry", entry);
+  setCursor(line, col) {
+    this.guard();
+    this.lib.editBufferSetCursor(this.bufferPtr, line, col);
   }
-  destroy() {
-    this.deactivate();
+  setCursorToLineCol(line, col) {
+    this.guard();
+    this.lib.editBufferSetCursorToLineCol(this.bufferPtr, line, col);
   }
-}
-var terminalConsoleCache = singleton("TerminalConsoleCache", () => {
-  const terminalConsoleCache2 = new TerminalConsoleCache;
-  process.on("exit", () => {
-    terminalConsoleCache2.destroy();
-  });
-  return terminalConsoleCache2;
-});
-var ConsolePosition;
+  setCursorByOffset(offset) {
+    this.guard();
+    this.lib.editBufferSetCursorByOffset(this.bufferPtr, offset);
+  }
+  getCursorPosition() {
+    this.guard();
+    return this.lib.editBufferGetCursorPosition(this.bufferPtr);
+  }
+  getNextWordBoundary() {
+    this.guard();
+    const boundary = this.lib.editBufferGetNextWordBoundary(this.bufferPtr);
+    return {
+      row: boundary.row,
+      col: boundary.col,
+      offset: boundary.offset
+    };
+  }
+  getPrevWordBoundary() {
+    this.guard();
+    const boundary = this.lib.editBufferGetPrevWordBoundary(this.bufferPtr);
+    return {
+      row: boundary.row,
+      col: boundary.col,
+      offset: boundary.offset
+    };
+  }
+  getEOL() {
+    this.guard();
+    const boundary = this.lib.editBufferGetEOL(this.bufferPtr);
+    return {
+      row: boundary.row,
+      col: boundary.col,
+      offset: boundary.offset
+    };
+  }
+  offsetToPosition(offset) {
+    this.guard();
+    const result = this.lib.editBufferOffsetToPosition(this.bufferPtr, offset);
+    if (!result)
+      return null;
+    return { row: result.row, col: result.col };
+  }
+  positionToOffset(row, col) {
+    this.guard();
+    return this.lib.editBufferPositionToOffset(this.bufferPtr, row, col);
+  }
+  getLineStartOffset(row) {
+    this.guard();
+    return this.lib.editBufferGetLineStartOffset(this.bufferPtr, row);
+  }
+  getTextRange(startOffset, endOffset) {
+    this.guard();
+    if (startOffset >= endOffset)
+      return "";
+    const maxSize = 1024 * 1024;
+    const textBytes = this.lib.editBufferGetTextRange(this.bufferPtr, startOffset, endOffset, maxSize);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
+  }
+  getTextRangeByCoords(startRow, startCol, endRow, endCol) {
+    this.guard();
+    const maxSize = 1024 * 1024;
+    const textBytes = this.lib.editBufferGetTextRangeByCoords(this.bufferPtr, startRow, startCol, endRow, endCol, maxSize);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
+  }
+  debugLogRope() {
+    this.guard();
+    this.lib.editBufferDebugLogRope(this.bufferPtr);
+  }
+  undo() {
+    this.guard();
+    const maxSize = 256;
+    const metaBytes = this.lib.editBufferUndo(this.bufferPtr, maxSize);
+    if (!metaBytes)
+      return null;
+    return this.lib.decoder.decode(metaBytes);
+  }
+  redo() {
+    this.guard();
+    const maxSize = 256;
+    const metaBytes = this.lib.editBufferRedo(this.bufferPtr, maxSize);
+    if (!metaBytes)
+      return null;
+    return this.lib.decoder.decode(metaBytes);
+  }
+  canUndo() {
+    this.guard();
+    return this.lib.editBufferCanUndo(this.bufferPtr);
+  }
+  canRedo() {
+    this.guard();
+    return this.lib.editBufferCanRedo(this.bufferPtr);
+  }
+  clearHistory() {
+    this.guard();
+    this.lib.editBufferClearHistory(this.bufferPtr);
+  }
+  setDefaultFg(fg2) {
+    this.guard();
+    this.lib.textBufferSetDefaultFg(this.textBufferPtr, fg2);
+  }
+  setDefaultBg(bg2) {
+    this.guard();
+    this.lib.textBufferSetDefaultBg(this.textBufferPtr, bg2);
+  }
+  setDefaultAttributes(attributes) {
+    this.guard();
+    this.lib.textBufferSetDefaultAttributes(this.textBufferPtr, attributes);
+  }
+  resetDefaults() {
+    this.guard();
+    this.lib.textBufferResetDefaults(this.textBufferPtr);
+  }
+  setSyntaxStyle(style) {
+    this.guard();
+    this._syntaxStyle = style ?? undefined;
+    this.lib.textBufferSetSyntaxStyle(this.textBufferPtr, style?.ptr ?? null);
+  }
+  getSyntaxStyle() {
+    this.guard();
+    return this._syntaxStyle ?? null;
+  }
+  addHighlight(lineIdx, highlight) {
+    this.guard();
+    this.lib.textBufferAddHighlight(this.textBufferPtr, lineIdx, highlight);
+  }
+  addHighlightByCharRange(highlight) {
+    this.guard();
+    this.lib.textBufferAddHighlightByCharRange(this.textBufferPtr, highlight);
+  }
+  removeHighlightsByRef(hlRef) {
+    this.guard();
+    this.lib.textBufferRemoveHighlightsByRef(this.textBufferPtr, hlRef);
+  }
+  clearLineHighlights(lineIdx) {
+    this.guard();
+    this.lib.textBufferClearLineHighlights(this.textBufferPtr, lineIdx);
+  }
+  clearAllHighlights() {
+    this.guard();
+    this.lib.textBufferClearAllHighlights(this.textBufferPtr);
+  }
+  getLineHighlights(lineIdx) {
+    this.guard();
+    return this.lib.textBufferGetLineHighlights(this.textBufferPtr, lineIdx);
+  }
+  clear() {
+    this.guard();
+    this.lib.editBufferClear(this.bufferPtr);
+  }
+  destroy() {
+    if (this._destroyed)
+      return;
+    this._destroyed = true;
+    EditBuffer.registry.delete(this.id);
+    this.lib.destroyEditBuffer(this.bufferPtr);
+  }
+}
+
+// src/editor-view.ts
+class EditorView {
+  lib;
+  viewPtr;
+  editBuffer;
+  _destroyed = false;
+  _extmarksController;
+  _textBufferViewPtr;
+  constructor(lib, ptr5, editBuffer) {
+    this.lib = lib;
+    this.viewPtr = ptr5;
+    this.editBuffer = editBuffer;
+  }
+  static create(editBuffer, viewportWidth, viewportHeight) {
+    const lib = resolveRenderLib();
+    const viewPtr = lib.createEditorView(editBuffer.ptr, viewportWidth, viewportHeight);
+    return new EditorView(lib, viewPtr, editBuffer);
+  }
+  guard() {
+    if (this._destroyed)
+      throw new Error("EditorView is destroyed");
+  }
+  get ptr() {
+    this.guard();
+    return this.viewPtr;
+  }
+  setViewportSize(width, height) {
+    this.guard();
+    this.lib.editorViewSetViewportSize(this.viewPtr, width, height);
+  }
+  setViewport(x, y, width, height, moveCursor = true) {
+    this.guard();
+    this.lib.editorViewSetViewport(this.viewPtr, x, y, width, height, moveCursor);
+  }
+  getViewport() {
+    this.guard();
+    return this.lib.editorViewGetViewport(this.viewPtr);
+  }
+  setScrollMargin(margin) {
+    this.guard();
+    this.lib.editorViewSetScrollMargin(this.viewPtr, margin);
+  }
+  setWrapMode(mode) {
+    this.guard();
+    this.lib.editorViewSetWrapMode(this.viewPtr, mode);
+  }
+  getVirtualLineCount() {
+    this.guard();
+    return this.lib.editorViewGetVirtualLineCount(this.viewPtr);
+  }
+  getTotalVirtualLineCount() {
+    this.guard();
+    return this.lib.editorViewGetTotalVirtualLineCount(this.viewPtr);
+  }
+  setSelection(start, end, bgColor, fgColor) {
+    this.guard();
+    this.lib.editorViewSetSelection(this.viewPtr, start, end, bgColor || null, fgColor || null);
+  }
+  updateSelection(end, bgColor, fgColor) {
+    this.guard();
+    this.lib.editorViewUpdateSelection(this.viewPtr, end, bgColor || null, fgColor || null);
+  }
+  resetSelection() {
+    this.guard();
+    this.lib.editorViewResetSelection(this.viewPtr);
+  }
+  getSelection() {
+    this.guard();
+    return this.lib.editorViewGetSelection(this.viewPtr);
+  }
+  hasSelection() {
+    this.guard();
+    return this.getSelection() !== null;
+  }
+  setLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
+    this.guard();
+    return this.lib.editorViewSetLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null, updateCursor ?? false, followCursor ?? false);
+  }
+  updateLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
+    this.guard();
+    return this.lib.editorViewUpdateLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null, updateCursor ?? false, followCursor ?? false);
+  }
+  resetLocalSelection() {
+    this.guard();
+    this.lib.editorViewResetLocalSelection(this.viewPtr);
+  }
+  getSelectedText() {
+    this.guard();
+    const maxLength = 1024 * 1024;
+    const selectedBytes = this.lib.editorViewGetSelectedTextBytes(this.viewPtr, maxLength);
+    if (!selectedBytes)
+      return "";
+    return this.lib.decoder.decode(selectedBytes);
+  }
+  getCursor() {
+    this.guard();
+    return this.lib.editorViewGetCursor(this.viewPtr);
+  }
+  getText() {
+    this.guard();
+    const maxLength = 1024 * 1024;
+    const textBytes = this.lib.editorViewGetText(this.viewPtr, maxLength);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
+  }
+  getVisualCursor() {
+    this.guard();
+    return this.lib.editorViewGetVisualCursor(this.viewPtr);
+  }
+  moveUpVisual() {
+    this.guard();
+    this.lib.editorViewMoveUpVisual(this.viewPtr);
+  }
+  moveDownVisual() {
+    this.guard();
+    this.lib.editorViewMoveDownVisual(this.viewPtr);
+  }
+  deleteSelectedText() {
+    this.guard();
+    this.lib.editorViewDeleteSelectedText(this.viewPtr);
+  }
+  setCursorByOffset(offset) {
+    this.guard();
+    this.lib.editorViewSetCursorByOffset(this.viewPtr, offset);
+  }
+  getNextWordBoundary() {
+    this.guard();
+    return this.lib.editorViewGetNextWordBoundary(this.viewPtr);
+  }
+  getPrevWordBoundary() {
+    this.guard();
+    return this.lib.editorViewGetPrevWordBoundary(this.viewPtr);
+  }
+  getEOL() {
+    this.guard();
+    return this.lib.editorViewGetEOL(this.viewPtr);
+  }
+  getVisualSOL() {
+    this.guard();
+    return this.lib.editorViewGetVisualSOL(this.viewPtr);
+  }
+  getVisualEOL() {
+    this.guard();
+    return this.lib.editorViewGetVisualEOL(this.viewPtr);
+  }
+  getLineInfo() {
+    this.guard();
+    return this.lib.editorViewGetLineInfo(this.viewPtr);
+  }
+  getLogicalLineInfo() {
+    this.guard();
+    return this.lib.editorViewGetLogicalLineInfo(this.viewPtr);
+  }
+  get extmarks() {
+    if (!this._extmarksController) {
+      this._extmarksController = createExtmarksController(this.editBuffer, this);
+    }
+    return this._extmarksController;
+  }
+  setPlaceholderStyledText(chunks) {
+    this.guard();
+    this.lib.editorViewSetPlaceholderStyledText(this.viewPtr, chunks);
+  }
+  setTabIndicator(indicator) {
+    this.guard();
+    const codePoint = typeof indicator === "string" ? indicator.codePointAt(0) ?? 0 : indicator;
+    this.lib.editorViewSetTabIndicator(this.viewPtr, codePoint);
+  }
+  setTabIndicatorColor(color) {
+    this.guard();
+    this.lib.editorViewSetTabIndicatorColor(this.viewPtr, color);
+  }
+  measureForDimensions(width, height) {
+    this.guard();
+    if (!this._textBufferViewPtr) {
+      this._textBufferViewPtr = this.lib.editorViewGetTextBufferView(this.viewPtr);
+    }
+    return this.lib.textBufferViewMeasureForDimensions(this._textBufferViewPtr, width, height);
+  }
+  destroy() {
+    if (this._destroyed)
+      return;
+    if (this._extmarksController) {
+      this._extmarksController.destroy();
+      this._extmarksController = undefined;
+    }
+    this._destroyed = true;
+    this.lib.destroyEditorView(this.viewPtr);
+  }
+}
+
+// src/console.ts
+import { EventEmitter as EventEmitter8 } from "events";
+import { Console } from "console";
+import fs from "fs";
+import path5 from "path";
+import util2 from "util";
+
+// src/lib/output.capture.ts
+import { Writable } from "stream";
+import { EventEmitter as EventEmitter7 } from "events";
+
+class Capture extends EventEmitter7 {
+  output = [];
+  constructor() {
+    super();
+  }
+  get size() {
+    return this.output.length;
+  }
+  write(stream, data) {
+    this.output.push({ stream, output: data });
+    this.emit("write", stream, data);
+  }
+  claimOutput() {
+    const output = this.output.map((o) => o.output).join("");
+    this.clear();
+    return output;
+  }
+  clear() {
+    this.output = [];
+  }
+}
+
+class CapturedWritableStream extends Writable {
+  stream;
+  capture;
+  isTTY = true;
+  columns = process.stdout.columns || 80;
+  rows = process.stdout.rows || 24;
+  constructor(stream, capture) {
+    super();
+    this.stream = stream;
+    this.capture = capture;
+  }
+  _write(chunk, encoding, callback) {
+    const data = chunk.toString();
+    this.capture.write(this.stream, data);
+    callback();
+  }
+  getColorDepth() {
+    return process.stdout.getColorDepth?.() || 8;
+  }
+}
+
+// src/lib/keymapping.ts
+var defaultKeyAliases = {
+  enter: "return",
+  esc: "escape",
+  kp0: "0",
+  kp1: "1",
+  kp2: "2",
+  kp3: "3",
+  kp4: "4",
+  kp5: "5",
+  kp6: "6",
+  kp7: "7",
+  kp8: "8",
+  kp9: "9",
+  kpdecimal: ".",
+  kpdivide: "/",
+  kpmultiply: "*",
+  kpminus: "-",
+  kpplus: "+",
+  kpenter: "enter",
+  kpequal: "=",
+  kpseparator: ",",
+  kpleft: "left",
+  kpright: "right",
+  kpup: "up",
+  kpdown: "down",
+  kppageup: "pageup",
+  kppagedown: "pagedown",
+  kphome: "home",
+  kpend: "end",
+  kpinsert: "insert",
+  kpdelete: "delete"
+};
+function mergeKeyAliases(defaults, custom) {
+  return { ...defaults, ...custom };
+}
+function mergeKeyBindings(defaults, custom) {
+  const map = new Map;
+  for (const binding of defaults) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  for (const binding of custom) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  return Array.from(map.values());
+}
+function getKeyBindingKey(binding) {
+  return `${binding.name}:${binding.ctrl ? 1 : 0}:${binding.shift ? 1 : 0}:${binding.meta ? 1 : 0}:${binding.super ? 1 : 0}`;
+}
+function buildKeyBindingsMap(bindings, aliasMap) {
+  const map = new Map;
+  const aliases = aliasMap || {};
+  for (const binding of bindings) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding.action);
+  }
+  for (const binding of bindings) {
+    const normalizedName = aliases[binding.name] || binding.name;
+    if (normalizedName !== binding.name) {
+      const aliasedKey = getKeyBindingKey({ ...binding, name: normalizedName });
+      map.set(aliasedKey, binding.action);
+    }
+  }
+  return map;
+}
+function keyBindingToString(binding) {
+  const parts = [];
+  if (binding.ctrl)
+    parts.push("ctrl");
+  if (binding.shift)
+    parts.push("shift");
+  if (binding.meta)
+    parts.push("meta");
+  if (binding.super)
+    parts.push("super");
+  parts.push(binding.name);
+  return parts.join("+");
+}
+
+// src/console.ts
+function getCallerInfo() {
+  const err = new Error;
+  const stackLines = err.stack?.split(`
+`).slice(5) || [];
+  if (!stackLines.length)
+    return null;
+  const callerLine = stackLines[0].trim();
+  const regex = /at\s+(?:([\w$.<>]+)\s+\()?((?:\/|[A-Za-z]:\\)[^:]+):(\d+):(\d+)\)?/;
+  const match = callerLine.match(regex);
+  if (!match)
+    return null;
+  const functionName = match[1] || "<anonymous>";
+  const fullPath = match[2];
+  const fileName = fullPath.split(/[\\/]/).pop() || "<unknown>";
+  const lineNumber = parseInt(match[3], 10) || 0;
+  const columnNumber = parseInt(match[4], 10) || 0;
+  return { functionName, fullPath, fileName, lineNumber, columnNumber };
+}
+var capture = singleton("ConsoleCapture", () => new Capture);
+registerEnvVar({
+  name: "OTUI_USE_CONSOLE",
+  description: "Whether to use the console. Will not capture console output if set to false.",
+  type: "boolean",
+  default: true
+});
+registerEnvVar({
+  name: "SHOW_CONSOLE",
+  description: "Show the console at startup if set to true.",
+  type: "boolean",
+  default: false
+});
+
+class TerminalConsoleCache extends EventEmitter8 {
+  _cachedLogs = [];
+  MAX_CACHE_SIZE = 1000;
+  _collectCallerInfo = false;
+  _cachingEnabled = true;
+  _originalConsole = null;
+  get cachedLogs() {
+    return this._cachedLogs;
+  }
+  constructor() {
+    super();
+  }
+  activate() {
+    if (!this._originalConsole) {
+      this._originalConsole = global.console;
+    }
+    this.setupConsoleCapture();
+    this.overrideConsoleMethods();
+  }
+  setupConsoleCapture() {
+    if (!env.OTUI_USE_CONSOLE)
+      return;
+    const mockStdout = new CapturedWritableStream("stdout", capture);
+    const mockStderr = new CapturedWritableStream("stderr", capture);
+    global.console = new Console({
+      stdout: mockStdout,
+      stderr: mockStderr,
+      colorMode: true,
+      inspectOptions: {
+        compact: false,
+        breakLength: 80,
+        depth: 2
+      }
+    });
+  }
+  overrideConsoleMethods() {
+    console.log = (...args) => {
+      this.appendToConsole("LOG" /* LOG */, ...args);
+    };
+    console.info = (...args) => {
+      this.appendToConsole("INFO" /* INFO */, ...args);
+    };
+    console.warn = (...args) => {
+      this.appendToConsole("WARN" /* WARN */, ...args);
+    };
+    console.error = (...args) => {
+      this.appendToConsole("ERROR" /* ERROR */, ...args);
+    };
+    console.debug = (...args) => {
+      this.appendToConsole("DEBUG" /* DEBUG */, ...args);
+    };
+  }
+  setCollectCallerInfo(enabled) {
+    this._collectCallerInfo = enabled;
+  }
+  clearConsole() {
+    this._cachedLogs = [];
+  }
+  setCachingEnabled(enabled) {
+    this._cachingEnabled = enabled;
+  }
+  deactivate() {
+    this.restoreOriginalConsole();
+  }
+  restoreOriginalConsole() {
+    if (this._originalConsole) {
+      global.console = this._originalConsole;
+    }
+  }
+  addLogEntry(level, ...args) {
+    const callerInfo = this._collectCallerInfo ? getCallerInfo() : null;
+    const logEntry = [new Date, level, args, callerInfo];
+    if (this._cachingEnabled) {
+      if (this._cachedLogs.length >= this.MAX_CACHE_SIZE) {
+        this._cachedLogs.shift();
+      }
+      this._cachedLogs.push(logEntry);
+    }
+    return logEntry;
+  }
+  appendToConsole(level, ...args) {
+    if (this._cachedLogs.length >= this.MAX_CACHE_SIZE) {
+      this._cachedLogs.shift();
+    }
+    const entry = this.addLogEntry(level, ...args);
+    this.emit("entry", entry);
+  }
+  destroy() {
+    this.deactivate();
+  }
+}
+var terminalConsoleCache = singleton("TerminalConsoleCache", () => {
+  const terminalConsoleCache2 = new TerminalConsoleCache;
+  process.on("exit", () => {
+    terminalConsoleCache2.destroy();
+  });
+  return terminalConsoleCache2;
+});
+var ConsolePosition;
 ((ConsolePosition2) => {
   ConsolePosition2["TOP"] = "top";
   ConsolePosition2["BOTTOM"] = "bottom";
@@ -16257,7 +16789,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter7 {
+class TerminalConsole extends EventEmitter8 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -16358,699 +16890,1590 @@ class TerminalConsole extends EventEmitter7 {
       this.show();
     }
   }
-  buildActionHandlers() {
-    return new Map([
-      ["scroll-up", () => this.scrollUp()],
-      ["scroll-down", () => this.scrollDown()],
-      ["scroll-to-top", () => this.scrollToTop()],
-      ["scroll-to-bottom", () => this.scrollToBottomAction()],
-      ["position-previous", () => this.positionPrevious()],
-      ["position-next", () => this.positionNext()],
-      ["size-increase", () => this.sizeIncrease()],
-      ["size-decrease", () => this.sizeDecrease()],
-      ["save-logs", () => this.saveLogsAction()],
-      ["copy-selection", () => this.triggerCopyAction()]
-    ]);
+  buildActionHandlers() {
+    return new Map([
+      ["scroll-up", () => this.scrollUp()],
+      ["scroll-down", () => this.scrollDown()],
+      ["scroll-to-top", () => this.scrollToTop()],
+      ["scroll-to-bottom", () => this.scrollToBottomAction()],
+      ["position-previous", () => this.positionPrevious()],
+      ["position-next", () => this.positionNext()],
+      ["size-increase", () => this.sizeIncrease()],
+      ["size-decrease", () => this.sizeDecrease()],
+      ["save-logs", () => this.saveLogsAction()],
+      ["copy-selection", () => this.triggerCopyAction()]
+    ]);
+  }
+  activate() {
+    terminalConsoleCache.activate();
+  }
+  deactivate() {
+    terminalConsoleCache.deactivate();
+  }
+  _handleNewLog(logEntry) {
+    if (!this.isVisible)
+      return;
+    this._allLogEntries.push(logEntry);
+    if (this._allLogEntries.length > this.options.maxStoredLogs) {
+      this._allLogEntries.splice(0, this._allLogEntries.length - this.options.maxStoredLogs);
+    }
+    const newDisplayLines = this._processLogEntry(logEntry);
+    this._displayLines.push(...newDisplayLines);
+    if (this._displayLines.length > this.options.maxDisplayLines) {
+      this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
+      const linesRemoved = this._displayLines.length - this.options.maxDisplayLines;
+      this.scrollTopIndex = Math.max(0, this.scrollTopIndex - linesRemoved);
+    }
+    if (this.isScrolledToBottom) {
+      this._scrollToBottom();
+    }
+    this.markNeedsRerender();
+  }
+  _updateConsoleDimensions(termWidth, termHeight) {
+    const width = termWidth ?? this.renderer.width;
+    const height = termHeight ?? this.renderer.height;
+    const sizePercent = this.options.sizePercent / 100;
+    switch (this.options.position) {
+      case "top" /* TOP */:
+        this.consoleX = 0;
+        this.consoleY = 0;
+        this.consoleWidth = width;
+        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
+        break;
+      case "bottom" /* BOTTOM */:
+        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
+        this.consoleWidth = width;
+        this.consoleX = 0;
+        this.consoleY = height - this.consoleHeight;
+        break;
+      case "left" /* LEFT */:
+        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
+        this.consoleHeight = height;
+        this.consoleX = 0;
+        this.consoleY = 0;
+        break;
+      case "right" /* RIGHT */:
+        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
+        this.consoleHeight = height;
+        this.consoleY = 0;
+        this.consoleX = width - this.consoleWidth;
+        break;
+    }
+    this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
+  }
+  handleKeyPress(event) {
+    if (event.name === "escape") {
+      this.blur();
+      return;
+    }
+    const bindingKey = getKeyBindingKey({
+      name: event.name,
+      ctrl: event.ctrl,
+      shift: event.shift,
+      meta: event.meta,
+      super: event.super,
+      action: "scroll-up"
+    });
+    const action = this._keyBindingsMap.get(bindingKey);
+    if (action) {
+      const handler = this._actionHandlers.get(action);
+      if (handler) {
+        handler();
+        return;
+      }
+    }
+  }
+  scrollUp() {
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    if (this.currentLineIndex > 0) {
+      this.currentLineIndex--;
+      this.markNeedsRerender();
+    } else if (this.scrollTopIndex > 0) {
+      this.scrollTopIndex--;
+      this.isScrolledToBottom = false;
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollDown() {
+    const displayLineCount = this._displayLines.length;
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+    const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
+    if (canCursorMoveDown) {
+      this.currentLineIndex++;
+      this.markNeedsRerender();
+    } else if (this.scrollTopIndex < maxScrollTop) {
+      this.scrollTopIndex++;
+      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollToTop() {
+    if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
+      this.scrollTopIndex = 0;
+      this.currentLineIndex = 0;
+      this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollToBottomAction() {
+    const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
+    const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
+    if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
+      this._scrollToBottom(true);
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  positionPrevious() {
+    const currentPositionIndex = this._positions.indexOf(this.options.position);
+    const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
+    this.options.position = this._positions[prevIndex];
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  positionNext() {
+    const currentPositionIndex = this._positions.indexOf(this.options.position);
+    const nextIndex = (currentPositionIndex + 1) % this._positions.length;
+    this.options.position = this._positions[nextIndex];
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  sizeIncrease() {
+    this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  sizeDecrease() {
+    this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  saveLogsAction() {
+    this.saveLogsToFile();
+    return true;
+  }
+  triggerCopyAction() {
+    this.triggerCopy();
+    return true;
+  }
+  attachStdin() {
+    if (this.isFocused)
+      return;
+    this.renderer.keyInput.on("keypress", this.keyHandler);
+    this.isFocused = true;
+  }
+  detachStdin() {
+    if (!this.isFocused)
+      return;
+    this.renderer.keyInput.off("keypress", this.keyHandler);
+    this.isFocused = false;
+  }
+  formatTimestamp(date) {
+    return new Intl.DateTimeFormat("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    }).format(date);
+  }
+  formatArguments(args) {
+    return args.map((arg) => {
+      if (arg instanceof Error) {
+        const errorProps = arg;
+        return `Error: ${errorProps.message}
+` + (errorProps.stack ? `${errorProps.stack}
+` : "");
+      }
+      if (typeof arg === "object" && arg !== null) {
+        try {
+          return util2.inspect(arg, { depth: 2 });
+        } catch (e) {
+          return String(arg);
+        }
+      }
+      try {
+        return util2.inspect(arg, { depth: 2 });
+      } catch (e) {
+        return String(arg);
+      }
+    }).join(" ");
+  }
+  resize(width, height) {
+    this._updateConsoleDimensions(width, height);
+    if (this.frameBuffer) {
+      this.frameBuffer.resize(this.consoleWidth, this.consoleHeight);
+      const displayLineCount = this._displayLines.length;
+      const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+      const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+      this.scrollTopIndex = Math.min(this.scrollTopIndex, maxScrollTop);
+      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+      const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
+      this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, visibleLineCount - 1));
+      if (this.isVisible) {
+        this.markNeedsRerender();
+      }
+    }
+  }
+  clear() {
+    terminalConsoleCache.clearConsole();
+    this._allLogEntries = [];
+    this._displayLines = [];
+    this.markNeedsRerender();
+  }
+  toggle() {
+    if (this.isVisible) {
+      if (this.isFocused) {
+        this.hide();
+      } else {
+        this.focus();
+      }
+    } else {
+      this.show();
+    }
+    if (!this.renderer.isRunning) {
+      this.renderer.requestRender();
+    }
+  }
+  focus() {
+    this.attachStdin();
+    this._scrollToBottom(true);
+    this.markNeedsRerender();
   }
-  activate() {
-    terminalConsoleCache.activate();
+  blur() {
+    this.detachStdin();
+    this.markNeedsRerender();
   }
-  deactivate() {
-    terminalConsoleCache.deactivate();
+  show() {
+    if (!this.isVisible) {
+      this.isVisible = true;
+      this._processCachedLogs();
+      terminalConsoleCache.setCachingEnabled(false);
+      if (!this.frameBuffer) {
+        this.frameBuffer = OptimizedBuffer.create(this.consoleWidth, this.consoleHeight, this.renderer.widthMethod, {
+          respectAlpha: this.backgroundColor.a < 1,
+          id: "console framebuffer"
+        });
+      }
+      const logCount = terminalConsoleCache.cachedLogs.length;
+      const visibleLogLines = Math.min(this.consoleHeight, logCount);
+      this.currentLineIndex = Math.max(0, visibleLogLines - 1);
+      this.scrollTopIndex = 0;
+      this._scrollToBottom(true);
+      this.focus();
+      this.markNeedsRerender();
+    }
   }
-  _handleNewLog(logEntry) {
-    if (!this.isVisible)
+  hide() {
+    if (this.isVisible) {
+      this.isVisible = false;
+      this.blur();
+      terminalConsoleCache.setCachingEnabled(true);
+    }
+  }
+  destroy() {
+    this.stopAutoScroll();
+    this.hide();
+    this.deactivate();
+    terminalConsoleCache.off("entry", this._entryListener);
+  }
+  getCachedLogs() {
+    return terminalConsoleCache.cachedLogs.map((logEntry) => logEntry[0].toISOString() + " " + logEntry.slice(1).join(" ")).join(`
+`);
+  }
+  updateFrameBuffer() {
+    if (!this.frameBuffer)
       return;
-    this._allLogEntries.push(logEntry);
-    if (this._allLogEntries.length > this.options.maxStoredLogs) {
-      this._allLogEntries.splice(0, this._allLogEntries.length - this.options.maxStoredLogs);
+    this.frameBuffer.clear(this.backgroundColor);
+    const displayLines = this._displayLines;
+    const displayLineCount = displayLines.length;
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    this.frameBuffer.fillRect(0, 0, this.consoleWidth, 1, this._rgbaTitleBar);
+    const dynamicTitle = `${this._title}${this.isFocused ? " (Focused)" : ""}`;
+    const titleX = Math.max(0, Math.floor((this.consoleWidth - dynamicTitle.length) / 2));
+    this.frameBuffer.drawText(dynamicTitle, titleX, 0, this._rgbaTitleBarText, this._rgbaTitleBar);
+    const copyLabel = this.getCopyButtonLabel();
+    const copyButtonX = this.consoleWidth - copyLabel.length - 1;
+    if (copyButtonX >= 0) {
+      const copyButtonEnabled = this.hasSelection();
+      const disabledColor = RGBA.fromInts(100, 100, 100, 255);
+      const copyColor = copyButtonEnabled ? this._rgbaCopyButton : disabledColor;
+      this.frameBuffer.drawText(copyLabel, copyButtonX, 0, copyColor, this._rgbaTitleBar);
+      this._copyButtonBounds = { x: copyButtonX, y: 0, width: copyLabel.length, height: 1 };
+    } else {
+      this._copyButtonBounds = { x: -1, y: -1, width: 0, height: 0 };
     }
-    const newDisplayLines = this._processLogEntry(logEntry);
-    this._displayLines.push(...newDisplayLines);
-    if (this._displayLines.length > this.options.maxDisplayLines) {
-      this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
-      const linesRemoved = this._displayLines.length - this.options.maxDisplayLines;
-      this.scrollTopIndex = Math.max(0, this.scrollTopIndex - linesRemoved);
+    const startIndex = this.scrollTopIndex;
+    const endIndex = Math.min(startIndex + logAreaHeight, displayLineCount);
+    const visibleDisplayLines = displayLines.slice(startIndex, endIndex);
+    let lineY = 1;
+    for (let i = 0;i < visibleDisplayLines.length; i++) {
+      if (lineY >= this.consoleHeight)
+        break;
+      const displayLine = visibleDisplayLines[i];
+      const absoluteLineIndex = startIndex + i;
+      let levelColor = this._rgbaDefault;
+      switch (displayLine.level) {
+        case "INFO" /* INFO */:
+          levelColor = this._rgbaInfo;
+          break;
+        case "WARN" /* WARN */:
+          levelColor = this._rgbaWarn;
+          break;
+        case "ERROR" /* ERROR */:
+          levelColor = this._rgbaError;
+          break;
+        case "DEBUG" /* DEBUG */:
+          levelColor = this._rgbaDebug;
+          break;
+      }
+      const linePrefix = displayLine.indent ? " ".repeat(INDENT_WIDTH) : "";
+      const textToDraw = displayLine.text;
+      const textAvailableWidth = this.consoleWidth - 1 - (displayLine.indent ? INDENT_WIDTH : 0);
+      const showCursor = this.isFocused && lineY - 1 === this.currentLineIndex;
+      if (showCursor) {
+        this.frameBuffer.drawText(">", 0, lineY, this._rgbaCursor, this.backgroundColor);
+      } else {
+        this.frameBuffer.drawText(" ", 0, lineY, this._rgbaDefault, this.backgroundColor);
+      }
+      const fullText = `${linePrefix}${textToDraw.substring(0, textAvailableWidth)}`;
+      const selectionRange = this.getLineSelectionRange(absoluteLineIndex);
+      if (selectionRange) {
+        const adjustedStart = Math.max(0, selectionRange.start);
+        const adjustedEnd = Math.min(fullText.length, selectionRange.end);
+        if (adjustedStart > 0) {
+          this.frameBuffer.drawText(fullText.substring(0, adjustedStart), 1, lineY, levelColor);
+        }
+        if (adjustedStart < adjustedEnd) {
+          this.frameBuffer.fillRect(1 + adjustedStart, lineY, adjustedEnd - adjustedStart, 1, this._rgbaSelection);
+          this.frameBuffer.drawText(fullText.substring(adjustedStart, adjustedEnd), 1 + adjustedStart, lineY, levelColor, this._rgbaSelection);
+        }
+        if (adjustedEnd < fullText.length) {
+          this.frameBuffer.drawText(fullText.substring(adjustedEnd), 1 + adjustedEnd, lineY, levelColor);
+        }
+      } else {
+        this.frameBuffer.drawText(fullText, 1, lineY, levelColor);
+      }
+      lineY++;
     }
-    if (this.isScrolledToBottom) {
-      this._scrollToBottom();
+  }
+  renderToBuffer(buffer) {
+    if (!this.isVisible || !this.frameBuffer)
+      return;
+    if (this._needsFrameBufferUpdate) {
+      this.updateFrameBuffer();
+      this._needsFrameBufferUpdate = false;
     }
-    this.markNeedsRerender();
+    buffer.drawFrameBuffer(this.consoleX, this.consoleY, this.frameBuffer);
   }
-  _updateConsoleDimensions(termWidth, termHeight) {
-    const width = termWidth ?? this.renderer.width;
-    const height = termHeight ?? this.renderer.height;
-    const sizePercent = this.options.sizePercent / 100;
-    switch (this.options.position) {
-      case "top" /* TOP */:
-        this.consoleX = 0;
-        this.consoleY = 0;
-        this.consoleWidth = width;
-        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
-        break;
-      case "bottom" /* BOTTOM */:
-        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
-        this.consoleWidth = width;
-        this.consoleX = 0;
-        this.consoleY = height - this.consoleHeight;
-        break;
-      case "left" /* LEFT */:
-        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
-        this.consoleHeight = height;
-        this.consoleX = 0;
-        this.consoleY = 0;
-        break;
-      case "right" /* RIGHT */:
-        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
-        this.consoleHeight = height;
-        this.consoleY = 0;
-        this.consoleX = width - this.consoleWidth;
-        break;
+  setDebugMode(enabled) {
+    this._debugModeEnabled = enabled;
+    terminalConsoleCache.setCollectCallerInfo(enabled);
+    if (this.isVisible) {
+      this.markNeedsRerender();
     }
-    this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
   }
-  handleKeyPress(event) {
-    if (event.name === "escape") {
-      this.blur();
-      return;
+  toggleDebugMode() {
+    this.setDebugMode(!this._debugModeEnabled);
+  }
+  set keyBindings(bindings) {
+    this._keyBindings = bindings;
+    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, bindings);
+    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
+    this.markNeedsRerender();
+  }
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
+    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
+    this.markNeedsRerender();
+  }
+  set onCopySelection(callback) {
+    this.options.onCopySelection = callback;
+  }
+  get onCopySelection() {
+    return this.options.onCopySelection;
+  }
+  _scrollToBottom(forceCursorToLastLine = false) {
+    const displayLineCount = this._displayLines.length;
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+    this.scrollTopIndex = maxScrollTop;
+    this.isScrolledToBottom = true;
+    const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
+    if (forceCursorToLastLine || this.currentLineIndex >= visibleLineCount) {
+      this.currentLineIndex = Math.max(0, visibleLineCount - 1);
     }
-    const bindingKey = getKeyBindingKey({
-      name: event.name,
-      ctrl: event.ctrl,
-      shift: event.shift,
-      meta: event.meta,
-      super: event.super,
-      action: "scroll-up"
-    });
-    const action = this._keyBindingsMap.get(bindingKey);
-    if (action) {
-      const handler = this._actionHandlers.get(action);
-      if (handler) {
-        handler();
-        return;
+  }
+  _processLogEntry(logEntry) {
+    const [date, level, args, callerInfo] = logEntry;
+    const displayLines = [];
+    const timestamp = this.formatTimestamp(date);
+    const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
+    const prefix = `[${timestamp}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
+    const formattedArgs = this.formatArguments(args);
+    const initialLines = formattedArgs.split(`
+`);
+    for (let i = 0;i < initialLines.length; i++) {
+      const lineText = initialLines[i];
+      const isFirstLineOfEntry = i === 0;
+      const availableWidth = this.consoleWidth - 1 - (isFirstLineOfEntry ? 0 : INDENT_WIDTH);
+      const linePrefix = isFirstLineOfEntry ? prefix : " ".repeat(INDENT_WIDTH);
+      const textToWrap = isFirstLineOfEntry ? linePrefix + lineText : lineText;
+      let currentPos = 0;
+      while (currentPos < textToWrap.length || isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0) {
+        const segment = textToWrap.substring(currentPos, currentPos + availableWidth);
+        const isFirstSegmentOfLine = currentPos === 0;
+        displayLines.push({
+          text: isFirstSegmentOfLine && !isFirstLineOfEntry ? linePrefix + segment : segment,
+          level,
+          indent: !isFirstLineOfEntry || !isFirstSegmentOfLine
+        });
+        currentPos += availableWidth;
+        if (isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0)
+          break;
       }
     }
+    return displayLines;
   }
-  scrollUp() {
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    if (this.currentLineIndex > 0) {
-      this.currentLineIndex--;
-      this.markNeedsRerender();
-    } else if (this.scrollTopIndex > 0) {
-      this.scrollTopIndex--;
-      this.isScrolledToBottom = false;
-      this.markNeedsRerender();
-    }
-    return true;
-  }
-  scrollDown() {
-    const displayLineCount = this._displayLines.length;
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-    const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
-    if (canCursorMoveDown) {
-      this.currentLineIndex++;
-      this.markNeedsRerender();
-    } else if (this.scrollTopIndex < maxScrollTop) {
-      this.scrollTopIndex++;
-      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-      this.markNeedsRerender();
+  _processCachedLogs() {
+    const logsToProcess = [...terminalConsoleCache.cachedLogs];
+    terminalConsoleCache.clearConsole();
+    this._allLogEntries.push(...logsToProcess);
+    if (this._allLogEntries.length > this.options.maxStoredLogs) {
+      this._allLogEntries.splice(0, this._allLogEntries.length - this.options.maxStoredLogs);
     }
-    return true;
-  }
-  scrollToTop() {
-    if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
-      this.scrollTopIndex = 0;
-      this.currentLineIndex = 0;
-      this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
-      this.markNeedsRerender();
+    for (const logEntry of logsToProcess) {
+      const processed = this._processLogEntry(logEntry);
+      this._displayLines.push(...processed);
     }
-    return true;
-  }
-  scrollToBottomAction() {
-    const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
-    const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
-    if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
-      this._scrollToBottom(true);
-      this.markNeedsRerender();
+    if (this._displayLines.length > this.options.maxDisplayLines) {
+      this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
     }
-    return true;
-  }
-  positionPrevious() {
-    const currentPositionIndex = this._positions.indexOf(this.options.position);
-    const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
-    this.options.position = this._positions[prevIndex];
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
   }
-  positionNext() {
-    const currentPositionIndex = this._positions.indexOf(this.options.position);
-    const nextIndex = (currentPositionIndex + 1) % this._positions.length;
-    this.options.position = this._positions[nextIndex];
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
+  hasSelection() {
+    if (this._selectionStart === null || this._selectionEnd === null)
+      return false;
+    return this._selectionStart.line !== this._selectionEnd.line || this._selectionStart.col !== this._selectionEnd.col;
   }
-  sizeIncrease() {
-    this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
+  normalizeSelection() {
+    if (!this._selectionStart || !this._selectionEnd)
+      return null;
+    const start = this._selectionStart;
+    const end = this._selectionEnd;
+    const startBeforeEnd = start.line < end.line || start.line === end.line && start.col <= end.col;
+    if (startBeforeEnd) {
+      return {
+        startLine: start.line,
+        startCol: start.col,
+        endLine: end.line,
+        endCol: end.col
+      };
+    } else {
+      return {
+        startLine: end.line,
+        startCol: end.col,
+        endLine: start.line,
+        endCol: start.col
+      };
+    }
   }
-  sizeDecrease() {
-    this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
+  getSelectedText() {
+    const selection2 = this.normalizeSelection();
+    if (!selection2)
+      return "";
+    const lines = [];
+    for (let i = selection2.startLine;i <= selection2.endLine; i++) {
+      if (i < 0 || i >= this._displayLines.length)
+        continue;
+      const line = this._displayLines[i];
+      const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
+      const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
+      const fullText = linePrefix + line.text.substring(0, textAvailableWidth);
+      let text = fullText;
+      if (i === selection2.startLine && i === selection2.endLine) {
+        text = fullText.substring(selection2.startCol, selection2.endCol);
+      } else if (i === selection2.startLine) {
+        text = fullText.substring(selection2.startCol);
+      } else if (i === selection2.endLine) {
+        text = fullText.substring(0, selection2.endCol);
+      }
+      lines.push(text);
+    }
+    return lines.join(`
+`);
   }
-  saveLogsAction() {
-    this.saveLogsToFile();
-    return true;
+  clearSelection() {
+    this._selectionStart = null;
+    this._selectionEnd = null;
+    this._isDragging = false;
+    this.stopAutoScroll();
   }
-  triggerCopyAction() {
-    this.triggerCopy();
-    return true;
+  stopAutoScroll() {
+    if (this._autoScrollInterval !== null) {
+      this.clock.clearInterval(this._autoScrollInterval);
+      this._autoScrollInterval = null;
+    }
   }
-  attachStdin() {
-    if (this.isFocused)
-      return;
-    this.renderer.keyInput.on("keypress", this.keyHandler);
-    this.isFocused = true;
+  startAutoScroll(direction) {
+    this.stopAutoScroll();
+    this._autoScrollInterval = this.clock.setInterval(() => {
+      if (direction === "up") {
+        if (this.scrollTopIndex > 0) {
+          this.scrollTopIndex--;
+          this.isScrolledToBottom = false;
+          if (this._selectionEnd) {
+            this._selectionEnd = {
+              line: this.scrollTopIndex,
+              col: this._selectionEnd.col
+            };
+          }
+          this.markNeedsRerender();
+        } else {
+          this.stopAutoScroll();
+        }
+      } else {
+        const displayLineCount = this._displayLines.length;
+        const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+        const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+        if (this.scrollTopIndex < maxScrollTop) {
+          this.scrollTopIndex++;
+          this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+          if (this._selectionEnd) {
+            const maxLine = this.scrollTopIndex + logAreaHeight - 1;
+            this._selectionEnd = {
+              line: Math.min(maxLine, displayLineCount - 1),
+              col: this._selectionEnd.col
+            };
+          }
+          this.markNeedsRerender();
+        } else {
+          this.stopAutoScroll();
+        }
+      }
+    }, 50);
   }
-  detachStdin() {
-    if (!this.isFocused)
+  triggerCopy() {
+    if (!this.hasSelection())
       return;
-    this.renderer.keyInput.off("keypress", this.keyHandler);
-    this.isFocused = false;
-  }
-  formatTimestamp(date) {
-    return new Intl.DateTimeFormat("en-US", {
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      hour12: false
-    }).format(date);
+    const text = this.getSelectedText();
+    if (text && this.options.onCopySelection) {
+      try {
+        this.options.onCopySelection(text);
+      } catch {}
+      this.clearSelection();
+      this.markNeedsRerender();
+    }
   }
-  formatArguments(args) {
-    return args.map((arg) => {
-      if (arg instanceof Error) {
-        const errorProps = arg;
-        return `Error: ${errorProps.message}
-` + (errorProps.stack ? `${errorProps.stack}
-` : "");
-      }
-      if (typeof arg === "object" && arg !== null) {
-        try {
-          return util2.inspect(arg, { depth: 2 });
-        } catch (e) {
-          return String(arg);
-        }
+  getLineSelectionRange(lineIndex) {
+    const selection2 = this.normalizeSelection();
+    if (!selection2)
+      return null;
+    if (lineIndex < selection2.startLine || lineIndex > selection2.endLine) {
+      return null;
+    }
+    const line = this._displayLines[lineIndex];
+    if (!line)
+      return null;
+    const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
+    const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
+    const fullTextLength = linePrefix.length + Math.min(line.text.length, textAvailableWidth);
+    let start = 0;
+    let end = fullTextLength;
+    if (lineIndex === selection2.startLine) {
+      start = Math.max(0, selection2.startCol);
+    }
+    if (lineIndex === selection2.endLine) {
+      end = Math.min(fullTextLength, selection2.endCol);
+    }
+    if (start >= end)
+      return null;
+    return { start, end };
+  }
+  handleMouse(event) {
+    if (!this.isVisible)
+      return false;
+    const localX = event.x - this.consoleX;
+    const localY = event.y - this.consoleY;
+    if (localX < 0 || localX >= this.consoleWidth || localY < 0 || localY >= this.consoleHeight) {
+      return false;
+    }
+    if (event.type === "scroll" && event.scroll) {
+      if (event.scroll.direction === "up") {
+        this.scrollUp();
+      } else if (event.scroll.direction === "down") {
+        this.scrollDown();
       }
-      try {
-        return util2.inspect(arg, { depth: 2 });
-      } catch (e) {
-        return String(arg);
+      return true;
+    }
+    if (localY === 0) {
+      if (event.type === "down" && event.button === 0 && localX >= this._copyButtonBounds.x && localX < this._copyButtonBounds.x + this._copyButtonBounds.width) {
+        this.triggerCopy();
+        return true;
       }
-    }).join(" ");
-  }
-  resize(width, height) {
-    this._updateConsoleDimensions(width, height);
-    if (this.frameBuffer) {
-      this.frameBuffer.resize(this.consoleWidth, this.consoleHeight);
-      const displayLineCount = this._displayLines.length;
+      return true;
+    }
+    const lineIndex = this.scrollTopIndex + (localY - 1);
+    const colIndex = Math.max(0, localX - 1);
+    if (event.type === "down" && event.button === 0) {
+      this.clearSelection();
+      this._selectionStart = { line: lineIndex, col: colIndex };
+      this._selectionEnd = { line: lineIndex, col: colIndex };
+      this._isDragging = true;
+      this.markNeedsRerender();
+      return true;
+    }
+    if (event.type === "drag" && this._isDragging) {
+      this._selectionEnd = { line: lineIndex, col: colIndex };
       const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-      const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-      this.scrollTopIndex = Math.min(this.scrollTopIndex, maxScrollTop);
-      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-      const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
-      this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, visibleLineCount - 1));
-      if (this.isVisible) {
+      const relativeY = localY - 1;
+      if (relativeY <= 0) {
+        this.startAutoScroll("up");
+      } else if (relativeY >= logAreaHeight - 1) {
+        this.startAutoScroll("down");
+      } else {
+        this.stopAutoScroll();
+      }
+      this.markNeedsRerender();
+      return true;
+    }
+    if (event.type === "up") {
+      if (this._isDragging) {
+        this._selectionEnd = { line: lineIndex, col: colIndex };
+        this._isDragging = false;
+        this.stopAutoScroll();
         this.markNeedsRerender();
       }
+      return true;
     }
+    return true;
   }
-  clear() {
-    terminalConsoleCache.clearConsole();
-    this._allLogEntries = [];
-    this._displayLines = [];
-    this.markNeedsRerender();
+  get visible() {
+    return this.isVisible;
   }
-  toggle() {
-    if (this.isVisible) {
-      if (this.isFocused) {
-        this.hide();
-      } else {
-        this.focus();
+  get bounds() {
+    return {
+      x: this.consoleX,
+      y: this.consoleY,
+      width: this.consoleWidth,
+      height: this.consoleHeight
+    };
+  }
+  saveLogsToFile() {
+    try {
+      const timestamp = Date.now();
+      const filename = `_console_${timestamp}.log`;
+      const filepath = path5.join(process.cwd(), filename);
+      const allLogEntries = [...this._allLogEntries, ...terminalConsoleCache.cachedLogs];
+      const logLines = [];
+      for (const [date, level, args, callerInfo] of allLogEntries) {
+        const timestampStr = this.formatTimestamp(date);
+        const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
+        const prefix = `[${timestampStr}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
+        const formattedArgs = this.formatArguments(args);
+        logLines.push(prefix + formattedArgs);
       }
-    } else {
-      this.show();
-    }
-    if (!this.renderer.isRunning) {
-      this.renderer.requestRender();
+      const content = logLines.join(`
+`);
+      fs.writeFileSync(filepath, content, "utf8");
+      console.info(`Console logs saved to: ${filename}`);
+    } catch (error) {
+      console.error(`Failed to save console logs:`, error);
     }
   }
-  focus() {
-    this.attachStdin();
-    this._scrollToBottom(true);
-    this.markNeedsRerender();
-  }
-  blur() {
-    this.detachStdin();
-    this.markNeedsRerender();
-  }
-  show() {
-    if (!this.isVisible) {
-      this.isVisible = true;
-      this._processCachedLogs();
-      terminalConsoleCache.setCachingEnabled(false);
-      if (!this.frameBuffer) {
-        this.frameBuffer = OptimizedBuffer.create(this.consoleWidth, this.consoleHeight, this.renderer.widthMethod, {
-          respectAlpha: this.backgroundColor.a < 1,
-          id: "console framebuffer"
+}
+
+// src/renderables/EditBufferRenderable.ts
+var BrandedEditBufferRenderable = Symbol.for("@opentui/core/EditBufferRenderable");
+var EditBufferRenderableEvents;
+((EditBufferRenderableEvents2) => {
+  EditBufferRenderableEvents2["TRAITS_CHANGED"] = "traits-changed";
+})(EditBufferRenderableEvents ||= {});
+function sameCapture(a, b) {
+  if (a === b)
+    return true;
+  if (!a || !b)
+    return !a && !b;
+  if (a.length !== b.length)
+    return false;
+  return a.every((item, i) => item === b[i]);
+}
+function sameTraits(a, b) {
+  return a.suspend === b.suspend && a.status === b.status && sameCapture(a.capture, b.capture);
+}
+function isEditBufferRenderable(obj) {
+  return !!(obj && typeof obj === "object" && (BrandedEditBufferRenderable in obj));
+}
+
+class EditBufferRenderable extends Renderable {
+  [BrandedEditBufferRenderable] = true;
+  _focusable = true;
+  selectable = true;
+  _traits = {};
+  _textColor;
+  _backgroundColor;
+  _defaultAttributes;
+  _selectionBg;
+  _selectionFg;
+  _wrapMode = "word";
+  _scrollMargin = 0.2;
+  _showCursor = true;
+  _cursorColor;
+  _cursorStyle;
+  lastLocalSelection = null;
+  _tabIndicator;
+  _tabIndicatorColor;
+  _cursorChangeListener = undefined;
+  _contentChangeListener = undefined;
+  _autoScrollVelocity = 0;
+  _autoScrollAccumulator = 0;
+  _scrollSpeed = 16;
+  _keyboardSelectionActive = false;
+  editBuffer;
+  editorView;
+  _defaultOptions = {
+    textColor: RGBA.fromValues(1, 1, 1, 1),
+    backgroundColor: "transparent",
+    selectionBg: undefined,
+    selectionFg: undefined,
+    selectable: true,
+    attributes: 0,
+    wrapMode: "word",
+    scrollMargin: 0.2,
+    scrollSpeed: 16,
+    showCursor: true,
+    cursorColor: RGBA.fromValues(1, 1, 1, 1),
+    cursorStyle: {
+      style: "block",
+      blinking: true
+    },
+    tabIndicator: undefined,
+    tabIndicatorColor: undefined
+  };
+  constructor(ctx, options) {
+    super(ctx, options);
+    this._textColor = parseColor(options.textColor ?? this._defaultOptions.textColor);
+    this._backgroundColor = parseColor(options.backgroundColor ?? this._defaultOptions.backgroundColor);
+    this._defaultAttributes = options.attributes ?? this._defaultOptions.attributes;
+    this._selectionBg = options.selectionBg ? parseColor(options.selectionBg) : this._defaultOptions.selectionBg;
+    this._selectionFg = options.selectionFg ? parseColor(options.selectionFg) : this._defaultOptions.selectionFg;
+    this.selectable = options.selectable ?? this._defaultOptions.selectable;
+    this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
+    this._scrollMargin = options.scrollMargin ?? this._defaultOptions.scrollMargin;
+    this._scrollSpeed = options.scrollSpeed ?? this._defaultOptions.scrollSpeed;
+    this._showCursor = options.showCursor ?? this._defaultOptions.showCursor;
+    this._cursorColor = parseColor(options.cursorColor ?? this._defaultOptions.cursorColor);
+    this._cursorStyle = options.cursorStyle ?? this._defaultOptions.cursorStyle;
+    this._tabIndicator = options.tabIndicator ?? this._defaultOptions.tabIndicator;
+    this._tabIndicatorColor = options.tabIndicatorColor ? parseColor(options.tabIndicatorColor) : this._defaultOptions.tabIndicatorColor;
+    this.editBuffer = EditBuffer.create(this._ctx.widthMethod);
+    this.editorView = EditorView.create(this.editBuffer, this.width || 80, this.height || 24);
+    this.editorView.setWrapMode(this._wrapMode);
+    this.editorView.setScrollMargin(this._scrollMargin);
+    this.editBuffer.setDefaultFg(this._textColor);
+    this.editBuffer.setDefaultBg(this._backgroundColor);
+    this.editBuffer.setDefaultAttributes(this._defaultAttributes);
+    if (options.syntaxStyle) {
+      this.editBuffer.setSyntaxStyle(options.syntaxStyle);
+    }
+    if (this._tabIndicator !== undefined) {
+      this.editorView.setTabIndicator(this._tabIndicator);
+    }
+    if (this._tabIndicatorColor !== undefined) {
+      this.editorView.setTabIndicatorColor(this._tabIndicatorColor);
+    }
+    this.setupMeasureFunc();
+    this.setupEventListeners(options);
+  }
+  get lineInfo() {
+    return this.editorView.getLogicalLineInfo();
+  }
+  setupEventListeners(options) {
+    this._cursorChangeListener = options.onCursorChange;
+    this._contentChangeListener = options.onContentChange;
+    this.editBuffer.on("cursor-changed", () => {
+      if (this._cursorChangeListener) {
+        const cursor = this.editBuffer.getCursorPosition();
+        this._cursorChangeListener({
+          line: cursor.row,
+          visualColumn: cursor.col
         });
       }
-      const logCount = terminalConsoleCache.cachedLogs.length;
-      const visibleLogLines = Math.min(this.consoleHeight, logCount);
-      this.currentLineIndex = Math.max(0, visibleLogLines - 1);
-      this.scrollTopIndex = 0;
-      this._scrollToBottom(true);
-      this.focus();
-      this.markNeedsRerender();
-    }
+    });
+    this.editBuffer.on("content-changed", () => {
+      this.yogaNode.markDirty();
+      this.requestRender();
+      this.emit("line-info-change");
+      if (this._contentChangeListener) {
+        this._contentChangeListener({});
+      }
+    });
   }
-  hide() {
-    if (this.isVisible) {
-      this.isVisible = false;
-      this.blur();
-      terminalConsoleCache.setCachingEnabled(true);
-    }
+  get lineCount() {
+    return this.editBuffer.getLineCount();
   }
-  destroy() {
-    this.stopAutoScroll();
-    this.hide();
-    this.deactivate();
-    terminalConsoleCache.off("entry", this._entryListener);
+  get virtualLineCount() {
+    return this.editorView.getVirtualLineCount();
   }
-  getCachedLogs() {
-    return terminalConsoleCache.cachedLogs.map((logEntry) => logEntry[0].toISOString() + " " + logEntry.slice(1).join(" ")).join(`
-`);
+  get scrollY() {
+    return this.editorView.getViewport().offsetY;
   }
-  updateFrameBuffer() {
-    if (!this.frameBuffer)
+  get plainText() {
+    return this.editBuffer.getText();
+  }
+  get logicalCursor() {
+    return this.editBuffer.getCursorPosition();
+  }
+  get visualCursor() {
+    return this.editorView.getVisualCursor();
+  }
+  get cursorOffset() {
+    return this.editorView.getVisualCursor().offset;
+  }
+  set cursorOffset(offset) {
+    this.editorView.setCursorByOffset(offset);
+    this.requestRender();
+  }
+  get cursorCharacterOffset() {
+    const len = this.plainText.length;
+    if (len <= 0)
       return;
-    this.frameBuffer.clear(this.backgroundColor);
-    const displayLines = this._displayLines;
-    const displayLineCount = displayLines.length;
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    this.frameBuffer.fillRect(0, 0, this.consoleWidth, 1, this._rgbaTitleBar);
-    const dynamicTitle = `${this._title}${this.isFocused ? " (Focused)" : ""}`;
-    const titleX = Math.max(0, Math.floor((this.consoleWidth - dynamicTitle.length) / 2));
-    this.frameBuffer.drawText(dynamicTitle, titleX, 0, this._rgbaTitleBarText, this._rgbaTitleBar);
-    const copyLabel = this.getCopyButtonLabel();
-    const copyButtonX = this.consoleWidth - copyLabel.length - 1;
-    if (copyButtonX >= 0) {
-      const copyButtonEnabled = this.hasSelection();
-      const disabledColor = RGBA.fromInts(100, 100, 100, 255);
-      const copyColor = copyButtonEnabled ? this._rgbaCopyButton : disabledColor;
-      this.frameBuffer.drawText(copyLabel, copyButtonX, 0, copyColor, this._rgbaTitleBar);
-      this._copyButtonBounds = { x: copyButtonX, y: 0, width: copyLabel.length, height: 1 };
-    } else {
-      this._copyButtonBounds = { x: -1, y: -1, width: 0, height: 0 };
+    const cursor = this.logicalCursor;
+    const offset = this.cursorOffset;
+    if (offset >= len) {
+      if (cursor.col > 0)
+        return len - 1;
+      return 0;
     }
-    const startIndex = this.scrollTopIndex;
-    const endIndex = Math.min(startIndex + logAreaHeight, displayLineCount);
-    const visibleDisplayLines = displayLines.slice(startIndex, endIndex);
-    let lineY = 1;
-    for (let i = 0;i < visibleDisplayLines.length; i++) {
-      if (lineY >= this.consoleHeight)
-        break;
-      const displayLine = visibleDisplayLines[i];
-      const absoluteLineIndex = startIndex + i;
-      let levelColor = this._rgbaDefault;
-      switch (displayLine.level) {
-        case "INFO" /* INFO */:
-          levelColor = this._rgbaInfo;
-          break;
-        case "WARN" /* WARN */:
-          levelColor = this._rgbaWarn;
-          break;
-        case "ERROR" /* ERROR */:
-          levelColor = this._rgbaError;
-          break;
-        case "DEBUG" /* DEBUG */:
-          levelColor = this._rgbaDebug;
-          break;
-      }
-      const linePrefix = displayLine.indent ? " ".repeat(INDENT_WIDTH) : "";
-      const textToDraw = displayLine.text;
-      const textAvailableWidth = this.consoleWidth - 1 - (displayLine.indent ? INDENT_WIDTH : 0);
-      const showCursor = this.isFocused && lineY - 1 === this.currentLineIndex;
-      if (showCursor) {
-        this.frameBuffer.drawText(">", 0, lineY, this._rgbaCursor, this.backgroundColor);
-      } else {
-        this.frameBuffer.drawText(" ", 0, lineY, this._rgbaDefault, this.backgroundColor);
-      }
-      const fullText = `${linePrefix}${textToDraw.substring(0, textAvailableWidth)}`;
-      const selectionRange = this.getLineSelectionRange(absoluteLineIndex);
-      if (selectionRange) {
-        const adjustedStart = Math.max(0, selectionRange.start);
-        const adjustedEnd = Math.min(fullText.length, selectionRange.end);
-        if (adjustedStart > 0) {
-          this.frameBuffer.drawText(fullText.substring(0, adjustedStart), 1, lineY, levelColor);
-        }
-        if (adjustedStart < adjustedEnd) {
-          this.frameBuffer.fillRect(1 + adjustedStart, lineY, adjustedEnd - adjustedStart, 1, this._rgbaSelection);
-          this.frameBuffer.drawText(fullText.substring(adjustedStart, adjustedEnd), 1 + adjustedStart, lineY, levelColor, this._rgbaSelection);
-        }
-        if (adjustedEnd < fullText.length) {
-          this.frameBuffer.drawText(fullText.substring(adjustedEnd), 1 + adjustedEnd, lineY, levelColor);
-        }
-      } else {
-        this.frameBuffer.drawText(fullText, 1, lineY, levelColor);
-      }
-      lineY++;
+    if (this.plainText[offset] === `
+` && cursor.col > 0) {
+      return offset - 1;
+    }
+    return offset;
+  }
+  get textColor() {
+    return this._textColor;
+  }
+  set textColor(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.textColor);
+    if (this._textColor !== newColor) {
+      this._textColor = newColor;
+      this.editBuffer.setDefaultFg(newColor);
+      this.requestRender();
     }
   }
-  renderToBuffer(buffer) {
-    if (!this.isVisible || !this.frameBuffer)
+  get selectionBg() {
+    return this._selectionBg;
+  }
+  get traits() {
+    return this._traits;
+  }
+  set traits(value) {
+    if (sameTraits(this._traits, value))
       return;
-    if (this._needsFrameBufferUpdate) {
-      this.updateFrameBuffer();
-      this._needsFrameBufferUpdate = false;
+    const prev = this._traits;
+    this._traits = value;
+    this.emit("traits-changed" /* TRAITS_CHANGED */, value, prev);
+  }
+  set selectionBg(value) {
+    const newColor = value ? parseColor(value) : this._defaultOptions.selectionBg;
+    if (this._selectionBg !== newColor) {
+      this._selectionBg = newColor;
+      this.refreshSelectionStyle();
+      this.requestRender();
     }
-    buffer.drawFrameBuffer(this.consoleX, this.consoleY, this.frameBuffer);
   }
-  setDebugMode(enabled) {
-    this._debugModeEnabled = enabled;
-    terminalConsoleCache.setCollectCallerInfo(enabled);
-    if (this.isVisible) {
-      this.markNeedsRerender();
+  get selectionFg() {
+    return this._selectionFg;
+  }
+  set selectionFg(value) {
+    const newColor = value ? parseColor(value) : this._defaultOptions.selectionFg;
+    if (this._selectionFg !== newColor) {
+      this._selectionFg = newColor;
+      this.refreshSelectionStyle();
+      this.requestRender();
     }
   }
-  toggleDebugMode() {
-    this.setDebugMode(!this._debugModeEnabled);
+  get backgroundColor() {
+    return this._backgroundColor;
   }
-  set keyBindings(bindings) {
-    this._keyBindings = bindings;
-    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, bindings);
-    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
-    this.markNeedsRerender();
+  set backgroundColor(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.backgroundColor);
+    if (this._backgroundColor !== newColor) {
+      this._backgroundColor = newColor;
+      this.editBuffer.setDefaultBg(newColor);
+      this.requestRender();
+    }
   }
-  set keyAliasMap(aliases) {
-    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
-    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, this._keyBindings);
-    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
-    this.markNeedsRerender();
+  get attributes() {
+    return this._defaultAttributes;
   }
-  set onCopySelection(callback) {
-    this.options.onCopySelection = callback;
+  set attributes(value) {
+    if (this._defaultAttributes !== value) {
+      this._defaultAttributes = value;
+      this.editBuffer.setDefaultAttributes(value);
+      this.requestRender();
+    }
   }
-  get onCopySelection() {
-    return this.options.onCopySelection;
+  get wrapMode() {
+    return this._wrapMode;
   }
-  _scrollToBottom(forceCursorToLastLine = false) {
-    const displayLineCount = this._displayLines.length;
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-    this.scrollTopIndex = maxScrollTop;
-    this.isScrolledToBottom = true;
-    const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
-    if (forceCursorToLastLine || this.currentLineIndex >= visibleLineCount) {
-      this.currentLineIndex = Math.max(0, visibleLineCount - 1);
+  set wrapMode(value) {
+    if (this._wrapMode !== value) {
+      this._wrapMode = value;
+      this.editorView.setWrapMode(value);
+      this.yogaNode.markDirty();
+      this.requestRender();
     }
   }
-  _processLogEntry(logEntry) {
-    const [date, level, args, callerInfo] = logEntry;
-    const displayLines = [];
-    const timestamp = this.formatTimestamp(date);
-    const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
-    const prefix = `[${timestamp}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
-    const formattedArgs = this.formatArguments(args);
-    const initialLines = formattedArgs.split(`
-`);
-    for (let i = 0;i < initialLines.length; i++) {
-      const lineText = initialLines[i];
-      const isFirstLineOfEntry = i === 0;
-      const availableWidth = this.consoleWidth - 1 - (isFirstLineOfEntry ? 0 : INDENT_WIDTH);
-      const linePrefix = isFirstLineOfEntry ? prefix : " ".repeat(INDENT_WIDTH);
-      const textToWrap = isFirstLineOfEntry ? linePrefix + lineText : lineText;
-      let currentPos = 0;
-      while (currentPos < textToWrap.length || isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0) {
-        const segment = textToWrap.substring(currentPos, currentPos + availableWidth);
-        const isFirstSegmentOfLine = currentPos === 0;
-        displayLines.push({
-          text: isFirstSegmentOfLine && !isFirstLineOfEntry ? linePrefix + segment : segment,
-          level,
-          indent: !isFirstLineOfEntry || !isFirstSegmentOfLine
-        });
-        currentPos += availableWidth;
-        if (isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0)
-          break;
+  get showCursor() {
+    return this._showCursor;
+  }
+  set showCursor(value) {
+    if (this._showCursor !== value) {
+      this._showCursor = value;
+      if (!value && this._focused) {
+        this._ctx.setCursorPosition(0, 0, false);
       }
+      this.requestRender();
     }
-    return displayLines;
   }
-  _processCachedLogs() {
-    const logsToProcess = [...terminalConsoleCache.cachedLogs];
-    terminalConsoleCache.clearConsole();
-    this._allLogEntries.push(...logsToProcess);
-    if (this._allLogEntries.length > this.options.maxStoredLogs) {
-      this._allLogEntries.splice(0, this._allLogEntries.length - this.options.maxStoredLogs);
+  get cursorColor() {
+    return this._cursorColor;
+  }
+  set cursorColor(value) {
+    const newColor = parseColor(value);
+    if (this._cursorColor !== newColor) {
+      this._cursorColor = newColor;
+      if (this._focused) {
+        this.requestRender();
+      }
     }
-    for (const logEntry of logsToProcess) {
-      const processed = this._processLogEntry(logEntry);
-      this._displayLines.push(...processed);
+  }
+  get cursorStyle() {
+    return this._cursorStyle;
+  }
+  set cursorStyle(style) {
+    const newStyle = style;
+    if (this.cursorStyle.style !== newStyle.style || this.cursorStyle.blinking !== newStyle.blinking) {
+      this._cursorStyle = newStyle;
+      if (this._focused) {
+        this.requestRender();
+      }
     }
-    if (this._displayLines.length > this.options.maxDisplayLines) {
-      this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
+  }
+  get tabIndicator() {
+    return this._tabIndicator;
+  }
+  set tabIndicator(value) {
+    if (this._tabIndicator !== value) {
+      this._tabIndicator = value;
+      if (value !== undefined) {
+        this.editorView.setTabIndicator(value);
+      }
+      this.requestRender();
     }
   }
-  hasSelection() {
-    if (this._selectionStart === null || this._selectionEnd === null)
-      return false;
-    return this._selectionStart.line !== this._selectionEnd.line || this._selectionStart.col !== this._selectionEnd.col;
+  get tabIndicatorColor() {
+    return this._tabIndicatorColor;
   }
-  normalizeSelection() {
-    if (!this._selectionStart || !this._selectionEnd)
-      return null;
-    const start = this._selectionStart;
-    const end = this._selectionEnd;
-    const startBeforeEnd = start.line < end.line || start.line === end.line && start.col <= end.col;
-    if (startBeforeEnd) {
-      return {
-        startLine: start.line,
-        startCol: start.col,
-        endLine: end.line,
-        endCol: end.col
-      };
-    } else {
-      return {
-        startLine: end.line,
-        startCol: end.col,
-        endLine: start.line,
-        endCol: start.col
-      };
+  set tabIndicatorColor(value) {
+    const newColor = value ? parseColor(value) : undefined;
+    if (this._tabIndicatorColor !== newColor) {
+      this._tabIndicatorColor = newColor;
+      if (newColor !== undefined) {
+        this.editorView.setTabIndicatorColor(newColor);
+      }
+      this.requestRender();
     }
   }
-  getSelectedText() {
-    const selection2 = this.normalizeSelection();
-    if (!selection2)
-      return "";
-    const lines = [];
-    for (let i = selection2.startLine;i <= selection2.endLine; i++) {
-      if (i < 0 || i >= this._displayLines.length)
-        continue;
-      const line = this._displayLines[i];
-      const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
-      const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
-      const fullText = linePrefix + line.text.substring(0, textAvailableWidth);
-      let text = fullText;
-      if (i === selection2.startLine && i === selection2.endLine) {
-        text = fullText.substring(selection2.startCol, selection2.endCol);
-      } else if (i === selection2.startLine) {
-        text = fullText.substring(selection2.startCol);
-      } else if (i === selection2.endLine) {
-        text = fullText.substring(0, selection2.endCol);
+  get scrollSpeed() {
+    return this._scrollSpeed;
+  }
+  set scrollSpeed(value) {
+    this._scrollSpeed = Math.max(0, value);
+  }
+  onMouseEvent(event) {
+    if (event.type === "scroll") {
+      this.handleScroll(event);
+    }
+  }
+  handleScroll(event) {
+    if (!event.scroll)
+      return;
+    const { direction, delta } = event.scroll;
+    const viewport = this.editorView.getViewport();
+    if (direction === "up") {
+      const newOffsetY = Math.max(0, viewport.offsetY - delta);
+      this.editorView.setViewport(viewport.offsetX, newOffsetY, viewport.width, viewport.height, true);
+      this.requestRender();
+    } else if (direction === "down") {
+      const totalVirtualLines = this.editorView.getTotalVirtualLineCount();
+      const maxOffsetY = Math.max(0, totalVirtualLines - viewport.height);
+      const newOffsetY = Math.min(viewport.offsetY + delta, maxOffsetY);
+      this.editorView.setViewport(viewport.offsetX, newOffsetY, viewport.width, viewport.height, true);
+      this.requestRender();
+    }
+    if (this._wrapMode === "none") {
+      if (direction === "left") {
+        const newOffsetX = Math.max(0, viewport.offsetX - delta);
+        this.editorView.setViewport(newOffsetX, viewport.offsetY, viewport.width, viewport.height, true);
+        this.requestRender();
+      } else if (direction === "right") {
+        const newOffsetX = viewport.offsetX + delta;
+        this.editorView.setViewport(newOffsetX, viewport.offsetY, viewport.width, viewport.height, true);
+        this.requestRender();
       }
-      lines.push(text);
     }
-    return lines.join(`
-`);
   }
-  clearSelection() {
-    this._selectionStart = null;
-    this._selectionEnd = null;
-    this._isDragging = false;
-    this.stopAutoScroll();
+  onResize(width, height) {
+    this.editorView.setViewportSize(width, height);
   }
-  stopAutoScroll() {
-    if (this._autoScrollInterval !== null) {
-      this.clock.clearInterval(this._autoScrollInterval);
-      this._autoScrollInterval = null;
+  refreshLocalSelection() {
+    if (this.lastLocalSelection) {
+      return this.updateLocalSelection(this.lastLocalSelection);
     }
+    return false;
   }
-  startAutoScroll(direction) {
-    this.stopAutoScroll();
-    this._autoScrollInterval = this.clock.setInterval(() => {
-      if (direction === "up") {
-        if (this.scrollTopIndex > 0) {
-          this.scrollTopIndex--;
-          this.isScrolledToBottom = false;
-          if (this._selectionEnd) {
-            this._selectionEnd = {
-              line: this.scrollTopIndex,
-              col: this._selectionEnd.col
-            };
-          }
-          this.markNeedsRerender();
-        } else {
-          this.stopAutoScroll();
-        }
+  updateLocalSelection(localSelection) {
+    if (!localSelection?.isActive) {
+      this.editorView.resetLocalSelection();
+      return true;
+    }
+    return this.editorView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg, false);
+  }
+  shouldStartSelection(x, y) {
+    if (!this.selectable)
+      return false;
+    const localX = x - this.x;
+    const localY = y - this.y;
+    return localX >= 0 && localX < this.width && localY >= 0 && localY < this.height;
+  }
+  onSelectionChanged(selection2) {
+    const localSelection = convertGlobalToLocalSelection(selection2, this.x, this.y);
+    this.lastLocalSelection = localSelection;
+    const updateCursor = true;
+    const followCursor = this._keyboardSelectionActive;
+    let changed;
+    if (!localSelection?.isActive) {
+      this._keyboardSelectionActive = false;
+      this.editorView.resetLocalSelection();
+      changed = true;
+    } else if (selection2?.isStart) {
+      changed = this.editorView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg, updateCursor, followCursor);
+    } else {
+      changed = this.editorView.updateLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg, updateCursor, followCursor);
+    }
+    if (changed && localSelection?.isActive && selection2?.isDragging) {
+      const viewport = this.editorView.getViewport();
+      const focusY = localSelection.focusY;
+      const scrollMargin = Math.max(1, Math.floor(viewport.height * this._scrollMargin));
+      if (focusY < scrollMargin) {
+        this._autoScrollVelocity = -this._scrollSpeed;
+      } else if (focusY >= viewport.height - scrollMargin) {
+        this._autoScrollVelocity = this._scrollSpeed;
       } else {
-        const displayLineCount = this._displayLines.length;
-        const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-        const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-        if (this.scrollTopIndex < maxScrollTop) {
-          this.scrollTopIndex++;
-          this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-          if (this._selectionEnd) {
-            const maxLine = this.scrollTopIndex + logAreaHeight - 1;
-            this._selectionEnd = {
-              line: Math.min(maxLine, displayLineCount - 1),
-              col: this._selectionEnd.col
-            };
-          }
-          this.markNeedsRerender();
-        } else {
-          this.stopAutoScroll();
+        this._autoScrollVelocity = 0;
+      }
+    } else {
+      this._keyboardSelectionActive = false;
+      this._autoScrollVelocity = 0;
+      this._autoScrollAccumulator = 0;
+    }
+    if (changed) {
+      this.requestRender();
+    }
+    return this.hasSelection();
+  }
+  onUpdate(deltaTime) {
+    super.onUpdate(deltaTime);
+    if (this._autoScrollVelocity !== 0 && this.hasSelection()) {
+      const deltaSeconds = deltaTime / 1000;
+      this._autoScrollAccumulator += this._autoScrollVelocity * deltaSeconds;
+      const linesToScroll = Math.floor(Math.abs(this._autoScrollAccumulator));
+      if (linesToScroll > 0) {
+        const direction = this._autoScrollVelocity > 0 ? 1 : -1;
+        const viewport = this.editorView.getViewport();
+        const totalVirtualLines = this.editorView.getTotalVirtualLineCount();
+        const maxOffsetY = Math.max(0, totalVirtualLines - viewport.height);
+        const newOffsetY = Math.max(0, Math.min(viewport.offsetY + direction * linesToScroll, maxOffsetY));
+        if (newOffsetY !== viewport.offsetY) {
+          this.editorView.setViewport(viewport.offsetX, newOffsetY, viewport.width, viewport.height, false);
+          this._ctx.requestSelectionUpdate();
         }
+        this._autoScrollAccumulator -= direction * linesToScroll;
       }
-    }, 50);
+    }
+  }
+  getSelectedText() {
+    return this.editorView.getSelectedText();
+  }
+  hasSelection() {
+    return this.editorView.hasSelection();
+  }
+  getSelection() {
+    return this.editorView.getSelection();
+  }
+  refreshSelectionStyle() {
+    if (this.lastLocalSelection) {
+      this.updateLocalSelection(this.lastLocalSelection);
+      return;
+    }
+    const selection2 = this.getSelection();
+    if (!selection2)
+      return;
+    this.editorView.setSelection(selection2.start, selection2.end, this._selectionBg, this._selectionFg);
+  }
+  deleteSelectedText() {
+    this.editorView.deleteSelectedText();
+    this._ctx.clearSelection();
+    this.requestRender();
+  }
+  setSelection(start, end) {
+    this.lastLocalSelection = null;
+    this.editorView.resetLocalSelection();
+    this._ctx.clearSelection();
+    this.editorView.setSelection(start, end, this._selectionBg, this._selectionFg);
+    this.requestRender();
+  }
+  setSelectionInclusive(start, end) {
+    this.setSelection(Math.min(start, end), Math.max(start, end) + 1);
+  }
+  clearSelection() {
+    const had = this.hasSelection();
+    this.lastLocalSelection = null;
+    this.editorView.resetSelection();
+    this.editorView.resetLocalSelection();
+    this._ctx.clearSelection();
+    if (had) {
+      this.requestRender();
+    }
+    return had;
+  }
+  deleteSelection() {
+    if (!this.hasSelection())
+      return false;
+    this.lastLocalSelection = null;
+    this.deleteSelectedText();
+    return true;
+  }
+  setCursor(row, col) {
+    this.editBuffer.setCursor(row, col);
+    this.requestRender();
+  }
+  insertChar(char) {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
+    }
+    this.editBuffer.insertChar(char);
+    this.requestRender();
+  }
+  insertText(text) {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
+    }
+    this.editBuffer.insertText(text);
+    this.requestRender();
+  }
+  deleteChar() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
+      return true;
+    }
+    this._ctx.clearSelection();
+    this.editBuffer.deleteChar();
+    this.requestRender();
+    return true;
+  }
+  deleteCharBackward() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
+      return true;
+    }
+    this._ctx.clearSelection();
+    this.editBuffer.deleteCharBackward();
+    this.requestRender();
+    return true;
   }
-  triggerCopy() {
-    if (!this.hasSelection())
-      return;
-    const text = this.getSelectedText();
-    if (text && this.options.onCopySelection) {
-      try {
-        this.options.onCopySelection(text);
-      } catch {}
-      this.clearSelection();
-      this.markNeedsRerender();
+  newLine() {
+    this._ctx.clearSelection();
+    this.editBuffer.newLine();
+    this.requestRender();
+    return true;
+  }
+  deleteLine() {
+    this._ctx.clearSelection();
+    this.editBuffer.deleteLine();
+    this.requestRender();
+    return true;
+  }
+  moveCursorLeft(options) {
+    const select = options?.select ?? false;
+    if (!select && this.hasSelection()) {
+      const selection2 = this.getSelection();
+      this.editBuffer.setCursorByOffset(selection2.start);
+      this._ctx.clearSelection();
+      this.requestRender();
+      return true;
     }
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.moveCursorLeft();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
   }
-  getLineSelectionRange(lineIndex) {
-    const selection2 = this.normalizeSelection();
-    if (!selection2)
-      return null;
-    if (lineIndex < selection2.startLine || lineIndex > selection2.endLine) {
-      return null;
+  moveCursorRight(options) {
+    const select = options?.select ?? false;
+    if (!select && this.hasSelection()) {
+      const selection2 = this.getSelection();
+      const targetOffset = this.cursorOffset === selection2.start ? selection2.end - 1 : selection2.end;
+      this.editBuffer.setCursorByOffset(targetOffset);
+      this._ctx.clearSelection();
+      this.requestRender();
+      return true;
     }
-    const line = this._displayLines[lineIndex];
-    if (!line)
-      return null;
-    const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
-    const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
-    const fullTextLength = linePrefix.length + Math.min(line.text.length, textAvailableWidth);
-    let start = 0;
-    let end = fullTextLength;
-    if (lineIndex === selection2.startLine) {
-      start = Math.max(0, selection2.startCol);
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.moveCursorRight();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  moveCursorUp(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editorView.moveUpVisual();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  moveCursorDown(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editorView.moveDownVisual();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoLine(line) {
+    this.editBuffer.gotoLine(line);
+    this.requestRender();
+  }
+  gotoLineStart() {
+    this.setCursor(this.logicalCursor.row, 0);
+  }
+  gotoLineTextEnd() {
+    const eol = this.editBuffer.getEOL();
+    this.setCursor(eol.row, eol.col);
+  }
+  gotoLineHome(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const cursor = this.editorView.getCursor();
+    if (cursor.col === 0 && cursor.row > 0) {
+      this.editBuffer.setCursor(cursor.row - 1, 0);
+      const prevLineEol = this.editBuffer.getEOL();
+      this.editBuffer.setCursor(prevLineEol.row, prevLineEol.col);
+    } else {
+      this.editBuffer.setCursor(cursor.row, 0);
     }
-    if (lineIndex === selection2.endLine) {
-      end = Math.min(fullTextLength, selection2.endCol);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoLineEnd(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const cursor = this.editorView.getCursor();
+    const eol = this.editBuffer.getEOL();
+    const lineCount = this.editBuffer.getLineCount();
+    if (cursor.col === eol.col && cursor.row < lineCount - 1) {
+      this.editBuffer.setCursor(cursor.row + 1, 0);
+    } else {
+      this.editBuffer.setCursor(eol.row, eol.col);
     }
-    if (start >= end)
-      return null;
-    return { start, end };
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
   }
-  handleMouse(event) {
-    if (!this.isVisible)
-      return false;
-    const localX = event.x - this.consoleX;
-    const localY = event.y - this.consoleY;
-    if (localX < 0 || localX >= this.consoleWidth || localY < 0 || localY >= this.consoleHeight) {
-      return false;
+  gotoVisualLineHome(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const sol = this.editorView.getVisualSOL();
+    this.editBuffer.setCursor(sol.logicalRow, sol.logicalCol);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoVisualLineEnd(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const eol = this.editorView.getVisualEOL();
+    this.editBuffer.setCursor(eol.logicalRow, eol.logicalCol);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoBufferHome(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.setCursor(0, 0);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoBufferEnd(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.gotoLine(999999);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  selectAll() {
+    this.updateSelectionForMovement(false, true);
+    this.editBuffer.setCursor(0, 0);
+    return this.gotoBufferEnd({ select: true });
+  }
+  deleteToLineEnd() {
+    const cursor = this.editorView.getCursor();
+    const eol = this.editBuffer.getEOL();
+    if (eol.col > cursor.col) {
+      this.editBuffer.deleteRange(cursor.row, cursor.col, eol.row, eol.col);
     }
-    if (event.type === "scroll" && event.scroll) {
-      if (event.scroll.direction === "up") {
-        this.scrollUp();
-      } else if (event.scroll.direction === "down") {
-        this.scrollDown();
-      }
-      return true;
+    this.requestRender();
+    return true;
+  }
+  deleteToLineStart() {
+    const cursor = this.editorView.getCursor();
+    if (cursor.col > 0) {
+      this.editBuffer.deleteRange(cursor.row, 0, cursor.row, cursor.col);
     }
-    if (localY === 0) {
-      if (event.type === "down" && event.button === 0 && localX >= this._copyButtonBounds.x && localX < this._copyButtonBounds.x + this._copyButtonBounds.width) {
-        this.triggerCopy();
-        return true;
-      }
+    this.requestRender();
+    return true;
+  }
+  undo() {
+    this._ctx.clearSelection();
+    this.editBuffer.undo();
+    this.requestRender();
+    return true;
+  }
+  redo() {
+    this._ctx.clearSelection();
+    this.editBuffer.redo();
+    this.requestRender();
+    return true;
+  }
+  moveWordForward(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const nextWord = this.editBuffer.getNextWordBoundary();
+    this.editBuffer.setCursorByOffset(nextWord.offset);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  moveWordBackward(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const prevWord = this.editBuffer.getPrevWordBoundary();
+    this.editBuffer.setCursorByOffset(prevWord.offset);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  deleteWordForward() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
       return true;
     }
-    const lineIndex = this.scrollTopIndex + (localY - 1);
-    const colIndex = Math.max(0, localX - 1);
-    if (event.type === "down" && event.button === 0) {
-      this.clearSelection();
-      this._selectionStart = { line: lineIndex, col: colIndex };
-      this._selectionEnd = { line: lineIndex, col: colIndex };
-      this._isDragging = true;
-      this.markNeedsRerender();
+    const currentCursor = this.editBuffer.getCursorPosition();
+    const nextWord = this.editBuffer.getNextWordBoundary();
+    if (nextWord.offset > currentCursor.offset) {
+      this.editBuffer.deleteRange(currentCursor.row, currentCursor.col, nextWord.row, nextWord.col);
+    }
+    this._ctx.clearSelection();
+    this.requestRender();
+    return true;
+  }
+  deleteWordBackward() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
       return true;
     }
-    if (event.type === "drag" && this._isDragging) {
-      this._selectionEnd = { line: lineIndex, col: colIndex };
-      const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-      const relativeY = localY - 1;
-      if (relativeY <= 0) {
-        this.startAutoScroll("up");
-      } else if (relativeY >= logAreaHeight - 1) {
-        this.startAutoScroll("down");
+    const currentCursor = this.editBuffer.getCursorPosition();
+    const prevWord = this.editBuffer.getPrevWordBoundary();
+    if (prevWord.offset < currentCursor.offset) {
+      this.editBuffer.deleteRange(prevWord.row, prevWord.col, currentCursor.row, currentCursor.col);
+    }
+    this._ctx.clearSelection();
+    this.requestRender();
+    return true;
+  }
+  setupMeasureFunc() {
+    const measureFunc = (width, widthMode, height, heightMode) => {
+      let effectiveWidth;
+      if (widthMode === MeasureMode.Undefined || isNaN(width)) {
+        effectiveWidth = 0;
       } else {
-        this.stopAutoScroll();
+        effectiveWidth = width;
       }
-      this.markNeedsRerender();
-      return true;
-    }
-    if (event.type === "up") {
-      if (this._isDragging) {
-        this._selectionEnd = { line: lineIndex, col: colIndex };
-        this._isDragging = false;
-        this.stopAutoScroll();
-        this.markNeedsRerender();
+      const effectiveHeight = isNaN(height) ? 1 : height;
+      const measureResult = this.editorView.measureForDimensions(Math.floor(effectiveWidth), Math.floor(effectiveHeight));
+      const measuredWidth = measureResult ? Math.max(1, measureResult.widthColsMax) : 1;
+      const measuredHeight = measureResult ? Math.max(1, measureResult.lineCount) : 1;
+      if (widthMode === MeasureMode.AtMost && this._positionType !== "absolute") {
+        return {
+          width: Math.min(effectiveWidth, measuredWidth),
+          height: Math.min(effectiveHeight, measuredHeight)
+        };
       }
-      return true;
+      return {
+        width: measuredWidth,
+        height: measuredHeight
+      };
+    };
+    this.yogaNode.setMeasureFunc(measureFunc);
+  }
+  render(buffer, deltaTime) {
+    if (!this.visible)
+      return;
+    if (this.isDestroyed)
+      return;
+    this.markClean();
+    this._ctx.addToHitGrid(this.x, this.y, this.width, this.height, this.num);
+    this.renderSelf(buffer);
+    this.renderCursor(buffer);
+  }
+  renderSelf(buffer) {
+    buffer.drawEditorView(this.editorView, this.x, this.y);
+  }
+  renderCursor(buffer) {
+    if (!this._showCursor || !this._focused)
+      return;
+    const visualCursor = this.editorView.getVisualCursor();
+    const cursorX = this.x + visualCursor.visualCol + 1;
+    const cursorY = this.y + visualCursor.visualRow + 1;
+    this._ctx.setCursorPosition(cursorX, cursorY, true);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
+  }
+  focus() {
+    super.focus();
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
+    this.requestRender();
+  }
+  blur() {
+    super.blur();
+    this._ctx.setCursorPosition(0, 0, false);
+    this.requestRender();
+  }
+  onRemove() {
+    if (this._focused) {
+      this._ctx.setCursorPosition(0, 0, false);
     }
-    return true;
   }
-  get visible() {
-    return this.isVisible;
+  destroy() {
+    if (this.isDestroyed)
+      return;
+    this.traits = {};
+    if (this._focused) {
+      this._ctx.setCursorPosition(0, 0, false);
+      this.blur();
+    }
+    this.editorView.destroy();
+    this.editBuffer.destroy();
+    super.destroy();
   }
-  get bounds() {
-    return {
-      x: this.consoleX,
-      y: this.consoleY,
-      width: this.consoleWidth,
-      height: this.consoleHeight
-    };
+  set onCursorChange(handler) {
+    this._cursorChangeListener = handler;
   }
-  saveLogsToFile() {
-    try {
-      const timestamp = Date.now();
-      const filename = `_console_${timestamp}.log`;
-      const filepath = path5.join(process.cwd(), filename);
-      const allLogEntries = [...this._allLogEntries, ...terminalConsoleCache.cachedLogs];
-      const logLines = [];
-      for (const [date, level, args, callerInfo] of allLogEntries) {
-        const timestampStr = this.formatTimestamp(date);
-        const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
-        const prefix = `[${timestampStr}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
-        const formattedArgs = this.formatArguments(args);
-        logLines.push(prefix + formattedArgs);
+  get onCursorChange() {
+    return this._cursorChangeListener;
+  }
+  set onContentChange(handler) {
+    this._contentChangeListener = handler;
+  }
+  get onContentChange() {
+    return this._contentChangeListener;
+  }
+  get syntaxStyle() {
+    return this.editBuffer.getSyntaxStyle();
+  }
+  set syntaxStyle(style) {
+    this.editBuffer.setSyntaxStyle(style);
+    this.requestRender();
+  }
+  addHighlight(lineIdx, highlight) {
+    this.editBuffer.addHighlight(lineIdx, highlight);
+    this.requestRender();
+  }
+  addHighlightByCharRange(highlight) {
+    this.editBuffer.addHighlightByCharRange(highlight);
+    this.requestRender();
+  }
+  removeHighlightsByRef(hlRef) {
+    this.editBuffer.removeHighlightsByRef(hlRef);
+    this.requestRender();
+  }
+  clearLineHighlights(lineIdx) {
+    this.editBuffer.clearLineHighlights(lineIdx);
+    this.requestRender();
+  }
+  clearAllHighlights() {
+    this.editBuffer.clearAllHighlights();
+    this.requestRender();
+  }
+  getLineHighlights(lineIdx) {
+    return this.editBuffer.getLineHighlights(lineIdx);
+  }
+  setText(text) {
+    this.editBuffer.setText(text);
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  replaceText(text) {
+    this.editBuffer.replaceText(text);
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  clear() {
+    this.editBuffer.clear();
+    this.editBuffer.clearAllHighlights();
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  deleteRange(startLine, startCol, endLine, endCol) {
+    this.editBuffer.deleteRange(startLine, startCol, endLine, endCol);
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  getTextRange(startOffset, endOffset) {
+    return this.editBuffer.getTextRange(startOffset, endOffset);
+  }
+  getTextRangeByCoords(startRow, startCol, endRow, endCol) {
+    return this.editBuffer.getTextRangeByCoords(startRow, startCol, endRow, endCol);
+  }
+  updateSelectionForMovement(shiftPressed, isBeforeMovement) {
+    if (!this.selectable)
+      return;
+    if (!shiftPressed) {
+      this._keyboardSelectionActive = false;
+      this._ctx.clearSelection();
+      return;
+    }
+    this._keyboardSelectionActive = true;
+    const visualCursor = this.editorView.getVisualCursor();
+    const cursorX = this.x + visualCursor.visualCol;
+    const cursorY = this.y + visualCursor.visualRow;
+    if (isBeforeMovement) {
+      if (!this._ctx.hasSelection) {
+        this._ctx.startSelection(this, cursorX, cursorY);
       }
-      const content = logLines.join(`
-`);
-      fs.writeFileSync(filepath, content, "utf8");
-      console.info(`Console logs saved to: ${filename}`);
-    } catch (error) {
-      console.error(`Failed to save console logs:`, error);
+      return;
     }
+    this._ctx.updateSelection(this, cursorX, cursorY, { finishDragging: true });
   }
 }
 
@@ -17102,7 +18525,7 @@ class Clipboard {
 }
 
 // src/renderer.ts
-import { EventEmitter as EventEmitter8 } from "events";
+import { EventEmitter as EventEmitter9 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -17457,6 +18880,7 @@ var CliRenderEvents;
   CliRenderEvents2["RESIZE"] = "resize";
   CliRenderEvents2["FOCUS"] = "focus";
   CliRenderEvents2["BLUR"] = "blur";
+  CliRenderEvents2["FOCUSED_EDITOR"] = "focused_editor";
   CliRenderEvents2["THEME_MODE"] = "theme_mode";
   CliRenderEvents2["CAPABILITIES"] = "capabilities";
   CliRenderEvents2["SELECTION"] = "selection";
@@ -17474,7 +18898,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter8 {
+class CliRenderer extends EventEmitter9 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -17788,6 +19212,13 @@ Captured output:
   get currentFocusedRenderable() {
     return this._currentFocusedRenderable;
   }
+  get currentFocusedEditor() {
+    if (!this._currentFocusedRenderable)
+      return null;
+    if (!isEditBufferRenderable(this._currentFocusedRenderable))
+      return null;
+    return this._currentFocusedRenderable;
+  }
   normalizeClockTime(now, fallback) {
     if (Number.isFinite(now)) {
       return now;
@@ -17803,10 +19234,15 @@ Captured output:
   focusRenderable(renderable) {
     if (this._currentFocusedRenderable === renderable)
       return;
+    const prev = this.currentFocusedEditor;
     if (this._currentFocusedRenderable) {
       this._currentFocusedRenderable.blur();
     }
     this._currentFocusedRenderable = renderable;
+    const next = this.currentFocusedEditor;
+    if (prev !== next) {
+      this.emit("focused_editor" /* FOCUSED_EDITOR */, next, prev);
+    }
   }
   setCapturedRenderable(renderable) {
     if (this.capturedRenderable === renderable) {
@@ -19166,7 +20602,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, 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, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, 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, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, EditBuffer, EditorView, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=AAC1AF32CFE7F73F64756E2164756E21
-//# sourceMappingURL=index-wv534m5j.js.map
+//# debugId=D3013A6779DE950364756E2164756E21
+//# sourceMappingURL=index-vy1rm1x3.js.map