@opentui/core 0.0.0-20251106-788e97e4 → 0.0.0-20251112-a24ada2d

package/{index-pb1pm3hk.js → index-kj9k00yt.js}

@@ -27,7 +27,7 @@ var __export = (target, all) => {
 };
 var __require = import.meta.require;
 
-// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/index.js
+// ../../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/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/binaries/yoga-wasm-base64-esm.js
+// ../../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/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/generated/YGEnums.js
+// ../../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/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/wrapAssembly.js
+// ../../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/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/index.js
+// ../../node_modules/yoga-layout/dist/src/index.js
 var Yoga = wrapAssembly(await yoga_wasm_base64_esm_default());
 var src_default = Yoga;
 
@@ -2079,6 +2079,7 @@ var isShiftKey = (code) => {
 var isCtrlKey = (code) => {
   return ["Oa", "Ob", "Oc", "Od", "Oe", "[2^", "[3^", "[5^", "[6^", "[7^", "[8^"].includes(code);
 };
+var modifyOtherKeysRe = /^\x1b\[27;(\d+);(\d+)~$/;
 var parseKeypress = (s = "", options = {}) => {
   let parts;
   if (Buffer2.isBuffer(s)) {
@@ -2099,6 +2100,27 @@ var parseKeypress = (s = "", options = {}) => {
   if (s.startsWith("\x1B[M") && s.length >= 6) {
     return null;
   }
+  if (/^\x1b\[\d+;\d+;\d+t$/.test(s)) {
+    return null;
+  }
+  if (/^\x1b\[\d+;\d+R$/.test(s)) {
+    return null;
+  }
+  if (/^\x1b\[\?[\d;]+c$/.test(s)) {
+    return null;
+  }
+  if (/^\x1b\[\?[\d;]+\$y$/.test(s)) {
+    return null;
+  }
+  if (s === "\x1B[I" || s === "\x1B[O") {
+    return null;
+  }
+  if (/^\x1b\][\d;].*(\x1b\\|\x07)$/.test(s)) {
+    return null;
+  }
+  if (s === "\x1B[200~" || s === "\x1B[201~") {
+    return null;
+  }
   const key = {
     name: "",
     ctrl: false,
@@ -2118,6 +2140,29 @@ var parseKeypress = (s = "", options = {}) => {
       return kittyResult;
     }
   }
+  const modifyOtherKeysMatch = modifyOtherKeysRe.exec(s);
+  if (modifyOtherKeysMatch) {
+    const modifier = parseInt(modifyOtherKeysMatch[1], 10) - 1;
+    const charCode = parseInt(modifyOtherKeysMatch[2], 10);
+    key.ctrl = !!(modifier & 4);
+    key.meta = !!(modifier & 10);
+    key.shift = !!(modifier & 1);
+    key.option = !!(modifier & 2);
+    if (charCode === 13) {
+      key.name = "return";
+    } else if (charCode === 27) {
+      key.name = "escape";
+    } else if (charCode === 9) {
+      key.name = "tab";
+    } else if (charCode === 32) {
+      key.name = "space";
+    } else if (charCode === 127 || charCode === 8) {
+      key.name = "backspace";
+    } else {
+      key.name = String.fromCharCode(charCode);
+    }
+    return key;
+  }
   if (s === "\r" || s === "\x1B\r") {
     key.name = "return";
     key.meta = s.length === 2;
@@ -2190,201 +2235,8 @@ var parseKeypress = (s = "", options = {}) => {
   return key;
 };
 
-// src/lib/stdin-buffer.ts
-import { EventEmitter } from "events";
-var ESC = "\x1B";
-function isCompleteSequence(data) {
-  if (!data.startsWith(ESC)) {
-    return "not-escape";
-  }
-  if (data.length === 1) {
-    return "incomplete";
-  }
-  const afterEsc = data.slice(1);
-  if (afterEsc.startsWith("[")) {
-    if (afterEsc.startsWith("[M")) {
-      return data.length >= 6 ? "complete" : "incomplete";
-    }
-    return isCompleteCsiSequence(data);
-  }
-  if (afterEsc.startsWith("]")) {
-    return isCompleteOscSequence(data);
-  }
-  if (afterEsc.startsWith("O")) {
-    return afterEsc.length >= 2 ? "complete" : "incomplete";
-  }
-  if (afterEsc.length === 1) {
-    return "complete";
-  }
-  return "complete";
-}
-function isCompleteCsiSequence(data) {
-  if (!data.startsWith(ESC + "[")) {
-    return "complete";
-  }
-  if (data.length < 3) {
-    return "incomplete";
-  }
-  const payload = data.slice(2);
-  const lastChar = payload[payload.length - 1];
-  const lastCharCode = lastChar.charCodeAt(0);
-  if (lastCharCode >= 64 && lastCharCode <= 126) {
-    if (payload.startsWith("<")) {
-      const mouseMatch = /^<\d+;\d+;\d+[Mm]$/.test(payload);
-      if (mouseMatch) {
-        return "complete";
-      }
-      if (lastChar === "M" || lastChar === "m") {
-        const parts = payload.slice(1, -1).split(";");
-        if (parts.length === 3 && parts.every((p) => /^\d+$/.test(p))) {
-          return "complete";
-        }
-      }
-      return "incomplete";
-    }
-    return "complete";
-  }
-  return "incomplete";
-}
-function isCompleteOscSequence(data) {
-  if (!data.startsWith(ESC + "]")) {
-    return "complete";
-  }
-  if (data.endsWith(ESC + "\\") || data.endsWith("\x07")) {
-    return "complete";
-  }
-  return "incomplete";
-}
-function extractCompleteSequences(buffer) {
-  const sequences = [];
-  let pos = 0;
-  while (pos < buffer.length) {
-    const remaining = buffer.slice(pos);
-    if (remaining.startsWith(ESC)) {
-      let seqEnd = 1;
-      while (seqEnd <= remaining.length) {
-        const candidate = remaining.slice(0, seqEnd);
-        const status = isCompleteSequence(candidate);
-        if (status === "complete") {
-          sequences.push(candidate);
-          pos += seqEnd;
-          break;
-        } else if (status === "incomplete") {
-          seqEnd++;
-        } else {
-          sequences.push(candidate);
-          pos += seqEnd;
-          break;
-        }
-      }
-      if (seqEnd > remaining.length) {
-        return { sequences, remainder: remaining };
-      }
-    } else {
-      sequences.push(remaining[0]);
-      pos++;
-    }
-  }
-  return { sequences, remainder: "" };
-}
-
-class StdinBuffer extends EventEmitter {
-  buffer = "";
-  timeout = null;
-  timeoutMs;
-  stdin;
-  stdinListener;
-  constructor(stdin, options = {}) {
-    super();
-    this.stdin = stdin;
-    this.timeoutMs = options.timeout ?? 10;
-    this.stdinListener = (data) => {
-      this.handleData(data);
-    };
-    this.stdin.on("data", this.stdinListener);
-  }
-  handleData(data) {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
-    }
-    let str;
-    if (Buffer.isBuffer(data)) {
-      if (data.length === 1 && data[0] > 127) {
-        const byte = data[0] - 128;
-        str = "\x1B" + String.fromCharCode(byte);
-      } else {
-        str = data.toString();
-      }
-    } else {
-      str = data;
-    }
-    if (str.length === 0 && this.buffer.length === 0) {
-      this.emit("data", "");
-      return;
-    }
-    this.buffer += str;
-    const result = extractCompleteSequences(this.buffer);
-    this.buffer = result.remainder;
-    for (const sequence of result.sequences) {
-      this.emit("data", sequence);
-    }
-    if (this.buffer.length > 0) {
-      this.timeout = setTimeout(() => {
-        const flushed = this.flush();
-        for (const sequence of flushed) {
-          this.emit("data", sequence);
-        }
-      }, this.timeoutMs);
-    }
-  }
-  flush() {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
-    }
-    if (this.buffer.length === 0) {
-      return [];
-    }
-    const sequences = [this.buffer];
-    this.buffer = "";
-    return sequences;
-  }
-  clear() {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
-    }
-    this.buffer = "";
-  }
-  getBuffer() {
-    return this.buffer;
-  }
-  destroy() {
-    this.stdin.removeListener("data", this.stdinListener);
-    this.clear();
-  }
-}
-
-// src/lib/KeyHandler.ts
-import { EventEmitter as EventEmitter2 } from "events";
-
-// src/ansi.ts
-var ANSI = {
-  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
+import { EventEmitter } from "events";
 class KeyEvent {
   name;
   ctrl;
@@ -2443,40 +2295,20 @@ class PasteEvent {
   }
 }
 
-class KeyHandler extends EventEmitter2 {
-  stdin;
+class KeyHandler extends EventEmitter {
   useKittyKeyboard;
-  pasteMode = false;
-  pasteBuffer = [];
   suspended = false;
-  stdinBuffer;
-  dataListener;
-  constructor(stdin, useKittyKeyboard = false) {
+  constructor(useKittyKeyboard = false) {
     super();
-    this.stdin = stdin || process.stdin;
     this.useKittyKeyboard = useKittyKeyboard;
-    this.stdinBuffer = new StdinBuffer(this.stdin, { timeout: 5 });
-    this.dataListener = (sequence) => {
-      this.processSequence(sequence);
-    };
-    this.stdinBuffer.on("data", this.dataListener);
   }
-  processSequence(data) {
-    if (data.startsWith(ANSI.bracketedPasteStart)) {
-      this.pasteMode = true;
-    }
-    if (this.pasteMode) {
-      this.pasteBuffer.push(Bun.stripANSI(data));
-      if (data.endsWith(ANSI.bracketedPasteEnd)) {
-        this.pasteMode = false;
-        this.emit("paste", new PasteEvent(this.pasteBuffer.join("")));
-        this.pasteBuffer = [];
-      }
-      return;
+  processInput(data) {
+    if (this.suspended) {
+      return false;
     }
     const parsedKey = parseKeypress(data, { useKittyKeyboard: this.useKittyKeyboard });
     if (!parsedKey) {
-      return;
+      return false;
     }
     switch (parsedKey.eventType) {
       case "press":
@@ -2492,29 +2324,27 @@ class KeyHandler extends EventEmitter2 {
         this.emit("keypress", new KeyEvent(parsedKey));
         break;
     }
+    return true;
   }
-  destroy() {
-    this.stdinBuffer.removeListener("data", this.dataListener);
-    this.stdinBuffer.destroy();
+  processPaste(data) {
+    if (this.suspended) {
+      return;
+    }
+    const cleanedData = Bun.stripANSI(data);
+    this.emit("paste", new PasteEvent(cleanedData));
   }
   suspend() {
-    if (!this.suspended) {
-      this.suspended = true;
-      this.stdinBuffer.removeListener("data", this.dataListener);
-    }
+    this.suspended = true;
   }
   resume() {
-    if (this.suspended) {
-      this.suspended = false;
-      this.stdinBuffer.on("data", this.dataListener);
-    }
+    this.suspended = false;
   }
 }
 
 class InternalKeyHandler extends KeyHandler {
   renderableHandlers = new Map;
-  constructor(stdin, useKittyKeyboard = false) {
-    super(stdin, useKittyKeyboard);
+  constructor(useKittyKeyboard = false) {
+    super(useKittyKeyboard);
   }
   emit(event, ...args) {
     return this.emitWithPriority(event, ...args);
@@ -4528,59 +4358,299 @@ function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
       chunks.push(...hastToTextChunks(child, syntaxStyle, currentStyles));
     }
   }
-  return chunks;
-}
-function hastToStyledText(hast, syntaxStyle) {
-  const chunks = hastToTextChunks(hast, syntaxStyle);
-  return new StyledText(chunks);
+  return chunks;
+}
+function hastToStyledText(hast, syntaxStyle) {
+  const chunks = hastToTextChunks(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/stdin-buffer.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var ESC = "\x1B";
+var BRACKETED_PASTE_START = "\x1B[200~";
+var BRACKETED_PASTE_END = "\x1B[201~";
+function isCompleteSequence(data) {
+  if (!data.startsWith(ESC)) {
+    return "not-escape";
+  }
+  if (data.length === 1) {
+    return "incomplete";
+  }
+  const afterEsc = data.slice(1);
+  if (afterEsc.startsWith("[")) {
+    if (afterEsc.startsWith("[M")) {
+      return data.length >= 6 ? "complete" : "incomplete";
+    }
+    return isCompleteCsiSequence(data);
+  }
+  if (afterEsc.startsWith("]")) {
+    return isCompleteOscSequence(data);
+  }
+  if (afterEsc.startsWith("P")) {
+    return isCompleteDcsSequence(data);
+  }
+  if (afterEsc.startsWith("_")) {
+    return isCompleteApcSequence(data);
+  }
+  if (afterEsc.startsWith("O")) {
+    return afterEsc.length >= 2 ? "complete" : "incomplete";
+  }
+  if (afterEsc.length === 1) {
+    return "complete";
+  }
+  return "complete";
+}
+function isCompleteCsiSequence(data) {
+  if (!data.startsWith(ESC + "[")) {
+    return "complete";
+  }
+  if (data.length < 3) {
+    return "incomplete";
+  }
+  const payload = data.slice(2);
+  const lastChar = payload[payload.length - 1];
+  const lastCharCode = lastChar.charCodeAt(0);
+  if (lastCharCode >= 64 && lastCharCode <= 126) {
+    if (payload.startsWith("<")) {
+      const mouseMatch = /^<\d+;\d+;\d+[Mm]$/.test(payload);
+      if (mouseMatch) {
+        return "complete";
+      }
+      if (lastChar === "M" || lastChar === "m") {
+        const parts = payload.slice(1, -1).split(";");
+        if (parts.length === 3 && parts.every((p) => /^\d+$/.test(p))) {
+          return "complete";
+        }
+      }
+      return "incomplete";
+    }
+    return "complete";
+  }
+  return "incomplete";
+}
+function isCompleteOscSequence(data) {
+  if (!data.startsWith(ESC + "]")) {
+    return "complete";
+  }
+  if (data.endsWith(ESC + "\\") || data.endsWith("\x07")) {
+    return "complete";
+  }
+  return "incomplete";
+}
+function isCompleteDcsSequence(data) {
+  if (!data.startsWith(ESC + "P")) {
+    return "complete";
+  }
+  if (data.endsWith(ESC + "\\")) {
+    return "complete";
+  }
+  return "incomplete";
+}
+function isCompleteApcSequence(data) {
+  if (!data.startsWith(ESC + "_")) {
+    return "complete";
+  }
+  if (data.endsWith(ESC + "\\")) {
+    return "complete";
+  }
+  return "incomplete";
+}
+function extractCompleteSequences(buffer) {
+  const sequences = [];
+  let pos = 0;
+  while (pos < buffer.length) {
+    const remaining = buffer.slice(pos);
+    if (remaining.startsWith(ESC)) {
+      let seqEnd = 1;
+      while (seqEnd <= remaining.length) {
+        const candidate = remaining.slice(0, seqEnd);
+        const status = isCompleteSequence(candidate);
+        if (status === "complete") {
+          sequences.push(candidate);
+          pos += seqEnd;
+          break;
+        } else if (status === "incomplete") {
+          seqEnd++;
+        } else {
+          sequences.push(candidate);
+          pos += seqEnd;
+          break;
+        }
+      }
+      if (seqEnd > remaining.length) {
+        return { sequences, remainder: remaining };
+      }
+    } else {
+      sequences.push(remaining[0]);
+      pos++;
+    }
+  }
+  return { sequences, remainder: "" };
 }
 
-// src/lib/scroll-acceleration.ts
-class LinearScrollAccel {
-  tick(_now) {
-    return 1;
+class StdinBuffer extends EventEmitter2 {
+  buffer = "";
+  timeout = null;
+  timeoutMs;
+  pasteMode = false;
+  pasteBuffer = "";
+  constructor(options = {}) {
+    super();
+    this.timeoutMs = options.timeout ?? 10;
   }
-  reset() {}
-}
-
-class MacOSScrollAccel {
-  opts;
-  lastTickTime = 0;
-  velocityHistory = [];
-  historySize = 3;
-  streakTimeout = 150;
-  minTickInterval = 6;
-  constructor(opts = {}) {
-    this.opts = opts;
+  process(data) {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    let str;
+    if (Buffer.isBuffer(data)) {
+      if (data.length === 1 && data[0] > 127) {
+        const byte = data[0] - 128;
+        str = "\x1B" + String.fromCharCode(byte);
+      } else {
+        str = data.toString();
+      }
+    } else {
+      str = data;
+    }
+    if (str.length === 0 && this.buffer.length === 0) {
+      this.emit("data", "");
+      return;
+    }
+    this.buffer += str;
+    if (this.pasteMode) {
+      this.pasteBuffer += this.buffer;
+      this.buffer = "";
+      const endIndex = this.pasteBuffer.indexOf(BRACKETED_PASTE_END);
+      if (endIndex !== -1) {
+        const pastedContent = this.pasteBuffer.slice(0, endIndex);
+        const remaining = this.pasteBuffer.slice(endIndex + BRACKETED_PASTE_END.length);
+        this.pasteMode = false;
+        this.pasteBuffer = "";
+        this.emit("paste", pastedContent);
+        if (remaining.length > 0) {
+          this.process(remaining);
+        }
+      }
+      return;
+    }
+    const startIndex = this.buffer.indexOf(BRACKETED_PASTE_START);
+    if (startIndex !== -1) {
+      if (startIndex > 0) {
+        const beforePaste = this.buffer.slice(0, startIndex);
+        const result2 = extractCompleteSequences(beforePaste);
+        for (const sequence of result2.sequences) {
+          this.emit("data", sequence);
+        }
+      }
+      this.buffer = this.buffer.slice(startIndex + BRACKETED_PASTE_START.length);
+      this.pasteMode = true;
+      this.pasteBuffer = this.buffer;
+      this.buffer = "";
+      const endIndex = this.pasteBuffer.indexOf(BRACKETED_PASTE_END);
+      if (endIndex !== -1) {
+        const pastedContent = this.pasteBuffer.slice(0, endIndex);
+        const remaining = this.pasteBuffer.slice(endIndex + BRACKETED_PASTE_END.length);
+        this.pasteMode = false;
+        this.pasteBuffer = "";
+        this.emit("paste", pastedContent);
+        if (remaining.length > 0) {
+          this.process(remaining);
+        }
+      }
+      return;
+    }
+    const result = extractCompleteSequences(this.buffer);
+    this.buffer = result.remainder;
+    for (const sequence of result.sequences) {
+      this.emit("data", sequence);
+    }
+    if (this.buffer.length > 0) {
+      this.timeout = setTimeout(() => {
+        const flushed = this.flush();
+        for (const sequence of flushed) {
+          this.emit("data", sequence);
+        }
+      }, this.timeoutMs);
+    }
   }
-  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;
+  flush() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
     }
-    if (dt < this.minTickInterval) {
-      return 1;
+    if (this.buffer.length === 0) {
+      return [];
     }
-    this.lastTickTime = now;
-    this.velocityHistory.push(dt);
-    if (this.velocityHistory.length > this.historySize) {
-      this.velocityHistory.shift();
+    const sequences = [this.buffer];
+    this.buffer = "";
+    return sequences;
+  }
+  clear() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
     }
-    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);
+    this.buffer = "";
+    this.pasteMode = false;
+    this.pasteBuffer = "";
   }
-  reset() {
-    this.lastTickTime = 0;
-    this.velocityHistory = [];
+  getBuffer() {
+    return this.buffer;
+  }
+  destroy() {
+    this.clear();
   }
 }
 
@@ -7563,7 +7633,17 @@ class TerminalPalette {
       this.activeTimers.push(timer);
       inp.on("data", onData);
       this.activeListeners.push({ event: "data", handler: onData });
-      this.writeFn(["\x1B]10;?\x07", "\x1B]11;?\x07", "\x1B]12;?\x07", "\x1B]13;?\x07", "\x1B]14;?\x07", "\x1B]15;?\x07", "\x1B]16;?\x07", "\x1B]17;?\x07", "\x1B]19;?\x07"].join(""));
+      this.writeFn([
+        "\x1B]10;?\x07",
+        "\x1B]11;?\x07",
+        "\x1B]12;?\x07",
+        "\x1B]13;?\x07",
+        "\x1B]14;?\x07",
+        "\x1B]15;?\x07",
+        "\x1B]16;?\x07",
+        "\x1B]17;?\x07",
+        "\x1B]19;?\x07"
+      ].join(""));
     });
   }
   async detect(options) {
@@ -7810,7 +7890,7 @@ class OptimizedBuffer {
   }
 }
 
-// ../../node_modules/.bun/bun-ffi-structs@0.1.0+ca84541ac88a3075/node_modules/bun-ffi-structs/index.js
+// ../../node_modules/bun-ffi-structs/index.js
 import { ptr, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
 function fatalError(...args) {
   const message = args.join(" ");
@@ -7855,6 +7935,23 @@ function isObjectPointerDef(type) {
 function alignOffset(offset, align) {
   return offset + (align - 1) & ~(align - 1);
 }
+function enumTypeError(value) {
+  throw new TypeError(`Invalid enum value: ${value}`);
+}
+function defineEnum(mapping, base = "u32") {
+  const reverse2 = Object.fromEntries(Object.entries(mapping).map(([k, v]) => [v, k]));
+  return {
+    __type: "enum",
+    type: base,
+    to(value) {
+      return typeof value === "number" ? value : mapping[value] ?? enumTypeError(String(value));
+    },
+    from(value) {
+      return reverse2[value] ?? enumTypeError(String(value));
+    },
+    enum: mapping
+  };
+}
 function isEnum(type) {
   return typeof type === "object" && type.__type === "enum";
 }
@@ -7931,6 +8028,7 @@ function packObjectArray(val) {
   return bufferView;
 }
 var encoder = new TextEncoder;
+var decoder = new TextDecoder;
 function defineStruct(fields, structDefOptions) {
   let offset = 0;
   let maxAlign = 1;
@@ -7973,6 +8071,7 @@ function defineStruct(fields, structDefOptions) {
         const ptrVal = pointerUnpacker(view, off);
         return ptrVal;
       };
+      needsLengthOf = true;
     } else if (isEnum(typeOrStruct)) {
       const base = typeOrStruct.type;
       size = typeSizes[base];
@@ -8175,9 +8274,10 @@ function defineStruct(fields, structDefOptions) {
       lengthOfFields[options.lengthOf] = layoutField;
     }
     if (needsLengthOf) {
-      if (!lengthOfDef)
-        fatalError(`Internal error: needsLengthOf=true but lengthOfDef is null for ${name}`);
-      lengthOfRequested.push({ requester: layoutField, def: lengthOfDef });
+      const def = typeof typeOrStruct === "string" && typeOrStruct === "char*" ? "char*" : lengthOfDef;
+      if (!def)
+        fatalError(`Internal error: needsLengthOf=true but def is null for ${name}`);
+      lengthOfRequested.push({ requester: layoutField, def });
     }
     offset += size;
     maxAlign = Math.max(maxAlign, align);
@@ -8185,9 +8285,26 @@ function defineStruct(fields, structDefOptions) {
   for (const { requester, def } of lengthOfRequested) {
     const lengthOfField = lengthOfFields[requester.name];
     if (!lengthOfField) {
+      if (def === "char*") {
+        continue;
+      }
       throw new Error(`lengthOf field not found for array field ${requester.name}`);
     }
-    if (isPrimitiveType(def)) {
+    if (def === "char*") {
+      requester.unpack = (view, off) => {
+        const ptrAddress = pointerUnpacker(view, off);
+        const length = lengthOfField.unpack(view, lengthOfField.offset);
+        if (ptrAddress === 0) {
+          return null;
+        }
+        const byteLength = typeof length === "bigint" ? Number(length) : length;
+        if (byteLength === 0) {
+          return "";
+        }
+        const buffer = toArrayBuffer2(ptrAddress, 0, byteLength);
+        return decoder.decode(buffer);
+      };
+    } else if (isPrimitiveType(def)) {
       const elemSize = typeSizes[def];
       const { unpack: primitiveUnpack } = primitivePackers(def);
       requester.unpack = (view, off) => {
@@ -8427,6 +8544,27 @@ var VisualCursorStruct = defineStruct([
   ["logicalCol", "u32"],
   ["offset", "u32"]
 ]);
+var UnicodeMethodEnum = defineEnum({ wcwidth: 0, unicode: 1 }, "u8");
+var TerminalCapabilitiesStruct = defineStruct([
+  ["kitty_keyboard", "bool_u8"],
+  ["kitty_graphics", "bool_u8"],
+  ["rgb", "bool_u8"],
+  ["unicode", UnicodeMethodEnum],
+  ["sgr_pixels", "bool_u8"],
+  ["color_scheme_updates", "bool_u8"],
+  ["explicit_width", "bool_u8"],
+  ["scaled_text", "bool_u8"],
+  ["sixel", "bool_u8"],
+  ["focus_tracking", "bool_u8"],
+  ["sync", "bool_u8"],
+  ["bracketed_paste", "bool_u8"],
+  ["hyperlinks", "bool_u8"],
+  ["term_name", "char*"],
+  ["term_name_len", "u64", { lengthOf: "term_name" }],
+  ["term_version", "char*"],
+  ["term_version_len", "u64", { lengthOf: "term_version" }],
+  ["term_from_xtversion", "bool_u8"]
+]);
 
 // src/zig.ts
 var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
@@ -8748,6 +8886,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u8"],
       returns: "void"
     },
+    textBufferAppend: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    textBufferAppendFromMemId: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
     textBufferLoadFile: {
       args: ["ptr", "ptr", "usize"],
       returns: "bool"
@@ -9711,6 +9857,12 @@ class FFIRenderLib {
   textBufferSetTextFromMem(buffer, memId) {
     this.opentui.symbols.textBufferSetTextFromMem(buffer, memId);
   }
+  textBufferAppend(buffer, bytes) {
+    this.opentui.symbols.textBufferAppend(buffer, bytes, bytes.length);
+  }
+  textBufferAppendFromMemId(buffer, memId) {
+    this.opentui.symbols.textBufferAppendFromMemId(buffer, memId);
+  }
   textBufferLoadFile(buffer, path4) {
     const pathBytes = this.encoder.encode(path4);
     return this.opentui.symbols.textBufferLoadFile(buffer, pathBytes, pathBytes.length);
@@ -10242,25 +10394,29 @@ class FFIRenderLib {
     this.opentui.symbols.bufferClearScissorRects(buffer);
   }
   getTerminalCapabilities(renderer) {
-    const capsBuffer = new Uint8Array(64);
-    this.opentui.symbols.getTerminalCapabilities(renderer, capsBuffer);
-    let offset = 0;
-    const capabilities = {
-      kitty_keyboard: capsBuffer[offset++] !== 0,
-      kitty_graphics: capsBuffer[offset++] !== 0,
-      rgb: capsBuffer[offset++] !== 0,
-      unicode: capsBuffer[offset++] === 0 ? "wcwidth" : "unicode",
-      sgr_pixels: capsBuffer[offset++] !== 0,
-      color_scheme_updates: capsBuffer[offset++] !== 0,
-      explicit_width: capsBuffer[offset++] !== 0,
-      scaled_text: capsBuffer[offset++] !== 0,
-      sixel: capsBuffer[offset++] !== 0,
-      focus_tracking: capsBuffer[offset++] !== 0,
-      sync: capsBuffer[offset++] !== 0,
-      bracketed_paste: capsBuffer[offset++] !== 0,
-      hyperlinks: capsBuffer[offset++] !== 0
+    const capsBuffer = new ArrayBuffer(TerminalCapabilitiesStruct.size);
+    this.opentui.symbols.getTerminalCapabilities(renderer, ptr3(capsBuffer));
+    const caps = TerminalCapabilitiesStruct.unpack(capsBuffer);
+    return {
+      kitty_keyboard: caps.kitty_keyboard,
+      kitty_graphics: caps.kitty_graphics,
+      rgb: caps.rgb,
+      unicode: caps.unicode,
+      sgr_pixels: caps.sgr_pixels,
+      color_scheme_updates: caps.color_scheme_updates,
+      explicit_width: caps.explicit_width,
+      scaled_text: caps.scaled_text,
+      sixel: caps.sixel,
+      focus_tracking: caps.focus_tracking,
+      sync: caps.sync,
+      bracketed_paste: caps.bracketed_paste,
+      hyperlinks: caps.hyperlinks,
+      terminal: {
+        name: caps.term_name ?? "",
+        version: caps.term_version ?? "",
+        from_xtversion: caps.term_from_xtversion
+      }
     };
-    return capabilities;
   }
   processCapabilityResponse(renderer, response) {
     const responseBytes = this.encoder.encode(response);
@@ -10352,6 +10508,7 @@ class TextBuffer {
   _syntaxStyle;
   _textBytes;
   _memId;
+  _appendedChunks = [];
   constructor(lib, ptr4) {
     this.lib = lib;
     this.bufferPtr = ptr4;
@@ -10376,6 +10533,16 @@ class TextBuffer {
     this._length = this.lib.textBufferGetLength(this.bufferPtr);
     this._byteSize = this.lib.textBufferGetByteSize(this.bufferPtr);
     this._lineInfo = undefined;
+    this._appendedChunks = [];
+  }
+  append(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    this._appendedChunks.push(textBytes);
+    this.lib.textBufferAppend(this.bufferPtr, textBytes);
+    this._length = this.lib.textBufferGetLength(this.bufferPtr);
+    this._byteSize = this.lib.textBufferGetByteSize(this.bufferPtr);
+    this._lineInfo = undefined;
   }
   loadFile(path4) {
     this.guard();
@@ -10501,6 +10668,7 @@ class TextBuffer {
     this._byteSize = 0;
     this._lineInfo = undefined;
     this._textBytes = undefined;
+    this._appendedChunks = [];
   }
   reset() {
     this.guard();
@@ -10510,6 +10678,7 @@ class TextBuffer {
     this._lineInfo = undefined;
     this._textBytes = undefined;
     this._memId = undefined;
+    this._appendedChunks = [];
   }
   destroy() {
     if (this._destroyed)
@@ -10693,7 +10862,6 @@ class Renderable extends BaseRenderable {
   parent = null;
   childrenPrimarySortDirty = true;
   childrenSortedByPrimaryAxis = [];
-  _newChildren = [];
   onLifecyclePass = null;
   renderBefore;
   renderAfter;
@@ -11351,7 +11519,6 @@ class Renderable extends BaseRenderable {
     }
     obj.parent = this;
   }
-  _forceLayoutUpdateFor = null;
   add(obj, index) {
     if (!obj) {
       return -1;
@@ -11385,7 +11552,6 @@ class Renderable extends BaseRenderable {
         this.propagateLiveCount(renderable._liveCount);
       }
     }
-    this._newChildren.push(renderable);
     const childLayoutNode = renderable.getLayoutNode();
     const insertedIndex = this._childrenInLayoutOrder.length;
     this._childrenInLayoutOrder.push(renderable);
@@ -11438,11 +11604,9 @@ class Renderable extends BaseRenderable {
         this.propagateLiveCount(renderable._liveCount);
       }
     }
-    this._newChildren.push(renderable);
     this.childrenPrimarySortDirty = true;
     const anchorIndex = this._childrenInLayoutOrder.indexOf(anchor);
     const insertedIndex = Math.max(0, Math.min(anchorIndex, this._childrenInLayoutOrder.length));
-    this._forceLayoutUpdateFor = this._childrenInLayoutOrder.slice(insertedIndex);
     this._childrenInLayoutOrder.splice(insertedIndex, 0, renderable);
     this.yogaNode.insertChild(renderable.getLayoutNode(), insertedIndex);
     this.requestRender();
@@ -11476,16 +11640,6 @@ 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;
       }
     }
@@ -11503,18 +11657,6 @@ class Renderable extends BaseRenderable {
     this.onUpdate(deltaTime);
     this.updateFromLayout();
     renderList.push({ action: "render", renderable: this });
-    if (this._newChildren.length > 0) {
-      for (const child of this._newChildren) {
-        child.updateFromLayout();
-      }
-      this._newChildren = [];
-    }
-    if (this._forceLayoutUpdateFor) {
-      for (const child of this._forceLayoutUpdateFor) {
-        child.updateFromLayout();
-      }
-      this._forceLayoutUpdateFor = null;
-    }
     this.ensureZIndexSorted();
     const shouldPushScissor = this._overflow !== "visible" && this.width > 0 && this.height > 0;
     if (shouldPushScissor) {
@@ -11527,7 +11669,12 @@ class Renderable extends BaseRenderable {
         height: scissorRect.height
       });
     }
-    for (const child of this._getChildren()) {
+    const visibleChildren = this._getVisibleChildren();
+    for (const child of this._childrenInZIndexOrder) {
+      if (!visibleChildren.includes(child.num)) {
+        child.updateFromLayout();
+        continue;
+      }
       child.updateLayout(deltaTime, renderList);
     }
     if (shouldPushScissor) {
@@ -11552,8 +11699,8 @@ class Renderable extends BaseRenderable {
       buffer.drawFrameBuffer(this.x, this.y, this.frameBuffer);
     }
   }
-  _getChildren() {
-    return this._childrenInZIndexOrder;
+  _getVisibleChildren() {
+    return this._childrenInZIndexOrder.map((child) => child.num);
   }
   onUpdate(deltaTime) {}
   getScissorRect() {
@@ -12150,7 +12297,7 @@ class TerminalConsole extends EventEmitter8 {
   isVisible = false;
   isFocused = false;
   renderer;
-  stdinHandler;
+  keyHandler;
   options;
   _debugModeEnabled = false;
   frameBuffer = null;
@@ -12188,7 +12335,7 @@ class TerminalConsole extends EventEmitter8 {
     super();
     this.renderer = renderer;
     this.options = { ...DEFAULT_CONSOLE_OPTIONS, ...options };
-    this.stdinHandler = this.handleStdin.bind(this);
+    this.keyHandler = this.handleKeyPress.bind(this);
     this._debugModeEnabled = this.options.startInDebugMode;
     terminalConsoleCache.setCollectCallerInfo(this._debugModeEnabled);
     this._rgbaInfo = parseColor(this.options.colorInfo);
@@ -12267,75 +12414,65 @@ class TerminalConsole extends EventEmitter8 {
     }
     this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
   }
-  handleStdin(data) {
-    const key = data.toString();
+  handleKeyPress(event) {
     let needsRedraw = false;
     const displayLineCount = this._displayLines.length;
     const logAreaHeight = Math.max(1, this.consoleHeight - 1);
     const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
     const currentPositionIndex = this._positions.indexOf(this.options.position);
-    switch (key) {
-      case "\x1B":
-        this.blur();
-        break;
-      case "\x1B[1;2A":
-        if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
-          this.scrollTopIndex = 0;
-          this.currentLineIndex = 0;
-          this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
-          needsRedraw = true;
-        }
-        break;
-      case "\x1B[1;2B":
-        const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
-        const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
-        if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
-          this._scrollToBottom(true);
-          needsRedraw = true;
-        }
-        break;
-      case "\x1B[A":
-        if (this.currentLineIndex > 0) {
-          this.currentLineIndex--;
-          needsRedraw = true;
-        } else if (this.scrollTopIndex > 0) {
-          this.scrollTopIndex--;
-          this.isScrolledToBottom = false;
-          needsRedraw = true;
-        }
-        break;
-      case "\x1B[B":
-        const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
-        if (canCursorMoveDown) {
-          this.currentLineIndex++;
-          needsRedraw = true;
-        } else if (this.scrollTopIndex < maxScrollTop) {
-          this.scrollTopIndex++;
-          this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-          needsRedraw = true;
-        }
-        break;
-      case "\x10":
-        const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
-        this.options.position = this._positions[prevIndex];
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "\x0F":
-        const nextIndex = (currentPositionIndex + 1) % this._positions.length;
-        this.options.position = this._positions[nextIndex];
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "+":
-        this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "-":
-        this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "\x13":
-        this.saveLogsToFile();
-        break;
+    if (event.name === "escape") {
+      this.blur();
+      return;
+    }
+    if (event.name === "up" && event.shift) {
+      if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
+        this.scrollTopIndex = 0;
+        this.currentLineIndex = 0;
+        this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
+        needsRedraw = true;
+      }
+    } else if (event.name === "down" && event.shift) {
+      const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
+      const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
+      if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
+        this._scrollToBottom(true);
+        needsRedraw = true;
+      }
+    } else if (event.name === "up") {
+      if (this.currentLineIndex > 0) {
+        this.currentLineIndex--;
+        needsRedraw = true;
+      } else if (this.scrollTopIndex > 0) {
+        this.scrollTopIndex--;
+        this.isScrolledToBottom = false;
+        needsRedraw = true;
+      }
+    } else if (event.name === "down") {
+      const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
+      if (canCursorMoveDown) {
+        this.currentLineIndex++;
+        needsRedraw = true;
+      } else if (this.scrollTopIndex < maxScrollTop) {
+        this.scrollTopIndex++;
+        this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+        needsRedraw = true;
+      }
+    } else if (event.name === "p" && event.ctrl) {
+      const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
+      this.options.position = this._positions[prevIndex];
+      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
+    } else if (event.name === "o" && event.ctrl) {
+      const nextIndex = (currentPositionIndex + 1) % this._positions.length;
+      this.options.position = this._positions[nextIndex];
+      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
+    } else if (event.name === "+" || event.name === "=" && event.shift) {
+      this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
+      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
+    } else if (event.name === "-") {
+      this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
+      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
+    } else if (event.name === "s" && event.ctrl) {
+      this.saveLogsToFile();
     }
     if (needsRedraw) {
       this.markNeedsRerender();
@@ -12344,13 +12481,13 @@ class TerminalConsole extends EventEmitter8 {
   attachStdin() {
     if (this.isFocused)
       return;
-    process.stdin.on("data", this.stdinHandler);
+    this.renderer.keyInput.on("keypress", this.keyHandler);
     this.isFocused = true;
   }
   detachStdin() {
     if (!this.isFocused)
       return;
-    process.stdin.off("data", this.stdinHandler);
+    this.renderer.keyInput.off("keypress", this.keyHandler);
     this.isFocused = false;
   }
   formatTimestamp(date) {
@@ -12605,6 +12742,21 @@ class TerminalConsole extends EventEmitter8 {
   }
 }
 
+// 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/renderer.ts
 import { EventEmitter as EventEmitter9 } from "events";
 
@@ -12698,6 +12850,42 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
   return visibleChildren;
 }
 
+// src/lib/terminal-capability-detection.ts
+function isCapabilityResponse(sequence) {
+  if (/\x1b\[\?\d+(?:;\d+)*\$y/.test(sequence)) {
+    return true;
+  }
+  if (/\x1b\[1;(?!1R)\d+R/.test(sequence)) {
+    return true;
+  }
+  if (/\x1bP>\|[\s\S]*?\x1b\\/.test(sequence)) {
+    return true;
+  }
+  if (/\x1b_G[\s\S]*?\x1b\\/.test(sequence)) {
+    return true;
+  }
+  if (/\x1b\[\?\d+(?:;\d+)?u/.test(sequence)) {
+    return true;
+  }
+  if (/\x1b\[\?[0-9;]*c/.test(sequence)) {
+    return true;
+  }
+  return false;
+}
+function isPixelResolutionResponse(sequence) {
+  return /\x1b\[4;\d+;\d+t/.test(sequence);
+}
+function parsePixelResolution(sequence) {
+  const match = sequence.match(/\x1b\[4;(\d+);(\d+)t/);
+  if (match) {
+    return {
+      width: parseInt(match[2]),
+      height: parseInt(match[1])
+    };
+  }
+  return null;
+}
+
 // src/renderer.ts
 registerEnvVar({
   name: "OTUI_DUMP_CAPTURES",
@@ -12890,6 +13078,7 @@ class CliRenderer extends EventEmitter9 {
   _console;
   _resolution = null;
   _keyHandler;
+  _stdinBuffer;
   animationRequest = new Map;
   resizeTimeoutId = null;
   resizeDebounceDelay = 100;
@@ -12929,6 +13118,8 @@ class CliRenderer extends EventEmitter9 {
   _paletteDetector = null;
   _cachedPalette = null;
   _paletteDetectionPromise = null;
+  inputHandlers = [];
+  prependedInputHandlers = [];
   handleError = ((error) => {
     console.error(error);
     if (this._openConsoleOnError) {
@@ -13002,6 +13193,7 @@ Captured output:
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this.postProcessFns = config.postProcessFns || [];
+    this.prependedInputHandlers = config.prependInputHandlers || [];
     this.root = new RootRenderable(this);
     if (this.memorySnapshotInterval > 0) {
       this.startMemorySnapshotTimer();
@@ -13014,10 +13206,7 @@ Captured output:
     process.on("uncaughtException", this.handleError);
     process.on("unhandledRejection", this.handleError);
     process.on("exit", this.exitHandler);
-    this._console = new TerminalConsole(this, config.consoleOptions);
-    this.useConsole = config.useConsole ?? true;
-    this._openConsoleOnError = config.openConsoleOnError ?? true;
-    this._keyHandler = new InternalKeyHandler(this.stdin, config.useKittyKeyboard ?? true);
+    this._keyHandler = new InternalKeyHandler(config.useKittyKeyboard ?? true);
     this._keyHandler.on("keypress", (event) => {
       if (this.exitOnCtrlC && event.name === "c" && event.ctrl) {
         process.nextTick(() => {
@@ -13026,6 +13215,10 @@ Captured output:
         return;
       }
     });
+    this._stdinBuffer = new StdinBuffer({ timeout: 5 });
+    this._console = new TerminalConsole(this, config.consoleOptions);
+    this.useConsole = config.useConsole ?? true;
+    this._openConsoleOnError = config.openConsoleOnError ?? true;
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
       this.animationRequest.set(id, callback);
@@ -13257,52 +13450,86 @@ Captured output:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
-    await new Promise((resolve4) => {
-      const timeout = setTimeout(() => {
-        this.stdin.off("data", capListener);
-        resolve4(true);
-      }, 100);
-      const capListener = (str) => {
-        clearTimeout(timeout);
-        this.lib.processCapabilityResponse(this.rendererPtr, str);
-        this.stdin.off("data", capListener);
-        resolve4(true);
-      };
-      this.stdin.on("data", capListener);
-      this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
-    });
+    this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
+    setTimeout(() => {
+      this.removeInputHandler(this.capabilityHandler);
+    }, 5000);
     if (this._useMouse) {
       this.enableMouse();
     }
     this.queryPixelResolution();
   }
   stdinListener = ((data) => {
-    const str = data.toString();
-    if (this.waitingForPixelResolution && /\x1b\[4;\d+;\d+t/.test(str)) {
-      const match = str.match(/\x1b\[4;(\d+);(\d+)t/);
-      if (match) {
-        const resolution = {
-          width: parseInt(match[2]),
-          height: parseInt(match[1])
-        };
-        this._resolution = resolution;
-        this.waitingForPixelResolution = false;
-        return;
-      }
-    }
     if (this._useMouse && this.handleMouseData(data)) {
       return;
     }
-    this.emit("key", data);
+    this._stdinBuffer.process(data);
+  }).bind(this);
+  addInputHandler(handler) {
+    this.inputHandlers.push(handler);
+  }
+  prependInputHandler(handler) {
+    this.inputHandlers.unshift(handler);
+  }
+  removeInputHandler(handler) {
+    this.inputHandlers = this.inputHandlers.filter((h2) => h2 !== handler);
+  }
+  capabilityHandler = ((sequence) => {
+    if (isCapabilityResponse(sequence)) {
+      this.lib.processCapabilityResponse(this.rendererPtr, sequence);
+      this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
+      return true;
+    }
+    return false;
+  }).bind(this);
+  focusHandler = ((sequence) => {
+    if (sequence === "\x1B[I") {
+      this.emit("focus");
+      return true;
+    }
+    if (sequence === "\x1B[O") {
+      this.emit("blur");
+      return true;
+    }
+    return false;
   }).bind(this);
   setupInput() {
+    for (const handler of this.prependedInputHandlers) {
+      this.addInputHandler(handler);
+    }
+    this.addInputHandler((sequence) => {
+      if (isPixelResolutionResponse(sequence) && this.waitingForPixelResolution) {
+        const resolution = parsePixelResolution(sequence);
+        if (resolution) {
+          this._resolution = resolution;
+          this.waitingForPixelResolution = false;
+        }
+        return true;
+      }
+      return false;
+    });
+    this.addInputHandler(this.capabilityHandler);
+    this.addInputHandler(this.focusHandler);
+    this.addInputHandler((sequence) => {
+      return this._keyHandler.processInput(sequence);
+    });
     if (this.stdin.setRawMode) {
       this.stdin.setRawMode(true);
     }
     this.stdin.resume();
     this.stdin.setEncoding("utf8");
     this.stdin.on("data", this.stdinListener);
+    this._stdinBuffer.on("data", (sequence) => {
+      for (const handler of this.inputHandlers) {
+        if (handler(sequence)) {
+          return;
+        }
+      }
+    });
+    this._stdinBuffer.on("paste", (data) => {
+      this._keyHandler.processPaste(data);
+    });
   }
   handleMouseData(data) {
     const mouseEvent = this.mouseParser.parseMouseEvent(data);
@@ -13628,6 +13855,7 @@ Captured output:
     this._suspendedMouseEnabled = this._useMouse;
     this.disableMouse();
     this._keyHandler.suspend();
+    this._stdinBuffer.clear();
     if (this.stdin.setRawMode) {
       this.stdin.setRawMode(false);
     }
@@ -13697,7 +13925,7 @@ Captured output:
     } catch (e) {
       console.error("Error destroying root renderable:", e instanceof Error ? e.stack : String(e));
     }
-    this._keyHandler.destroy();
+    this._stdinBuffer.destroy();
     this._console.deactivate();
     this.disableStdoutInterception();
     if (this._splitHeight > 0) {
@@ -13970,7 +14198,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, StdinBuffer, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=064478AA2D709FB664756E2164756E21
-//# sourceMappingURL=index-pb1pm3hk.js.map
+//# debugId=7BD9FAB5ED52E27064756E2164756E21
+//# sourceMappingURL=index-kj9k00yt.js.map