@opentui/core 0.1.30 → 0.1.32

package/{index-0qmm1k4p.js → index-3f9h747j.js}

@@ -1769,10 +1769,10 @@ import { Buffer as Buffer2 } from "buffer";
 var kittyKeyMap = {
   27: "escape",
   9: "tab",
-  13: "enter",
+  13: "return",
   127: "backspace",
   57344: "escape",
-  57345: "enter",
+  57345: "return",
   57346: "tab",
   57347: "backspace",
   57348: "insert",
@@ -1896,6 +1896,7 @@ function parseKittyKeyboard(sequence) {
     sequence,
     raw: sequence,
     eventType: "press",
+    source: "kitty",
     super: false,
     hyper: false,
     capsLock: false,
@@ -2092,6 +2093,12 @@ var parseKeypress = (s = "", options = {}) => {
   } else if (!s) {
     s = "";
   }
+  if (/^\x1b\[<\d+;\d+;\d+[Mm]$/.test(s)) {
+    return null;
+  }
+  if (s.startsWith("\x1B[M") && s.length >= 6) {
+    return null;
+  }
   const key = {
     name: "",
     ctrl: false,
@@ -2101,20 +2108,24 @@ var parseKeypress = (s = "", options = {}) => {
     number: false,
     sequence: s,
     raw: s,
-    eventType: "press"
+    eventType: "press",
+    source: "raw"
   };
   key.sequence = key.sequence || s || key.name;
-  if (options.useKittyKeyboard && /^\x1b\[.*u$/.test(s)) {
+  if (options.useKittyKeyboard) {
     const kittyResult = parseKittyKeyboard(s);
     if (kittyResult) {
       return kittyResult;
     }
   }
-  if (s === "\r") {
+  if (s === "\r" || s === "\x1B\r") {
     key.name = "return";
+    key.meta = s.length === 2;
   } else if (s === `
+` || s === `\x1B
 `) {
-    key.name = "enter";
+    key.name = "linefeed";
+    key.meta = s.length === 2;
   } else if (s === "\t") {
     key.name = "tab";
   } else if (s === "\b" || s === "\x1B\b" || s === "\x7F" || s === "\x1B\x7F") {
@@ -2126,6 +2137,9 @@ var parseKeypress = (s = "", options = {}) => {
   } else if (s === " " || s === "\x1B ") {
     key.name = "space";
     key.meta = s.length === 2;
+  } else if (s === "\x00") {
+    key.name = "space";
+    key.ctrl = true;
   } else if (s.length === 1 && s <= "\x1A") {
     key.name = String.fromCharCode(s.charCodeAt(0) + 97 - 1);
     key.ctrl = true;
@@ -2176,8 +2190,184 @@ var parseKeypress = (s = "", options = {}) => {
   return key;
 };
 
-// src/lib/KeyHandler.ts
+// src/lib/stdin-buffer.ts
 import { EventEmitter } from "events";
+var ESC = "\x1B";
+function isCompleteSequence(data) {
+  if (!data.startsWith(ESC)) {
+    return "not-escape";
+  }
+  if (data.length === 1) {
+    return "incomplete";
+  }
+  const afterEsc = data.slice(1);
+  if (afterEsc.startsWith("[")) {
+    if (afterEsc.startsWith("[M")) {
+      return data.length >= 6 ? "complete" : "incomplete";
+    }
+    return isCompleteCsiSequence(data);
+  }
+  if (afterEsc.startsWith("]")) {
+    return isCompleteOscSequence(data);
+  }
+  if (afterEsc.startsWith("O")) {
+    return afterEsc.length >= 2 ? "complete" : "incomplete";
+  }
+  if (afterEsc.length === 1) {
+    return "complete";
+  }
+  return "complete";
+}
+function isCompleteCsiSequence(data) {
+  if (!data.startsWith(ESC + "[")) {
+    return "complete";
+  }
+  if (data.length < 3) {
+    return "incomplete";
+  }
+  const payload = data.slice(2);
+  const lastChar = payload[payload.length - 1];
+  const lastCharCode = lastChar.charCodeAt(0);
+  if (lastCharCode >= 64 && lastCharCode <= 126) {
+    if (payload.startsWith("<")) {
+      const mouseMatch = /^<\d+;\d+;\d+[Mm]$/.test(payload);
+      if (mouseMatch) {
+        return "complete";
+      }
+      if (lastChar === "M" || lastChar === "m") {
+        const parts = payload.slice(1, -1).split(";");
+        if (parts.length === 3 && parts.every((p) => /^\d+$/.test(p))) {
+          return "complete";
+        }
+      }
+      return "incomplete";
+    }
+    return "complete";
+  }
+  return "incomplete";
+}
+function isCompleteOscSequence(data) {
+  if (!data.startsWith(ESC + "]")) {
+    return "complete";
+  }
+  if (data.endsWith(ESC + "\\") || data.endsWith("\x07")) {
+    return "complete";
+  }
+  return "incomplete";
+}
+function extractCompleteSequences(buffer) {
+  const sequences = [];
+  let pos = 0;
+  while (pos < buffer.length) {
+    const remaining = buffer.slice(pos);
+    if (remaining.startsWith(ESC)) {
+      let seqEnd = 1;
+      while (seqEnd <= remaining.length) {
+        const candidate = remaining.slice(0, seqEnd);
+        const status = isCompleteSequence(candidate);
+        if (status === "complete") {
+          sequences.push(candidate);
+          pos += seqEnd;
+          break;
+        } else if (status === "incomplete") {
+          seqEnd++;
+        } else {
+          sequences.push(candidate);
+          pos += seqEnd;
+          break;
+        }
+      }
+      if (seqEnd > remaining.length) {
+        return { sequences, remainder: remaining };
+      }
+    } else {
+      sequences.push(remaining[0]);
+      pos++;
+    }
+  }
+  return { sequences, remainder: "" };
+}
+
+class StdinBuffer extends EventEmitter {
+  buffer = "";
+  timeout = null;
+  timeoutMs;
+  stdin;
+  stdinListener;
+  constructor(stdin, options = {}) {
+    super();
+    this.stdin = stdin;
+    this.timeoutMs = options.timeout ?? 10;
+    this.stdinListener = (data) => {
+      this.handleData(data);
+    };
+    this.stdin.on("data", this.stdinListener);
+  }
+  handleData(data) {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    let str;
+    if (Buffer.isBuffer(data)) {
+      if (data.length === 1 && data[0] > 127) {
+        const byte = data[0] - 128;
+        str = "\x1B" + String.fromCharCode(byte);
+      } else {
+        str = data.toString();
+      }
+    } else {
+      str = data;
+    }
+    if (str.length === 0 && this.buffer.length === 0) {
+      this.emit("data", "");
+      return;
+    }
+    this.buffer += str;
+    const result = extractCompleteSequences(this.buffer);
+    this.buffer = result.remainder;
+    for (const sequence of result.sequences) {
+      this.emit("data", sequence);
+    }
+    if (this.buffer.length > 0) {
+      this.timeout = setTimeout(() => {
+        const flushed = this.flush();
+        for (const sequence of flushed) {
+          this.emit("data", sequence);
+        }
+      }, this.timeoutMs);
+    }
+  }
+  flush() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    if (this.buffer.length === 0) {
+      return [];
+    }
+    const sequences = [this.buffer];
+    this.buffer = "";
+    return sequences;
+  }
+  clear() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    this.buffer = "";
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  destroy() {
+    this.stdin.removeListener("data", this.stdinListener);
+    this.clear();
+  }
+}
+
+// src/lib/KeyHandler.ts
+import { EventEmitter as EventEmitter2 } from "events";
 
 // src/ansi.ts
 var ANSI = {
@@ -2205,6 +2395,7 @@ class KeyEvent {
   number;
   raw;
   eventType;
+  source;
   code;
   super;
   hyper;
@@ -2222,6 +2413,7 @@ class KeyEvent {
     this.number = key.number;
     this.raw = key.raw;
     this.eventType = key.eventType;
+    this.source = key.source;
     this.code = key.code;
     this.super = key.super;
     this.hyper = key.hyper;
@@ -2251,62 +2443,70 @@ class PasteEvent {
   }
 }
 
-class KeyHandler extends EventEmitter {
+class KeyHandler extends EventEmitter2 {
   stdin;
   useKittyKeyboard;
-  listener;
   pasteMode = false;
   pasteBuffer = [];
   suspended = false;
+  stdinBuffer;
+  dataListener;
   constructor(stdin, useKittyKeyboard = false) {
     super();
     this.stdin = stdin || process.stdin;
     this.useKittyKeyboard = useKittyKeyboard;
-    this.listener = (key) => {
-      let data = key.toString();
-      if (data.startsWith(ANSI.bracketedPasteStart)) {
-        this.pasteMode = true;
-      }
-      if (this.pasteMode) {
-        this.pasteBuffer.push(Bun.stripANSI(data));
-        if (data.endsWith(ANSI.bracketedPasteEnd)) {
-          this.pasteMode = false;
-          this.emit("paste", new PasteEvent(this.pasteBuffer.join("")));
-          this.pasteBuffer = [];
-        }
-        return;
-      }
-      const parsedKey = parseKeypress(key, { useKittyKeyboard: this.useKittyKeyboard });
-      switch (parsedKey.eventType) {
-        case "press":
-          this.emit("keypress", new KeyEvent(parsedKey));
-          break;
-        case "repeat":
-          this.emit("keyrepeat", new KeyEvent(parsedKey));
-          break;
-        case "release":
-          this.emit("keyrelease", new KeyEvent(parsedKey));
-          break;
-        default:
-          this.emit("keypress", new KeyEvent(parsedKey));
-          break;
-      }
+    this.stdinBuffer = new StdinBuffer(this.stdin, { timeout: 5 });
+    this.dataListener = (sequence) => {
+      this.processSequence(sequence);
     };
-    this.stdin.on("data", this.listener);
+    this.stdinBuffer.on("data", this.dataListener);
+  }
+  processSequence(data) {
+    if (data.startsWith(ANSI.bracketedPasteStart)) {
+      this.pasteMode = true;
+    }
+    if (this.pasteMode) {
+      this.pasteBuffer.push(Bun.stripANSI(data));
+      if (data.endsWith(ANSI.bracketedPasteEnd)) {
+        this.pasteMode = false;
+        this.emit("paste", new PasteEvent(this.pasteBuffer.join("")));
+        this.pasteBuffer = [];
+      }
+      return;
+    }
+    const parsedKey = parseKeypress(data, { useKittyKeyboard: this.useKittyKeyboard });
+    if (!parsedKey) {
+      return;
+    }
+    switch (parsedKey.eventType) {
+      case "press":
+        this.emit("keypress", new KeyEvent(parsedKey));
+        break;
+      case "repeat":
+        this.emit("keyrepeat", new KeyEvent(parsedKey));
+        break;
+      case "release":
+        this.emit("keyrelease", new KeyEvent(parsedKey));
+        break;
+      default:
+        this.emit("keypress", new KeyEvent(parsedKey));
+        break;
+    }
   }
   destroy() {
-    this.stdin.removeListener("data", this.listener);
+    this.stdinBuffer.removeListener("data", this.dataListener);
+    this.stdinBuffer.destroy();
   }
   suspend() {
     if (!this.suspended) {
       this.suspended = true;
-      this.stdin.removeListener("data", this.listener);
+      this.stdinBuffer.removeListener("data", this.dataListener);
     }
   }
   resume() {
     if (this.suspended) {
       this.suspended = false;
-      this.stdin.on("data", this.listener);
+      this.stdinBuffer.on("data", this.dataListener);
     }
   }
 }
@@ -5100,19 +5300,141 @@ var env = new Proxy({}, {
 });
 
 // src/lib/tree-sitter-styled-text.ts
-function treeSitterToTextChunks(content, highlights, syntaxStyle) {
+registerEnvVar({ name: "OTUI_TS_STYLE_WARN", default: false, description: "Enable warnings for missing syntax styles" });
+function getSpecificity(group) {
+  return group.split(".").length;
+}
+function shouldSuppressInInjection(group, meta) {
+  if (meta?.isInjection) {
+    return false;
+  }
+  return group === "markup.raw.block";
+}
+function treeSitterToTextChunks(content, highlights, syntaxStyle, options) {
   const chunks = [];
   const defaultStyle = syntaxStyle.getStyle("default");
-  let currentIndex = 0;
+  const concealEnabled = options?.enabled ?? true;
+  const injectionContainerRanges = [];
+  const boundaries = [];
   for (let i = 0;i < highlights.length; i++) {
-    const [startIndex, endIndex, group] = highlights[i];
-    if (startIndex < currentIndex)
+    const [start, end, , meta] = highlights[i];
+    if (start === end)
       continue;
-    if (currentIndex < startIndex) {
-      const text2 = content.slice(currentIndex, startIndex);
+    if (meta?.containsInjection) {
+      injectionContainerRanges.push({ start, end });
+    }
+    boundaries.push({ offset: start, type: "start", highlightIndex: i });
+    boundaries.push({ offset: end, type: "end", highlightIndex: i });
+  }
+  boundaries.sort((a, b) => {
+    if (a.offset !== b.offset)
+      return a.offset - b.offset;
+    if (a.type === "end" && b.type === "start")
+      return -1;
+    if (a.type === "start" && b.type === "end")
+      return 1;
+    return 0;
+  });
+  const activeHighlights = new Set;
+  let currentOffset = 0;
+  for (let i = 0;i < boundaries.length; i++) {
+    const boundary = boundaries[i];
+    if (currentOffset < boundary.offset && activeHighlights.size > 0) {
+      const segmentText = content.slice(currentOffset, boundary.offset);
+      const activeGroups = [];
+      for (const idx of activeHighlights) {
+        const [, , group, meta] = highlights[idx];
+        activeGroups.push({ group, meta, index: idx });
+      }
+      const concealHighlight = concealEnabled ? activeGroups.find((h) => h.meta?.conceal !== undefined || h.group === "conceal" || h.group.startsWith("conceal.")) : undefined;
+      if (concealHighlight) {
+        let replacementText = "";
+        if (concealHighlight.meta?.conceal !== undefined) {
+          replacementText = concealHighlight.meta.conceal;
+        } else if (concealHighlight.group === "conceal.with.space") {
+          replacementText = " ";
+        }
+        if (replacementText) {
+          chunks.push({
+            __isChunk: true,
+            text: replacementText,
+            fg: defaultStyle?.fg,
+            bg: defaultStyle?.bg,
+            attributes: defaultStyle ? createTextAttributes({
+              bold: defaultStyle.bold,
+              italic: defaultStyle.italic,
+              underline: defaultStyle.underline,
+              dim: defaultStyle.dim
+            }) : 0
+          });
+        }
+      } else {
+        const insideInjectionContainer = injectionContainerRanges.some((range) => currentOffset >= range.start && currentOffset < range.end);
+        const validGroups = activeGroups.filter((h) => {
+          if (insideInjectionContainer && shouldSuppressInInjection(h.group, h.meta)) {
+            return false;
+          }
+          return true;
+        });
+        const sortedGroups = validGroups.sort((a, b) => {
+          const aSpec = getSpecificity(a.group);
+          const bSpec = getSpecificity(b.group);
+          if (aSpec !== bSpec)
+            return aSpec - bSpec;
+          return a.index - b.index;
+        });
+        const mergedStyle = {};
+        for (const { group } of sortedGroups) {
+          let styleForGroup = syntaxStyle.getStyle(group);
+          if (!styleForGroup && group.includes(".")) {
+            const baseName = group.split(".")[0];
+            styleForGroup = syntaxStyle.getStyle(baseName);
+          }
+          if (styleForGroup) {
+            if (styleForGroup.fg !== undefined)
+              mergedStyle.fg = styleForGroup.fg;
+            if (styleForGroup.bg !== undefined)
+              mergedStyle.bg = styleForGroup.bg;
+            if (styleForGroup.bold !== undefined)
+              mergedStyle.bold = styleForGroup.bold;
+            if (styleForGroup.italic !== undefined)
+              mergedStyle.italic = styleForGroup.italic;
+            if (styleForGroup.underline !== undefined)
+              mergedStyle.underline = styleForGroup.underline;
+            if (styleForGroup.dim !== undefined)
+              mergedStyle.dim = styleForGroup.dim;
+          } else {
+            if (group.includes(".")) {
+              const baseName = group.split(".")[0];
+              if (env.OTUI_TS_STYLE_WARN) {
+                console.warn(`Syntax style not found for group "${group}" or base scope "${baseName}", using default style`);
+              }
+            } else {
+              if (env.OTUI_TS_STYLE_WARN) {
+                console.warn(`Syntax style not found for group "${group}", using default style`);
+              }
+            }
+          }
+        }
+        const finalStyle = Object.keys(mergedStyle).length > 0 ? mergedStyle : defaultStyle;
+        chunks.push({
+          __isChunk: true,
+          text: segmentText,
+          fg: finalStyle?.fg,
+          bg: finalStyle?.bg,
+          attributes: finalStyle ? createTextAttributes({
+            bold: finalStyle.bold,
+            italic: finalStyle.italic,
+            underline: finalStyle.underline,
+            dim: finalStyle.dim
+          }) : 0
+        });
+      }
+    } else if (currentOffset < boundary.offset) {
+      const text = content.slice(currentOffset, boundary.offset);
       chunks.push({
         __isChunk: true,
-        text: text2,
+        text,
         fg: defaultStyle?.fg,
         bg: defaultStyle?.bg,
         attributes: defaultStyle ? createTextAttributes({
@@ -5122,37 +5444,39 @@ function treeSitterToTextChunks(content, highlights, syntaxStyle) {
           dim: defaultStyle.dim
         }) : 0
       });
-      currentIndex = startIndex;
     }
-    let resolvedStyle = syntaxStyle.getStyle(group);
-    let j = i + 1;
-    while (j < highlights.length && highlights[j][0] === startIndex) {
-      const [, , nextGroup] = highlights[j];
-      const nextStyle = syntaxStyle.getStyle(nextGroup);
-      if (nextStyle) {
-        resolvedStyle = nextStyle;
+    if (boundary.type === "start") {
+      activeHighlights.add(boundary.highlightIndex);
+    } else {
+      activeHighlights.delete(boundary.highlightIndex);
+      if (concealEnabled) {
+        const [, , group, meta] = highlights[boundary.highlightIndex];
+        if (meta?.concealLines !== undefined) {
+          if (boundary.offset < content.length && content[boundary.offset] === `
+`) {
+            currentOffset = boundary.offset + 1;
+            continue;
+          }
+        }
+        if (meta?.conceal !== undefined) {
+          if (meta.conceal === " ") {
+            if (boundary.offset < content.length && content[boundary.offset] === " ") {
+              currentOffset = boundary.offset + 1;
+              continue;
+            }
+          } else if (meta.conceal === "" && group === "conceal" && !meta.isInjection) {
+            if (boundary.offset < content.length && content[boundary.offset] === " ") {
+              currentOffset = boundary.offset + 1;
+              continue;
+            }
+          }
+        }
       }
-      j++;
     }
-    i = j - 1;
-    const text = content.slice(startIndex, endIndex);
-    const styleToUse = resolvedStyle || defaultStyle;
-    chunks.push({
-      __isChunk: true,
-      text,
-      fg: styleToUse?.fg,
-      bg: styleToUse?.bg,
-      attributes: styleToUse ? createTextAttributes({
-        bold: styleToUse.bold,
-        italic: styleToUse.italic,
-        underline: styleToUse.underline,
-        dim: styleToUse.dim
-      }) : 0
-    });
-    currentIndex = endIndex;
+    currentOffset = boundary.offset;
   }
-  if (currentIndex < content.length) {
-    const text = content.slice(currentIndex);
+  if (currentOffset < content.length) {
+    const text = content.slice(currentOffset);
     chunks.push({
       __isChunk: true,
       text,
@@ -5168,10 +5492,10 @@ function treeSitterToTextChunks(content, highlights, syntaxStyle) {
   }
   return chunks;
 }
-async function treeSitterToStyledText(content, filetype, syntaxStyle, client) {
+async function treeSitterToStyledText(content, filetype, syntaxStyle, client, options) {
   const result = await client.highlightOnce(content, filetype);
   if (result.highlights && result.highlights.length > 0) {
-    const chunks = treeSitterToTextChunks(content, result.highlights, syntaxStyle);
+    const chunks = treeSitterToTextChunks(content, result.highlights, syntaxStyle, options?.conceal);
     return new StyledText(chunks);
   } else {
     const defaultStyle = syntaxStyle.mergeStyles("default");
@@ -5189,7 +5513,7 @@ async function treeSitterToStyledText(content, filetype, syntaxStyle, client) {
 }
 
 // src/lib/tree-sitter/client.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 
 // src/lib/debounce.ts
 var TIMERS_MAP = new Map;
@@ -5302,6 +5626,11 @@ import javascript_highlights from "./assets/javascript/highlights.scm" with { ty
 import javascript_language from "./assets/javascript/tree-sitter-javascript.wasm" with { type: "file" };
 import typescript_highlights from "./assets/typescript/highlights.scm" with { type: "file" };
 import typescript_language from "./assets/typescript/tree-sitter-typescript.wasm" with { type: "file" };
+import markdown_highlights from "./assets/markdown/highlights.scm" with { type: "file" };
+import markdown_language from "./assets/markdown/tree-sitter-markdown.wasm" with { type: "file" };
+import markdown_injections from "./assets/markdown/injections.scm" with { type: "file" };
+import markdown_inline_highlights from "./assets/markdown_inline/highlights.scm" with { type: "file" };
+import markdown_inline_language from "./assets/markdown_inline/tree-sitter-markdown_inline.wasm" with { type: "file" };
 var _cachedParsers;
 function getParsers() {
   if (!_cachedParsers) {
@@ -5319,6 +5648,35 @@ function getParsers() {
           highlights: [resolve(dirname(fileURLToPath(import.meta.url)), typescript_highlights)]
         },
         wasm: resolve(dirname(fileURLToPath(import.meta.url)), typescript_language)
+      },
+      {
+        filetype: "markdown",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_highlights)],
+          injections: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_injections)]
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), markdown_language),
+        injectionMapping: {
+          nodeTypes: {
+            inline: "markdown_inline",
+            pipe_table_cell: "markdown_inline"
+          },
+          infoStringMap: {
+            javascript: "javascript",
+            js: "javascript",
+            typescript: "typescript",
+            ts: "typescript",
+            markdown: "markdown",
+            md: "markdown"
+          }
+        }
+      },
+      {
+        filetype: "markdown_inline",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_highlights)]
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_language)
       }
     ];
   }
@@ -5348,7 +5706,7 @@ function addDefaultParsers(parsers) {
 }
 var isUrl = (path) => path.startsWith("http://") || path.startsWith("https://");
 
-class TreeSitterClient extends EventEmitter2 {
+class TreeSitterClient extends EventEmitter3 {
   initialized = false;
   worker;
   buffers = new Map;
@@ -5463,7 +5821,8 @@ class TreeSitterClient extends EventEmitter2 {
       ...filetypeParser,
       wasm: this.resolvePath(filetypeParser.wasm),
       queries: {
-        highlights: filetypeParser.queries.highlights.map((path) => this.resolvePath(path))
+        highlights: filetypeParser.queries.highlights.map((path) => this.resolvePath(path)),
+        injections: filetypeParser.queries.injections?.map((path) => this.resolvePath(path))
       }
     };
     this.worker?.postMessage({ type: "ADD_FILETYPE_PARSER", filetypeParser: resolvedParser });
@@ -5569,6 +5928,14 @@ class TreeSitterClient extends EventEmitter2 {
       }
       return;
     }
+    if (type === "CLEAR_CACHE_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ error });
+      }
+      return;
+    }
     if (warning) {
       this.emitWarning(warning, bufferId);
       return;
@@ -5582,9 +5949,11 @@ class TreeSitterClient extends EventEmitter2 {
       const message = data.join(" ");
       this.emit("worker:log", logType, message);
       if (logType === "log") {
-        console.log("Worker stdout:", ...data);
+        console.log("TSWorker:", ...data);
       } else if (logType === "error") {
-        console.error("Worker stderr:", ...data);
+        console.error("TSWorker:", ...data);
+      } else if (logType === "warn") {
+        console.warn("TSWorker:", ...data);
       }
       return;
     }
@@ -5764,12 +6133,31 @@ class TreeSitterClient extends EventEmitter2 {
       });
     }
   }
+  async clearCache() {
+    if (!this.initialized || !this.worker) {
+      throw new Error("Cannot clear cache: client is not initialized");
+    }
+    const messageId = `clear_cache_${this.messageIdCounter++}`;
+    return new Promise((resolve3, reject) => {
+      this.messageCallbacks.set(messageId, (response) => {
+        if (response.error) {
+          reject(new Error(response.error));
+        } else {
+          resolve3();
+        }
+      });
+      this.worker.postMessage({
+        type: "CLEAR_CACHE",
+        messageId
+      });
+    });
+  }
 }
 
 // src/lib/data-paths.ts
 import os from "os";
 import path from "path";
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/lib/validate-dir-name.ts
 function isValidDirectoryName(name) {
@@ -5833,7 +6221,7 @@ registerEnvVar({
   default: ""
 });
 
-class DataPathsManager extends EventEmitter3 {
+class DataPathsManager extends EventEmitter4 {
   _appName;
   _globalConfigPath;
   _globalConfigFile;
@@ -5917,6 +6305,24 @@ function extToFiletype(extension) {
     ["rs", "rust"],
     ["c", "c"],
     ["cpp", "cpp"],
+    ["c++", "cpp"],
+    ["cs", "csharp"],
+    ["java", "java"],
+    ["kt", "kotlin"],
+    ["swift", "swift"],
+    ["php", "php"],
+    ["sql", "sql"],
+    ["pl", "perl"],
+    ["lua", "lua"],
+    ["erl", "erlang"],
+    ["exs", "elixir"],
+    ["ex", "elixir"],
+    ["elm", "elm"],
+    ["fsharp", "fsharp"],
+    ["fs", "fsharp"],
+    ["fsx", "fsharp"],
+    ["fsscript", "fsharp"],
+    ["fsi", "fsharp"],
     ["h", "c"],
     ["hpp", "cpp"],
     ["html", "html"],
@@ -6059,17 +6465,35 @@ class DownloadUtils {
 }
 
 // src/lib/tree-sitter/assets/update.ts
+import { readdir } from "fs/promises";
 var __dirname = "/Users/runner/work/opentui/opentui/packages/core/src/lib/tree-sitter/assets";
 function getDefaultOptions() {
   return {
-    configPath: path3.resolve(__dirname, "../parsers-config.json"),
+    configPath: path3.resolve(__dirname, "../parsers-config"),
     assetsDir: path3.resolve(__dirname),
     outputPath: path3.resolve(__dirname, "../default-parsers.ts")
   };
 }
 async function loadConfig(configPath) {
-  const configContent = await readFile(configPath, "utf-8");
-  return JSON.parse(configContent);
+  let ext = path3.extname(configPath);
+  let resolvedConfigPath = configPath;
+  if (ext === "") {
+    const files = await readdir(path3.dirname(configPath));
+    const file = files.find((file2) => file2.startsWith(path3.basename(configPath)) && (file2.endsWith(".json") || file2.endsWith(".ts") || file2.endsWith(".js")));
+    if (!file) {
+      throw new Error(`No config file found for ${configPath}`);
+    }
+    resolvedConfigPath = path3.join(path3.dirname(configPath), file);
+    ext = path3.extname(resolvedConfigPath);
+  }
+  if (ext === ".json") {
+    const configContent = await readFile(resolvedConfigPath, "utf-8");
+    return JSON.parse(configContent);
+  } else if (ext === ".ts" || ext === ".js") {
+    const { default: configContent } = await import(resolvedConfigPath);
+    return configContent;
+  }
+  throw new Error(`Unsupported config file extension: ${ext}`);
 }
 async function downloadLanguage(filetype, languageUrl, assetsDir, outputPath) {
   const languageDir = path3.join(assetsDir, filetype);
@@ -6081,53 +6505,85 @@ async function downloadLanguage(filetype, languageUrl, assetsDir, outputPath) {
   }
   return "./" + path3.relative(path3.dirname(outputPath), languagePath);
 }
-async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputPath) {
+async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputPath, queryType, configPath) {
   const queriesDir = path3.join(assetsDir, filetype);
-  const highlightsPath = path3.join(queriesDir, "highlights.scm");
+  const queryPath = path3.join(queriesDir, `${queryType}.scm`);
   const queryContents = [];
   for (let i = 0;i < queryUrls.length; i++) {
     const queryUrl = queryUrls[i];
-    console.log(`    Downloading query ${i + 1}/${queryUrls.length}: ${queryUrl}`);
-    try {
-      const response = await fetch(queryUrl);
-      if (!response.ok) {
-        console.warn(`Failed to download query from ${queryUrl}: ${response.statusText}`);
+    if (queryUrl.startsWith("./")) {
+      console.log(`    Using local query ${i + 1}/${queryUrls.length}: ${queryUrl}`);
+      try {
+        const localPath = path3.resolve(path3.dirname(configPath), queryUrl);
+        const content = await readFile(localPath, "utf-8");
+        if (content.trim()) {
+          queryContents.push(content);
+          console.log(`    \u2713 Loaded ${content.split(`
+`).length} lines from local file`);
+        }
+      } catch (error) {
+        console.warn(`Failed to read local query from ${queryUrl}: ${error}`);
         continue;
       }
-      const content = await response.text();
-      if (content.trim()) {
-        queryContents.push(`; Query from: ${queryUrl}
+    } else {
+      console.log(`    Downloading query ${i + 1}/${queryUrls.length}: ${queryUrl}`);
+      try {
+        const response = await fetch(queryUrl);
+        if (!response.ok) {
+          console.warn(`Failed to download query from ${queryUrl}: ${response.statusText}`);
+          continue;
+        }
+        const content = await response.text();
+        if (content.trim()) {
+          queryContents.push(`; Query from: ${queryUrl}
 ${content}`);
-        console.log(`    \u2713 Downloaded ${content.split(`
+          console.log(`    \u2713 Downloaded ${content.split(`
 `).length} lines`);
+        }
+      } catch (error) {
+        console.warn(`Failed to download query from ${queryUrl}: ${error}`);
+        continue;
       }
-    } catch (error) {
-      console.warn(`Failed to download query from ${queryUrl}: ${error}`);
-      continue;
     }
   }
   const combinedContent = queryContents.join(`
 
 `);
-  await writeFile2(highlightsPath, combinedContent, "utf-8");
-  console.log(`  Combined ${queryContents.length} queries into ${highlightsPath}`);
-  return "./" + path3.relative(path3.dirname(outputPath), highlightsPath);
+  await writeFile2(queryPath, combinedContent, "utf-8");
+  console.log(`  Combined ${queryContents.length} queries into ${queryPath}`);
+  return "./" + path3.relative(path3.dirname(outputPath), queryPath);
 }
 async function generateDefaultParsersFile(parsers, outputPath) {
   const imports = parsers.map((parser) => {
     const safeFiletype = parser.filetype.replace(/[^a-zA-Z0-9]/g, "_");
-    return `import ${safeFiletype}_highlights from "${parser.highlightsPath}" with { type: "file" }
-import ${safeFiletype}_language from "${parser.languagePath}" with { type: "file" }`;
+    const lines = [
+      `import ${safeFiletype}_highlights from "${parser.highlightsPath}" with { type: "file" }`,
+      `import ${safeFiletype}_language from "${parser.languagePath}" with { type: "file" }`
+    ];
+    if (parser.injectionsPath) {
+      lines.push(`import ${safeFiletype}_injections from "${parser.injectionsPath}" with { type: "file" }`);
+    }
+    return lines.join(`
+`);
   }).join(`
 `);
   const parserDefinitions = parsers.map((parser) => {
     const safeFiletype = parser.filetype.replace(/[^a-zA-Z0-9]/g, "_");
+    const queriesLines = [
+      `          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_highlights)],`
+    ];
+    if (parser.injectionsPath) {
+      queriesLines.push(`          injections: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_injections)],`);
+    }
+    const injectionMappingLine = parser.injectionMapping ? `        injectionMapping: ${JSON.stringify(parser.injectionMapping, null, 10)},` : "";
     return `      {
         filetype: "${parser.filetype}",
         queries: {
-          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_highlights)],
+${queriesLines.join(`
+`)}
         },
-        wasm: resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_language),
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_language),${injectionMappingLine ? `
+` + injectionMappingLine : ""}
       }`;
   }).join(`,
 `);
@@ -6172,11 +6628,18 @@ async function main(options) {
       console.log(`  Downloading language...`);
       const languagePath = await downloadLanguage(parser.filetype, parser.wasm, opts.assetsDir, opts.outputPath);
       console.log(`  Downloading ${parser.queries.highlights.length} highlight queries...`);
-      const highlightsPath = await downloadAndCombineQueries(parser.filetype, parser.queries.highlights, opts.assetsDir, opts.outputPath);
+      const highlightsPath = await downloadAndCombineQueries(parser.filetype, parser.queries.highlights, opts.assetsDir, opts.outputPath, "highlights", opts.configPath);
+      let injectionsPath;
+      if (parser.queries.injections && parser.queries.injections.length > 0) {
+        console.log(`  Downloading ${parser.queries.injections.length} injection queries...`);
+        injectionsPath = await downloadAndCombineQueries(parser.filetype, parser.queries.injections, opts.assetsDir, opts.outputPath, "injections", opts.configPath);
+      }
       generatedParsers.push({
         filetype: parser.filetype,
         languagePath,
-        highlightsPath
+        highlightsPath,
+        injectionsPath,
+        injectionMapping: parser.injectionMapping
       });
       console.log(`  \u2713 Completed ${parser.filetype}`);
     }
@@ -6204,10 +6667,684 @@ function getTreeSitterClient() {
     return client2;
   });
 }
+
+// src/lib/extmarks-history.ts
+class ExtmarksHistory {
+  undoStack = [];
+  redoStack = [];
+  saveSnapshot(extmarks, nextId) {
+    const snapshot = {
+      extmarks: new Map(Array.from(extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+      nextId
+    };
+    this.undoStack.push(snapshot);
+    this.redoStack = [];
+  }
+  undo() {
+    if (this.undoStack.length === 0)
+      return null;
+    return this.undoStack.pop();
+  }
+  redo() {
+    if (this.redoStack.length === 0)
+      return null;
+    return this.redoStack.pop();
+  }
+  pushRedo(snapshot) {
+    this.redoStack.push(snapshot);
+  }
+  pushUndo(snapshot) {
+    this.undoStack.push(snapshot);
+  }
+  clear() {
+    this.undoStack = [];
+    this.redoStack = [];
+  }
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+}
+
+// src/lib/extmarks.ts
+class ExtmarksController {
+  editBuffer;
+  editorView;
+  extmarks = new Map;
+  extmarksByTypeId = new Map;
+  metadata = new Map;
+  nextId = 1;
+  destroyed = false;
+  history = new ExtmarksHistory;
+  typeNameToId = new Map;
+  typeIdToName = new Map;
+  nextTypeId = 1;
+  originalMoveCursorLeft;
+  originalMoveCursorRight;
+  originalSetCursorByOffset;
+  originalMoveUpVisual;
+  originalMoveDownVisual;
+  originalDeleteCharBackward;
+  originalDeleteChar;
+  originalInsertText;
+  originalInsertChar;
+  originalDeleteRange;
+  originalSetText;
+  originalClear;
+  originalNewLine;
+  originalDeleteLine;
+  originalEditorViewDeleteSelectedText;
+  originalUndo;
+  originalRedo;
+  constructor(editBuffer, editorView) {
+    this.editBuffer = editBuffer;
+    this.editorView = editorView;
+    this.originalMoveCursorLeft = editBuffer.moveCursorLeft.bind(editBuffer);
+    this.originalMoveCursorRight = editBuffer.moveCursorRight.bind(editBuffer);
+    this.originalSetCursorByOffset = editBuffer.setCursorByOffset.bind(editBuffer);
+    this.originalMoveUpVisual = editorView.moveUpVisual.bind(editorView);
+    this.originalMoveDownVisual = editorView.moveDownVisual.bind(editorView);
+    this.originalDeleteCharBackward = editBuffer.deleteCharBackward.bind(editBuffer);
+    this.originalDeleteChar = editBuffer.deleteChar.bind(editBuffer);
+    this.originalInsertText = editBuffer.insertText.bind(editBuffer);
+    this.originalInsertChar = editBuffer.insertChar.bind(editBuffer);
+    this.originalDeleteRange = editBuffer.deleteRange.bind(editBuffer);
+    this.originalSetText = editBuffer.setText.bind(editBuffer);
+    this.originalClear = editBuffer.clear.bind(editBuffer);
+    this.originalNewLine = editBuffer.newLine.bind(editBuffer);
+    this.originalDeleteLine = editBuffer.deleteLine.bind(editBuffer);
+    this.originalEditorViewDeleteSelectedText = editorView.deleteSelectedText.bind(editorView);
+    this.originalUndo = editBuffer.undo.bind(editBuffer);
+    this.originalRedo = editBuffer.redo.bind(editBuffer);
+    this.wrapCursorMovement();
+    this.wrapDeletion();
+    this.wrapInsertion();
+    this.wrapEditorViewDeleteSelectedText();
+    this.wrapUndoRedo();
+    this.setupContentChangeListener();
+  }
+  wrapCursorMovement() {
+    this.editBuffer.moveCursorLeft = () => {
+      if (this.destroyed) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const targetOffset = currentOffset - 1;
+      if (targetOffset < 0) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset >= virtualExtmark.end) {
+        this.editBuffer.setCursorByOffset(virtualExtmark.start - 1);
+        return;
+      }
+      this.originalMoveCursorLeft();
+    };
+    this.editBuffer.moveCursorRight = () => {
+      if (this.destroyed) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const targetOffset = currentOffset + 1;
+      const textLength = this.editBuffer.getText().length;
+      if (targetOffset > textLength) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset <= virtualExtmark.start) {
+        this.editBuffer.setCursorByOffset(virtualExtmark.end);
+        return;
+      }
+      this.originalMoveCursorRight();
+    };
+    this.editorView.moveUpVisual = () => {
+      if (this.destroyed) {
+        this.originalMoveUpVisual();
+        return;
+      }
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveUpVisual();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalMoveUpVisual();
+      const newOffset = this.editorView.getVisualCursor().offset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(newOffset);
+      if (virtualExtmark) {
+        const distanceToStart = newOffset - virtualExtmark.start;
+        const distanceToEnd = virtualExtmark.end - newOffset;
+        if (distanceToStart < distanceToEnd) {
+          this.editorView.setCursorByOffset(virtualExtmark.start - 1);
+        } else {
+          this.editorView.setCursorByOffset(virtualExtmark.end);
+        }
+      }
+    };
+    this.editorView.moveDownVisual = () => {
+      if (this.destroyed) {
+        this.originalMoveDownVisual();
+        return;
+      }
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveDownVisual();
+        return;
+      }
+      this.originalMoveDownVisual();
+      const newOffset = this.editorView.getVisualCursor().offset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(newOffset);
+      if (virtualExtmark) {
+        const distanceToStart = newOffset - virtualExtmark.start;
+        const distanceToEnd = virtualExtmark.end - newOffset;
+        if (distanceToStart < distanceToEnd) {
+          this.editorView.setCursorByOffset(virtualExtmark.start - 1);
+        } else {
+          this.editorView.setCursorByOffset(virtualExtmark.end);
+        }
+      }
+    };
+    this.editBuffer.setCursorByOffset = (offset) => {
+      if (this.destroyed) {
+        this.originalSetCursorByOffset(offset);
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalSetCursorByOffset(offset);
+        return;
+      }
+      const movingForward = offset > currentOffset;
+      if (movingForward) {
+        const virtualExtmark = this.findVirtualExtmarkContaining(offset);
+        if (virtualExtmark && currentOffset <= virtualExtmark.start) {
+          this.originalSetCursorByOffset(virtualExtmark.end);
+          return;
+        }
+      } else {
+        for (const extmark of this.extmarks.values()) {
+          if (extmark.virtual && currentOffset >= extmark.end && offset < extmark.end && offset >= extmark.start) {
+            this.originalSetCursorByOffset(extmark.start - 1);
+            return;
+          }
+        }
+      }
+      this.originalSetCursorByOffset(offset);
+    };
+  }
+  wrapDeletion() {
+    this.editBuffer.deleteCharBackward = () => {
+      if (this.destroyed) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hadSelection = this.editorView.hasSelection();
+      if (currentOffset === 0) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      if (hadSelection) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      const targetOffset = currentOffset - 1;
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset === virtualExtmark.end) {
+        const startCursor = this.offsetToPosition(virtualExtmark.start);
+        const endCursor = this.offsetToPosition(virtualExtmark.end);
+        const deleteOffset = virtualExtmark.start;
+        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        this.deleteExtmarkById(virtualExtmark.id);
+        this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.updateHighlights();
+        return;
+      }
+      this.originalDeleteCharBackward();
+      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+    };
+    this.editBuffer.deleteChar = () => {
+      if (this.destroyed) {
+        this.originalDeleteChar();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const textLength = this.editBuffer.getText().length;
+      const hadSelection = this.editorView.hasSelection();
+      if (currentOffset >= textLength) {
+        this.originalDeleteChar();
+        return;
+      }
+      if (hadSelection) {
+        this.originalDeleteChar();
+        return;
+      }
+      const targetOffset = currentOffset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset === virtualExtmark.start) {
+        const startCursor = this.offsetToPosition(virtualExtmark.start);
+        const endCursor = this.offsetToPosition(virtualExtmark.end);
+        const deleteOffset = virtualExtmark.start;
+        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        this.deleteExtmarkById(virtualExtmark.id);
+        this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.updateHighlights();
+        return;
+      }
+      this.originalDeleteChar();
+      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+    };
+    this.editBuffer.deleteRange = (startLine, startCol, endLine, endCol) => {
+      if (this.destroyed) {
+        this.originalDeleteRange(startLine, startCol, endLine, endCol);
+        return;
+      }
+      this.saveSnapshot();
+      const startOffset = this.positionToOffset(startLine, startCol);
+      const endOffset = this.positionToOffset(endLine, endCol);
+      const length = endOffset - startOffset;
+      this.originalDeleteRange(startLine, startCol, endLine, endCol);
+      this.adjustExtmarksAfterDeletion(startOffset, length);
+    };
+    this.editBuffer.deleteLine = () => {
+      if (this.destroyed) {
+        this.originalDeleteLine();
+        return;
+      }
+      this.saveSnapshot();
+      const text = this.editBuffer.getText();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      let lineStart = 0;
+      for (let i = currentOffset - 1;i >= 0; i--) {
+        if (text[i] === `
+`) {
+          lineStart = i + 1;
+          break;
+        }
+      }
+      let lineEnd = text.length;
+      for (let i = currentOffset;i < text.length; i++) {
+        if (text[i] === `
+`) {
+          lineEnd = i + 1;
+          break;
+        }
+      }
+      const deleteLength = lineEnd - lineStart;
+      this.originalDeleteLine();
+      this.adjustExtmarksAfterDeletion(lineStart, deleteLength);
+    };
+  }
+  wrapInsertion() {
+    this.editBuffer.insertText = (text) => {
+      if (this.destroyed) {
+        this.originalInsertText(text);
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalInsertText(text);
+      this.adjustExtmarksAfterInsertion(currentOffset, text.length);
+    };
+    this.editBuffer.insertChar = (char) => {
+      if (this.destroyed) {
+        this.originalInsertChar(char);
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalInsertChar(char);
+      this.adjustExtmarksAfterInsertion(currentOffset, 1);
+    };
+    this.editBuffer.setText = (text, opts) => {
+      if (this.destroyed) {
+        this.originalSetText(text, opts);
+        return;
+      }
+      if (opts?.history !== false) {
+        this.saveSnapshot();
+      }
+      this.clear();
+      this.originalSetText(text, opts);
+    };
+    this.editBuffer.clear = () => {
+      if (this.destroyed) {
+        this.originalClear();
+        return;
+      }
+      this.saveSnapshot();
+      this.clear();
+      this.originalClear();
+    };
+    this.editBuffer.newLine = () => {
+      if (this.destroyed) {
+        this.originalNewLine();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalNewLine();
+      this.adjustExtmarksAfterInsertion(currentOffset, 1);
+    };
+  }
+  wrapEditorViewDeleteSelectedText() {
+    this.editorView.deleteSelectedText = () => {
+      if (this.destroyed) {
+        this.originalEditorViewDeleteSelectedText();
+        return;
+      }
+      this.saveSnapshot();
+      const selection = this.editorView.getSelection();
+      if (!selection) {
+        this.originalEditorViewDeleteSelectedText();
+        return;
+      }
+      const deleteOffset = Math.min(selection.start, selection.end);
+      const deleteLength = Math.abs(selection.end - selection.start);
+      this.originalEditorViewDeleteSelectedText();
+      if (deleteLength > 0) {
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+      }
+    };
+  }
+  setupContentChangeListener() {
+    this.editBuffer.on("content-changed", () => {
+      if (this.destroyed)
+        return;
+      this.updateHighlights();
+    });
+  }
+  deleteExtmarkById(id) {
+    const extmark = this.extmarks.get(id);
+    if (extmark) {
+      this.extmarks.delete(id);
+      this.extmarksByTypeId.get(extmark.typeId)?.delete(id);
+      this.metadata.delete(id);
+    }
+  }
+  findVirtualExtmarkContaining(offset) {
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.virtual && offset >= extmark.start && offset < extmark.end) {
+        return extmark;
+      }
+    }
+    return null;
+  }
+  adjustExtmarksAfterInsertion(insertOffset, length) {
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.start >= insertOffset) {
+        extmark.start += length;
+        extmark.end += length;
+      } else if (extmark.end > insertOffset) {
+        extmark.end += length;
+      }
+    }
+    this.updateHighlights();
+  }
+  adjustExtmarksAfterDeletion(deleteOffset, length) {
+    const toDelete = [];
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.end <= deleteOffset) {
+        continue;
+      }
+      if (extmark.start >= deleteOffset + length) {
+        extmark.start -= length;
+        extmark.end -= length;
+      } else if (extmark.start >= deleteOffset && extmark.end <= deleteOffset + length) {
+        toDelete.push(extmark.id);
+      } else if (extmark.start < deleteOffset && extmark.end > deleteOffset + length) {
+        extmark.end -= length;
+      } else if (extmark.start < deleteOffset && extmark.end > deleteOffset) {
+        extmark.end -= Math.min(extmark.end, deleteOffset + length) - deleteOffset;
+      } else if (extmark.start < deleteOffset + length && extmark.end > deleteOffset + length) {
+        const overlap = deleteOffset + length - extmark.start;
+        extmark.start = deleteOffset;
+        extmark.end -= length;
+      }
+    }
+    for (const id of toDelete) {
+      this.deleteExtmarkById(id);
+    }
+    this.updateHighlights();
+  }
+  offsetToPosition(offset) {
+    const result = this.editBuffer.offsetToPosition(offset);
+    if (!result) {
+      return { row: 0, col: 0 };
+    }
+    return result;
+  }
+  positionToOffset(row, col) {
+    return this.editBuffer.positionToOffset(row, col);
+  }
+  updateHighlights() {
+    this.editBuffer.clearAllHighlights();
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.styleId !== undefined) {
+        const startWithoutNewlines = this.offsetToCharOffset(extmark.start);
+        const endWithoutNewlines = this.offsetToCharOffset(extmark.end);
+        this.editBuffer.addHighlightByCharRange({
+          start: startWithoutNewlines,
+          end: endWithoutNewlines,
+          styleId: extmark.styleId,
+          priority: extmark.priority ?? 0,
+          hlRef: extmark.id
+        });
+      }
+    }
+  }
+  offsetToCharOffset(offset) {
+    const text = this.editBuffer.getText();
+    let charOffset = 0;
+    for (let i = 0;i < offset && i < text.length; i++) {
+      if (text[i] !== `
+`) {
+        charOffset++;
+      }
+    }
+    return charOffset;
+  }
+  create(options) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const id = this.nextId++;
+    const typeId = options.typeId ?? 0;
+    const extmark = {
+      id,
+      start: options.start,
+      end: options.end,
+      virtual: options.virtual ?? false,
+      styleId: options.styleId,
+      priority: options.priority,
+      data: options.data,
+      typeId
+    };
+    this.extmarks.set(id, extmark);
+    if (!this.extmarksByTypeId.has(typeId)) {
+      this.extmarksByTypeId.set(typeId, new Set);
+    }
+    this.extmarksByTypeId.get(typeId).add(id);
+    if (options.metadata !== undefined) {
+      this.metadata.set(id, options.metadata);
+    }
+    this.updateHighlights();
+    return id;
+  }
+  delete(id) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const extmark = this.extmarks.get(id);
+    if (!extmark)
+      return false;
+    this.deleteExtmarkById(id);
+    this.updateHighlights();
+    return true;
+  }
+  get(id) {
+    if (this.destroyed)
+      return null;
+    return this.extmarks.get(id) ?? null;
+  }
+  getAll() {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values());
+  }
+  getVirtual() {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values()).filter((e) => e.virtual);
+  }
+  getAtOffset(offset) {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values()).filter((e) => offset >= e.start && offset < e.end);
+  }
+  getAllForTypeId(typeId) {
+    if (this.destroyed)
+      return [];
+    const ids = this.extmarksByTypeId.get(typeId);
+    if (!ids)
+      return [];
+    return Array.from(ids).map((id) => this.extmarks.get(id)).filter((e) => e !== undefined);
+  }
+  clear() {
+    if (this.destroyed)
+      return;
+    this.extmarks.clear();
+    this.extmarksByTypeId.clear();
+    this.metadata.clear();
+    this.updateHighlights();
+  }
+  saveSnapshot() {
+    this.history.saveSnapshot(this.extmarks, this.nextId);
+  }
+  restoreSnapshot(snapshot) {
+    this.extmarks = new Map(Array.from(snapshot.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }]));
+    this.nextId = snapshot.nextId;
+    this.updateHighlights();
+  }
+  wrapUndoRedo() {
+    this.editBuffer.undo = () => {
+      if (this.destroyed) {
+        return this.originalUndo();
+      }
+      if (!this.history.canUndo()) {
+        return this.originalUndo();
+      }
+      const currentSnapshot = {
+        extmarks: new Map(Array.from(this.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+        nextId: this.nextId
+      };
+      this.history.pushRedo(currentSnapshot);
+      const snapshot = this.history.undo();
+      this.restoreSnapshot(snapshot);
+      return this.originalUndo();
+    };
+    this.editBuffer.redo = () => {
+      if (this.destroyed) {
+        return this.originalRedo();
+      }
+      if (!this.history.canRedo()) {
+        return this.originalRedo();
+      }
+      const currentSnapshot = {
+        extmarks: new Map(Array.from(this.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+        nextId: this.nextId
+      };
+      this.history.pushUndo(currentSnapshot);
+      const snapshot = this.history.redo();
+      this.restoreSnapshot(snapshot);
+      return this.originalRedo();
+    };
+  }
+  registerType(typeName) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const existing = this.typeNameToId.get(typeName);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const typeId = this.nextTypeId++;
+    this.typeNameToId.set(typeName, typeId);
+    this.typeIdToName.set(typeId, typeName);
+    return typeId;
+  }
+  getTypeId(typeName) {
+    if (this.destroyed)
+      return null;
+    return this.typeNameToId.get(typeName) ?? null;
+  }
+  getTypeName(typeId) {
+    if (this.destroyed)
+      return null;
+    return this.typeIdToName.get(typeId) ?? null;
+  }
+  getMetadataFor(extmarkId) {
+    if (this.destroyed)
+      return;
+    return this.metadata.get(extmarkId);
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.editBuffer.moveCursorLeft = this.originalMoveCursorLeft;
+    this.editBuffer.moveCursorRight = this.originalMoveCursorRight;
+    this.editBuffer.setCursorByOffset = this.originalSetCursorByOffset;
+    this.editorView.moveUpVisual = this.originalMoveUpVisual;
+    this.editorView.moveDownVisual = this.originalMoveDownVisual;
+    this.editBuffer.deleteCharBackward = this.originalDeleteCharBackward;
+    this.editBuffer.deleteChar = this.originalDeleteChar;
+    this.editBuffer.insertText = this.originalInsertText;
+    this.editBuffer.insertChar = this.originalInsertChar;
+    this.editBuffer.deleteRange = this.originalDeleteRange;
+    this.editBuffer.setText = this.originalSetText;
+    this.editBuffer.clear = this.originalClear;
+    this.editBuffer.newLine = this.originalNewLine;
+    this.editBuffer.deleteLine = this.originalDeleteLine;
+    this.editorView.deleteSelectedText = this.originalEditorViewDeleteSelectedText;
+    this.editBuffer.undo = this.originalUndo;
+    this.editBuffer.redo = this.originalRedo;
+    this.extmarks.clear();
+    this.extmarksByTypeId.clear();
+    this.metadata.clear();
+    this.typeNameToId.clear();
+    this.typeIdToName.clear();
+    this.history.clear();
+    this.destroyed = true;
+  }
+}
+function createExtmarksController(editBuffer, editorView) {
+  return new ExtmarksController(editBuffer, editorView);
+}
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr3 } from "bun:ffi";
 import { existsSync as existsSync2 } from "fs";
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 
 // src/buffer.ts
 import { toArrayBuffer } from "bun:ffi";
@@ -7315,6 +8452,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
+    textBufferGetTabWidth: {
+      args: ["ptr"],
+      returns: "u8"
+    },
+    textBufferSetTabWidth: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
     textBufferRegisterMemBuffer: {
       args: ["ptr", "ptr", "usize", "bool"],
       returns: "u16"
@@ -7379,6 +8524,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "usize"],
       returns: "void"
     },
+    textBufferGetHighlightCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
     createTextBufferView: {
       args: ["ptr"],
       returns: "ptr"
@@ -7439,6 +8588,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr", "usize"],
       returns: "usize"
     },
+    textBufferViewSetTabIndicator: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferViewSetTabIndicatorColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     bufferDrawTextBufferView: {
       args: ["ptr", "ptr", "i32", "i32"],
       returns: "void"
@@ -7483,6 +8640,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    editorViewGetLineInfoDirect: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "u32"
+    },
+    editorViewGetLogicalLineInfoDirect: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "u32"
+    },
     createEditBuffer: {
       args: ["u8"],
       returns: "ptr"
@@ -7564,7 +8729,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     editBufferGetCursorPosition: {
-      args: ["ptr", "ptr", "ptr", "ptr"],
+      args: ["ptr", "ptr"],
       returns: "void"
     },
     editBufferGetId: {
@@ -7599,12 +8764,8 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
-    editBufferSetPlaceholder: {
-      args: ["ptr", "ptr", "usize"],
-      returns: "void"
-    },
-    editBufferSetPlaceholderColor: {
-      args: ["ptr", "ptr"],
+    editBufferClear: {
+      args: ["ptr"],
       returns: "void"
     },
     editBufferGetNextWordBoundary: {
@@ -7619,6 +8780,18 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr"],
       returns: "void"
     },
+    editBufferOffsetToPosition: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "bool"
+    },
+    editBufferPositionToOffset: {
+      args: ["ptr", "u32", "u32"],
+      returns: "u32"
+    },
+    editBufferGetLineStartOffset: {
+      args: ["ptr", "u32"],
+      returns: "u32"
+    },
     editorViewSetSelection: {
       args: ["ptr", "u32", "u32", "ptr", "ptr"],
       returns: "void"
@@ -7683,6 +8856,18 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr"],
       returns: "void"
     },
+    editorViewSetPlaceholderStyledText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editorViewSetTabIndicator: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editorViewSetTabIndicatorColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     getArenaAllocatedBytes: {
       args: [],
       returns: "usize"
@@ -7840,7 +9025,7 @@ class FFIRenderLib {
   decoder = new TextDecoder;
   logCallbackWrapper;
   eventCallbackWrapper;
-  _nativeEvents = new EventEmitter4;
+  _nativeEvents = new EventEmitter5;
   _anyEventHandlers = [];
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
@@ -8191,6 +9376,12 @@ class FFIRenderLib {
   textBufferResetDefaults(buffer) {
     this.opentui.symbols.textBufferResetDefaults(buffer);
   }
+  textBufferGetTabWidth(buffer) {
+    return this.opentui.symbols.textBufferGetTabWidth(buffer);
+  }
+  textBufferSetTabWidth(buffer, width) {
+    this.opentui.symbols.textBufferSetTabWidth(buffer, width);
+  }
   textBufferRegisterMemBuffer(buffer, bytes, owned = false) {
     const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, bytes, bytes.length, owned);
     if (result === 65535) {
@@ -8344,6 +9535,12 @@ class FFIRenderLib {
     }
     return outBuffer.slice(0, actualLen);
   }
+  textBufferViewSetTabIndicator(view, indicator) {
+    this.opentui.symbols.textBufferViewSetTabIndicator(view, indicator);
+  }
+  textBufferViewSetTabIndicatorColor(view, color) {
+    this.opentui.symbols.textBufferViewSetTabIndicatorColor(view, color.buffer);
+  }
   textBufferAddHighlightByCharRange(buffer, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
     this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr3(packedHighlight));
@@ -8376,6 +9573,9 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferFreeLineHighlights(nativePtr, count);
     return results;
   }
+  textBufferGetHighlightCount(buffer) {
+    return this.opentui.symbols.textBufferGetHighlightCount(buffer);
+  }
   getArenaAllocatedBytes() {
     const result = this.opentui.symbols.getArenaAllocatedBytes();
     return typeof result === "bigint" ? Number(result) : result;
@@ -8432,6 +9632,34 @@ class FFIRenderLib {
     }
     return result;
   }
+  editorViewGetLineInfo(view) {
+    const lineCount = this.editorViewGetVirtualLineCount(view);
+    if (lineCount === 0) {
+      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
+    }
+    const lineStarts = new Uint32Array(lineCount);
+    const lineWidths = new Uint32Array(lineCount);
+    const maxLineWidth = this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr3(lineStarts), ptr3(lineWidths));
+    return {
+      maxLineWidth,
+      lineStarts: Array.from(lineStarts),
+      lineWidths: Array.from(lineWidths)
+    };
+  }
+  editorViewGetLogicalLineInfo(view) {
+    const lineCount = this.editorViewGetVirtualLineCount(view);
+    if (lineCount === 0) {
+      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
+    }
+    const lineStarts = new Uint32Array(lineCount);
+    const lineWidths = new Uint32Array(lineCount);
+    const maxLineWidth = this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr3(lineStarts), ptr3(lineWidths));
+    return {
+      maxLineWidth,
+      lineStarts: Array.from(lineStarts),
+      lineWidths: Array.from(lineWidths)
+    };
+  }
   createEditBuffer(widthMethod) {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
     const bufferPtr = this.opentui.symbols.createEditBuffer(widthMethodCode);
@@ -8505,15 +9733,9 @@ class FFIRenderLib {
     this.opentui.symbols.editBufferSetCursorByOffset(buffer, offset);
   }
   editBufferGetCursorPosition(buffer) {
-    const line = new Uint32Array(1);
-    const visualColumn = new Uint32Array(1);
-    const offset = new Uint32Array(1);
-    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr3(line), ptr3(visualColumn), ptr3(offset));
-    return {
-      line: line[0],
-      visualColumn: visualColumn[0],
-      offset: offset[0]
-    };
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetId(buffer) {
     return this.opentui.symbols.editBufferGetId(buffer);
@@ -8553,16 +9775,8 @@ class FFIRenderLib {
   editBufferClearHistory(buffer) {
     this.opentui.symbols.editBufferClearHistory(buffer);
   }
-  editBufferSetPlaceholder(buffer, text) {
-    if (text === null) {
-      this.opentui.symbols.editBufferSetPlaceholder(buffer, null, 0);
-    } else {
-      const textBytes = this.encoder.encode(text);
-      this.opentui.symbols.editBufferSetPlaceholder(buffer, textBytes, textBytes.length);
-    }
-  }
-  editBufferSetPlaceholderColor(buffer, color) {
-    this.opentui.symbols.editBufferSetPlaceholderColor(buffer, color.buffer);
+  editBufferClear(buffer) {
+    this.opentui.symbols.editBufferClear(buffer);
   }
   editBufferGetNextWordBoundary(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
@@ -8579,6 +9793,19 @@ class FFIRenderLib {
     this.opentui.symbols.editBufferGetEOL(buffer, ptr3(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
+  editBufferOffsetToPosition(buffer, offset) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr3(cursorBuffer));
+    if (!success)
+      return null;
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferPositionToOffset(buffer, row, col) {
+    return this.opentui.symbols.editBufferPositionToOffset(buffer, row, col);
+  }
+  editBufferGetLineStartOffset(buffer, row) {
+    return this.opentui.symbols.editBufferGetLineStartOffset(buffer, row);
+  }
   editorViewSetSelection(view, start, end, bgColor, fgColor) {
     const bg2 = bgColor ? bgColor.buffer : null;
     const fg2 = fgColor ? fgColor.buffer : null;
@@ -8717,6 +9944,21 @@ class FFIRenderLib {
     const result = this.opentui.symbols.syntaxStyleGetStyleCount(style);
     return typeof result === "bigint" ? Number(result) : result;
   }
+  editorViewSetPlaceholderStyledText(view, chunks) {
+    const nonEmptyChunks = chunks.filter((c) => c.text.length > 0);
+    if (nonEmptyChunks.length === 0) {
+      this.opentui.symbols.editorViewSetPlaceholderStyledText(view, null, 0);
+      return;
+    }
+    const chunksBuffer = StyledChunkStruct.packList(nonEmptyChunks);
+    this.opentui.symbols.editorViewSetPlaceholderStyledText(view, ptr3(chunksBuffer), nonEmptyChunks.length);
+  }
+  editorViewSetTabIndicator(view, indicator) {
+    this.opentui.symbols.editorViewSetTabIndicator(view, indicator);
+  }
+  editorViewSetTabIndicatorColor(view, color) {
+    this.opentui.symbols.editorViewSetTabIndicatorColor(view, color.buffer);
+  }
   onNativeEvent(name, handler) {
     this._nativeEvents.on(name, handler);
   }
@@ -8873,6 +10115,10 @@ class TextBuffer {
     this.guard();
     return this.lib.textBufferGetLineHighlights(this.bufferPtr, lineIdx);
   }
+  getHighlightCount() {
+    this.guard();
+    return this.lib.textBufferGetHighlightCount(this.bufferPtr);
+  }
   setSyntaxStyle(style) {
     this.guard();
     this._syntaxStyle = style ?? undefined;
@@ -8882,6 +10128,14 @@ class TextBuffer {
     this.guard();
     return this._syntaxStyle ?? null;
   }
+  setTabWidth(width) {
+    this.guard();
+    this.lib.textBufferSetTabWidth(this.bufferPtr, width);
+  }
+  getTabWidth() {
+    this.guard();
+    return this.lib.textBufferGetTabWidth(this.bufferPtr);
+  }
   clear() {
     this.guard();
     this.lib.textBufferClear(this.bufferPtr);
@@ -8908,7 +10162,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -9001,7 +10255,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter5 {
+class BaseRenderable extends EventEmitter6 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -9179,9 +10433,9 @@ class Renderable extends BaseRenderable {
       }
     };
     this.pasteHandler = (event) => {
-      this._pasteListener?.call(this, event.text);
+      this._pasteListener?.call(this, event);
       if (!event.defaultPrevented && this.handlePaste) {
-        this.handlePaste(event.text);
+        this.handlePaste(event);
       }
     };
     this.ctx._internalKeyInput.onInternal("keypress", this.keypressHandler);
@@ -10322,7 +11576,7 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 import { Console } from "console";
 import fs from "fs";
 import path4 from "path";
@@ -10330,9 +11584,9 @@ import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 
-class Capture extends EventEmitter6 {
+class Capture extends EventEmitter7 {
   output = [];
   constructor() {
     super();
@@ -10408,7 +11662,7 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter7 {
+class TerminalConsoleCache extends EventEmitter8 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -10534,7 +11788,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter7 {
+class TerminalConsole extends EventEmitter8 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -10994,7 +12248,7 @@ class TerminalConsole extends EventEmitter7 {
 }
 
 // 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) {
@@ -11220,7 +12474,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter8 {
+class CliRenderer extends EventEmitter9 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -11248,7 +12502,7 @@ class CliRenderer extends EventEmitter8 {
   frameTimes = [];
   maxStatSamples = 300;
   postProcessFns = [];
-  backgroundColor = RGBA.fromHex("#000000");
+  backgroundColor = RGBA.fromInts(0, 0, 0, 0);
   waitingForPixelResolution = false;
   rendering = false;
   renderingNative = false;
@@ -11312,30 +12566,10 @@ class CliRenderer extends EventEmitter8 {
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   handleError = ((error) => {
-    this.stop();
-    this.destroy();
-    new Promise((resolve4) => {
-      setTimeout(() => {
-        resolve4(true);
-      }, 100);
-    }).then(() => {
-      this.realStdoutWrite.call(this.stdout, `
-`.repeat(this._terminalHeight));
-      this.realStdoutWrite.call(this.stdout, `
-=== FATAL ERROR OCCURRED ===
-`);
-      this.dumpOutputCache();
-      this.realStdoutWrite.call(this.stdout, `
-Error details:
-`);
-      this.realStdoutWrite.call(this.stdout, error.message || "unknown error");
-      this.realStdoutWrite.call(this.stdout, `
-`);
-      this.realStdoutWrite.call(this.stdout, error.stack || error.toString());
-      this.realStdoutWrite.call(this.stdout, `
-`);
-      process.exit(1);
-    });
+    console.error(error);
+    if (true) {
+      this.console.show();
+    }
   }).bind(this);
   dumpOutputCache(optionalMessage = "") {
     const cachedLogs = this.console.getCachedLogs();
@@ -11360,8 +12594,10 @@ Captured output:
   exitHandler = (() => {
     this.destroy();
     if (env.OTUI_DUMP_CAPTURES) {
-      this.dumpOutputCache(`=== CAPTURED OUTPUT ===
+      Bun.sleep(100).then(() => {
+        this.dumpOutputCache(`=== CAPTURED OUTPUT ===
 `);
+      });
     }
   }).bind(this);
   warningHandler = ((warning) => {
@@ -11417,6 +12653,14 @@ Captured output:
     this._console = new TerminalConsole(this, config.consoleOptions);
     this.useConsole = config.useConsole ?? true;
     this._keyHandler = new InternalKeyHandler(this.stdin, config.useKittyKeyboard ?? false);
+    this._keyHandler.on("keypress", (event) => {
+      if (this.exitOnCtrlC && event.name === "c" && event.ctrl) {
+        process.nextTick(() => {
+          this.destroy();
+        });
+        return;
+      }
+    });
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
       this.animationRequest.set(id, callback);
@@ -11676,12 +12920,6 @@ Captured output:
         return;
       }
     }
-    if (this.exitOnCtrlC && str === "\x03") {
-      process.nextTick(() => {
-        this.destroy();
-      });
-      return;
-    }
     if (this._useMouse && this.handleMouseData(data)) {
       return;
     }
@@ -11878,7 +13116,7 @@ Captured output:
       this.renderOffset = height - this._splitHeight;
       this.width = width;
       this.height = this._splitHeight;
-      this.currentRenderBuffer.clear(RGBA.fromHex("#000000"));
+      this.currentRenderBuffer.clear(this.backgroundColor);
       this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
     } else {
       this.width = width;
@@ -12321,7 +13559,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, StdinBuffer, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=19E28318FF03F69E64756E2164756E21
-//# sourceMappingURL=index-0qmm1k4p.js.map
+//# debugId=F6CF4AF7A66F05DD64756E2164756E21
+//# sourceMappingURL=index-3f9h747j.js.map