@opentui/core 0.1.24 → 0.1.25

package/{index-0yx9rnxg.js → index-6kvgbzah.js}

@@ -2175,30 +2175,46 @@ var parseKeypress = (s = "", options = {}) => {
 // src/lib/KeyHandler.ts
 import { EventEmitter } from "events";
 
-// src/singleton.ts
-var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
-function singleton(key, factory) {
-  const bag = globalThis[singletonCacheSymbol] ??= {};
-  if (!(key in bag)) {
-    bag[key] = factory();
-  }
-  return bag[key];
-}
+// src/ansi.ts
+var ANSI = {
+  switchToAlternateScreen: "\x1B[?1049h",
+  switchToMainScreen: "\x1B[?1049l",
+  reset: "\x1B[0m",
+  scrollDown: (lines) => `\x1B[${lines}T`,
+  scrollUp: (lines) => `\x1B[${lines}S`,
+  moveCursor: (row, col) => `\x1B[${row};${col}H`,
+  moveCursorAndClear: (row, col) => `\x1B[${row};${col}H\x1B[J`,
+  setRgbBackground: (r, g, b) => `\x1B[48;2;${r};${g};${b}m`,
+  resetBackground: "\x1B[49m",
+  bracketedPasteStart: "\x1B[200~",
+  bracketedPasteEnd: "\x1B[201~"
+};
 
 // src/lib/KeyHandler.ts
 class KeyHandler extends EventEmitter {
   stdin;
   useKittyKeyboard;
+  listener;
+  pasteMode = false;
+  pasteBuffer = [];
   constructor(stdin, useKittyKeyboard = false) {
     super();
     this.stdin = stdin || process.stdin;
     this.useKittyKeyboard = useKittyKeyboard;
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(true);
-    }
-    this.stdin.resume();
-    this.stdin.setEncoding("utf8");
-    this.stdin.on("data", (key) => {
+    this.listener = (key) => {
+      let data = key.toString();
+      if (data.startsWith(ANSI.bracketedPasteStart)) {
+        this.pasteMode = true;
+      }
+      if (this.pasteMode) {
+        this.pasteBuffer.push(Bun.stripANSI(data));
+        if (data.endsWith(ANSI.bracketedPasteEnd)) {
+          this.pasteMode = false;
+          this.emit("paste", this.pasteBuffer.join(""));
+          this.pasteBuffer = [];
+        }
+        return;
+      }
       const parsedKey = parseKeypress(key, { useKittyKeyboard: this.useKittyKeyboard });
       switch (parsedKey.eventType) {
         case "press":
@@ -2214,18 +2230,12 @@ class KeyHandler extends EventEmitter {
           this.emit("keypress", parsedKey);
           break;
       }
-    });
+    };
+    this.stdin.on("data", this.listener);
   }
   destroy() {
-    this.stdin.removeAllListeners("data");
-  }
-}
-var keyHandler = null;
-function getKeyHandler(useKittyKeyboard = false) {
-  if (!keyHandler) {
-    keyHandler = singleton("KeyHandler", () => new KeyHandler(process.stdin, useKittyKeyboard));
+    this.stdin.removeListener("data", this.listener);
   }
-  return keyHandler;
 }
 
 // src/lib/RGBA.ts
@@ -4804,6 +4814,166 @@ class ASCIIFontSelectionHelper {
     return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
   }
 }
+
+// src/lib/singleton.ts
+var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
+function singleton(key, factory) {
+  const bag = globalThis[singletonCacheSymbol] ??= {};
+  if (!(key in bag)) {
+    bag[key] = factory();
+  }
+  return bag[key];
+}
+
+// src/lib/env.ts
+var envRegistry = {};
+function registerEnvVar(config) {
+  const existing = envRegistry[config.name];
+  if (existing) {
+    if (existing.description !== config.description || existing.type !== config.type || existing.default !== config.default) {
+      throw new Error(`Environment variable "${config.name}" is already registered with different configuration. ` + `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`);
+    }
+    return;
+  }
+  envRegistry[config.name] = config;
+}
+function normalizeBoolean(value) {
+  const lowerValue = value.toLowerCase();
+  return ["true", "1", "on", "yes"].includes(lowerValue);
+}
+function parseEnvValue(config) {
+  const envValue = process.env[config.name];
+  if (envValue === undefined && config.default !== undefined) {
+    return config.default;
+  }
+  if (envValue === undefined) {
+    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`);
+  }
+  switch (config.type) {
+    case "boolean":
+      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue);
+    case "number":
+      const numValue = Number(envValue);
+      if (isNaN(numValue)) {
+        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`);
+      }
+      return numValue;
+    case "string":
+    default:
+      return envValue;
+  }
+}
+
+class EnvStore {
+  parsedValues = new Map;
+  get(key) {
+    if (this.parsedValues.has(key)) {
+      return this.parsedValues.get(key);
+    }
+    if (!(key in envRegistry)) {
+      throw new Error(`Environment variable ${key} is not registered.`);
+    }
+    try {
+      const value = parseEnvValue(envRegistry[key]);
+      this.parsedValues.set(key, value);
+      return value;
+    } catch (error) {
+      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  has(key) {
+    return key in envRegistry;
+  }
+}
+var envStore = singleton("env-store", () => new EnvStore);
+function generateEnvMarkdown() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `# Environment Variables
+
+No environment variables registered.
+`;
+  }
+  let markdown = `# Environment Variables
+
+`;
+  for (const config of configs) {
+    markdown += `## ${config.name}
+
+`;
+    markdown += `${config.description}
+
+`;
+    markdown += `**Type:** \`${config.type || "string"}\`  
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      markdown += `**Default:** \`${defaultValue}\`  
+`;
+    } else {
+      markdown += `**Default:** *Required*  
+`;
+    }
+    markdown += `
+`;
+  }
+  return markdown;
+}
+function generateEnvColored() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `\x1B[1;36mEnvironment Variables\x1B[0m
+
+No environment variables registered.
+`;
+  }
+  let output = `\x1B[1;36mEnvironment Variables\x1B[0m
+
+`;
+  for (const config of configs) {
+    output += `\x1B[1;33m${config.name}\x1B[0m
+`;
+    output += `${config.description}
+`;
+    output += `\x1B[32mType:\x1B[0m \x1B[36m${config.type || "string"}\x1B[0m
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      output += `\x1B[32mDefault:\x1B[0m \x1B[35m${defaultValue}\x1B[0m
+`;
+    } else {
+      output += `\x1B[32mDefault:\x1B[0m \x1B[31mRequired\x1B[0m
+`;
+    }
+    output += `
+`;
+  }
+  return output;
+}
+var env = new Proxy({}, {
+  get(target, prop) {
+    if (typeof prop !== "string") {
+      return;
+    }
+    return envStore.get(prop);
+  },
+  has(target, prop) {
+    return envStore.has(prop);
+  },
+  ownKeys() {
+    return Object.keys(envRegistry);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    if (envStore.has(prop)) {
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => envStore.get(prop)
+      };
+    }
+    return;
+  }
+});
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer2, JSCallback, ptr } from "bun:ffi";
 import { existsSync } from "fs";
@@ -5010,6 +5180,18 @@ var targetLibPath = module.default;
 if (!existsSync(targetLibPath)) {
   throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
 }
+registerEnvVar({
+  name: "OTUI_DEBUG_FFI",
+  description: "Enable debug logging for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_TRACE_FFI",
+  description: "Enable tracing for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
   const rawSymbols = dlopen(resolvedLibPath, {
@@ -5057,6 +5239,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    queryPixelResolution: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createOptimizedBuffer: {
       args: ["u32", "u32", "bool", "u8", "ptr", "usize"],
       returns: "ptr"
@@ -5346,7 +5532,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     }
   });
-  if (process.env.DEBUG_FFI === "true" || process.env.TRACE_FFI === "true") {
+  if (env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) {
     return {
       symbols: convertToDebugSymbols(rawSymbols.symbols)
     };
@@ -5360,7 +5546,7 @@ function convertToDebugSymbols(symbols) {
   Object.entries(symbols).forEach(([key, value]) => {
     debugSymbols[key] = value;
   });
-  if (process.env.DEBUG_FFI === "true") {
+  if (env.OTUI_DEBUG_FFI) {
     Object.entries(symbols).forEach(([key, value]) => {
       if (typeof value === "function") {
         debugSymbols[key] = (...args) => {
@@ -5372,7 +5558,7 @@ function convertToDebugSymbols(symbols) {
       }
     });
   }
-  if (process.env.TRACE_FFI === "true") {
+  if (env.OTUI_TRACE_FFI) {
     hasTracing = true;
     Object.entries(symbols).forEach(([key, value]) => {
       if (typeof value === "function") {
@@ -5734,6 +5920,9 @@ class FFIRenderLib {
   setupTerminal(renderer, useAlternateScreen) {
     this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
   }
+  queryPixelResolution(renderer) {
+    this.opentui.symbols.queryPixelResolution(renderer);
+  }
   createTextBuffer(widthMethod) {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
     const bufferPtr = this.opentui.symbols.createTextBuffer(widthMethodCode);
@@ -6222,6 +6411,9 @@ class BaseRenderable extends EventEmitter2 {
     this._visible = value;
   }
 }
+var yogaConfig = src_default.Config.create();
+yogaConfig.setUseWebDefaults(false);
+yogaConfig.setPointScaleFactor(1);
 
 class Renderable extends BaseRenderable {
   static renderablesByNumber = new Map;
@@ -6242,11 +6434,13 @@ class Renderable extends BaseRenderable {
   _focusable = false;
   _focused = false;
   keypressHandler = null;
+  pasteHandler = null;
   _live = false;
   _liveCount = 0;
   _sizeChangeListener = undefined;
   _mouseListener = null;
   _mouseListeners = {};
+  _pasteListener = undefined;
   _keyListeners = {};
   yogaNode;
   _positionType = "relative";
@@ -6283,7 +6477,7 @@ class Renderable extends BaseRenderable {
     this.buffered = options.buffered ?? false;
     this._live = options.live ?? false;
     this._liveCount = this._live && this._visible ? 1 : 0;
-    this.yogaNode = src_default.Node.create();
+    this.yogaNode = src_default.Node.create(yogaConfig);
     this.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
     this.setupYogaProperties(options);
     this.applyEventOptions(options);
@@ -6356,7 +6550,14 @@ class Renderable extends BaseRenderable {
         this.handleKeyPress(key);
       }
     };
+    this.pasteHandler = (text) => {
+      this._pasteListener?.call(this, text);
+      if (this.handlePaste) {
+        this.handlePaste(text);
+      }
+    };
     this.ctx.keyInput.on("keypress", this.keypressHandler);
+    this.ctx.keyInput.on("paste", this.pasteHandler);
     this.emit("focused" /* FOCUSED */);
   }
   blur() {
@@ -6368,6 +6569,10 @@ class Renderable extends BaseRenderable {
       this.ctx.keyInput.off("keypress", this.keypressHandler);
       this.keypressHandler = null;
     }
+    if (this.pasteHandler) {
+      this.ctx.keyInput.off("paste", this.pasteHandler);
+      this.pasteHandler = null;
+    }
     this.emit("blurred" /* BLURRED */);
   }
   get focused() {
@@ -6396,9 +6601,11 @@ class Renderable extends BaseRenderable {
     for (const child of this._childrenInLayoutOrder) {
       if (child.id === id)
         return child;
-      const found = child.findDescendantById(id);
-      if (found)
-        return found;
+      if (isRenderable(child)) {
+        const found = child.findDescendantById(id);
+        if (found)
+          return found;
+      }
     }
     return;
   }
@@ -6551,8 +6758,7 @@ class Renderable extends BaseRenderable {
     if (options.flexShrink !== undefined) {
       node.setFlexShrink(options.flexShrink);
     } else {
-      const shrinkValue = options.flexGrow && options.flexGrow > 0 ? 1 : 0;
-      node.setFlexShrink(shrinkValue);
+      node.setFlexShrink(1);
     }
     if (options.flexDirection !== undefined) {
       node.setFlexDirection(parseFlexDirection(options.flexDirection));
@@ -7196,6 +7402,12 @@ class Renderable extends BaseRenderable {
     else
       delete this._mouseListeners["scroll"];
   }
+  set onPaste(handler) {
+    this._pasteListener = handler;
+  }
+  get onPaste() {
+    return this._pasteListener;
+  }
   set onKeyDown(handler) {
     if (handler)
       this._keyListeners["down"] = handler;
@@ -7222,23 +7434,20 @@ class Renderable extends BaseRenderable {
     this.onMouseOver = options.onMouseOver;
     this.onMouseOut = options.onMouseOut;
     this.onMouseScroll = options.onMouseScroll;
+    this.onPaste = options.onPaste;
     this.onKeyDown = options.onKeyDown;
     this.onSizeChange = options.onSizeChange;
   }
 }
 
 class RootRenderable extends Renderable {
-  yogaConfig;
   renderList = [];
   constructor(ctx) {
     super(ctx, { id: "__root__", zIndex: 0, visible: true, width: ctx.width, height: ctx.height, enableLayout: true });
-    this.yogaConfig = src_default.Config.create();
-    this.yogaConfig.setUseWebDefaults(false);
-    this.yogaConfig.setPointScaleFactor(1);
     if (this.yogaNode) {
       this.yogaNode.free();
     }
-    this.yogaNode = src_default.Node.create(this.yogaConfig);
+    this.yogaNode = src_default.Node.create(yogaConfig);
     this.yogaNode.setWidth(ctx.width);
     this.yogaNode.setHeight(ctx.height);
     this.yogaNode.setFlexDirection(FlexDirection.Column);
@@ -7288,11 +7497,6 @@ class RootRenderable extends Renderable {
     this.height = height;
     this.emit("resized" /* RESIZED */, { width, height });
   }
-  destroySelf() {
-    try {
-      this.yogaConfig.free();
-    } catch (error) {}
-  }
 }
 
 // src/renderables/composition/vnode.ts
@@ -7535,6 +7739,18 @@ function getCallerInfo() {
   return { functionName, fullPath, fileName, lineNumber, columnNumber };
 }
 var capture = singleton("ConsoleCapture", () => new Capture);
+registerEnvVar({
+  name: "OTUI_USE_CONSOLE",
+  description: "Whether to use the console. Will not capture console output if set to false.",
+  type: "boolean",
+  default: true
+});
+registerEnvVar({
+  name: "SHOW_CONSOLE",
+  description: "Show the console at startup if set to true.",
+  type: "boolean",
+  default: false
+});
 
 class TerminalConsoleCache extends EventEmitter4 {
   _cachedLogs = [];
@@ -7552,7 +7768,7 @@ class TerminalConsoleCache extends EventEmitter4 {
     this.overrideConsoleMethods();
   }
   setupConsoleCapture() {
-    if (process.env.OTUI_USE_CONSOLE === "false")
+    if (!env.OTUI_USE_CONSOLE)
       return;
     const mockStdout = new CapturedWritableStream("stdout", capture);
     const mockStderr = new CapturedWritableStream("stderr", capture);
@@ -7717,7 +7933,7 @@ class TerminalConsole extends EventEmitter4 {
     terminalConsoleCache.on("entry", (logEntry) => {
       this._handleNewLog(logEntry);
     });
-    if (process.env.SHOW_CONSOLE === "true") {
+    if (env.SHOW_CONSOLE) {
       this.show();
     }
   }
@@ -8116,37 +8332,6 @@ class TerminalConsole extends EventEmitter4 {
   }
 }
 
-// src/ansi.ts
-var ANSI = {
-  switchToAlternateScreen: "\x1B[?1049h",
-  switchToMainScreen: "\x1B[?1049l",
-  reset: "\x1B[0m",
-  hideCursor: "\x1B[?25l",
-  showCursor: "\x1B[?25h",
-  resetCursorColor: "\x1B]12;default\x07",
-  saveCursorState: "\x1B[s",
-  restoreCursorState: "\x1B[u",
-  queryPixelSize: "\x1B[14t",
-  scrollDown: (lines) => `\x1B[${lines}T`,
-  scrollUp: (lines) => `\x1B[${lines}S`,
-  moveCursor: (row, col) => `\x1B[${row};${col}H`,
-  moveCursorAndClear: (row, col) => `\x1B[${row};${col}H\x1B[J`,
-  clearFromCursor: "\x1B[J",
-  setRgbBackground: (r, g, b) => `\x1B[48;2;${r};${g};${b}m`,
-  resetBackground: "\x1B[49m",
-  enableMouseTracking: "\x1B[?1000h",
-  disableMouseTracking: "\x1B[?1000l",
-  enableButtonEventTracking: "\x1B[?1002h",
-  disableButtonEventTracking: "\x1B[?1002l",
-  enableAnyEventTracking: "\x1B[?1003h",
-  disableAnyEventTracking: "\x1B[?1003l",
-  enableSGRMouseMode: "\x1B[?1006h",
-  disableSGRMouseMode: "\x1B[?1006l",
-  makeRoomForRenderer: (height) => `
-`.repeat(height) + `\x1B[${height}A`,
-  clearRendererSpace: (height) => `\x1B[${height}A\x1B[1G\x1B[J`
-};
-
 // src/renderer.ts
 import { EventEmitter as EventEmitter5 } from "events";
 
@@ -8226,6 +8411,19 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
 }
 
 // src/renderer.ts
+registerEnvVar({
+  name: "OTUI_DUMP_CAPTURES",
+  description: "Dump captured output when the renderer exits.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_NO_NATIVE_RENDER",
+  description: "Disable native rendering. This will not actually output ansi and is useful for debugging.",
+  type: "boolean",
+  default: false
+});
+
 class MouseEvent {
   type;
   button;
@@ -8277,6 +8475,20 @@ singleton("ProcessExitSignals", () => {
     });
   });
 });
+var rendererTracker = singleton("RendererTracker", () => {
+  const renderers = new Set;
+  return {
+    addRenderer: (renderer) => {
+      renderers.add(renderer);
+    },
+    removeRenderer: (renderer) => {
+      renderers.delete(renderer);
+      if (renderers.size === 0) {
+        process.stdin.pause();
+      }
+    }
+  };
+});
 async function createCliRenderer(config = {}) {
   if (process.argv.includes("--delay-start")) {
     await new Promise((resolve) => setTimeout(resolve, 5000));
@@ -8408,17 +8620,7 @@ class CliRenderer extends EventEmitter5 {
       this.realStdoutWrite.call(this.stdout, `
 === FATAL ERROR OCCURRED ===
 `);
-      this.realStdoutWrite.call(this.stdout, `Console cache:
-`);
-      this.realStdoutWrite.call(this.stdout, this.console.getCachedLogs());
-      this.realStdoutWrite.call(this.stdout, `
-Captured output:
-`);
-      const capturedOutput = capture.claimOutput();
-      if (capturedOutput) {
-        this.realStdoutWrite.call(this.stdout, capturedOutput + `
-`);
-      }
+      this.dumpOutputCache();
       this.realStdoutWrite.call(this.stdout, `
 Error details:
 `);
@@ -8431,14 +8633,39 @@ Error details:
       process.exit(1);
     });
   }).bind(this);
+  dumpOutputCache(optionalMessage = "") {
+    const cachedLogs = this.console.getCachedLogs();
+    const capturedOutput = capture.claimOutput();
+    if (capturedOutput.length > 0 || cachedLogs.length > 0) {
+      this.realStdoutWrite.call(this.stdout, optionalMessage);
+    }
+    if (cachedLogs.length > 0) {
+      this.realStdoutWrite.call(this.stdout, `Console cache:
+`);
+      this.realStdoutWrite.call(this.stdout, cachedLogs);
+    }
+    if (capturedOutput.length > 0) {
+      this.realStdoutWrite.call(this.stdout, `
+Captured output:
+`);
+      this.realStdoutWrite.call(this.stdout, capturedOutput + `
+`);
+    }
+    this.realStdoutWrite.call(this.stdout, ANSI.reset);
+  }
   exitHandler = (() => {
     this.destroy();
+    if (env.OTUI_DUMP_CAPTURES) {
+      this.dumpOutputCache(`=== CAPTURED OUTPUT ===
+`);
+    }
   }).bind(this);
   warningHandler = ((warning) => {
     console.warn(JSON.stringify(warning.message, null, 2));
   }).bind(this);
   constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
+    rendererTracker.addRenderer(this);
     this.stdin = stdin;
     this.stdout = stdout;
     this.realStdoutWrite = stdout.write;
@@ -8495,7 +8722,7 @@ Error details:
       global.window = {};
     }
     global.window.requestAnimationFrame = requestAnimationFrame;
-    if (process.env.OTUI_NO_NATIVE_RENDER === "true") {
+    if (env.OTUI_NO_NATIVE_RENDER) {
       this.renderNative = () => {
         if (this._splitHeight > 0) {
           this.flushStdoutCache(this._splitHeight);
@@ -8698,11 +8925,6 @@ Error details:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(true);
-    }
-    this.stdin.resume();
-    this.stdin.setEncoding("utf8");
     await new Promise((resolve) => {
       const timeout = setTimeout(() => {
         this.stdin.off("data", capListener);
@@ -8739,7 +8961,7 @@ Error details:
     }
     if (this.exitOnCtrlC && str === "\x03") {
       process.nextTick(() => {
-        process.exit();
+        this.destroy();
       });
       return;
     }
@@ -8749,6 +8971,11 @@ Error details:
     this.emit("key", data);
   }).bind(this);
   setupInput() {
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(true);
+    }
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
     this.stdin.on("data", this.stdinListener);
   }
   handleMouseData(data) {
@@ -8914,7 +9141,7 @@ Error details:
   }
   queryPixelResolution() {
     this.waitingForPixelResolution = true;
-    this.writeOut(ANSI.queryPixelSize);
+    this.lib.queryPixelResolution(this.rendererPtr);
   }
   processResize(width, height) {
     if (width === this._terminalWidth && height === this._terminalHeight)
@@ -8977,9 +9204,6 @@ Error details:
     this.lib.setDebugOverlay(this.rendererPtr, this.debugOverlay.enabled, this.debugOverlay.corner);
     this.requestRender();
   }
-  clearTerminal() {
-    this.lib.clearTerminal(this.rendererPtr);
-  }
   setTerminalTitle(title) {
     this.lib.setTerminalTitle(this.rendererPtr, title);
   }
@@ -9092,22 +9316,22 @@ Error details:
     }
   }
   destroy() {
-    this.stdin.removeListener("data", this.stdinListener);
     process.removeListener("SIGWINCH", this.sigwinchHandler);
     process.removeListener("uncaughtException", this.handleError);
     process.removeListener("unhandledRejection", this.handleError);
-    process.removeListener("exit", this.exitHandler);
     process.removeListener("warning", this.warningHandler);
     capture.removeListener("write", this.captureCallback);
     if (this.memorySnapshotTimer) {
       clearInterval(this.memorySnapshotTimer);
     }
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(false);
-    }
     if (this.isDestroyed)
       return;
     this.isDestroyed = true;
+    if (this.renderTimeout) {
+      clearTimeout(this.renderTimeout);
+      this.renderTimeout = null;
+    }
+    this._isRunning = false;
     this.waitingForPixelResolution = false;
     this.capturedRenderable = undefined;
     this.root.destroyRecursively();
@@ -9117,7 +9341,12 @@ Error details:
     if (this._splitHeight > 0) {
       this.flushStdoutCache(this._splitHeight, true);
     }
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
+    this.stdin.removeListener("data", this.stdinListener);
     this.lib.destroyRenderer(this.rendererPtr);
+    rendererTracker.removeRenderer(this);
   }
   startRenderLoop() {
     if (!this._isRunning)
@@ -9174,7 +9403,9 @@ Error details:
       postProcessFn(this.nextRenderBuffer, deltaTime);
     }
     this._console.renderToBuffer(this.nextRenderBuffer);
-    this.renderNative();
+    if (!this.isDestroyed) {
+      this.renderNative();
+    }
     const overallFrameTime = performance.now() - overallStart;
     this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
     if (this.gatherStats) {
@@ -9341,7 +9572,7 @@ Error details:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyHandler, getKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, generateEnvMarkdown, generateEnvColored, env, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
 
-//# debugId=F7540B181A9A091164756E2164756E21
-//# sourceMappingURL=index-0yx9rnxg.js.map
+//# debugId=FA47EE78BCA83E8664756E2164756E21
+//# sourceMappingURL=index-6kvgbzah.js.map