@opentui/core 0.1.31 → 0.1.32

package/{index-91qheh74.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,
@@ -2107,10 +2108,11 @@ 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;
@@ -2122,7 +2124,7 @@ var parseKeypress = (s = "", options = {}) => {
   } else if (s === `
 ` || s === `\x1B
 `) {
-    key.name = "enter";
+    key.name = "linefeed";
     key.meta = s.length === 2;
   } else if (s === "\t") {
     key.name = "tab";
@@ -2135,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;
@@ -2185,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 = {
@@ -2214,6 +2395,7 @@ class KeyEvent {
   number;
   raw;
   eventType;
+  source;
   code;
   super;
   hyper;
@@ -2231,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;
@@ -2260,65 +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 });
-      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;
-      }
+    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);
     }
   }
 }
@@ -5112,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({
@@ -5134,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,
@@ -5180,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");
@@ -5201,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;
@@ -5314,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) {
@@ -5331,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)
       }
     ];
   }
@@ -5360,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;
@@ -5475,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 });
@@ -5581,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;
@@ -5594,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;
     }
@@ -5776,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) {
@@ -5845,7 +6221,7 @@ registerEnvVar({
   default: ""
 });
 
-class DataPathsManager extends EventEmitter3 {
+class DataPathsManager extends EventEmitter4 {
   _appName;
   _globalConfigPath;
   _globalConfigFile;
@@ -5929,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"],
@@ -6071,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);
@@ -6093,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(`,
 `);
@@ -6184,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}`);
     }
@@ -6893,7 +7344,7 @@ function createExtmarksController(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";
@@ -8001,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"
@@ -8065,6 +8524,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "usize"],
       returns: "void"
     },
+    textBufferGetHighlightCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
     createTextBufferView: {
       args: ["ptr"],
       returns: "ptr"
@@ -8125,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"
@@ -8389,6 +8860,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr", "usize"],
       returns: "void"
     },
+    editorViewSetTabIndicator: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editorViewSetTabIndicatorColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     getArenaAllocatedBytes: {
       args: [],
       returns: "usize"
@@ -8546,7 +9025,7 @@ class FFIRenderLib {
   decoder = new TextDecoder;
   logCallbackWrapper;
   eventCallbackWrapper;
-  _nativeEvents = new EventEmitter4;
+  _nativeEvents = new EventEmitter5;
   _anyEventHandlers = [];
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
@@ -8897,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) {
@@ -9050,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));
@@ -9082,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;
@@ -9459,6 +9953,12 @@ class FFIRenderLib {
     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);
   }
@@ -9615,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;
@@ -9624,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);
@@ -9650,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) {
@@ -9743,7 +10255,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter5 {
+class BaseRenderable extends EventEmitter6 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -11064,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";
@@ -11072,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();
@@ -11150,7 +11662,7 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter7 {
+class TerminalConsoleCache extends EventEmitter8 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -11276,7 +11788,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter7 {
+class TerminalConsole extends EventEmitter8 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -11736,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) {
@@ -11962,7 +12474,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter8 {
+class CliRenderer extends EventEmitter9 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -12141,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);
@@ -12400,12 +12920,6 @@ Captured output:
         return;
       }
     }
-    if (this.exitOnCtrlC && str === "\x03") {
-      process.nextTick(() => {
-        this.destroy();
-      });
-      return;
-    }
     if (this._useMouse && this.handleMouseData(data)) {
       return;
     }
@@ -13045,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, 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 };
+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=6145BB5C85305CD464756E2164756E21
-//# sourceMappingURL=index-91qheh74.js.map
+//# debugId=F6CF4AF7A66F05DD64756E2164756E21
+//# sourceMappingURL=index-3f9h747j.js.map