@opentui/core 0.0.0-20251031-fc297165 → 0.0.0-20251106-dd34dace

package/{index-vr8t68wb.js → index-n8nbvvhk.js}

@@ -1896,6 +1896,7 @@ function parseKittyKeyboard(sequence) {
     sequence,
     raw: sequence,
     eventType: "press",
+    source: "kitty",
     super: false,
     hyper: false,
     capsLock: false,
@@ -2107,10 +2108,11 @@ var parseKeypress = (s = "", options = {}) => {
     number: false,
     sequence: s,
     raw: s,
-    eventType: "press"
+    eventType: "press",
+    source: "raw"
   };
   key.sequence = key.sequence || s || key.name;
-  if (options.useKittyKeyboard && /^\x1b\[.*u$/.test(s)) {
+  if (options.useKittyKeyboard) {
     const kittyResult = parseKittyKeyboard(s);
     if (kittyResult) {
       return kittyResult;
@@ -2135,6 +2137,9 @@ var parseKeypress = (s = "", options = {}) => {
   } else if (s === " " || s === "\x1B ") {
     key.name = "space";
     key.meta = s.length === 2;
+  } else if (s === "\x00") {
+    key.name = "space";
+    key.ctrl = true;
   } else if (s.length === 1 && s <= "\x1A") {
     key.name = String.fromCharCode(s.charCodeAt(0) + 97 - 1);
     key.ctrl = true;
@@ -2185,8 +2190,184 @@ var parseKeypress = (s = "", options = {}) => {
   return key;
 };
 
-// src/lib/KeyHandler.ts
+// src/lib/stdin-buffer.ts
 import { EventEmitter } from "events";
+var ESC = "\x1B";
+function isCompleteSequence(data) {
+  if (!data.startsWith(ESC)) {
+    return "not-escape";
+  }
+  if (data.length === 1) {
+    return "incomplete";
+  }
+  const afterEsc = data.slice(1);
+  if (afterEsc.startsWith("[")) {
+    if (afterEsc.startsWith("[M")) {
+      return data.length >= 6 ? "complete" : "incomplete";
+    }
+    return isCompleteCsiSequence(data);
+  }
+  if (afterEsc.startsWith("]")) {
+    return isCompleteOscSequence(data);
+  }
+  if (afterEsc.startsWith("O")) {
+    return afterEsc.length >= 2 ? "complete" : "incomplete";
+  }
+  if (afterEsc.length === 1) {
+    return "complete";
+  }
+  return "complete";
+}
+function isCompleteCsiSequence(data) {
+  if (!data.startsWith(ESC + "[")) {
+    return "complete";
+  }
+  if (data.length < 3) {
+    return "incomplete";
+  }
+  const payload = data.slice(2);
+  const lastChar = payload[payload.length - 1];
+  const lastCharCode = lastChar.charCodeAt(0);
+  if (lastCharCode >= 64 && lastCharCode <= 126) {
+    if (payload.startsWith("<")) {
+      const mouseMatch = /^<\d+;\d+;\d+[Mm]$/.test(payload);
+      if (mouseMatch) {
+        return "complete";
+      }
+      if (lastChar === "M" || lastChar === "m") {
+        const parts = payload.slice(1, -1).split(";");
+        if (parts.length === 3 && parts.every((p) => /^\d+$/.test(p))) {
+          return "complete";
+        }
+      }
+      return "incomplete";
+    }
+    return "complete";
+  }
+  return "incomplete";
+}
+function isCompleteOscSequence(data) {
+  if (!data.startsWith(ESC + "]")) {
+    return "complete";
+  }
+  if (data.endsWith(ESC + "\\") || data.endsWith("\x07")) {
+    return "complete";
+  }
+  return "incomplete";
+}
+function extractCompleteSequences(buffer) {
+  const sequences = [];
+  let pos = 0;
+  while (pos < buffer.length) {
+    const remaining = buffer.slice(pos);
+    if (remaining.startsWith(ESC)) {
+      let seqEnd = 1;
+      while (seqEnd <= remaining.length) {
+        const candidate = remaining.slice(0, seqEnd);
+        const status = isCompleteSequence(candidate);
+        if (status === "complete") {
+          sequences.push(candidate);
+          pos += seqEnd;
+          break;
+        } else if (status === "incomplete") {
+          seqEnd++;
+        } else {
+          sequences.push(candidate);
+          pos += seqEnd;
+          break;
+        }
+      }
+      if (seqEnd > remaining.length) {
+        return { sequences, remainder: remaining };
+      }
+    } else {
+      sequences.push(remaining[0]);
+      pos++;
+    }
+  }
+  return { sequences, remainder: "" };
+}
+
+class StdinBuffer extends EventEmitter {
+  buffer = "";
+  timeout = null;
+  timeoutMs;
+  stdin;
+  stdinListener;
+  constructor(stdin, options = {}) {
+    super();
+    this.stdin = stdin;
+    this.timeoutMs = options.timeout ?? 10;
+    this.stdinListener = (data) => {
+      this.handleData(data);
+    };
+    this.stdin.on("data", this.stdinListener);
+  }
+  handleData(data) {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    let str;
+    if (Buffer.isBuffer(data)) {
+      if (data.length === 1 && data[0] > 127) {
+        const byte = data[0] - 128;
+        str = "\x1B" + String.fromCharCode(byte);
+      } else {
+        str = data.toString();
+      }
+    } else {
+      str = data;
+    }
+    if (str.length === 0 && this.buffer.length === 0) {
+      this.emit("data", "");
+      return;
+    }
+    this.buffer += str;
+    const result = extractCompleteSequences(this.buffer);
+    this.buffer = result.remainder;
+    for (const sequence of result.sequences) {
+      this.emit("data", sequence);
+    }
+    if (this.buffer.length > 0) {
+      this.timeout = setTimeout(() => {
+        const flushed = this.flush();
+        for (const sequence of flushed) {
+          this.emit("data", sequence);
+        }
+      }, this.timeoutMs);
+    }
+  }
+  flush() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    if (this.buffer.length === 0) {
+      return [];
+    }
+    const sequences = [this.buffer];
+    this.buffer = "";
+    return sequences;
+  }
+  clear() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    this.buffer = "";
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  destroy() {
+    this.stdin.removeListener("data", this.stdinListener);
+    this.clear();
+  }
+}
+
+// src/lib/KeyHandler.ts
+import { EventEmitter as EventEmitter2 } from "events";
 
 // src/ansi.ts
 var ANSI = {
@@ -2214,6 +2395,7 @@ class KeyEvent {
   number;
   raw;
   eventType;
+  source;
   code;
   super;
   hyper;
@@ -2231,6 +2413,7 @@ class KeyEvent {
     this.number = key.number;
     this.raw = key.raw;
     this.eventType = key.eventType;
+    this.source = key.source;
     this.code = key.code;
     this.super = key.super;
     this.hyper = key.hyper;
@@ -2260,65 +2443,70 @@ class PasteEvent {
   }
 }
 
-class KeyHandler extends EventEmitter {
+class KeyHandler extends EventEmitter2 {
   stdin;
   useKittyKeyboard;
-  listener;
   pasteMode = false;
   pasteBuffer = [];
   suspended = false;
+  stdinBuffer;
+  dataListener;
   constructor(stdin, useKittyKeyboard = false) {
     super();
     this.stdin = stdin || process.stdin;
     this.useKittyKeyboard = useKittyKeyboard;
-    this.listener = (key) => {
-      let data = key.toString();
-      if (data.startsWith(ANSI.bracketedPasteStart)) {
-        this.pasteMode = true;
-      }
-      if (this.pasteMode) {
-        this.pasteBuffer.push(Bun.stripANSI(data));
-        if (data.endsWith(ANSI.bracketedPasteEnd)) {
-          this.pasteMode = false;
-          this.emit("paste", new PasteEvent(this.pasteBuffer.join("")));
-          this.pasteBuffer = [];
-        }
-        return;
-      }
-      const parsedKey = parseKeypress(key, { useKittyKeyboard: this.useKittyKeyboard });
-      if (!parsedKey) {
-        return;
-      }
-      switch (parsedKey.eventType) {
-        case "press":
-          this.emit("keypress", new KeyEvent(parsedKey));
-          break;
-        case "repeat":
-          this.emit("keyrepeat", new KeyEvent(parsedKey));
-          break;
-        case "release":
-          this.emit("keyrelease", new KeyEvent(parsedKey));
-          break;
-        default:
-          this.emit("keypress", new KeyEvent(parsedKey));
-          break;
-      }
+    this.stdinBuffer = new StdinBuffer(this.stdin, { timeout: 5 });
+    this.dataListener = (sequence) => {
+      this.processSequence(sequence);
     };
-    this.stdin.on("data", this.listener);
+    this.stdinBuffer.on("data", this.dataListener);
+  }
+  processSequence(data) {
+    if (data.startsWith(ANSI.bracketedPasteStart)) {
+      this.pasteMode = true;
+    }
+    if (this.pasteMode) {
+      this.pasteBuffer.push(Bun.stripANSI(data));
+      if (data.endsWith(ANSI.bracketedPasteEnd)) {
+        this.pasteMode = false;
+        this.emit("paste", new PasteEvent(this.pasteBuffer.join("")));
+        this.pasteBuffer = [];
+      }
+      return;
+    }
+    const parsedKey = parseKeypress(data, { useKittyKeyboard: this.useKittyKeyboard });
+    if (!parsedKey) {
+      return;
+    }
+    switch (parsedKey.eventType) {
+      case "press":
+        this.emit("keypress", new KeyEvent(parsedKey));
+        break;
+      case "repeat":
+        this.emit("keyrepeat", new KeyEvent(parsedKey));
+        break;
+      case "release":
+        this.emit("keyrelease", new KeyEvent(parsedKey));
+        break;
+      default:
+        this.emit("keypress", new KeyEvent(parsedKey));
+        break;
+    }
   }
   destroy() {
-    this.stdin.removeListener("data", this.listener);
+    this.stdinBuffer.removeListener("data", this.dataListener);
+    this.stdinBuffer.destroy();
   }
   suspend() {
     if (!this.suspended) {
       this.suspended = true;
-      this.stdin.removeListener("data", this.listener);
+      this.stdinBuffer.removeListener("data", this.dataListener);
     }
   }
   resume() {
     if (this.suspended) {
       this.suspended = false;
-      this.stdin.on("data", this.listener);
+      this.stdinBuffer.on("data", this.dataListener);
     }
   }
 }
@@ -5325,7 +5513,7 @@ async function treeSitterToStyledText(content, filetype, syntaxStyle, client, op
 }
 
 // src/lib/tree-sitter/client.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 
 // src/lib/debounce.ts
 var TIMERS_MAP = new Map;
@@ -5518,7 +5706,7 @@ function addDefaultParsers(parsers) {
 }
 var isUrl = (path) => path.startsWith("http://") || path.startsWith("https://");
 
-class TreeSitterClient extends EventEmitter2 {
+class TreeSitterClient extends EventEmitter3 {
   initialized = false;
   worker;
   buffers = new Map;
@@ -5969,7 +6157,7 @@ class TreeSitterClient extends EventEmitter2 {
 // src/lib/data-paths.ts
 import os from "os";
 import path from "path";
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/lib/validate-dir-name.ts
 function isValidDirectoryName(name) {
@@ -6033,7 +6221,7 @@ registerEnvVar({
   default: ""
 });
 
-class DataPathsManager extends EventEmitter3 {
+class DataPathsManager extends EventEmitter4 {
   _appName;
   _globalConfigPath;
   _globalConfigFile;
@@ -7156,7 +7344,7 @@ function createExtmarksController(editBuffer, editorView) {
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr3 } from "bun:ffi";
 import { existsSync as existsSync2 } from "fs";
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 
 // src/buffer.ts
 import { toArrayBuffer } from "bun:ffi";
@@ -8220,6 +8408,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
+    setUseKittyKeyboard: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    getUseKittyKeyboard: {
+      args: ["ptr"],
+      returns: "bool"
+    },
     setupTerminal: {
       args: ["ptr", "bool"],
       returns: "void"
@@ -8340,6 +8536,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "u32"
     },
+    textBufferGetTextRange: {
+      args: ["ptr", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferGetTextRangeByCoords: {
+      args: ["ptr", "u32", "u32", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
     createTextBufferView: {
       args: ["ptr"],
       returns: "ptr"
@@ -8604,6 +8808,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u32"],
       returns: "u32"
     },
+    editBufferGetTextRange: {
+      args: ["ptr", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferGetTextRangeByCoords: {
+      args: ["ptr", "u32", "u32", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
     editorViewSetSelection: {
       args: ["ptr", "u32", "u32", "ptr", "ptr"],
       returns: "void"
@@ -8724,16 +8936,28 @@ function convertToDebugSymbols(symbols) {
   const debugSymbols = {};
   const traceSymbols = {};
   let hasTracing = false;
+  let ffiLogWriter = null;
   Object.entries(symbols).forEach(([key, value]) => {
     debugSymbols[key] = value;
   });
   if (env.OTUI_DEBUG_FFI) {
+    const now = new Date;
+    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
+    const logFilePath = `ffi_debug_${timestamp}.log`;
+    ffiLogWriter = Bun.file(logFilePath).writer();
+    const writer = ffiLogWriter;
+    const writeSync = (msg) => {
+      const buffer = new TextEncoder().encode(msg + `
+`);
+      writer.write(buffer);
+      writer.flush();
+    };
     Object.entries(symbols).forEach(([key, value]) => {
       if (typeof value === "function") {
         debugSymbols[key] = (...args) => {
-          console.log(`${key}(${args.map((arg) => String(arg)).join(", ")})`);
+          writeSync(`${key}(${args.map((arg) => String(arg)).join(", ")})`);
           const result = value(...args);
-          console.log(`${key} returned:`, String(result));
+          writeSync(`${key} returned: ${String(result)}`);
           return result;
         };
       }
@@ -8755,6 +8979,13 @@ function convertToDebugSymbols(symbols) {
       }
     });
   }
+  if (env.OTUI_DEBUG_FFI && ffiLogWriter) {
+    process.on("exit", () => {
+      try {
+        ffiLogWriter.end();
+      } catch (e) {}
+    });
+  }
   if (hasTracing) {
     process.on("exit", () => {
       const allStats = [];
@@ -8837,7 +9068,7 @@ class FFIRenderLib {
   decoder = new TextDecoder;
   logCallbackWrapper;
   eventCallbackWrapper;
-  _nativeEvents = new EventEmitter4;
+  _nativeEvents = new EventEmitter5;
   _anyEventHandlers = [];
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
@@ -9144,6 +9375,12 @@ class FFIRenderLib {
   disableKittyKeyboard(renderer) {
     this.opentui.symbols.disableKittyKeyboard(renderer);
   }
+  setUseKittyKeyboard(renderer, use) {
+    this.opentui.symbols.setUseKittyKeyboard(renderer, use);
+  }
+  getUseKittyKeyboard(renderer) {
+    return this.opentui.symbols.getUseKittyKeyboard(renderer);
+  }
   setupTerminal(renderer, useAlternateScreen) {
     this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
   }
@@ -9238,6 +9475,24 @@ class FFIRenderLib {
     }
     return outBuffer.slice(0, actualLen);
   }
+  textBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRange(buffer, startOffset, endOffset, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, len);
+  }
+  textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, len);
+  }
   createTextBufferView(textBuffer) {
     const viewPtr = this.opentui.symbols.createTextBufferView(textBuffer);
     if (!viewPtr) {
@@ -9618,6 +9873,22 @@ class FFIRenderLib {
   editBufferGetLineStartOffset(buffer, row) {
     return this.opentui.symbols.editBufferGetLineStartOffset(buffer, row);
   }
+  editBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRange(buffer, startOffset, endOffset, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0)
+      return null;
+    return outBuffer.slice(0, len);
+  }
+  editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0)
+      return null;
+    return outBuffer.slice(0, len);
+  }
   editorViewSetSelection(view, start, end, bgColor, fgColor) {
     const bg2 = bgColor ? bgColor.buffer : null;
     const fg2 = fgColor ? fgColor.buffer : null;
@@ -9903,6 +10174,17 @@ class TextBuffer {
       return "";
     return this.lib.decoder.decode(plainBytes);
   }
+  getTextRange(startOffset, endOffset) {
+    this.guard();
+    if (startOffset >= endOffset)
+      return "";
+    if (this._byteSize === 0)
+      return "";
+    const rangeBytes = this.lib.textBufferGetTextRange(this.bufferPtr, startOffset, endOffset, this._byteSize);
+    if (!rangeBytes)
+      return "";
+    return this.lib.decoder.decode(rangeBytes);
+  }
   addHighlightByCharRange(highlight) {
     this.guard();
     this.lib.textBufferAddHighlightByCharRange(this.bufferPtr, highlight);
@@ -9974,7 +10256,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -10067,7 +10349,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter5 {
+class BaseRenderable extends EventEmitter6 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -10789,7 +11071,7 @@ class Renderable extends BaseRenderable {
     }
     try {
       const widthMethod = this._ctx.widthMethod;
-      this.frameBuffer = OptimizedBuffer.create(w, h, widthMethod, { respectAlpha: true });
+      this.frameBuffer = OptimizedBuffer.create(w, h, widthMethod, { respectAlpha: true, id: `framebuffer-${this.id}` });
     } catch (error) {
       console.error(`Failed to create frame buffer for ${this.id}:`, error);
       this.frameBuffer = null;
@@ -11388,7 +11670,7 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 import { Console } from "console";
 import fs from "fs";
 import path4 from "path";
@@ -11396,9 +11678,9 @@ import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 
-class Capture extends EventEmitter6 {
+class Capture extends EventEmitter7 {
   output = [];
   constructor() {
     super();
@@ -11474,7 +11756,7 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter7 {
+class TerminalConsoleCache extends EventEmitter8 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -11600,7 +11882,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter7 {
+class TerminalConsole extends EventEmitter8 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -11689,34 +11971,34 @@ class TerminalConsole extends EventEmitter7 {
     }
     this.markNeedsRerender();
   }
-  _updateConsoleDimensions() {
-    const termWidth = this.renderer.terminalWidth;
-    const termHeight = this.renderer.terminalHeight;
+  _updateConsoleDimensions(termWidth, termHeight) {
+    const width = termWidth ?? this.renderer.terminalWidth;
+    const height = termHeight ?? this.renderer.terminalHeight;
     const sizePercent = this.options.sizePercent / 100;
     switch (this.options.position) {
       case "top" /* TOP */:
         this.consoleX = 0;
         this.consoleY = 0;
-        this.consoleWidth = termWidth;
-        this.consoleHeight = Math.max(1, Math.floor(termHeight * sizePercent));
+        this.consoleWidth = width;
+        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
         break;
       case "bottom" /* BOTTOM */:
-        this.consoleHeight = Math.max(1, Math.floor(termHeight * sizePercent));
-        this.consoleWidth = termWidth;
+        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
+        this.consoleWidth = width;
         this.consoleX = 0;
-        this.consoleY = termHeight - this.consoleHeight;
+        this.consoleY = height - this.consoleHeight;
         break;
       case "left" /* LEFT */:
-        this.consoleWidth = Math.max(1, Math.floor(termWidth * sizePercent));
-        this.consoleHeight = termHeight;
+        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
+        this.consoleHeight = height;
         this.consoleX = 0;
         this.consoleY = 0;
         break;
       case "right" /* RIGHT */:
-        this.consoleWidth = Math.max(1, Math.floor(termWidth * sizePercent));
-        this.consoleHeight = termHeight;
+        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
+        this.consoleHeight = height;
         this.consoleY = 0;
-        this.consoleX = termWidth - this.consoleWidth;
+        this.consoleX = width - this.consoleWidth;
         break;
     }
     this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
@@ -11838,7 +12120,7 @@ class TerminalConsole extends EventEmitter7 {
     }).join(" ");
   }
   resize(width, height) {
-    this._updateConsoleDimensions();
+    this._updateConsoleDimensions(width, height);
     if (this.frameBuffer) {
       this.frameBuffer.resize(this.consoleWidth, this.consoleHeight);
       const displayLineCount = this._displayLines.length;
@@ -12060,7 +12342,7 @@ class TerminalConsole extends EventEmitter7 {
 }
 
 // src/renderer.ts
-import { EventEmitter as EventEmitter8 } from "events";
+import { EventEmitter as EventEmitter9 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -12268,6 +12550,8 @@ async function createCliRenderer(config = {}) {
     config.useThread = false;
   }
   ziglib.setUseThread(rendererPtr, config.useThread);
+  const useKittyKeyboard = config.useKittyKeyboard ?? true;
+  ziglib.setUseKittyKeyboard(rendererPtr, useKittyKeyboard);
   const renderer = new CliRenderer(ziglib, rendererPtr, stdin, stdout, width, height, config);
   await renderer.setupTerminal();
   return renderer;
@@ -12286,7 +12570,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter8 {
+class CliRenderer extends EventEmitter9 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -12377,9 +12661,10 @@ class CliRenderer extends EventEmitter8 {
   _latestPointer = { x: 0, y: 0 };
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
+  _openConsoleOnError = true;
   handleError = ((error) => {
     console.error(error);
-    if (true) {
+    if (this._openConsoleOnError) {
       this.console.show();
     }
   }).bind(this);
@@ -12464,7 +12749,16 @@ Captured output:
     process.on("exit", this.exitHandler);
     this._console = new TerminalConsole(this, config.consoleOptions);
     this.useConsole = config.useConsole ?? true;
-    this._keyHandler = new InternalKeyHandler(this.stdin, config.useKittyKeyboard ?? false);
+    this._openConsoleOnError = config.openConsoleOnError ?? true;
+    this._keyHandler = new InternalKeyHandler(this.stdin, config.useKittyKeyboard ?? true);
+    this._keyHandler.on("keypress", (event) => {
+      if (this.exitOnCtrlC && event.name === "c" && event.ctrl) {
+        process.nextTick(() => {
+          this.destroy();
+        });
+        return;
+      }
+    });
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
       this.animationRequest.set(id, callback);
@@ -12592,6 +12886,12 @@ Captured output:
   get capabilities() {
     return this._capabilities;
   }
+  get useKittyKeyboard() {
+    return this.lib.getUseKittyKeyboard(this.rendererPtr);
+  }
+  set useKittyKeyboard(use) {
+    this.lib.setUseKittyKeyboard(this.rendererPtr, use);
+  }
   set experimental_splitHeight(splitHeight) {
     if (splitHeight < 0)
       splitHeight = 0;
@@ -12724,12 +13024,6 @@ Captured output:
         return;
       }
     }
-    if (this.exitOnCtrlC && str === "\x03") {
-      process.nextTick(() => {
-        this.destroy();
-      });
-      return;
-    }
     if (this._useMouse && this.handleMouseData(data)) {
       return;
     }
@@ -13369,7 +13663,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, StdinBuffer, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=3D6AC881EA3F1FB664756E2164756E21
-//# sourceMappingURL=index-vr8t68wb.js.map
+//# debugId=A88F8272C607FC3964756E2164756E21
+//# sourceMappingURL=index-n8nbvvhk.js.map