@opentui/core 0.0.0-20250912-12c969f4 → 0.0.0-20250915-f5db043a

package/{index-mh94hn7d.js → index-6esrcarp.js}

@@ -1,3 +1,4 @@
+// @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -1907,6 +1908,237 @@ function createTrackedNode(metadata = {}, yogaConfig) {
 
 // src/lib/parse.keypress.ts
 import { Buffer } from "buffer";
+
+// src/lib/parse.keypress-kitty.ts
+var kittyKeyMap = {
+  27: "escape",
+  9: "tab",
+  13: "enter",
+  127: "backspace",
+  57344: "escape",
+  57345: "enter",
+  57346: "tab",
+  57347: "backspace",
+  57348: "insert",
+  57349: "delete",
+  57350: "left",
+  57351: "right",
+  57352: "up",
+  57353: "down",
+  57354: "pageup",
+  57355: "pagedown",
+  57356: "home",
+  57357: "end",
+  57364: "f1",
+  57365: "f2",
+  57366: "f3",
+  57367: "f4",
+  57368: "f5",
+  57369: "f6",
+  57370: "f7",
+  57371: "f8",
+  57372: "f9",
+  57373: "f10",
+  57374: "f11",
+  57375: "f12",
+  57376: "f13",
+  57377: "f14",
+  57378: "f15",
+  57379: "f16",
+  57380: "f17",
+  57381: "f18",
+  57382: "f19",
+  57383: "f20",
+  57384: "f21",
+  57385: "f22",
+  57386: "f23",
+  57387: "f24",
+  57388: "f25",
+  57389: "f26",
+  57390: "f27",
+  57391: "f28",
+  57392: "f29",
+  57393: "f30",
+  57394: "f31",
+  57395: "f32",
+  57396: "f33",
+  57397: "f34",
+  57398: "f35",
+  57400: "kp0",
+  57401: "kp1",
+  57402: "kp2",
+  57403: "kp3",
+  57404: "kp4",
+  57405: "kp5",
+  57406: "kp6",
+  57407: "kp7",
+  57408: "kp8",
+  57409: "kp9",
+  57410: "kpdecimal",
+  57411: "kpdivide",
+  57412: "kpmultiply",
+  57413: "kpminus",
+  57414: "kpplus",
+  57415: "kpenter",
+  57416: "kpequal",
+  57428: "mediaplay",
+  57429: "mediapause",
+  57430: "mediaplaypause",
+  57431: "mediareverse",
+  57432: "mediastop",
+  57433: "mediafastforward",
+  57434: "mediarewind",
+  57435: "medianext",
+  57436: "mediaprev",
+  57437: "mediarecord",
+  57438: "volumedown",
+  57439: "volumeup",
+  57440: "mute",
+  57441: "leftshift",
+  57442: "leftctrl",
+  57443: "leftalt",
+  57444: "leftsuper",
+  57445: "lefthyper",
+  57446: "leftmeta",
+  57447: "rightshift",
+  57448: "rightctrl",
+  57449: "rightalt",
+  57450: "rightsuper",
+  57451: "righthyper",
+  57452: "rightmeta",
+  57453: "iso_level3_shift",
+  57454: "iso_level5_shift"
+};
+function fromKittyMods(mod) {
+  return {
+    shift: !!(mod & 1),
+    alt: !!(mod & 2),
+    ctrl: !!(mod & 4),
+    super: !!(mod & 8),
+    hyper: !!(mod & 16),
+    meta: !!(mod & 32),
+    capsLock: !!(mod & 64),
+    numLock: !!(mod & 128)
+  };
+}
+function parseKittyKeyboard(sequence) {
+  const kittyRe = /^\x1b\[([^\x1b]+)u$/;
+  const match = kittyRe.exec(sequence);
+  if (!match)
+    return null;
+  const params = match[1];
+  const fields = params.split(";");
+  if (fields.length < 1)
+    return null;
+  const key = {
+    name: "",
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    number: false,
+    sequence,
+    raw: sequence,
+    eventType: "press",
+    super: false,
+    hyper: false,
+    capsLock: false,
+    numLock: false
+  };
+  let text = "";
+  const field1 = fields[0]?.split(":") || [];
+  const codepointStr = field1[0];
+  if (!codepointStr)
+    return null;
+  const codepoint = parseInt(codepointStr, 10);
+  if (isNaN(codepoint))
+    return null;
+  let shiftedCodepoint;
+  let baseCodepoint;
+  if (field1[1]) {
+    const shifted = parseInt(field1[1], 10);
+    if (!isNaN(shifted) && shifted > 0 && shifted <= 1114111) {
+      shiftedCodepoint = shifted;
+    }
+  }
+  if (field1[2]) {
+    const base = parseInt(field1[2], 10);
+    if (!isNaN(base) && base > 0 && base <= 1114111) {
+      baseCodepoint = base;
+    }
+  }
+  const knownKey = kittyKeyMap[codepoint];
+  if (knownKey) {
+    key.name = knownKey;
+    key.code = `[${codepoint}u`;
+  } else {
+    if (codepoint > 0 && codepoint <= 1114111) {
+      const char = String.fromCodePoint(codepoint);
+      key.name = char;
+      if (baseCodepoint) {
+        key.baseCode = baseCodepoint;
+      }
+    } else {
+      return null;
+    }
+  }
+  if (fields[1]) {
+    const field2 = fields[1].split(":");
+    const modifierStr = field2[0];
+    const eventTypeStr = field2[1];
+    if (modifierStr) {
+      const modifierMask = parseInt(modifierStr, 10);
+      if (!isNaN(modifierMask) && modifierMask > 1) {
+        const mods = fromKittyMods(modifierMask - 1);
+        key.shift = mods.shift;
+        key.ctrl = mods.ctrl;
+        key.meta = mods.alt || mods.meta;
+        key.option = mods.alt;
+        key.super = mods.super;
+        key.hyper = mods.hyper;
+        key.capsLock = mods.capsLock;
+        key.numLock = mods.numLock;
+      }
+    }
+    if (eventTypeStr === "1" || !eventTypeStr) {
+      key.eventType = "press";
+    } else if (eventTypeStr === "2") {
+      key.eventType = "repeat";
+    } else if (eventTypeStr === "3") {
+      key.eventType = "release";
+    } else {
+      key.eventType = "press";
+    }
+  }
+  if (fields[2]) {
+    const codepoints = fields[2].split(":");
+    for (const cpStr of codepoints) {
+      const cp = parseInt(cpStr, 10);
+      if (!isNaN(cp) && cp > 0 && cp <= 1114111) {
+        text += String.fromCodePoint(cp);
+      }
+    }
+  }
+  if (text === "") {
+    const isPrintable = key.name.length > 0 && !kittyKeyMap[codepoint];
+    if (isPrintable) {
+      if (key.shift && shiftedCodepoint) {
+        text = String.fromCodePoint(shiftedCodepoint);
+      } else {
+        text = key.name;
+      }
+    }
+  }
+  if (key.name === " " && key.shift && !key.ctrl && !key.meta) {
+    text = " ";
+  }
+  if (text) {
+    key.sequence = text;
+  }
+  return key;
+}
+
+// src/lib/parse.keypress.ts
 var metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
 var fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
 var keyName = {
@@ -1990,7 +2222,7 @@ var isShiftKey = (code) => {
 var isCtrlKey = (code) => {
   return ["Oa", "Ob", "Oc", "Od", "Oe", "[2^", "[3^", "[5^", "[6^", "[7^", "[8^"].includes(code);
 };
-var parseKeypress = (s = "") => {
+var parseKeypress = (s = "", options = {}) => {
   let parts;
   if (Buffer.isBuffer(s)) {
     if (s[0] > 127 && s[1] === undefined) {
@@ -2012,9 +2244,16 @@ var parseKeypress = (s = "") => {
     option: false,
     number: false,
     sequence: s,
-    raw: s
+    raw: s,
+    eventType: "press"
   };
   key.sequence = key.sequence || s || key.name;
+  if (options.useKittyKeyboard && /^\x1b\[.*u$/.test(s)) {
+    const kittyResult = parseKittyKeyboard(s);
+    if (kittyResult) {
+      return kittyResult;
+    }
+  }
   if (s === "\r") {
     key.name = "return";
   } else if (s === `
@@ -2054,15 +2293,21 @@ var parseKeypress = (s = "") => {
       key.option = true;
     }
     const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
-    const modifier = (parts[3] || parts[5] || 1) - 1;
+    const modifier = parseInt(parts[3] || parts[5] || "1", 10) - 1;
     key.ctrl = !!(modifier & 4);
     key.meta = !!(modifier & 10);
     key.shift = !!(modifier & 1);
     key.option = !!(modifier & 2);
     key.code = code;
-    key.name = keyName[code];
-    key.shift = isShiftKey(code) || key.shift;
-    key.ctrl = isCtrlKey(code) || key.ctrl;
+    const keyNameResult = keyName[code];
+    if (keyNameResult) {
+      key.name = keyNameResult;
+      key.shift = isShiftKey(code) || key.shift;
+      key.ctrl = isCtrlKey(code) || key.ctrl;
+    } else {
+      key.name = "";
+      key.code = undefined;
+    }
   } else if (s === "\x1B[3~") {
     key.name = "delete";
     key.meta = false;
@@ -2086,26 +2331,43 @@ function singleton(key, factory) {
 
 // src/lib/KeyHandler.ts
 class KeyHandler extends EventEmitter2 {
-  constructor() {
+  stdin;
+  useKittyKeyboard;
+  constructor(stdin, useKittyKeyboard = false) {
     super();
-    if (process.stdin.setRawMode) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (key) => {
-      const parsedKey = parseKeypress(key);
-      this.emit("keypress", parsedKey);
+    this.stdin = stdin || process.stdin;
+    this.useKittyKeyboard = useKittyKeyboard;
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(true);
+    }
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
+    this.stdin.on("data", (key) => {
+      const parsedKey = parseKeypress(key, { useKittyKeyboard: this.useKittyKeyboard });
+      switch (parsedKey.eventType) {
+        case "press":
+          this.emit("keypress", parsedKey);
+          break;
+        case "repeat":
+          this.emit("keyrepeat", parsedKey);
+          break;
+        case "release":
+          this.emit("keyrelease", parsedKey);
+          break;
+        default:
+          this.emit("keypress", parsedKey);
+          break;
+      }
     });
   }
   destroy() {
-    process.stdin.removeAllListeners("data");
+    this.stdin.removeAllListeners("data");
   }
 }
 var keyHandler = null;
-function getKeyHandler() {
+function getKeyHandler(useKittyKeyboard = false) {
   if (!keyHandler) {
-    keyHandler = singleton("KeyHandler", () => new KeyHandler);
+    keyHandler = singleton("KeyHandler", () => new KeyHandler(process.stdin, useKittyKeyboard));
   }
   return keyHandler;
 }
@@ -4782,6 +5044,13 @@ class OptimizedBuffer {
     this.guard();
     return this.lib.bufferGetId(this.bufferPtr);
   }
+  getRealCharBytes(addLineBreaks = false) {
+    this.guard();
+    const realSize = this.lib.bufferGetRealCharSize(this.bufferPtr);
+    const outputBuffer = new Uint8Array(realSize);
+    const bytesWritten = this.lib.bufferWriteResolvedChars(this.bufferPtr, outputBuffer, addLineBreaks);
+    return outputBuffer.slice(0, bytesWritten);
+  }
   clear(bg2 = RGBA.fromValues(0, 0, 0, 1)) {
     this.guard();
     this.lib.bufferClear(this.bufferPtr, bg2);
@@ -4887,7 +5156,7 @@ if (!existsSync(targetLibPath)) {
 }
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
-  return dlopen(resolvedLibPath, {
+  const rawSymbols = dlopen(resolvedLibPath, {
     setLogCallback: {
       args: ["ptr"],
       returns: "void"
@@ -4897,7 +5166,7 @@ function getOpenTUILib(libPath) {
       returns: "ptr"
     },
     destroyRenderer: {
-      args: ["ptr", "bool", "u32"],
+      args: ["ptr"],
       returns: "void"
     },
     setUseThread: {
@@ -4984,6 +5253,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr", "usize"],
       returns: "usize"
     },
+    bufferGetRealCharSize: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    bufferWriteResolvedChars: {
+      args: ["ptr", "ptr", "usize", "bool"],
+      returns: "u32"
+    },
     bufferDrawText: {
       args: ["ptr", "ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
       returns: "void"
@@ -5217,6 +5494,115 @@ function getOpenTUILib(libPath) {
       returns: "void"
     }
   });
+  if (process.env.DEBUG_FFI === "true" || process.env.TRACE_FFI === "true") {
+    return {
+      symbols: convertToDebugSymbols(rawSymbols.symbols)
+    };
+  }
+  return rawSymbols;
+}
+function convertToDebugSymbols(symbols) {
+  const debugSymbols = {};
+  const traceSymbols = {};
+  let hasTracing = false;
+  Object.entries(symbols).forEach(([key, value]) => {
+    debugSymbols[key] = value;
+  });
+  if (process.env.DEBUG_FFI === "true") {
+    Object.entries(symbols).forEach(([key, value]) => {
+      if (typeof value === "function") {
+        debugSymbols[key] = (...args) => {
+          console.log(`${key}(${args.map((arg) => String(arg)).join(", ")})`);
+          const result = value(...args);
+          console.log(`${key} returned:`, String(result));
+          return result;
+        };
+      }
+    });
+  }
+  if (process.env.TRACE_FFI === "true") {
+    hasTracing = true;
+    Object.entries(symbols).forEach(([key, value]) => {
+      if (typeof value === "function") {
+        traceSymbols[key] = [];
+        const originalFunc = debugSymbols[key];
+        debugSymbols[key] = (...args) => {
+          const start = performance.now();
+          const result = originalFunc(...args);
+          const end = performance.now();
+          traceSymbols[key].push(end - start);
+          return result;
+        };
+      }
+    });
+  }
+  if (hasTracing) {
+    process.on("exit", () => {
+      const allStats = [];
+      for (const [key, timings] of Object.entries(traceSymbols)) {
+        if (!Array.isArray(timings) || timings.length === 0) {
+          continue;
+        }
+        const sortedTimings = [...timings].sort((a, b) => a - b);
+        const count = sortedTimings.length;
+        const total = sortedTimings.reduce((acc, t2) => acc + t2, 0);
+        const average = total / count;
+        const min = sortedTimings[0];
+        const max = sortedTimings[count - 1];
+        const medianIndex = Math.floor(count / 2);
+        const p90Index = Math.floor(count * 0.9);
+        const p99Index = Math.floor(count * 0.99);
+        const median = sortedTimings[medianIndex];
+        const p90 = sortedTimings[Math.min(p90Index, count - 1)];
+        const p99 = sortedTimings[Math.min(p99Index, count - 1)];
+        allStats.push({
+          name: key,
+          count,
+          total,
+          average,
+          min,
+          max,
+          median,
+          p90,
+          p99
+        });
+      }
+      allStats.sort((a, b) => b.total - a.total);
+      console.log(`
+--- OpenTUI FFI Call Performance ---`);
+      console.log("Sorted by total time spent (descending)");
+      console.log("-------------------------------------------------------------------------------------------------------------------------");
+      if (allStats.length === 0) {
+        console.log("No trace data collected or all symbols had zero calls.");
+      } else {
+        const nameHeader = "Symbol";
+        const callsHeader = "Calls";
+        const totalHeader = "Total (ms)";
+        const avgHeader = "Avg (ms)";
+        const minHeader = "Min (ms)";
+        const maxHeader = "Max (ms)";
+        const medHeader = "Med (ms)";
+        const p90Header = "P90 (ms)";
+        const p99Header = "P99 (ms)";
+        const nameWidth = Math.max(nameHeader.length, ...allStats.map((s) => s.name.length));
+        const countWidth = Math.max(callsHeader.length, ...allStats.map((s) => String(s.count).length));
+        const totalWidth = Math.max(totalHeader.length, ...allStats.map((s) => s.total.toFixed(2).length));
+        const avgWidth = Math.max(avgHeader.length, ...allStats.map((s) => s.average.toFixed(2).length));
+        const minWidth = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length));
+        const maxWidth = Math.max(maxHeader.length, ...allStats.map((s) => s.max.toFixed(2).length));
+        const medianWidth = Math.max(medHeader.length, ...allStats.map((s) => s.median.toFixed(2).length));
+        const p90Width = Math.max(p90Header.length, ...allStats.map((s) => s.p90.toFixed(2).length));
+        const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
+        console.log(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(minWidth)} | ${maxHeader.padStart(maxWidth)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
+        console.log(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(minWidth)}-+-${"-".repeat(maxWidth)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
+        allStats.forEach((stat) => {
+          console.log(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(minWidth)} | ${stat.max.toFixed(2).padStart(maxWidth)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
+        });
+      }
+      console.log("-------------------------------------------------------------------------------------------------------------------------");
+    });
+  }
+  return debugSymbols;
 }
 var LogLevel2;
 ((LogLevel3) => {
@@ -5283,8 +5669,8 @@ class FFIRenderLib {
   createRenderer(width, height, options = { testing: false }) {
     return this.opentui.symbols.createRenderer(width, height, options.testing);
   }
-  destroyRenderer(renderer, useAlternateScreen, splitHeight) {
-    this.opentui.symbols.destroyRenderer(renderer, useAlternateScreen, splitHeight);
+  destroyRenderer(renderer) {
+    this.opentui.symbols.destroyRenderer(renderer);
   }
   setUseThread(renderer, useThread) {
     this.opentui.symbols.setUseThread(renderer, useThread);
@@ -5360,6 +5746,13 @@ class FFIRenderLib {
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     return this.decoder.decode(outBuffer.slice(0, len));
   }
+  bufferGetRealCharSize(buffer) {
+    return this.opentui.symbols.bufferGetRealCharSize(buffer);
+  }
+  bufferWriteResolvedChars(buffer, outputBuffer, addLineBreaks) {
+    const bytesWritten = this.opentui.symbols.bufferWriteResolvedChars(buffer, outputBuffer, outputBuffer.length, addLineBreaks);
+    return typeof bytesWritten === "bigint" ? Number(bytesWritten) : bytesWritten;
+  }
   getBufferWidth(buffer) {
     return this.opentui.symbols.getBufferWidth(buffer);
   }
@@ -5990,7 +6383,6 @@ class Renderable extends BaseRenderable {
   frameBuffer = null;
   _focusable = false;
   _focused = false;
-  keyHandler = getKeyHandler();
   keypressHandler = null;
   _live = false;
   _liveCount = 0;
@@ -6095,7 +6487,7 @@ class Renderable extends BaseRenderable {
         this.handleKeyPress(key);
       }
     };
-    this.keyHandler.on("keypress", this.keypressHandler);
+    this.ctx.keyInput.on("keypress", this.keypressHandler);
     this.emit("focused" /* FOCUSED */);
   }
   blur() {
@@ -6104,7 +6496,7 @@ class Renderable extends BaseRenderable {
     this._focused = false;
     this.requestRender();
     if (this.keypressHandler) {
-      this.keyHandler.off("keypress", this.keypressHandler);
+      this.ctx.keyInput.off("keypress", this.keypressHandler);
       this.keypressHandler = null;
     }
     this.emit("blurred" /* BLURRED */);
@@ -8061,6 +8453,7 @@ class CliRenderer extends EventEmitter6 {
   };
   _console;
   _resolution = null;
+  _keyHandler;
   animationRequest = new Map;
   resizeTimeoutId = null;
   resizeDebounceDelay = 100;
@@ -8085,11 +8478,57 @@ class CliRenderer extends EventEmitter6 {
   };
   _useConsole = true;
   mouseParser = new MouseParser;
-  sigwinchHandler = null;
+  sigwinchHandler = (() => {
+    const width = this.stdout.columns || 80;
+    const height = this.stdout.rows || 24;
+    this.handleResize(width, height);
+  }).bind(this);
   _capabilities = null;
   _latestPointer = { x: 0, y: 0 };
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
+  handleError = ((error) => {
+    this.stop();
+    this.destroy();
+    new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, 100);
+    }).then(() => {
+      this.realStdoutWrite.call(this.stdout, `
+`.repeat(this._terminalHeight));
+      this.realStdoutWrite.call(this.stdout, `
+=== FATAL ERROR OCCURRED ===
+`);
+      this.realStdoutWrite.call(this.stdout, `Console cache:
+`);
+      this.realStdoutWrite.call(this.stdout, this.console.getCachedLogs());
+      this.realStdoutWrite.call(this.stdout, `
+Captured output:
+`);
+      const capturedOutput = capture.claimOutput();
+      if (capturedOutput) {
+        this.realStdoutWrite.call(this.stdout, capturedOutput + `
+`);
+      }
+      this.realStdoutWrite.call(this.stdout, `
+Error details:
+`);
+      this.realStdoutWrite.call(this.stdout, error.message || "unknown error");
+      this.realStdoutWrite.call(this.stdout, `
+`);
+      this.realStdoutWrite.call(this.stdout, error.stack || error.toString());
+      this.realStdoutWrite.call(this.stdout, `
+`);
+      process.exit(1);
+    });
+  }).bind(this);
+  exitHandler = (() => {
+    this.destroy();
+  }).bind(this);
+  warningHandler = ((warning) => {
+    console.warn(JSON.stringify(warning.message, null, 2));
+  }).bind(this);
   constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
     this.stdin = stdin;
@@ -8112,7 +8551,7 @@ class CliRenderer extends EventEmitter6 {
     this.exitOnCtrlC = config.exitOnCtrlC === undefined ? true : config.exitOnCtrlC;
     this.resizeDebounceDelay = config.debounceDelay || 100;
     this.targetFps = config.targetFps || 30;
-    this.memorySnapshotInterval = config.memorySnapshotInterval || 5000;
+    this.memorySnapshotInterval = config.memorySnapshotInterval ?? 0;
     this.gatherStats = config.gatherStats || false;
     this.maxStatSamples = config.maxStatSamples || 300;
     this.enableMouseMovement = config.enableMouseMovement || true;
@@ -8127,58 +8566,14 @@ class CliRenderer extends EventEmitter6 {
       this.startMemorySnapshotTimer();
     }
     this.stdout.write = this.interceptStdoutWrite.bind(this);
-    this.sigwinchHandler = () => {
-      const width2 = this.stdout.columns || 80;
-      const height2 = this.stdout.rows || 24;
-      this.handleResize(width2, height2);
-    };
     process.on("SIGWINCH", this.sigwinchHandler);
-    const handleError = (error) => {
-      this.stop();
-      this.destroy();
-      new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(true);
-        }, 100);
-      }).then(() => {
-        this.realStdoutWrite.call(this.stdout, `
-`.repeat(this._terminalHeight));
-        this.realStdoutWrite.call(this.stdout, `
-=== FATAL ERROR OCCURRED ===
-`);
-        this.realStdoutWrite.call(this.stdout, `Console cache:
-`);
-        this.realStdoutWrite.call(this.stdout, this.console.getCachedLogs());
-        this.realStdoutWrite.call(this.stdout, `
-Captured output:
-`);
-        const capturedOutput = capture.claimOutput();
-        if (capturedOutput) {
-          this.realStdoutWrite.call(this.stdout, capturedOutput + `
-`);
-        }
-        this.realStdoutWrite.call(this.stdout, `
-Error details:
-`);
-        this.realStdoutWrite.call(this.stdout, error.message || "unknown error");
-        this.realStdoutWrite.call(this.stdout, `
-`);
-        this.realStdoutWrite.call(this.stdout, error.stack || error.toString());
-        this.realStdoutWrite.call(this.stdout, `
-`);
-        process.exit(1);
-      });
-    };
-    process.on("warning", (warning) => {
-      console.warn(JSON.stringify(warning.message, null, 2));
-    });
-    process.on("uncaughtException", handleError);
-    process.on("unhandledRejection", handleError);
-    process.on("exit", () => {
-      this.destroy();
-    });
+    process.on("warning", this.warningHandler);
+    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._keyHandler = new KeyHandler(this.stdin, config.useKittyKeyboard ?? false);
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
       this.animationRequest.set(id, callback);
@@ -8263,6 +8658,9 @@ Error details:
   get console() {
     return this._console;
   }
+  get keyInput() {
+    return this._keyHandler;
+  }
   get terminalWidth() {
     return this._terminalWidth;
   }
@@ -8362,10 +8760,13 @@ Error details:
     const flush = ANSI.moveCursorAndClear(rendererStartLine, 1);
     const outputLine = this._terminalHeight - this._splitHeight;
     const move = ANSI.moveCursor(outputLine, 1);
-    const backgroundColor = this.backgroundColor.toInts();
-    const newlines = " ".repeat(this.width) + `
+    let clear = "";
+    if (space > 0) {
+      const backgroundColor = this.backgroundColor.toInts();
+      const newlines = " ".repeat(this.width) + `
 `.repeat(space);
-    const clear = ANSI.setRgbBackground(backgroundColor[0], backgroundColor[1], backgroundColor[2]) + newlines + ANSI.resetBackground;
+      clear = ANSI.setRgbBackground(backgroundColor[0], backgroundColor[1], backgroundColor[2]) + newlines + ANSI.resetBackground;
+    }
     this.writeOut(flush + move + output + clear);
     return true;
   }
@@ -8416,32 +8817,33 @@ Error details:
     }
     this.queryPixelResolution();
   }
-  setupInput() {
-    this.stdin.on("data", (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.exitOnCtrlC && str === "\x03") {
-        process.nextTick(() => {
-          process.exit();
-        });
-        return;
-      }
-      if (this._useMouse && this.handleMouseData(data)) {
+  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;
       }
-      this.emit("key", data);
-    });
+    }
+    if (this.exitOnCtrlC && str === "\x03") {
+      process.nextTick(() => {
+        process.exit();
+      });
+      return;
+    }
+    if (this._useMouse && this.handleMouseData(data)) {
+      return;
+    }
+    this.emit("key", data);
+  }).bind(this);
+  setupInput() {
+    this.stdin.on("data", this.stdinListener);
   }
   handleMouseData(data) {
     const mouseEvent = this.mouseParser.parseMouseEvent(data);
@@ -8556,6 +8958,8 @@ Error details:
     return false;
   }
   takeMemorySnapshot() {
+    if (this.isDestroyed)
+      return;
     const memoryUsage = process.memoryUsage();
     this.lastMemorySnapshot = {
       heapUsed: memoryUsage.heapUsed,
@@ -8768,19 +9172,28 @@ Error details:
     }
   }
   destroy() {
-    this.stdin.setRawMode(false);
+    this.stdin.removeListener("data", this.stdinListener);
+    process.removeListener("SIGWINCH", this.sigwinchHandler);
+    process.removeListener("uncaughtException", this.handleError);
+    process.removeListener("unhandledRejection", this.handleError);
+    process.removeListener("exit", this.exitHandler);
+    process.removeListener("warning", this.warningHandler);
+    capture.removeListener("write", this.captureCallback);
+    if (this.memorySnapshotTimer) {
+      clearInterval(this.memorySnapshotTimer);
+    }
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
     if (this.isDestroyed)
       return;
     this.isDestroyed = true;
     this.waitingForPixelResolution = false;
     this.capturedRenderable = undefined;
-    if (this.sigwinchHandler) {
-      process.removeListener("SIGWINCH", this.sigwinchHandler);
-      this.sigwinchHandler = null;
-    }
+    this._keyHandler.destroy();
     this._console.deactivate();
     this.disableStdoutInterception();
-    this.lib.destroyRenderer(this.rendererPtr, this._useAlternateScreen, this._splitHeight);
+    this.lib.destroyRenderer(this.rendererPtr);
   }
   startRenderLoop() {
     if (!this._isRunning)
@@ -9006,5 +9419,5 @@ Error details:
 
 export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, TrackedNode, createTrackedNode, nonAlphanumericKeys, parseKeypress, KeyHandler, getKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isValidPercentage, isMarginType, isPaddingType, isPositionType, isPositionTypeType, isOverflowType, isDimensionType, isFlexBasisType, isSizeType, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
 
-//# debugId=5DA797F1A7D4887764756E2164756E21
-//# sourceMappingURL=index-mh94hn7d.js.map
+//# debugId=ACCACBFBC5B1AC8B64756E2164756E21
+//# sourceMappingURL=index-6esrcarp.js.map