@opentui/core 0.1.24 → 0.1.26

package/{index-0yx9rnxg.js → index-pxa2sv92.js}

@@ -1763,7 +1763,7 @@ var BorderCharArrays = {
 };
 
 // src/lib/parse.keypress.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 
 // src/lib/parse.keypress-kitty.ts
 var kittyKeyMap = {
@@ -2080,7 +2080,7 @@ var isCtrlKey = (code) => {
 };
 var parseKeypress = (s = "", options = {}) => {
   let parts;
-  if (Buffer.isBuffer(s)) {
+  if (Buffer2.isBuffer(s)) {
     if (s[0] > 127 && s[1] === undefined) {
       s[0] -= 128;
       s = "\x1B" + String(s);
@@ -2143,6 +2143,10 @@ var parseKeypress = (s = "", options = {}) => {
     key.meta = true;
     key.shift = /^[A-Z]$/.test(parts[1]);
     key.name = parts[1];
+  } else if (s.length === 2 && s[0] === "\x1B" && s[1] <= "\x1A") {
+    key.meta = true;
+    key.ctrl = true;
+    key.name = String.fromCharCode(s.charCodeAt(1) + 97 - 1);
   } else if (parts = fnKeyRe.exec(s)) {
     const segs = [...s];
     if (segs[0] === "\x1B" && segs[1] === "\x1B") {
@@ -2175,57 +2179,162 @@ var parseKeypress = (s = "", options = {}) => {
 // src/lib/KeyHandler.ts
 import { EventEmitter } from "events";
 
-// src/singleton.ts
-var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
-function singleton(key, factory) {
-  const bag = globalThis[singletonCacheSymbol] ??= {};
-  if (!(key in bag)) {
-    bag[key] = factory();
+// src/ansi.ts
+var ANSI = {
+  switchToAlternateScreen: "\x1B[?1049h",
+  switchToMainScreen: "\x1B[?1049l",
+  reset: "\x1B[0m",
+  scrollDown: (lines) => `\x1B[${lines}T`,
+  scrollUp: (lines) => `\x1B[${lines}S`,
+  moveCursor: (row, col) => `\x1B[${row};${col}H`,
+  moveCursorAndClear: (row, col) => `\x1B[${row};${col}H\x1B[J`,
+  setRgbBackground: (r, g, b) => `\x1B[48;2;${r};${g};${b}m`,
+  resetBackground: "\x1B[49m",
+  bracketedPasteStart: "\x1B[200~",
+  bracketedPasteEnd: "\x1B[201~"
+};
+
+// src/lib/KeyHandler.ts
+class KeyEvent {
+  name;
+  ctrl;
+  meta;
+  shift;
+  option;
+  sequence;
+  number;
+  raw;
+  eventType;
+  code;
+  super;
+  hyper;
+  capsLock;
+  numLock;
+  baseCode;
+  _defaultPrevented = false;
+  constructor(key) {
+    this.name = key.name;
+    this.ctrl = key.ctrl;
+    this.meta = key.meta;
+    this.shift = key.shift;
+    this.option = key.option;
+    this.sequence = key.sequence;
+    this.number = key.number;
+    this.raw = key.raw;
+    this.eventType = key.eventType;
+    this.code = key.code;
+    this.super = key.super;
+    this.hyper = key.hyper;
+    this.capsLock = key.capsLock;
+    this.numLock = key.numLock;
+    this.baseCode = key.baseCode;
+  }
+  get defaultPrevented() {
+    return this._defaultPrevented;
+  }
+  preventDefault() {
+    this._defaultPrevented = true;
+  }
+}
+
+class PasteEvent {
+  text;
+  _defaultPrevented = false;
+  constructor(text) {
+    this.text = text;
+  }
+  get defaultPrevented() {
+    return this._defaultPrevented;
+  }
+  preventDefault() {
+    this._defaultPrevented = true;
   }
-  return bag[key];
 }
 
-// src/lib/KeyHandler.ts
 class KeyHandler extends EventEmitter {
   stdin;
   useKittyKeyboard;
+  listener;
+  pasteMode = false;
+  pasteBuffer = [];
   constructor(stdin, useKittyKeyboard = false) {
     super();
     this.stdin = stdin || process.stdin;
     this.useKittyKeyboard = useKittyKeyboard;
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(true);
-    }
-    this.stdin.resume();
-    this.stdin.setEncoding("utf8");
-    this.stdin.on("data", (key) => {
+    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", parsedKey);
+          this.emit("keypress", new KeyEvent(parsedKey));
           break;
         case "repeat":
-          this.emit("keyrepeat", parsedKey);
+          this.emit("keyrepeat", new KeyEvent(parsedKey));
           break;
         case "release":
-          this.emit("keyrelease", parsedKey);
+          this.emit("keyrelease", new KeyEvent(parsedKey));
           break;
         default:
-          this.emit("keypress", parsedKey);
+          this.emit("keypress", new KeyEvent(parsedKey));
           break;
       }
-    });
+    };
+    this.stdin.on("data", this.listener);
   }
   destroy() {
-    this.stdin.removeAllListeners("data");
+    this.stdin.removeListener("data", this.listener);
   }
 }
-var keyHandler = null;
-function getKeyHandler(useKittyKeyboard = false) {
-  if (!keyHandler) {
-    keyHandler = singleton("KeyHandler", () => new KeyHandler(process.stdin, useKittyKeyboard));
+
+class InternalKeyHandler extends KeyHandler {
+  renderableHandlers = new Map;
+  constructor(stdin, useKittyKeyboard = false) {
+    super(stdin, useKittyKeyboard);
+  }
+  emit(event, ...args) {
+    return this.emitWithPriority(event, ...args);
+  }
+  emitWithPriority(event, ...args) {
+    const hasGlobalListeners = super.emit(event, ...args);
+    const renderableSet = this.renderableHandlers.get(event);
+    let hasRenderableListeners = false;
+    if (renderableSet && renderableSet.size > 0) {
+      hasRenderableListeners = true;
+      if (event === "keypress" || event === "keyrepeat" || event === "keyrelease" || event === "paste") {
+        const keyEvent = args[0];
+        if (keyEvent.defaultPrevented)
+          return hasGlobalListeners || hasRenderableListeners;
+      }
+      for (const handler of renderableSet) {
+        handler(...args);
+      }
+    }
+    return hasGlobalListeners || hasRenderableListeners;
+  }
+  onInternal(event, handler) {
+    if (!this.renderableHandlers.has(event)) {
+      this.renderableHandlers.set(event, new Set);
+    }
+    this.renderableHandlers.get(event).add(handler);
+  }
+  offInternal(event, handler) {
+    const handlers = this.renderableHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
   }
-  return keyHandler;
 }
 
 // src/lib/RGBA.ts
@@ -4079,60 +4188,9 @@ function isStyledText(obj) {
 class StyledText {
   [BrandedStyledText] = true;
   chunks;
-  textRenderable;
   constructor(chunks) {
     this.chunks = chunks;
   }
-  mount(textRenderable) {
-    this.textRenderable = textRenderable;
-  }
-  insert(chunk, index) {
-    const originalLength = this.chunks.length;
-    if (this.textRenderable) {
-      this.textRenderable.insertChunk(chunk, index ?? originalLength);
-      let newChunks;
-      if (index === undefined || index === originalLength) {
-        newChunks = [...this.chunks, chunk];
-      } else {
-        newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index)];
-      }
-      this.chunks = newChunks;
-    }
-    return this;
-  }
-  remove(chunk) {
-    if (this.textRenderable) {
-      this.textRenderable.removeChunk(chunk);
-      const originalLength = this.chunks.length;
-      const index = this.chunks.indexOf(chunk);
-      if (index === -1)
-        return this;
-      let newChunks;
-      if (index === originalLength - 1) {
-        newChunks = this.chunks.slice(0, -1);
-      } else {
-        newChunks = [...this.chunks.slice(0, index), ...this.chunks.slice(index + 1)];
-      }
-      this.chunks = newChunks;
-    }
-    return this;
-  }
-  replace(chunk, oldChunk) {
-    if (this.textRenderable) {
-      this.textRenderable.replaceChunk(chunk, oldChunk);
-      const index = this.chunks.indexOf(oldChunk);
-      if (index === -1)
-        return this;
-      let newChunks;
-      if (index === this.chunks.length - 1) {
-        newChunks = [...this.chunks.slice(0, -1), chunk];
-      } else {
-        newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index + 1)];
-      }
-      this.chunks = newChunks;
-    }
-    return this;
-  }
 }
 function stringToStyledText(content) {
   const chunk = {
@@ -4228,7 +4286,36 @@ function t(strings, ...values) {
   return new StyledText(chunks);
 }
 
-// src/lib/hast-styled-text.ts
+// src/lib/syntax-style.ts
+function convertThemeToStyles(theme) {
+  const flatStyles = {};
+  for (const tokenStyle of theme) {
+    const styleDefinition = {};
+    if (tokenStyle.style.foreground) {
+      styleDefinition.fg = parseColor(tokenStyle.style.foreground);
+    }
+    if (tokenStyle.style.background) {
+      styleDefinition.bg = parseColor(tokenStyle.style.background);
+    }
+    if (tokenStyle.style.bold !== undefined) {
+      styleDefinition.bold = tokenStyle.style.bold;
+    }
+    if (tokenStyle.style.italic !== undefined) {
+      styleDefinition.italic = tokenStyle.style.italic;
+    }
+    if (tokenStyle.style.underline !== undefined) {
+      styleDefinition.underline = tokenStyle.style.underline;
+    }
+    if (tokenStyle.style.dim !== undefined) {
+      styleDefinition.dim = tokenStyle.style.dim;
+    }
+    for (const scope of tokenStyle.scope) {
+      flatStyles[scope] = styleDefinition;
+    }
+  }
+  return flatStyles;
+}
+
 class SyntaxStyle {
   styles;
   mergedStyleCache;
@@ -4236,6 +4323,10 @@ class SyntaxStyle {
     this.styles = styles;
     this.mergedStyleCache = new Map;
   }
+  static fromTheme(theme) {
+    const flatStyles = convertThemeToStyles(theme);
+    return new SyntaxStyle(flatStyles);
+  }
   mergeStyles(...styleNames) {
     const cacheKey = styleNames.join(":");
     const cached = this.mergedStyleCache.get(cacheKey);
@@ -4243,7 +4334,7 @@ class SyntaxStyle {
       return cached;
     const styleDefinition = {};
     for (const name of styleNames) {
-      const style = this.styles[name];
+      const style = this.getStyle(name);
       if (!style)
         continue;
       if (style.fg)
@@ -4273,6 +4364,18 @@ class SyntaxStyle {
     this.mergedStyleCache.set(cacheKey, merged);
     return merged;
   }
+  getStyle(name) {
+    if (Object.prototype.hasOwnProperty.call(this.styles, name)) {
+      return this.styles[name];
+    }
+    if (name.includes(".")) {
+      const baseName = name.split(".")[0];
+      if (Object.prototype.hasOwnProperty.call(this.styles, baseName)) {
+        return this.styles[baseName];
+      }
+    }
+    return;
+  }
   clearCache() {
     this.mergedStyleCache.clear();
   }
@@ -4280,6 +4383,8 @@ class SyntaxStyle {
     return this.mergedStyleCache.size;
   }
 }
+
+// src/lib/hast-styled-text.ts
 function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
   const chunks = [];
   if (node.type === "text") {
@@ -4311,6 +4416,55 @@ function hastToStyledText(hast, syntaxStyle) {
   return new StyledText(chunks);
 }
 
+// src/lib/scroll-acceleration.ts
+class LinearScrollAccel {
+  tick(_now) {
+    return 1;
+  }
+  reset() {}
+}
+
+class MacOSScrollAccel {
+  opts;
+  lastTickTime = 0;
+  velocityHistory = [];
+  historySize = 3;
+  streakTimeout = 150;
+  minTickInterval = 6;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  tick(now = Date.now()) {
+    const A = this.opts.A ?? 0.8;
+    const tau = this.opts.tau ?? 3;
+    const maxMultiplier = this.opts.maxMultiplier ?? 6;
+    const dt = this.lastTickTime ? now - this.lastTickTime : Infinity;
+    if (dt === Infinity || dt > this.streakTimeout) {
+      this.lastTickTime = now;
+      this.velocityHistory = [];
+      return 1;
+    }
+    if (dt < this.minTickInterval) {
+      return 1;
+    }
+    this.lastTickTime = now;
+    this.velocityHistory.push(dt);
+    if (this.velocityHistory.length > this.historySize) {
+      this.velocityHistory.shift();
+    }
+    const avgInterval = this.velocityHistory.reduce((a, b) => a + b, 0) / this.velocityHistory.length;
+    const referenceInterval = 100;
+    const velocity = referenceInterval / avgInterval;
+    const x = velocity / tau;
+    const multiplier = 1 + A * (Math.exp(x) - 1);
+    return Math.min(multiplier, maxMultiplier);
+  }
+  reset() {
+    this.lastTickTime = 0;
+    this.velocityHistory = [];
+  }
+}
+
 // src/lib/yoga.options.ts
 function parseAlign(value) {
   switch (value.toLowerCase()) {
@@ -4739,74 +4893,1356 @@ function convertGlobalToLocalSelection(globalSelection, localX, localY) {
   };
 }
 
-class ASCIIFontSelectionHelper {
-  getText;
-  getFont;
-  localSelection = null;
-  constructor(getText, getFont) {
-    this.getText = getText;
-    this.getFont = getFont;
+class ASCIIFontSelectionHelper {
+  getText;
+  getFont;
+  localSelection = null;
+  constructor(getText, getFont) {
+    this.getText = getText;
+    this.getFont = getFont;
+  }
+  hasSelection() {
+    return this.localSelection !== null;
+  }
+  getSelection() {
+    return this.localSelection;
+  }
+  shouldStartSelection(localX, localY, width, height) {
+    if (localX < 0 || localX >= width || localY < 0 || localY >= height) {
+      return false;
+    }
+    const text = this.getText();
+    const font = this.getFont();
+    const charIndex = coordinateToCharacterIndex(localX, text, font);
+    return charIndex >= 0 && charIndex <= text.length;
+  }
+  onLocalSelectionChanged(localSelection, width, height) {
+    const previousSelection = this.localSelection;
+    if (!localSelection?.isActive) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    }
+    const text = this.getText();
+    const font = this.getFont();
+    const selStart = { x: localSelection.anchorX, y: localSelection.anchorY };
+    const selEnd = { x: localSelection.focusX, y: localSelection.focusY };
+    if (height - 1 < selStart.y || 0 > selEnd.y) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    }
+    let startCharIndex = 0;
+    let endCharIndex = text.length;
+    if (selStart.y > height - 1) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    } else if (selStart.y >= 0 && selStart.y <= height - 1) {
+      if (selStart.x > 0) {
+        startCharIndex = coordinateToCharacterIndex(selStart.x, text, font);
+      }
+    }
+    if (selEnd.y < 0) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    } else if (selEnd.y >= 0 && selEnd.y <= height - 1) {
+      if (selEnd.x >= 0) {
+        endCharIndex = coordinateToCharacterIndex(selEnd.x, text, font);
+      } else {
+        endCharIndex = 0;
+      }
+    }
+    if (startCharIndex < endCharIndex && startCharIndex >= 0 && endCharIndex <= text.length) {
+      this.localSelection = { start: startCharIndex, end: endCharIndex };
+    } else {
+      this.localSelection = null;
+    }
+    return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
+  }
+}
+
+// src/lib/singleton.ts
+var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
+function singleton(key, factory) {
+  const bag = globalThis[singletonCacheSymbol] ??= {};
+  if (!(key in bag)) {
+    bag[key] = factory();
+  }
+  return bag[key];
+}
+function destroySingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  if (bag && key in bag) {
+    delete bag[key];
+  }
+}
+function hasSingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  return bag && key in bag;
+}
+
+// src/lib/env.ts
+var envRegistry = singleton("env-registry", () => ({}));
+function registerEnvVar(config) {
+  const existing = envRegistry[config.name];
+  if (existing) {
+    if (existing.description !== config.description || existing.type !== config.type || existing.default !== config.default) {
+      throw new Error(`Environment variable "${config.name}" is already registered with different configuration. ` + `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`);
+    }
+    return;
+  }
+  envRegistry[config.name] = config;
+}
+function normalizeBoolean(value) {
+  const lowerValue = value.toLowerCase();
+  return ["true", "1", "on", "yes"].includes(lowerValue);
+}
+function parseEnvValue(config) {
+  const envValue = process.env[config.name];
+  if (envValue === undefined && config.default !== undefined) {
+    return config.default;
+  }
+  if (envValue === undefined) {
+    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`);
+  }
+  switch (config.type) {
+    case "boolean":
+      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue);
+    case "number":
+      const numValue = Number(envValue);
+      if (isNaN(numValue)) {
+        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`);
+      }
+      return numValue;
+    case "string":
+    default:
+      return envValue;
+  }
+}
+
+class EnvStore {
+  parsedValues = new Map;
+  get(key) {
+    if (this.parsedValues.has(key)) {
+      return this.parsedValues.get(key);
+    }
+    if (!(key in envRegistry)) {
+      throw new Error(`Environment variable ${key} is not registered.`);
+    }
+    try {
+      const value = parseEnvValue(envRegistry[key]);
+      this.parsedValues.set(key, value);
+      return value;
+    } catch (error) {
+      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  has(key) {
+    return key in envRegistry;
+  }
+  clearCache() {
+    this.parsedValues.clear();
+  }
+}
+var envStore = singleton("env-store", () => new EnvStore);
+function clearEnvCache() {
+  envStore.clearCache();
+}
+function generateEnvMarkdown() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `# Environment Variables
+
+No environment variables registered.
+`;
+  }
+  let markdown = `# Environment Variables
+
+`;
+  for (const config of configs) {
+    markdown += `## ${config.name}
+
+`;
+    markdown += `${config.description}
+
+`;
+    markdown += `**Type:** \`${config.type || "string"}\`  
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      markdown += `**Default:** \`${defaultValue}\`  
+`;
+    } else {
+      markdown += `**Default:** *Required*  
+`;
+    }
+    markdown += `
+`;
+  }
+  return markdown;
+}
+function generateEnvColored() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `\x1B[1;36mEnvironment Variables\x1B[0m
+
+No environment variables registered.
+`;
+  }
+  let output = `\x1B[1;36mEnvironment Variables\x1B[0m
+
+`;
+  for (const config of configs) {
+    output += `\x1B[1;33m${config.name}\x1B[0m
+`;
+    output += `${config.description}
+`;
+    output += `\x1B[32mType:\x1B[0m \x1B[36m${config.type || "string"}\x1B[0m
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      output += `\x1B[32mDefault:\x1B[0m \x1B[35m${defaultValue}\x1B[0m
+`;
+    } else {
+      output += `\x1B[32mDefault:\x1B[0m \x1B[31mRequired\x1B[0m
+`;
+    }
+    output += `
+`;
+  }
+  return output;
+}
+var env = new Proxy({}, {
+  get(target, prop) {
+    if (typeof prop !== "string") {
+      return;
+    }
+    return envStore.get(prop);
+  },
+  has(target, prop) {
+    return envStore.has(prop);
+  },
+  ownKeys() {
+    return Object.keys(envRegistry);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    if (envStore.has(prop)) {
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => envStore.get(prop)
+      };
+    }
+    return;
+  }
+});
+
+// src/lib/tree-sitter-styled-text.ts
+function treeSitterToTextChunks(content, highlights, syntaxStyle) {
+  const chunks = [];
+  const defaultStyle = syntaxStyle.getStyle("default");
+  let currentIndex = 0;
+  for (let i = 0;i < highlights.length; i++) {
+    const [startIndex, endIndex, group] = highlights[i];
+    if (startIndex < currentIndex)
+      continue;
+    if (currentIndex < startIndex) {
+      const text2 = content.slice(currentIndex, startIndex);
+      chunks.push({
+        __isChunk: true,
+        text: text2,
+        fg: defaultStyle?.fg,
+        bg: defaultStyle?.bg,
+        attributes: defaultStyle ? createTextAttributes({
+          bold: defaultStyle.bold,
+          italic: defaultStyle.italic,
+          underline: defaultStyle.underline,
+          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;
+      }
+      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;
+  }
+  if (currentIndex < content.length) {
+    const text = content.slice(currentIndex);
+    chunks.push({
+      __isChunk: true,
+      text,
+      fg: defaultStyle?.fg,
+      bg: defaultStyle?.bg,
+      attributes: defaultStyle ? createTextAttributes({
+        bold: defaultStyle.bold,
+        italic: defaultStyle.italic,
+        underline: defaultStyle.underline,
+        dim: defaultStyle.dim
+      }) : 0
+    });
+  }
+  return chunks;
+}
+async function treeSitterToStyledText(content, filetype, syntaxStyle, client) {
+  const result = await client.highlightOnce(content, filetype);
+  if (result.highlights && result.highlights.length > 0) {
+    const chunks = treeSitterToTextChunks(content, result.highlights, syntaxStyle);
+    return new StyledText(chunks);
+  } else {
+    const defaultStyle = syntaxStyle.mergeStyles("default");
+    const chunks = [
+      {
+        __isChunk: true,
+        text: content,
+        fg: defaultStyle.fg,
+        bg: defaultStyle.bg,
+        attributes: defaultStyle.attributes
+      }
+    ];
+    return new StyledText(chunks);
+  }
+}
+
+// src/lib/tree-sitter/client.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/lib/debounce.ts
+var TIMERS_MAP = new Map;
+
+class DebounceController {
+  scopeId;
+  constructor(scopeId) {
+    this.scopeId = scopeId;
+    if (!TIMERS_MAP.has(this.scopeId)) {
+      TIMERS_MAP.set(this.scopeId, new Map);
+    }
+  }
+  debounce(id, ms, fn) {
+    const scopeMap = TIMERS_MAP.get(this.scopeId);
+    return new Promise((resolve, reject) => {
+      if (scopeMap.has(id)) {
+        clearTimeout(scopeMap.get(id));
+      }
+      const timerId = setTimeout(() => {
+        try {
+          resolve(fn());
+        } catch (error) {
+          reject(error);
+        }
+        scopeMap.delete(id);
+      }, ms);
+      scopeMap.set(id, timerId);
+    });
+  }
+  clearDebounce(id) {
+    const scopeMap = TIMERS_MAP.get(this.scopeId);
+    if (scopeMap && scopeMap.has(id)) {
+      clearTimeout(scopeMap.get(id));
+      scopeMap.delete(id);
+    }
+  }
+  clear() {
+    const scopeMap = TIMERS_MAP.get(this.scopeId);
+    if (scopeMap) {
+      scopeMap.forEach((timerId) => clearTimeout(timerId));
+      scopeMap.clear();
+    }
+  }
+}
+function createDebounce(scopeId) {
+  return new DebounceController(scopeId);
+}
+function clearDebounceScope(scopeId) {
+  const scopeMap = TIMERS_MAP.get(scopeId);
+  if (scopeMap) {
+    scopeMap.forEach((timerId) => clearTimeout(timerId));
+    scopeMap.clear();
+  }
+}
+
+// src/lib/queue.ts
+class ProcessQueue {
+  processor;
+  queue = [];
+  processing = false;
+  autoProcess = true;
+  constructor(processor, autoProcess = true) {
+    this.processor = processor;
+    this.autoProcess = autoProcess;
+  }
+  enqueue(item) {
+    this.queue.push(item);
+    if (!this.processing && this.autoProcess) {
+      this.processQueue();
+    }
+  }
+  processQueue() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    this.processing = true;
+    queueMicrotask(async () => {
+      if (this.queue.length === 0) {
+        this.processing = false;
+        return;
+      }
+      const item = this.queue.shift();
+      try {
+        await this.processor(item);
+      } catch (error) {
+        console.error("Error processing queue item:", error);
+      }
+      if (this.queue.length > 0) {
+        this.processQueue();
+      } else {
+        this.processing = false;
+      }
+    });
+  }
+  clear() {
+    this.queue = [];
+  }
+  isProcessing() {
+    return this.processing;
+  }
+  size() {
+    return this.queue.length;
+  }
+}
+
+// src/lib/tree-sitter/default-parsers.ts
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import javascript_highlights from "./assets/javascript/highlights.scm" with { type: "file" };
+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" };
+var _cachedParsers;
+function getParsers() {
+  if (!_cachedParsers) {
+    _cachedParsers = [
+      {
+        filetype: "javascript",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), javascript_highlights)]
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), javascript_language)
+      },
+      {
+        filetype: "typescript",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), typescript_highlights)]
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), typescript_language)
+      }
+    ];
+  }
+  return _cachedParsers;
+}
+
+// src/lib/tree-sitter/client.ts
+import { resolve as resolve2, isAbsolute } from "path";
+import { existsSync } from "fs";
+import { parse } from "path";
+registerEnvVar({
+  name: "OTUI_TREE_SITTER_WORKER_PATH",
+  description: "Path to the TreeSitter worker",
+  type: "string",
+  default: ""
+});
+var DEFAULT_PARSERS = getParsers();
+function addDefaultParsers(parsers) {
+  for (const parser of parsers) {
+    const existingIndex = DEFAULT_PARSERS.findIndex((p) => p.filetype === parser.filetype);
+    if (existingIndex >= 0) {
+      DEFAULT_PARSERS[existingIndex] = parser;
+    } else {
+      DEFAULT_PARSERS.push(parser);
+    }
+  }
+}
+var isUrl = (path) => path.startsWith("http://") || path.startsWith("https://");
+
+class TreeSitterClient extends EventEmitter2 {
+  initialized = false;
+  worker;
+  buffers = new Map;
+  initializePromise;
+  initializeResolvers;
+  messageCallbacks = new Map;
+  messageIdCounter = 0;
+  editQueues = new Map;
+  debouncer;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.debouncer = createDebounce("tree-sitter-client");
+    this.startWorker();
+  }
+  emitError(error, bufferId) {
+    if (this.listenerCount("error") > 0) {
+      this.emit("error", error, bufferId);
+    }
+  }
+  emitWarning(warning, bufferId) {
+    if (this.listenerCount("warning") > 0) {
+      this.emit("warning", warning, bufferId);
+    }
+  }
+  startWorker() {
+    if (this.worker) {
+      return;
+    }
+    let worker_path;
+    if (env.OTUI_TREE_SITTER_WORKER_PATH) {
+      worker_path = env.OTUI_TREE_SITTER_WORKER_PATH;
+    } else if (typeof OTUI_TREE_SITTER_WORKER_PATH !== "undefined") {
+      worker_path = OTUI_TREE_SITTER_WORKER_PATH;
+    } else if (this.options.workerPath) {
+      worker_path = this.options.workerPath;
+    } else {
+      worker_path = new URL("./parser.worker.js", import.meta.url).href;
+      if (!existsSync(resolve2(import.meta.dirname, "parser.worker.js"))) {
+        worker_path = new URL("./parser.worker.ts", import.meta.url).href;
+      }
+    }
+    this.worker = new Worker(worker_path);
+    this.worker.onmessage = this.handleWorkerMessage.bind(this);
+    this.worker.onerror = (error) => {
+      console.error("TreeSitter worker error:", error.message);
+      if (this.initializeResolvers) {
+        clearTimeout(this.initializeResolvers.timeoutId);
+        this.initializeResolvers.reject(new Error(`Worker error: ${error.message}`));
+        this.initializeResolvers = undefined;
+      }
+      this.emitError(`Worker error: ${error.message}`);
+    };
+  }
+  stopWorker() {
+    if (!this.worker) {
+      return;
+    }
+    this.worker.terminate();
+    this.worker = undefined;
+  }
+  handleReset() {
+    this.buffers.clear();
+    this.stopWorker();
+    this.startWorker();
+    this.initializePromise = undefined;
+    this.initializeResolvers = undefined;
+    return this.initialize();
+  }
+  async initialize() {
+    if (this.initializePromise) {
+      return this.initializePromise;
+    }
+    this.initializePromise = new Promise((resolve3, reject) => {
+      const timeoutMs = this.options.initTimeout ?? 1e4;
+      const timeoutId = setTimeout(() => {
+        const error = new Error("Worker initialization timed out");
+        console.error("TreeSitter client:", error.message);
+        this.initializeResolvers = undefined;
+        reject(error);
+      }, timeoutMs);
+      this.initializeResolvers = { resolve: resolve3, reject, timeoutId };
+      this.worker?.postMessage({
+        type: "INIT",
+        dataPath: this.options.dataPath
+      });
+    });
+    await this.initializePromise;
+    await this.registerDefaultParsers();
+    return this.initializePromise;
+  }
+  async registerDefaultParsers() {
+    for (const parser of DEFAULT_PARSERS) {
+      this.addFiletypeParser(parser);
+    }
+  }
+  resolvePath(path) {
+    if (isUrl(path)) {
+      return path;
+    }
+    if (/\$bunfs/.test(path)) {
+      return "/$bunfs/root/" + parse(path).base;
+    }
+    if (!isAbsolute(path)) {
+      return resolve2(path);
+    }
+    return path;
+  }
+  addFiletypeParser(filetypeParser) {
+    const resolvedParser = {
+      ...filetypeParser,
+      wasm: this.resolvePath(filetypeParser.wasm),
+      queries: {
+        highlights: filetypeParser.queries.highlights.map((path) => this.resolvePath(path))
+      }
+    };
+    this.worker?.postMessage({ type: "ADD_FILETYPE_PARSER", filetypeParser: resolvedParser });
+  }
+  async getPerformance() {
+    const messageId = `performance_${this.messageIdCounter++}`;
+    return new Promise((resolve3) => {
+      this.messageCallbacks.set(messageId, resolve3);
+      this.worker?.postMessage({ type: "GET_PERFORMANCE", messageId });
+    });
+  }
+  async highlightOnce(content, filetype) {
+    if (!this.initialized) {
+      try {
+        await this.initialize();
+      } catch (error) {
+        return { error: "Could not highlight because of initialization error" };
+      }
+    }
+    const messageId = `oneshot_${this.messageIdCounter++}`;
+    return new Promise((resolve3) => {
+      this.messageCallbacks.set(messageId, resolve3);
+      this.worker?.postMessage({
+        type: "ONESHOT_HIGHLIGHT",
+        content,
+        filetype,
+        messageId
+      });
+    });
+  }
+  handleWorkerMessage(event) {
+    const { type, bufferId, error, highlights, warning, messageId, hasParser, performance: performance2, version } = event.data;
+    if (type === "HIGHLIGHT_RESPONSE") {
+      const buffer = this.buffers.get(bufferId);
+      if (!buffer || !buffer.hasParser)
+        return;
+      if (buffer.version !== version) {
+        this.resetBuffer(bufferId, buffer.version, buffer.content);
+        return;
+      }
+      this.emit("highlights:response", bufferId, version, highlights);
+    }
+    if (type === "INIT_RESPONSE") {
+      if (this.initializeResolvers) {
+        clearTimeout(this.initializeResolvers.timeoutId);
+        if (error) {
+          console.error("TreeSitter client initialization failed:", error);
+          this.initializeResolvers.reject(new Error(error));
+        } else {
+          this.initialized = true;
+          this.initializeResolvers.resolve();
+        }
+        this.initializeResolvers = undefined;
+        return;
+      }
+    }
+    if (type === "PARSER_INIT_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ hasParser, warning, error });
+      }
+      return;
+    }
+    if (type === "PRELOAD_PARSER_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ hasParser });
+      }
+      return;
+    }
+    if (type === "BUFFER_DISPOSED") {
+      const callback = this.messageCallbacks.get(`dispose_${bufferId}`);
+      if (callback) {
+        this.messageCallbacks.delete(`dispose_${bufferId}`);
+        callback(true);
+      }
+      this.emit("buffer:disposed", bufferId);
+      return;
+    }
+    if (type === "PERFORMANCE_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback(performance2);
+      }
+      return;
+    }
+    if (type === "ONESHOT_HIGHLIGHT_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ highlights, warning, error });
+      }
+      return;
+    }
+    if (type === "UPDATE_DATA_PATH_RESPONSE") {
+      const callback = this.messageCallbacks.get(messageId);
+      if (callback) {
+        this.messageCallbacks.delete(messageId);
+        callback({ error });
+      }
+      return;
+    }
+    if (warning) {
+      this.emitWarning(warning, bufferId);
+      return;
+    }
+    if (error) {
+      this.emitError(error, bufferId);
+      return;
+    }
+    if (type === "WORKER_LOG") {
+      const { logType, data } = event.data;
+      const message = data.join(" ");
+      this.emit("worker:log", logType, message);
+      if (logType === "log") {
+        console.log("Worker stdout:", ...data);
+      } else if (logType === "error") {
+        console.error("Worker stderr:", ...data);
+      }
+      return;
+    }
+  }
+  async preloadParser(filetype) {
+    const messageId = `has_parser_${this.messageIdCounter++}`;
+    const response = await new Promise((resolve3) => {
+      this.messageCallbacks.set(messageId, resolve3);
+      this.worker?.postMessage({
+        type: "PRELOAD_PARSER",
+        filetype,
+        messageId
+      });
+    });
+    return response.hasParser;
+  }
+  async createBuffer(id, content, filetype, version = 1, autoInitialize = true) {
+    if (!this.initialized) {
+      if (!autoInitialize) {
+        this.emitError("Could not create buffer because client is not initialized");
+        return false;
+      }
+      try {
+        await this.initialize();
+      } catch (error) {
+        this.emitError("Could not create buffer because of initialization error");
+        return false;
+      }
+    }
+    if (this.buffers.has(id)) {
+      throw new Error(`Buffer with id ${id} already exists`);
+    }
+    this.buffers.set(id, { id, content, filetype, version, hasParser: false });
+    const messageId = `init_${this.messageIdCounter++}`;
+    const response = await new Promise((resolve3) => {
+      this.messageCallbacks.set(messageId, resolve3);
+      this.worker?.postMessage({
+        type: "INITIALIZE_PARSER",
+        bufferId: id,
+        version,
+        content,
+        filetype,
+        messageId
+      });
+    });
+    if (!response.hasParser) {
+      this.emit("buffer:initialized", id, false);
+      if (filetype !== "plaintext") {
+        this.emitWarning(response.warning || response.error || "Buffer has no parser", id);
+      }
+      return false;
+    }
+    const bufferState = { id, content, filetype, version, hasParser: true };
+    this.buffers.set(id, bufferState);
+    this.emit("buffer:initialized", id, true);
+    return true;
+  }
+  async updateBuffer(id, edits, newContent, version) {
+    if (!this.initialized) {
+      return;
+    }
+    const buffer = this.buffers.get(id);
+    if (!buffer || !buffer.hasParser) {
+      return;
+    }
+    this.buffers.set(id, { ...buffer, content: newContent, version });
+    if (!this.editQueues.has(id)) {
+      this.editQueues.set(id, new ProcessQueue((item) => this.processEdit(id, item.edits, item.newContent, item.version, item.isReset)));
+    }
+    const bufferQueue = this.editQueues.get(id);
+    bufferQueue.enqueue({ edits, newContent, version });
+  }
+  async processEdit(bufferId, edits, newContent, version, isReset = false) {
+    this.worker?.postMessage({
+      type: isReset ? "RESET_BUFFER" : "HANDLE_EDITS",
+      bufferId,
+      version,
+      content: newContent,
+      edits
+    });
+  }
+  async removeBuffer(bufferId) {
+    if (!this.initialized) {
+      return;
+    }
+    this.buffers.delete(bufferId);
+    if (this.editQueues.has(bufferId)) {
+      this.editQueues.get(bufferId)?.clear();
+      this.editQueues.delete(bufferId);
+    }
+    if (this.worker) {
+      await new Promise((resolve3) => {
+        const messageId = `dispose_${bufferId}`;
+        this.messageCallbacks.set(messageId, resolve3);
+        try {
+          this.worker.postMessage({
+            type: "DISPOSE_BUFFER",
+            bufferId
+          });
+        } catch (error) {
+          console.error("Error disposing buffer", error);
+          resolve3(false);
+        }
+        setTimeout(() => {
+          if (this.messageCallbacks.has(messageId)) {
+            this.messageCallbacks.delete(messageId);
+            console.warn({ bufferId }, "Timed out waiting for buffer to be disposed");
+            resolve3(false);
+          }
+        }, 3000);
+      });
+    }
+    this.debouncer.clearDebounce(`reset-${bufferId}`);
+  }
+  async destroy() {
+    if (this.initializeResolvers) {
+      clearTimeout(this.initializeResolvers.timeoutId);
+      this.initializeResolvers = undefined;
+    }
+    for (const [messageId, callback] of this.messageCallbacks.entries()) {
+      if (typeof callback === "function") {
+        try {
+          callback({ error: "Client destroyed" });
+        } catch (e) {}
+      }
+    }
+    this.messageCallbacks.clear();
+    clearDebounceScope("tree-sitter-client");
+    this.debouncer.clear();
+    this.editQueues.clear();
+    this.buffers.clear();
+    this.stopWorker();
+    this.initialized = false;
+    this.initializePromise = undefined;
+  }
+  async resetBuffer(bufferId, version, content) {
+    if (!this.initialized) {
+      return;
+    }
+    const buffer = this.buffers.get(bufferId);
+    if (!buffer || !buffer.hasParser) {
+      this.emitError("Cannot reset buffer with no parser", bufferId);
+      return;
+    }
+    this.buffers.set(bufferId, { ...buffer, content, version });
+    this.debouncer.debounce(`reset-${bufferId}`, 10, () => this.processEdit(bufferId, [], content, version, true));
+  }
+  getBuffer(bufferId) {
+    return this.buffers.get(bufferId);
+  }
+  getAllBuffers() {
+    return Array.from(this.buffers.values());
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  async setDataPath(dataPath) {
+    if (this.options.dataPath === dataPath) {
+      return;
+    }
+    this.options.dataPath = dataPath;
+    if (this.initialized && this.worker) {
+      const messageId = `update_datapath_${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: "UPDATE_DATA_PATH",
+          dataPath,
+          messageId
+        });
+      });
+    }
+  }
+}
+
+// src/lib/data-paths.ts
+import os from "os";
+import path from "path";
+import { EventEmitter as EventEmitter3 } from "events";
+
+// src/lib/validate-dir-name.ts
+function isValidDirectoryName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  if (name.trim().length === 0) {
+    return false;
+  }
+  const reservedNames = [
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9"
+  ];
+  if (reservedNames.includes(name.toUpperCase())) {
+    return false;
+  }
+  const invalidChars = /[<>:"|?*\/\\\x00-\x1f]/;
+  if (invalidChars.test(name)) {
+    return false;
+  }
+  if (name.endsWith(".") || name.endsWith(" ")) {
+    return false;
+  }
+  if (name === "." || name === "..") {
+    return false;
+  }
+  return true;
+}
+
+// src/lib/data-paths.ts
+registerEnvVar({
+  name: "XDG_CONFIG_HOME",
+  description: "Base directory for user-specific configuration files",
+  type: "string",
+  default: ""
+});
+registerEnvVar({
+  name: "XDG_DATA_HOME",
+  description: "Base directory for user-specific data files",
+  type: "string",
+  default: ""
+});
+
+class DataPathsManager extends EventEmitter3 {
+  _appName;
+  _globalConfigPath;
+  _globalConfigFile;
+  _localConfigFile;
+  _globalDataPath;
+  constructor() {
+    super();
+    this._appName = "opentui";
   }
-  hasSelection() {
-    return this.localSelection !== null;
+  get appName() {
+    return this._appName;
   }
-  getSelection() {
-    return this.localSelection;
+  set appName(value) {
+    if (!isValidDirectoryName(value)) {
+      throw new Error(`Invalid app name "${value}": must be a valid directory name`);
+    }
+    if (this._appName !== value) {
+      this._appName = value;
+      this._globalConfigPath = undefined;
+      this._globalConfigFile = undefined;
+      this._localConfigFile = undefined;
+      this._globalDataPath = undefined;
+      this.emit("paths:changed", this.toObject());
+    }
   }
-  shouldStartSelection(localX, localY, width, height) {
-    if (localX < 0 || localX >= width || localY < 0 || localY >= height) {
-      return false;
+  get globalConfigPath() {
+    if (this._globalConfigPath === undefined) {
+      const homeDir = os.homedir();
+      const xdgConfigHome = env.XDG_CONFIG_HOME;
+      const baseConfigDir = xdgConfigHome || path.join(homeDir, ".config");
+      this._globalConfigPath = path.join(baseConfigDir, this._appName);
     }
-    const text = this.getText();
-    const font = this.getFont();
-    const charIndex = coordinateToCharacterIndex(localX, text, font);
-    return charIndex >= 0 && charIndex <= text.length;
+    return this._globalConfigPath;
   }
-  onLocalSelectionChanged(localSelection, width, height) {
-    const previousSelection = this.localSelection;
-    if (!localSelection?.isActive) {
-      this.localSelection = null;
-      return previousSelection !== null;
+  get globalConfigFile() {
+    if (this._globalConfigFile === undefined) {
+      this._globalConfigFile = path.join(this.globalConfigPath, "init.ts");
     }
-    const text = this.getText();
-    const font = this.getFont();
-    const selStart = { x: localSelection.anchorX, y: localSelection.anchorY };
-    const selEnd = { x: localSelection.focusX, y: localSelection.focusY };
-    if (height - 1 < selStart.y || 0 > selEnd.y) {
-      this.localSelection = null;
-      return previousSelection !== null;
+    return this._globalConfigFile;
+  }
+  get localConfigFile() {
+    if (this._localConfigFile === undefined) {
+      this._localConfigFile = path.join(process.cwd(), `.${this._appName}.ts`);
     }
-    let startCharIndex = 0;
-    let endCharIndex = text.length;
-    if (selStart.y > height - 1) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    } else if (selStart.y >= 0 && selStart.y <= height - 1) {
-      if (selStart.x > 0) {
-        startCharIndex = coordinateToCharacterIndex(selStart.x, text, font);
-      }
+    return this._localConfigFile;
+  }
+  get globalDataPath() {
+    if (this._globalDataPath === undefined) {
+      const homeDir = os.homedir();
+      const xdgDataHome = env.XDG_DATA_HOME;
+      const baseDataDir = xdgDataHome || path.join(homeDir, ".local/share");
+      this._globalDataPath = path.join(baseDataDir, this._appName);
     }
-    if (selEnd.y < 0) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    } else if (selEnd.y >= 0 && selEnd.y <= height - 1) {
-      if (selEnd.x >= 0) {
-        endCharIndex = coordinateToCharacterIndex(selEnd.x, text, font);
+    return this._globalDataPath;
+  }
+  toObject() {
+    return {
+      globalConfigPath: this.globalConfigPath,
+      globalConfigFile: this.globalConfigFile,
+      localConfigFile: this.localConfigFile,
+      globalDataPath: this.globalDataPath
+    };
+  }
+}
+function getDataPaths() {
+  return singleton("data-paths-opentui", () => new DataPathsManager);
+}
+
+// src/lib/tree-sitter/resolve-ft.ts
+function extToFiletype(extension) {
+  const extensionToFiletype = new Map([
+    ["js", "javascript"],
+    ["jsx", "javascriptreact"],
+    ["ts", "typescript"],
+    ["tsx", "typescriptreact"],
+    ["md", "markdown"],
+    ["json", "json"],
+    ["py", "python"],
+    ["rb", "ruby"],
+    ["go", "go"],
+    ["rs", "rust"],
+    ["c", "c"],
+    ["cpp", "cpp"],
+    ["h", "c"],
+    ["hpp", "cpp"],
+    ["html", "html"],
+    ["css", "css"],
+    ["scss", "scss"],
+    ["less", "less"],
+    ["sh", "shell"],
+    ["bash", "shell"],
+    ["zsh", "shell"],
+    ["vim", "vim"],
+    ["yaml", "yaml"],
+    ["yml", "yaml"],
+    ["toml", "toml"],
+    ["xml", "xml"],
+    ["zig", "zig"]
+  ]);
+  return extensionToFiletype.get(extension);
+}
+function pathToFiletype(path2) {
+  if (typeof path2 !== "string")
+    return;
+  const lastDot = path2.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === path2.length - 1) {
+    return;
+  }
+  const extension = path2.substring(lastDot + 1);
+  return extToFiletype(extension);
+}
+
+// src/lib/tree-sitter/assets/update.ts
+import { readFile, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import * as path3 from "path";
+
+// src/lib/tree-sitter/download-utils.ts
+import { mkdir, writeFile } from "fs/promises";
+import * as path2 from "path";
+
+class DownloadUtils {
+  static hashUrl(url) {
+    let hash = 0;
+    for (let i = 0;i < url.length; i++) {
+      const char = url.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+  static async downloadOrLoad(source, cacheDir, cacheSubdir, fileExtension, useHashForCache = true, filetype) {
+    const isUrl2 = source.startsWith("http://") || source.startsWith("https://");
+    if (isUrl2) {
+      let cacheFileName;
+      if (useHashForCache) {
+        const hash = this.hashUrl(source);
+        cacheFileName = filetype ? `${filetype}-${hash}${fileExtension}` : `${hash}${fileExtension}`;
       } else {
-        endCharIndex = 0;
+        cacheFileName = path2.basename(source);
+      }
+      const cacheFile = path2.join(cacheDir, cacheSubdir, cacheFileName);
+      await mkdir(path2.dirname(cacheFile), { recursive: true });
+      try {
+        const cachedContent = await Bun.file(cacheFile).arrayBuffer();
+        if (cachedContent.byteLength > 0) {
+          console.log(`Loaded from cache: ${cacheFile} (${source})`);
+          return { content: cachedContent, filePath: cacheFile };
+        }
+      } catch (error) {}
+      try {
+        console.log(`Downloading from URL: ${source}`);
+        const response = await fetch(source);
+        if (!response.ok) {
+          return { error: `Failed to fetch from ${source}: ${response.statusText}` };
+        }
+        const content = await response.arrayBuffer();
+        try {
+          await writeFile(cacheFile, Buffer.from(content));
+          console.log(`Cached: ${source}`);
+        } catch (cacheError) {
+          console.warn(`Failed to cache: ${cacheError}`);
+        }
+        return { content, filePath: cacheFile };
+      } catch (error) {
+        return { error: `Error downloading from ${source}: ${error}` };
+      }
+    } else {
+      try {
+        console.log(`Loading from local path: ${source}`);
+        const content = await Bun.file(source).arrayBuffer();
+        return { content, filePath: source };
+      } catch (error) {
+        return { error: `Error loading from local path ${source}: ${error}` };
       }
     }
-    if (startCharIndex < endCharIndex && startCharIndex >= 0 && endCharIndex <= text.length) {
-      this.localSelection = { start: startCharIndex, end: endCharIndex };
+  }
+  static async downloadToPath(source, targetPath) {
+    const isUrl2 = source.startsWith("http://") || source.startsWith("https://");
+    await mkdir(path2.dirname(targetPath), { recursive: true });
+    if (isUrl2) {
+      try {
+        console.log(`Downloading from URL: ${source}`);
+        const response = await fetch(source);
+        if (!response.ok) {
+          return { error: `Failed to fetch from ${source}: ${response.statusText}` };
+        }
+        const content = await response.arrayBuffer();
+        await writeFile(targetPath, Buffer.from(content));
+        console.log(`Downloaded: ${source} -> ${targetPath}`);
+        return { content, filePath: targetPath };
+      } catch (error) {
+        return { error: `Error downloading from ${source}: ${error}` };
+      }
     } else {
-      this.localSelection = null;
+      try {
+        console.log(`Copying from local path: ${source}`);
+        const content = await Bun.file(source).arrayBuffer();
+        await writeFile(targetPath, Buffer.from(content));
+        return { content, filePath: targetPath };
+      } catch (error) {
+        return { error: `Error copying from local path ${source}: ${error}` };
+      }
     }
-    return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
   }
+  static async fetchHighlightQueries(sources, cacheDir, filetype) {
+    const queryPromises = sources.map((source) => this.fetchHighlightQuery(source, cacheDir, filetype));
+    const queryResults = await Promise.all(queryPromises);
+    const validQueries = queryResults.filter((query) => query.trim().length > 0);
+    return validQueries.join(`
+`);
+  }
+  static async fetchHighlightQuery(source, cacheDir, filetype) {
+    const result = await this.downloadOrLoad(source, cacheDir, "queries", ".scm", true, filetype);
+    if (result.error) {
+      console.error(`Error fetching highlight query from ${source}:`, result.error);
+      return "";
+    }
+    if (result.content) {
+      return new TextDecoder().decode(result.content);
+    }
+    return "";
+  }
+}
+
+// src/lib/tree-sitter/assets/update.ts
+var __dirname = "/Users/runner/work/opentui/opentui/packages/core/src/lib/tree-sitter/assets";
+function getDefaultOptions() {
+  return {
+    configPath: path3.resolve(__dirname, "../parsers-config.json"),
+    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);
+}
+async function downloadLanguage(filetype, languageUrl, assetsDir, outputPath) {
+  const languageDir = path3.join(assetsDir, filetype);
+  const languageFilename = path3.basename(languageUrl);
+  const languagePath = path3.join(languageDir, languageFilename);
+  const result = await DownloadUtils.downloadToPath(languageUrl, languagePath);
+  if (result.error) {
+    throw new Error(`Failed to download language for ${filetype}: ${result.error}`);
+  }
+  return "./" + path3.relative(path3.dirname(outputPath), languagePath);
+}
+async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputPath) {
+  const queriesDir = path3.join(assetsDir, filetype);
+  const highlightsPath = path3.join(queriesDir, "highlights.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}`);
+        continue;
+      }
+      const content = await response.text();
+      if (content.trim()) {
+        queryContents.push(`; Query from: ${queryUrl}
+${content}`);
+        console.log(`    \u2713 Downloaded ${content.split(`
+`).length} lines`);
+      }
+    } 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);
+}
+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" }`;
+  }).join(`
+`);
+  const parserDefinitions = parsers.map((parser) => {
+    const safeFiletype = parser.filetype.replace(/[^a-zA-Z0-9]/g, "_");
+    return `      {
+        filetype: "${parser.filetype}",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_highlights)],
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_language),
+      }`;
+  }).join(`,
+`);
+  const fileContent = `// This file is generated by assets/update.ts - DO NOT EDIT MANUALLY
+// Run 'bun assets/update.ts' to regenerate this file
+// Last generated: ${new Date().toISOString()}
+
+import type { FiletypeParserOptions } from "./types"
+import { resolve, dirname } from "path"
+import { fileURLToPath } from "url"
+
+${imports}
+
+// Cached parsers to avoid re-resolving paths on every call
+let _cachedParsers: FiletypeParserOptions[] | undefined
+
+export function getParsers(): FiletypeParserOptions[] {
+  if (!_cachedParsers) {
+    _cachedParsers = [
+${parserDefinitions},
+    ]
+  }
+  return _cachedParsers
+}
+`;
+  await mkdir2(path3.dirname(outputPath), { recursive: true });
+  await writeFile2(outputPath, fileContent, "utf-8");
+  console.log(`Generated ${path3.basename(outputPath)} with ${parsers.length} parsers`);
+}
+async function main(options) {
+  const opts = { ...getDefaultOptions(), ...options };
+  try {
+    console.log("Loading parsers configuration...");
+    console.log(`  Config: ${opts.configPath}`);
+    console.log(`  Assets Dir: ${opts.assetsDir}`);
+    console.log(`  Output: ${opts.outputPath}`);
+    const config = await loadConfig(opts.configPath);
+    console.log(`Found ${config.parsers.length} parsers to process`);
+    const generatedParsers = [];
+    for (const parser of config.parsers) {
+      console.log(`Processing ${parser.filetype}...`);
+      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);
+      generatedParsers.push({
+        filetype: parser.filetype,
+        languagePath,
+        highlightsPath
+      });
+      console.log(`  \u2713 Completed ${parser.filetype}`);
+    }
+    console.log("Generating output file...");
+    await generateDefaultParsersFile(generatedParsers, opts.outputPath);
+    console.log("\u2705 Update completed successfully!");
+  } catch (error) {
+    console.error("\u274C Update failed:", error);
+    process.exit(1);
+  }
+}
+if (false) {}
+
+// src/lib/tree-sitter/index.ts
+function getTreeSitterClient() {
+  const dataPathsManager = getDataPaths();
+  const defaultOptions = {
+    dataPath: dataPathsManager.globalDataPath
+  };
+  return singleton("tree-sitter-client", () => {
+    const client2 = new TreeSitterClient(defaultOptions);
+    dataPathsManager.on("paths:changed", (paths) => {
+      client2.setDataPath(paths.globalDataPath);
+    });
+    return client2;
+  });
 }
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer2, JSCallback, ptr } from "bun:ffi";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 
 // src/buffer.ts
 import { toArrayBuffer } from "bun:ffi";
@@ -5007,9 +6443,24 @@ class OptimizedBuffer {
 // src/zig.ts
 var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
 var targetLibPath = module.default;
-if (!existsSync(targetLibPath)) {
+if (/\$bunfs/.test(targetLibPath)) {
+  targetLibPath = targetLibPath.replace("../", "");
+}
+if (!existsSync2(targetLibPath)) {
   throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
 }
+registerEnvVar({
+  name: "OTUI_DEBUG_FFI",
+  description: "Enable debug logging for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_TRACE_FFI",
+  description: "Enable tracing for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
   const rawSymbols = dlopen(resolvedLibPath, {
@@ -5057,6 +6508,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    queryPixelResolution: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createOptimizedBuffer: {
       args: ["u32", "u32", "bool", "u8", "ptr", "usize"],
       returns: "ptr"
@@ -5346,7 +6801,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     }
   });
-  if (process.env.DEBUG_FFI === "true" || process.env.TRACE_FFI === "true") {
+  if (env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) {
     return {
       symbols: convertToDebugSymbols(rawSymbols.symbols)
     };
@@ -5360,7 +6815,7 @@ function convertToDebugSymbols(symbols) {
   Object.entries(symbols).forEach(([key, value]) => {
     debugSymbols[key] = value;
   });
-  if (process.env.DEBUG_FFI === "true") {
+  if (env.OTUI_DEBUG_FFI) {
     Object.entries(symbols).forEach(([key, value]) => {
       if (typeof value === "function") {
         debugSymbols[key] = (...args) => {
@@ -5372,7 +6827,7 @@ function convertToDebugSymbols(symbols) {
       }
     });
   }
-  if (process.env.TRACE_FFI === "true") {
+  if (env.OTUI_TRACE_FFI) {
     hasTracing = true;
     Object.entries(symbols).forEach(([key, value]) => {
       if (typeof value === "function") {
@@ -5734,6 +7189,9 @@ class FFIRenderLib {
   setupTerminal(renderer, useAlternateScreen) {
     this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
   }
+  queryPixelResolution(renderer) {
+    this.opentui.symbols.queryPixelResolution(renderer);
+  }
   createTextBuffer(widthMethod) {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
     const bufferPtr = this.opentui.symbols.createTextBuffer(widthMethodCode);
@@ -6092,7 +7550,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -6185,7 +7643,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter2 {
+class BaseRenderable extends EventEmitter4 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -6222,6 +7680,9 @@ class BaseRenderable extends EventEmitter2 {
     this._visible = value;
   }
 }
+var yogaConfig = src_default.Config.create();
+yogaConfig.setUseWebDefaults(false);
+yogaConfig.setPointScaleFactor(1);
 
 class Renderable extends BaseRenderable {
   static renderablesByNumber = new Map;
@@ -6242,11 +7703,13 @@ class Renderable extends BaseRenderable {
   _focusable = false;
   _focused = false;
   keypressHandler = null;
+  pasteHandler = null;
   _live = false;
   _liveCount = 0;
   _sizeChangeListener = undefined;
   _mouseListener = null;
   _mouseListeners = {};
+  _pasteListener = undefined;
   _keyListeners = {};
   yogaNode;
   _positionType = "relative";
@@ -6283,7 +7746,7 @@ class Renderable extends BaseRenderable {
     this.buffered = options.buffered ?? false;
     this._live = options.live ?? false;
     this._liveCount = this._live && this._visible ? 1 : 0;
-    this.yogaNode = src_default.Node.create();
+    this.yogaNode = src_default.Node.create(yogaConfig);
     this.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
     this.setupYogaProperties(options);
     this.applyEventOptions(options);
@@ -6352,11 +7815,18 @@ class Renderable extends BaseRenderable {
     this.requestRender();
     this.keypressHandler = (key) => {
       this._keyListeners["down"]?.(key);
-      if (this.handleKeyPress) {
+      if (!key.defaultPrevented && this.handleKeyPress) {
         this.handleKeyPress(key);
       }
     };
-    this.ctx.keyInput.on("keypress", this.keypressHandler);
+    this.pasteHandler = (event) => {
+      this._pasteListener?.call(this, event.text);
+      if (!event.defaultPrevented && this.handlePaste) {
+        this.handlePaste(event.text);
+      }
+    };
+    this.ctx._internalKeyInput.onInternal("keypress", this.keypressHandler);
+    this.ctx._internalKeyInput.onInternal("paste", this.pasteHandler);
     this.emit("focused" /* FOCUSED */);
   }
   blur() {
@@ -6365,9 +7835,13 @@ class Renderable extends BaseRenderable {
     this._focused = false;
     this.requestRender();
     if (this.keypressHandler) {
-      this.ctx.keyInput.off("keypress", this.keypressHandler);
+      this.ctx._internalKeyInput.offInternal("keypress", this.keypressHandler);
       this.keypressHandler = null;
     }
+    if (this.pasteHandler) {
+      this.ctx._internalKeyInput.offInternal("paste", this.pasteHandler);
+      this.pasteHandler = null;
+    }
     this.emit("blurred" /* BLURRED */);
   }
   get focused() {
@@ -6396,9 +7870,11 @@ class Renderable extends BaseRenderable {
     for (const child of this._childrenInLayoutOrder) {
       if (child.id === id)
         return child;
-      const found = child.findDescendantById(id);
-      if (found)
-        return found;
+      if (isRenderable(child)) {
+        const found = child.findDescendantById(id);
+        if (found)
+          return found;
+      }
     }
     return;
   }
@@ -6551,8 +8027,7 @@ class Renderable extends BaseRenderable {
     if (options.flexShrink !== undefined) {
       node.setFlexShrink(options.flexShrink);
     } else {
-      const shrinkValue = options.flexGrow && options.flexGrow > 0 ? 1 : 0;
-      node.setFlexShrink(shrinkValue);
+      node.setFlexShrink(1);
     }
     if (options.flexDirection !== undefined) {
       node.setFlexDirection(parseFlexDirection(options.flexDirection));
@@ -6965,10 +8440,11 @@ class Renderable extends BaseRenderable {
     if (renderable.parent === this) {
       this.yogaNode.removeChild(renderable.getLayoutNode());
       this._childrenInLayoutOrder.splice(this._childrenInLayoutOrder.indexOf(renderable), 1);
-    } else if (renderable.parent) {
+    } else {
       this.replaceParent(renderable);
       this.needsZIndexSort = true;
       this.renderableMapById.set(renderable.id, renderable);
+      this._childrenInZIndexOrder.push(renderable);
       if (typeof renderable.onLifecyclePass === "function") {
         this._ctx.registerLifecyclePass(renderable);
       }
@@ -7013,6 +8489,16 @@ class Renderable extends BaseRenderable {
         if (zIndexIndex !== -1) {
           this._childrenInZIndexOrder.splice(zIndexIndex, 1);
         }
+        if (this._forceLayoutUpdateFor) {
+          const forceIndex = this._forceLayoutUpdateFor.findIndex((obj2) => obj2.id === id);
+          if (forceIndex !== -1) {
+            this._forceLayoutUpdateFor?.splice(forceIndex, 1);
+          }
+        }
+        const newChildIndex = this._newChildren.findIndex((obj2) => obj2.id === id);
+        if (newChildIndex !== -1) {
+          this._newChildren?.splice(newChildIndex, 1);
+        }
         this.childrenPrimarySortDirty = true;
       }
     }
@@ -7121,7 +8607,8 @@ class Renderable extends BaseRenderable {
     } catch (e) {}
   }
   destroyRecursively() {
-    for (const child of this._childrenInLayoutOrder) {
+    const children = [...this._childrenInLayoutOrder];
+    for (const child of children) {
       child.destroyRecursively();
     }
     this.destroy();
@@ -7196,6 +8683,12 @@ class Renderable extends BaseRenderable {
     else
       delete this._mouseListeners["scroll"];
   }
+  set onPaste(handler) {
+    this._pasteListener = handler;
+  }
+  get onPaste() {
+    return this._pasteListener;
+  }
   set onKeyDown(handler) {
     if (handler)
       this._keyListeners["down"] = handler;
@@ -7222,23 +8715,20 @@ class Renderable extends BaseRenderable {
     this.onMouseOver = options.onMouseOver;
     this.onMouseOut = options.onMouseOut;
     this.onMouseScroll = options.onMouseScroll;
+    this.onPaste = options.onPaste;
     this.onKeyDown = options.onKeyDown;
     this.onSizeChange = options.onSizeChange;
   }
 }
 
 class RootRenderable extends Renderable {
-  yogaConfig;
   renderList = [];
   constructor(ctx) {
     super(ctx, { id: "__root__", zIndex: 0, visible: true, width: ctx.width, height: ctx.height, enableLayout: true });
-    this.yogaConfig = src_default.Config.create();
-    this.yogaConfig.setUseWebDefaults(false);
-    this.yogaConfig.setPointScaleFactor(1);
     if (this.yogaNode) {
       this.yogaNode.free();
     }
-    this.yogaNode = src_default.Node.create(this.yogaConfig);
+    this.yogaNode = src_default.Node.create(yogaConfig);
     this.yogaNode.setWidth(ctx.width);
     this.yogaNode.setHeight(ctx.height);
     this.yogaNode.setFlexDirection(FlexDirection.Column);
@@ -7288,11 +8778,6 @@ class RootRenderable extends Renderable {
     this.height = height;
     this.emit("resized" /* RESIZED */, { width, height });
   }
-  destroySelf() {
-    try {
-      this.yogaConfig.free();
-    } catch (error) {}
-  }
 }
 
 // src/renderables/composition/vnode.ts
@@ -7462,17 +8947,17 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 import { Console } from "console";
 import fs from "fs";
-import path from "path";
+import path4 from "path";
 import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 
-class Capture extends EventEmitter3 {
+class Capture extends EventEmitter5 {
   output = [];
   constructor() {
     super();
@@ -7535,8 +9020,20 @@ function getCallerInfo() {
   return { functionName, fullPath, fileName, lineNumber, columnNumber };
 }
 var capture = singleton("ConsoleCapture", () => new Capture);
+registerEnvVar({
+  name: "OTUI_USE_CONSOLE",
+  description: "Whether to use the console. Will not capture console output if set to false.",
+  type: "boolean",
+  default: true
+});
+registerEnvVar({
+  name: "SHOW_CONSOLE",
+  description: "Show the console at startup if set to true.",
+  type: "boolean",
+  default: false
+});
 
-class TerminalConsoleCache extends EventEmitter4 {
+class TerminalConsoleCache extends EventEmitter6 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -7552,7 +9049,7 @@ class TerminalConsoleCache extends EventEmitter4 {
     this.overrideConsoleMethods();
   }
   setupConsoleCapture() {
-    if (process.env.OTUI_USE_CONSOLE === "false")
+    if (!env.OTUI_USE_CONSOLE)
       return;
     const mockStdout = new CapturedWritableStream("stdout", capture);
     const mockStderr = new CapturedWritableStream("stderr", capture);
@@ -7657,7 +9154,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter4 {
+class TerminalConsole extends EventEmitter6 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -7717,7 +9214,7 @@ class TerminalConsole extends EventEmitter4 {
     terminalConsoleCache.on("entry", (logEntry) => {
       this._handleNewLog(logEntry);
     });
-    if (process.env.SHOW_CONSOLE === "true") {
+    if (env.SHOW_CONSOLE) {
       this.show();
     }
   }
@@ -8096,7 +9593,7 @@ class TerminalConsole extends EventEmitter4 {
     try {
       const timestamp = Date.now();
       const filename = `_console_${timestamp}.log`;
-      const filepath = path.join(process.cwd(), filename);
+      const filepath = path4.join(process.cwd(), filename);
       const allLogEntries = [...this._allLogEntries, ...terminalConsoleCache.cachedLogs];
       const logLines = [];
       for (const [date, level, args, callerInfo] of allLogEntries) {
@@ -8116,39 +9613,8 @@ class TerminalConsole extends EventEmitter4 {
   }
 }
 
-// src/ansi.ts
-var ANSI = {
-  switchToAlternateScreen: "\x1B[?1049h",
-  switchToMainScreen: "\x1B[?1049l",
-  reset: "\x1B[0m",
-  hideCursor: "\x1B[?25l",
-  showCursor: "\x1B[?25h",
-  resetCursorColor: "\x1B]12;default\x07",
-  saveCursorState: "\x1B[s",
-  restoreCursorState: "\x1B[u",
-  queryPixelSize: "\x1B[14t",
-  scrollDown: (lines) => `\x1B[${lines}T`,
-  scrollUp: (lines) => `\x1B[${lines}S`,
-  moveCursor: (row, col) => `\x1B[${row};${col}H`,
-  moveCursorAndClear: (row, col) => `\x1B[${row};${col}H\x1B[J`,
-  clearFromCursor: "\x1B[J",
-  setRgbBackground: (r, g, b) => `\x1B[48;2;${r};${g};${b}m`,
-  resetBackground: "\x1B[49m",
-  enableMouseTracking: "\x1B[?1000h",
-  disableMouseTracking: "\x1B[?1000l",
-  enableButtonEventTracking: "\x1B[?1002h",
-  disableButtonEventTracking: "\x1B[?1002l",
-  enableAnyEventTracking: "\x1B[?1003h",
-  disableAnyEventTracking: "\x1B[?1003l",
-  enableSGRMouseMode: "\x1B[?1006h",
-  disableSGRMouseMode: "\x1B[?1006l",
-  makeRoomForRenderer: (height) => `
-`.repeat(height) + `\x1B[${height}A`,
-  clearRendererSpace: (height) => `\x1B[${height}A\x1B[1G\x1B[J`
-};
-
 // src/renderer.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -8226,6 +9692,31 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
 }
 
 // src/renderer.ts
+registerEnvVar({
+  name: "OTUI_DUMP_CAPTURES",
+  description: "Dump captured output when the renderer exits.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_NO_NATIVE_RENDER",
+  description: "Disable native rendering. This will not actually output ansi and is useful for debugging.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_USE_ALTERNATE_SCREEN",
+  description: "Whether to use the console. Will not capture console output if set to false.",
+  type: "boolean",
+  default: true
+});
+registerEnvVar({
+  name: "OTUI_OVERRIDE_STDOUT",
+  description: "Override the stdout stream. This is useful for debugging.",
+  type: "boolean",
+  default: true
+});
+
 class MouseEvent {
   type;
   button;
@@ -8277,9 +9768,27 @@ singleton("ProcessExitSignals", () => {
     });
   });
 });
+var rendererTracker = singleton("RendererTracker", () => {
+  const renderers = new Set;
+  return {
+    addRenderer: (renderer) => {
+      renderers.add(renderer);
+    },
+    removeRenderer: (renderer) => {
+      renderers.delete(renderer);
+      if (renderers.size === 0) {
+        process.stdin.pause();
+        if (hasSingleton("tree-sitter-client")) {
+          getTreeSitterClient().destroy();
+          destroySingleton("tree-sitter-client");
+        }
+      }
+    }
+  };
+});
 async function createCliRenderer(config = {}) {
   if (process.argv.includes("--delay-start")) {
-    await new Promise((resolve) => setTimeout(resolve, 5000));
+    await new Promise((resolve4) => setTimeout(resolve4, 5000));
   }
   const stdin = config.stdin || process.stdin;
   const stdout = config.stdout || process.stdout;
@@ -8306,14 +9815,14 @@ var CliRenderEvents;
 ((CliRenderEvents2) => {
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
 })(CliRenderEvents ||= {});
-class CliRenderer extends EventEmitter5 {
+class CliRenderer extends EventEmitter7 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
   stdin;
   stdout;
   exitOnCtrlC;
-  isDestroyed = false;
+  _isDestroyed = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
@@ -8367,7 +9876,7 @@ class CliRenderer extends EventEmitter5 {
   resizeDebounceDelay = 100;
   enableMouseMovement = false;
   _useMouse = true;
-  _useAlternateScreen = true;
+  _useAlternateScreen = env.OTUI_USE_ALTERNATE_SCREEN;
   capturedRenderable;
   lastOverRenderableNum = 0;
   lastOverRenderable;
@@ -8398,9 +9907,9 @@ class CliRenderer extends EventEmitter5 {
   handleError = ((error) => {
     this.stop();
     this.destroy();
-    new Promise((resolve) => {
+    new Promise((resolve4) => {
       setTimeout(() => {
-        resolve(true);
+        resolve4(true);
       }, 100);
     }).then(() => {
       this.realStdoutWrite.call(this.stdout, `
@@ -8408,17 +9917,7 @@ class CliRenderer extends EventEmitter5 {
       this.realStdoutWrite.call(this.stdout, `
 === FATAL ERROR OCCURRED ===
 `);
-      this.realStdoutWrite.call(this.stdout, `Console cache:
-`);
-      this.realStdoutWrite.call(this.stdout, this.console.getCachedLogs());
-      this.realStdoutWrite.call(this.stdout, `
-Captured output:
-`);
-      const capturedOutput = capture.claimOutput();
-      if (capturedOutput) {
-        this.realStdoutWrite.call(this.stdout, capturedOutput + `
-`);
-      }
+      this.dumpOutputCache();
       this.realStdoutWrite.call(this.stdout, `
 Error details:
 `);
@@ -8431,14 +9930,39 @@ Error details:
       process.exit(1);
     });
   }).bind(this);
+  dumpOutputCache(optionalMessage = "") {
+    const cachedLogs = this.console.getCachedLogs();
+    const capturedOutput = capture.claimOutput();
+    if (capturedOutput.length > 0 || cachedLogs.length > 0) {
+      this.realStdoutWrite.call(this.stdout, optionalMessage);
+    }
+    if (cachedLogs.length > 0) {
+      this.realStdoutWrite.call(this.stdout, `Console cache:
+`);
+      this.realStdoutWrite.call(this.stdout, cachedLogs);
+    }
+    if (capturedOutput.length > 0) {
+      this.realStdoutWrite.call(this.stdout, `
+Captured output:
+`);
+      this.realStdoutWrite.call(this.stdout, capturedOutput + `
+`);
+    }
+    this.realStdoutWrite.call(this.stdout, ANSI.reset);
+  }
   exitHandler = (() => {
     this.destroy();
+    if (env.OTUI_DUMP_CAPTURES) {
+      this.dumpOutputCache(`=== CAPTURED OUTPUT ===
+`);
+    }
   }).bind(this);
   warningHandler = ((warning) => {
     console.warn(JSON.stringify(warning.message, null, 2));
   }).bind(this);
   constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
+    rendererTracker.addRenderer(this);
     this.stdin = stdin;
     this.stdout = stdout;
     this.realStdoutWrite = stdout.write;
@@ -8464,7 +9988,7 @@ Error details:
     this.maxStatSamples = config.maxStatSamples || 300;
     this.enableMouseMovement = config.enableMouseMovement || true;
     this._useMouse = config.useMouse ?? true;
-    this._useAlternateScreen = config.useAlternateScreen ?? true;
+    this._useAlternateScreen = config.useAlternateScreen ?? env.OTUI_USE_ALTERNATE_SCREEN;
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this.postProcessFns = config.postProcessFns || [];
@@ -8472,7 +9996,9 @@ Error details:
     if (this.memorySnapshotInterval > 0) {
       this.startMemorySnapshotTimer();
     }
-    this.stdout.write = this.interceptStdoutWrite.bind(this);
+    if (env.OTUI_OVERRIDE_STDOUT) {
+      this.stdout.write = this.interceptStdoutWrite.bind(this);
+    }
     process.on("SIGWINCH", this.sigwinchHandler);
     process.on("warning", this.warningHandler);
     process.on("uncaughtException", this.handleError);
@@ -8480,7 +10006,7 @@ Error details:
     process.on("exit", this.exitHandler);
     this._console = new TerminalConsole(this, config.consoleOptions);
     this.useConsole = config.useConsole ?? true;
-    this._keyHandler = new KeyHandler(this.stdin, config.useKittyKeyboard ?? false);
+    this._keyHandler = new InternalKeyHandler(this.stdin, config.useKittyKeyboard ?? false);
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
       this.animationRequest.set(id, callback);
@@ -8495,7 +10021,7 @@ Error details:
       global.window = {};
     }
     global.window.requestAnimationFrame = requestAnimationFrame;
-    if (process.env.OTUI_NO_NATIVE_RENDER === "true") {
+    if (env.OTUI_NO_NATIVE_RENDER) {
       this.renderNative = () => {
         if (this._splitHeight > 0) {
           this.flushStdoutCache(this._splitHeight);
@@ -8504,6 +10030,9 @@ Error details:
     }
     this.setupInput();
   }
+  get isDestroyed() {
+    return this._isDestroyed;
+  }
   registerLifecyclePass(renderable) {
     this.lifecyclePasses.add(renderable);
   }
@@ -8568,6 +10097,9 @@ Error details:
   get keyInput() {
     return this._keyHandler;
   }
+  get _internalKeyInput() {
+    return this._keyHandler;
+  }
   get terminalWidth() {
     return this._terminalWidth;
   }
@@ -8698,21 +10230,16 @@ Error details:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(true);
-    }
-    this.stdin.resume();
-    this.stdin.setEncoding("utf8");
-    await new Promise((resolve) => {
+    await new Promise((resolve4) => {
       const timeout = setTimeout(() => {
         this.stdin.off("data", capListener);
-        resolve(true);
+        resolve4(true);
       }, 100);
       const capListener = (str) => {
         clearTimeout(timeout);
         this.lib.processCapabilityResponse(this.rendererPtr, str);
         this.stdin.off("data", capListener);
-        resolve(true);
+        resolve4(true);
       };
       this.stdin.on("data", capListener);
       this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
@@ -8739,7 +10266,7 @@ Error details:
     }
     if (this.exitOnCtrlC && str === "\x03") {
       process.nextTick(() => {
-        process.exit();
+        this.destroy();
       });
       return;
     }
@@ -8749,6 +10276,11 @@ Error details:
     this.emit("key", data);
   }).bind(this);
   setupInput() {
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(true);
+    }
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
     this.stdin.on("data", this.stdinListener);
   }
   handleMouseData(data) {
@@ -8864,7 +10396,7 @@ Error details:
     return false;
   }
   takeMemorySnapshot() {
-    if (this.isDestroyed)
+    if (this._isDestroyed)
       return;
     const memoryUsage = process.memoryUsage();
     this.lastMemorySnapshot = {
@@ -8897,7 +10429,7 @@ Error details:
     }
   }
   handleResize(width, height) {
-    if (this.isDestroyed)
+    if (this._isDestroyed)
       return;
     if (this._splitHeight > 0) {
       this.processResize(width, height);
@@ -8914,7 +10446,7 @@ Error details:
   }
   queryPixelResolution() {
     this.waitingForPixelResolution = true;
-    this.writeOut(ANSI.queryPixelSize);
+    this.lib.queryPixelResolution(this.rendererPtr);
   }
   processResize(width, height) {
     if (width === this._terminalWidth && height === this._terminalHeight)
@@ -8977,9 +10509,6 @@ Error details:
     this.lib.setDebugOverlay(this.rendererPtr, this.debugOverlay.enabled, this.debugOverlay.corner);
     this.requestRender();
   }
-  clearTerminal() {
-    this.lib.clearTerminal(this.rendererPtr);
-  }
   setTerminalTitle(title) {
     this.lib.setTerminalTitle(this.rendererPtr, title);
   }
@@ -9059,7 +10588,7 @@ Error details:
     this.controlState = this._isRunning ? "auto_started" /* AUTO_STARTED */ : "idle" /* IDLE */;
   }
   internalStart() {
-    if (!this._isRunning && !this.isDestroyed) {
+    if (!this._isRunning && !this._isDestroyed) {
       this._isRunning = true;
       if (this.memorySnapshotInterval > 0) {
         this.startMemorySnapshotTimer();
@@ -9079,7 +10608,7 @@ Error details:
     this.internalStop();
   }
   internalStop() {
-    if (this.isRunning && !this.isDestroyed) {
+    if (this.isRunning && !this._isDestroyed) {
       this._isRunning = false;
       if (this.memorySnapshotTimer) {
         clearInterval(this.memorySnapshotTimer);
@@ -9092,32 +10621,41 @@ Error details:
     }
   }
   destroy() {
-    this.stdin.removeListener("data", this.stdinListener);
     process.removeListener("SIGWINCH", this.sigwinchHandler);
     process.removeListener("uncaughtException", this.handleError);
     process.removeListener("unhandledRejection", this.handleError);
-    process.removeListener("exit", this.exitHandler);
     process.removeListener("warning", this.warningHandler);
     capture.removeListener("write", this.captureCallback);
     if (this.memorySnapshotTimer) {
       clearInterval(this.memorySnapshotTimer);
     }
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(false);
-    }
-    if (this.isDestroyed)
+    if (this._isDestroyed)
       return;
-    this.isDestroyed = true;
+    this._isDestroyed = true;
+    if (this.renderTimeout) {
+      clearTimeout(this.renderTimeout);
+      this.renderTimeout = null;
+    }
+    this._isRunning = false;
     this.waitingForPixelResolution = false;
     this.capturedRenderable = undefined;
-    this.root.destroyRecursively();
+    try {
+      this.root.destroyRecursively();
+    } catch (e) {
+      console.error("Error destroying root renderable:", e instanceof Error ? e.stack : String(e));
+    }
     this._keyHandler.destroy();
     this._console.deactivate();
     this.disableStdoutInterception();
     if (this._splitHeight > 0) {
       this.flushStdoutCache(this._splitHeight, true);
     }
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
+    this.stdin.removeListener("data", this.stdinListener);
     this.lib.destroyRenderer(this.rendererPtr);
+    rendererTracker.removeRenderer(this);
   }
   startRenderLoop() {
     if (!this._isRunning)
@@ -9130,7 +10668,7 @@ Error details:
     this.loop();
   }
   async loop() {
-    if (this.rendering || this.isDestroyed)
+    if (this.rendering || this._isDestroyed)
       return;
     this.rendering = true;
     if (this.renderTimeout) {
@@ -9174,15 +10712,17 @@ Error details:
       postProcessFn(this.nextRenderBuffer, deltaTime);
     }
     this._console.renderToBuffer(this.nextRenderBuffer);
-    this.renderNative();
-    const overallFrameTime = performance.now() - overallStart;
-    this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
-    if (this.gatherStats) {
-      this.collectStatSample(overallFrameTime);
-    }
-    if (this._isRunning) {
-      const delay = Math.max(1, this.targetFrameTime - Math.floor(overallFrameTime));
-      this.renderTimeout = setTimeout(() => this.loop(), delay);
+    if (!this._isDestroyed) {
+      this.renderNative();
+      const overallFrameTime = performance.now() - overallStart;
+      this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
+      if (this.gatherStats) {
+        this.collectStatSample(overallFrameTime);
+      }
+      if (this._isRunning) {
+        const delay = Math.max(1, this.targetFrameTime - Math.floor(overallFrameTime));
+        this.renderTimeout = setTimeout(() => this.loop(), delay);
+      }
     }
     this.rendering = false;
     if (this.immediateRerenderRequested) {
@@ -9341,7 +10881,7 @@ Error details:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyHandler, getKeyHandler, 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, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, 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, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, convertThemeToStyles, SyntaxStyle, 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, CliRenderer };
 
-//# debugId=F7540B181A9A091164756E2164756E21
-//# sourceMappingURL=index-0yx9rnxg.js.map
+//# debugId=66FAF32C902A5E0B64756E2164756E21
+//# sourceMappingURL=index-pxa2sv92.js.map