@opentui/core 0.1.25 → 0.1.27

package/{index-6kvgbzah.js → index-zx1dwm33.js}

@@ -27,7 +27,7 @@ var __export = (target, all) => {
 };
 var __require = import.meta.require;
 
-// ../../node_modules/yoga-layout/dist/src/index.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/index.js
 var exports_src = {};
 __export(exports_src, {
   default: () => src_default,
@@ -51,7 +51,7 @@ __export(exports_src, {
   Align: () => Align
 });
 
-// ../../node_modules/yoga-layout/dist/binaries/yoga-wasm-base64-esm.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/binaries/yoga-wasm-base64-esm.js
 var loadYoga = (() => {
   var _scriptDir = import.meta.url;
   return function(loadYoga2) {
@@ -1356,7 +1356,7 @@ var loadYoga = (() => {
 })();
 var yoga_wasm_base64_esm_default = loadYoga;
 
-// ../../node_modules/yoga-layout/dist/src/generated/YGEnums.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/generated/YGEnums.js
 var Align = /* @__PURE__ */ function(Align2) {
   Align2[Align2["Auto"] = 0] = "Auto";
   Align2[Align2["FlexStart"] = 1] = "FlexStart";
@@ -1559,7 +1559,7 @@ var constants = {
 };
 var YGEnums_default = constants;
 
-// ../../node_modules/yoga-layout/dist/src/wrapAssembly.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/wrapAssembly.js
 function wrapAssembly(lib) {
   function patch(prototype, name, fn) {
     const original = prototype[name];
@@ -1661,7 +1661,7 @@ function wrapAssembly(lib) {
   };
 }
 
-// ../../node_modules/yoga-layout/dist/src/index.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/index.js
 var Yoga = wrapAssembly(await yoga_wasm_base64_esm_default());
 var src_default = Yoga;
 
@@ -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") {
@@ -2191,12 +2195,69 @@ var ANSI = {
 };
 
 // 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;
+  }
+}
+
 class KeyHandler extends EventEmitter {
   stdin;
   useKittyKeyboard;
   listener;
   pasteMode = false;
   pasteBuffer = [];
+  suspended = false;
   constructor(stdin, useKittyKeyboard = false) {
     super();
     this.stdin = stdin || process.stdin;
@@ -2210,7 +2271,7 @@ class KeyHandler extends EventEmitter {
         this.pasteBuffer.push(Bun.stripANSI(data));
         if (data.endsWith(ANSI.bracketedPasteEnd)) {
           this.pasteMode = false;
-          this.emit("paste", this.pasteBuffer.join(""));
+          this.emit("paste", new PasteEvent(this.pasteBuffer.join("")));
           this.pasteBuffer = [];
         }
         return;
@@ -2218,16 +2279,16 @@ class KeyHandler extends EventEmitter {
       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;
       }
     };
@@ -2236,6 +2297,57 @@ class KeyHandler extends EventEmitter {
   destroy() {
     this.stdin.removeListener("data", this.listener);
   }
+  suspend() {
+    if (!this.suspended) {
+      this.suspended = true;
+      this.stdin.removeListener("data", this.listener);
+    }
+  }
+  resume() {
+    if (this.suspended) {
+      this.suspended = false;
+      this.stdin.on("data", this.listener);
+    }
+  }
+}
+
+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);
+    }
+  }
 }
 
 // src/lib/RGBA.ts
@@ -4089,60 +4201,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 = {
@@ -4238,7 +4299,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;
@@ -4246,6 +4336,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);
@@ -4253,7 +4347,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)
@@ -4283,6 +4377,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();
   }
@@ -4290,6 +4396,8 @@ class SyntaxStyle {
     return this.mergedStyleCache.size;
   }
 }
+
+// src/lib/hast-styled-text.ts
 function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
   const chunks = [];
   if (node.type === "text") {
@@ -4321,6 +4429,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()) {
@@ -4824,9 +4981,19 @@ function singleton(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 = {};
+var envRegistry = singleton("env-registry", () => ({}));
 function registerEnvVar(config) {
   const existing = envRegistry[config.name];
   if (existing) {
@@ -4884,8 +5051,14 @@ class EnvStore {
   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) {
@@ -4974,9 +5147,1115 @@ var env = new Proxy({}, {
     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";
+  }
+  get appName() {
+    return this._appName;
+  }
+  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());
+    }
+  }
+  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);
+    }
+    return this._globalConfigPath;
+  }
+  get globalConfigFile() {
+    if (this._globalConfigFile === undefined) {
+      this._globalConfigFile = path.join(this.globalConfigPath, "init.ts");
+    }
+    return this._globalConfigFile;
+  }
+  get localConfigFile() {
+    if (this._localConfigFile === undefined) {
+      this._localConfigFile = path.join(process.cwd(), `.${this._appName}.ts`);
+    }
+    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);
+    }
+    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 {
+        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}` };
+      }
+    }
+  }
+  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 {
+      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}` };
+      }
+    }
+  }
+  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";
@@ -5177,7 +6456,10 @@ 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({
@@ -6281,7 +7563,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) {
@@ -6374,7 +7656,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter2 {
+class BaseRenderable extends EventEmitter4 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -6546,18 +7828,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.pasteHandler = (text) => {
-      this._pasteListener?.call(this, text);
-      if (this.handlePaste) {
-        this.handlePaste(text);
+    this.pasteHandler = (event) => {
+      this._pasteListener?.call(this, event.text);
+      if (!event.defaultPrevented && this.handlePaste) {
+        this.handlePaste(event.text);
       }
     };
-    this.ctx.keyInput.on("keypress", this.keypressHandler);
-    this.ctx.keyInput.on("paste", this.pasteHandler);
+    this.ctx._internalKeyInput.onInternal("keypress", this.keypressHandler);
+    this.ctx._internalKeyInput.onInternal("paste", this.pasteHandler);
     this.emit("focused" /* FOCUSED */);
   }
   blur() {
@@ -6566,11 +7848,11 @@ 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.keyInput.off("paste", this.pasteHandler);
+      this.ctx._internalKeyInput.offInternal("paste", this.pasteHandler);
       this.pasteHandler = null;
     }
     this.emit("blurred" /* BLURRED */);
@@ -7171,10 +8453,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);
       }
@@ -7219,6 +8502,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;
       }
     }
@@ -7327,7 +8620,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();
@@ -7666,17 +8960,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();
@@ -7752,7 +9046,7 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter4 {
+class TerminalConsoleCache extends EventEmitter6 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -7873,7 +9167,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter4 {
+class TerminalConsole extends EventEmitter6 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -8312,7 +9606,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) {
@@ -8333,7 +9627,7 @@ class TerminalConsole extends EventEmitter4 {
 }
 
 // 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) {
@@ -8423,6 +9717,18 @@ registerEnvVar({
   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;
@@ -8485,13 +9791,17 @@ var rendererTracker = singleton("RendererTracker", () => {
       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;
@@ -8518,14 +9828,24 @@ var CliRenderEvents;
 ((CliRenderEvents2) => {
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
 })(CliRenderEvents ||= {});
-class CliRenderer extends EventEmitter5 {
+var RendererControlState;
+((RendererControlState2) => {
+  RendererControlState2["IDLE"] = "idle";
+  RendererControlState2["AUTO_STARTED"] = "auto_started";
+  RendererControlState2["EXPLICIT_STARTED"] = "explicit_started";
+  RendererControlState2["EXPLICIT_PAUSED"] = "explicit_paused";
+  RendererControlState2["EXPLICIT_SUSPENDED"] = "explicit_suspended";
+  RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
+})(RendererControlState ||= {});
+
+class CliRenderer extends EventEmitter7 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
   stdin;
   stdout;
   exitOnCtrlC;
-  isDestroyed = false;
+  _isDestroyed = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
@@ -8559,7 +9879,7 @@ class CliRenderer extends EventEmitter5 {
   immediateRerenderRequested = false;
   updateScheduled = false;
   liveRequestCounter = 0;
-  controlState = "idle" /* IDLE */;
+  _controlState = "idle" /* IDLE */;
   frameCallbacks = [];
   renderStats = {
     frameCount: 0,
@@ -8579,7 +9899,9 @@ class CliRenderer extends EventEmitter5 {
   resizeDebounceDelay = 100;
   enableMouseMovement = false;
   _useMouse = true;
-  _useAlternateScreen = true;
+  _useAlternateScreen = env.OTUI_USE_ALTERNATE_SCREEN;
+  _suspendedMouseEnabled = false;
+  _previousControlState = "idle" /* IDLE */;
   capturedRenderable;
   lastOverRenderableNum = 0;
   lastOverRenderable;
@@ -8610,9 +9932,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, `
@@ -8663,6 +9985,9 @@ Captured output:
   warningHandler = ((warning) => {
     console.warn(JSON.stringify(warning.message, null, 2));
   }).bind(this);
+  get controlState() {
+    return this._controlState;
+  }
   constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
     rendererTracker.addRenderer(this);
@@ -8691,7 +10016,7 @@ Captured output:
     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 || [];
@@ -8699,7 +10024,9 @@ Captured output:
     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);
@@ -8707,7 +10034,7 @@ Captured output:
     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);
@@ -8731,6 +10058,9 @@ Captured output:
     }
     this.setupInput();
   }
+  get isDestroyed() {
+    return this._isDestroyed;
+  }
   registerLifecyclePass(renderable) {
     this.lifecyclePasses.add(renderable);
   }
@@ -8764,7 +10094,7 @@ Captured output:
     return this.realStdoutWrite.call(this.stdout, chunk, encoding, callback);
   }
   requestRender() {
-    if (!this.rendering && !this.updateScheduled && !this._isRunning) {
+    if (!this.rendering && !this.updateScheduled && !this._isRunning && this._controlState !== "explicit_suspended" /* EXPLICIT_SUSPENDED */) {
       this.updateScheduled = true;
       process.nextTick(() => {
         this.loop();
@@ -8795,6 +10125,9 @@ Captured output:
   get keyInput() {
     return this._keyHandler;
   }
+  get _internalKeyInput() {
+    return this._keyHandler;
+  }
   get terminalWidth() {
     return this._terminalWidth;
   }
@@ -8824,7 +10157,7 @@ Captured output:
     return this.liveRequestCounter;
   }
   get currentControlState() {
-    return this.controlState;
+    return this._controlState;
   }
   get capabilities() {
     return this._capabilities;
@@ -8904,9 +10237,11 @@ Captured output:
     return true;
   }
   enableMouse() {
+    this._useMouse = true;
     this.lib.enableMouse(this.rendererPtr, this.enableMouseMovement);
   }
   disableMouse() {
+    this._useMouse = false;
     this.capturedRenderable = undefined;
     this.mouseParser.reset();
     this.lib.disableMouse(this.rendererPtr);
@@ -8925,16 +10260,16 @@ Captured output:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
-    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);
@@ -9091,7 +10426,7 @@ Captured output:
     return false;
   }
   takeMemorySnapshot() {
-    if (this.isDestroyed)
+    if (this._isDestroyed)
       return;
     const memoryUsage = process.memoryUsage();
     this.lastMemorySnapshot = {
@@ -9124,7 +10459,7 @@ Captured output:
     }
   }
   handleResize(width, height) {
-    if (this.isDestroyed)
+    if (this._isDestroyed)
       return;
     if (this._splitHeight > 0) {
       this.processResize(width, height);
@@ -9263,27 +10598,27 @@ Captured output:
   }
   requestLive() {
     this.liveRequestCounter++;
-    if (this.controlState === "idle" /* IDLE */ && this.liveRequestCounter > 0) {
-      this.controlState = "auto_started" /* AUTO_STARTED */;
+    if (this._controlState === "idle" /* IDLE */ && this.liveRequestCounter > 0) {
+      this._controlState = "auto_started" /* AUTO_STARTED */;
       this.internalStart();
     }
   }
   dropLive() {
     this.liveRequestCounter = Math.max(0, this.liveRequestCounter - 1);
-    if (this.controlState === "auto_started" /* AUTO_STARTED */ && this.liveRequestCounter === 0) {
-      this.controlState = "idle" /* IDLE */;
+    if (this._controlState === "auto_started" /* AUTO_STARTED */ && this.liveRequestCounter === 0) {
+      this._controlState = "idle" /* IDLE */;
       this.internalPause();
     }
   }
   start() {
-    this.controlState = "explicit_started" /* EXPLICIT_STARTED */;
+    this._controlState = "explicit_started" /* EXPLICIT_STARTED */;
     this.internalStart();
   }
   auto() {
-    this.controlState = this._isRunning ? "auto_started" /* AUTO_STARTED */ : "idle" /* IDLE */;
+    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();
@@ -9292,18 +10627,44 @@ Captured output:
     }
   }
   pause() {
-    this.controlState = "explicit_paused" /* EXPLICIT_PAUSED */;
+    this._controlState = "explicit_paused" /* EXPLICIT_PAUSED */;
     this.internalPause();
   }
+  suspend() {
+    this._previousControlState = this._controlState;
+    this._controlState = "explicit_suspended" /* EXPLICIT_SUSPENDED */;
+    this.internalPause();
+    this._suspendedMouseEnabled = this._useMouse;
+    this.disableMouse();
+    this._keyHandler.suspend();
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
+    this.stdin.pause();
+  }
+  resume() {
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(true);
+    }
+    this.stdin.resume();
+    this._keyHandler.resume();
+    if (this._suspendedMouseEnabled) {
+      this.enableMouse();
+    }
+    this._controlState = this._previousControlState;
+    if (this._previousControlState === "auto_started" /* AUTO_STARTED */ || this._previousControlState === "explicit_started" /* EXPLICIT_STARTED */) {
+      this.internalStart();
+    }
+  }
   internalPause() {
     this._isRunning = false;
   }
   stop() {
-    this.controlState = "explicit_stopped" /* EXPLICIT_STOPPED */;
+    this._controlState = "explicit_stopped" /* EXPLICIT_STOPPED */;
     this.internalStop();
   }
   internalStop() {
-    if (this.isRunning && !this.isDestroyed) {
+    if (this.isRunning && !this._isDestroyed) {
       this._isRunning = false;
       if (this.memorySnapshotTimer) {
         clearInterval(this.memorySnapshotTimer);
@@ -9324,9 +10685,9 @@ Captured output:
     if (this.memorySnapshotTimer) {
       clearInterval(this.memorySnapshotTimer);
     }
-    if (this.isDestroyed)
+    if (this._isDestroyed)
       return;
-    this.isDestroyed = true;
+    this._isDestroyed = true;
     if (this.renderTimeout) {
       clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
@@ -9334,7 +10695,11 @@ Captured output:
     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();
@@ -9359,7 +10724,7 @@ Captured output:
     this.loop();
   }
   async loop() {
-    if (this.rendering || this.isDestroyed)
+    if (this.rendering || this._isDestroyed)
       return;
     this.rendering = true;
     if (this.renderTimeout) {
@@ -9403,17 +10768,17 @@ Captured output:
       postProcessFn(this.nextRenderBuffer, deltaTime);
     }
     this._console.renderToBuffer(this.nextRenderBuffer);
-    if (!this.isDestroyed) {
+    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);
+      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) {
@@ -9572,7 +10937,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyHandler, 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, envRegistry, registerEnvVar, generateEnvMarkdown, generateEnvColored, env, 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, RendererControlState, CliRenderer };
 
-//# debugId=FA47EE78BCA83E8664756E2164756E21
-//# sourceMappingURL=index-6kvgbzah.js.map
+//# debugId=4CAC9B07B4894E3E64756E2164756E21
+//# sourceMappingURL=index-zx1dwm33.js.map