@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/render-BAwdjfki.js

@@ -0,0 +1,2806 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const process$2 = __cjs_getProcess;
+const {
+  env,
+  cwd
+} = process$2;
+const {
+  Stream
+} = __cjs_getBuiltinModule("node:stream");
+import { jsxs, jsx } from 'react/jsx-runtime';
+const {
+  Buffer
+} = __cjs_getBuiltinModule("node:buffer");
+const {
+  Console
+} = __cjs_getBuiltinModule("node:console");
+import { cursorShow, cursorUp, cursorTo, cursorDown, eraseLines, cursorHide, cursorNextLine, eraseLineEnd, ALT_SCREEN_ON, resetTerminal, ALT_SCREEN_OFF } from '@visulima/ansi';
+import { wordWrap } from '@visulima/string';
+import patchConsole from 'patch-console';
+import { ConcurrentRoot, LegacyRoot } from 'react-reconciler/constants.js';
+import Yoga from 'yoga-layout';
+import { a as accessibilityContext } from './AccessibilityContext-BLelHhNU.js';
+const {
+  EventEmitter
+} = __cjs_getBuiltinModule("node:events");
+import { PureComponent, useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { a as animationContext } from './AnimationContext-BcJg8Jr6.js';
+import { A as AppContext } from './AppContext-CP0U6H7O.js';
+import { C as CursorContext } from './CursorContext-JxRzlqAx.js';
+const {
+  existsSync,
+  readFileSync
+} = __cjs_getBuiltinModule("node:fs");
+const require$$1 = __cjs_getBuiltinModule("module");
+import Box from './Box-D_pSJ9Jp.js';
+import Text from './Text-DvAUdZcK.js';
+import { F as FocusContext } from './FocusContext-CWkYtgcm.js';
+import { S as StderrContext } from './StderrContext-Bj4Mf7v7.js';
+import { S as StdinContext } from './StdinContext-Bq_GNJ3z.js';
+import { S as StdoutContext } from './StdoutContext-CgjWeCdO.js';
+import { c as createNode } from './dom-DvzhsAez.js';
+import { resolveFlags } from './kittyFlags-bNNf_9kX.js';
+import { a as clearStyledLineCache } from './measure-text-DItZYotK.js';
+import { r as reconcilerInstance, s as styles } from './reconciler-gfmqURLy.js';
+import { a as renderToStatic, r as renderer } from './renderer-B3wROkeg.js';
+import { measureAndExtractObservers } from './ResizeObserverEntry-Br4seLeQ.js';
+import { calculateScroll } from './getScrollHeight-BubfU_df.js';
+import { g as getWindowSize } from './utils-BgdlrbOH.js';
+
+import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
+const require = __cjs_mod__.createRequire(import.meta.url);
+function debounce$1(func, debounceMs, { signal, edges } = {}) {
+  let pendingThis = void 0;
+  let pendingArgs = null;
+  const leading = edges != null && edges.includes("leading");
+  const trailing = edges == null || edges.includes("trailing");
+  const invoke = () => {
+    if (pendingArgs !== null) {
+      func.apply(pendingThis, pendingArgs);
+      pendingThis = void 0;
+      pendingArgs = null;
+    }
+  };
+  const onTimerEnd = () => {
+    if (trailing) {
+      invoke();
+    }
+    cancel();
+  };
+  let timeoutId = null;
+  const schedule = () => {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      onTimerEnd();
+    }, debounceMs);
+  };
+  const cancelTimer = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  const cancel = () => {
+    cancelTimer();
+    pendingThis = void 0;
+    pendingArgs = null;
+  };
+  const flush = () => {
+    invoke();
+  };
+  const debounced = function(...args) {
+    if (signal?.aborted) {
+      return;
+    }
+    pendingThis = this;
+    pendingArgs = args;
+    const isFirstCall = timeoutId == null;
+    schedule();
+    if (leading && isFirstCall) {
+      invoke();
+    }
+  };
+  debounced.schedule = schedule;
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  signal?.addEventListener("abort", cancel, { once: true });
+  return debounced;
+}
+
+function debounce(func, debounceMs = 0, options = {}) {
+  if (typeof options !== "object") {
+    options = {};
+  }
+  const { leading = false, trailing = true, maxWait } = options;
+  const edges = Array(2);
+  if (leading) {
+    edges[0] = "leading";
+  }
+  if (trailing) {
+    edges[1] = "trailing";
+  }
+  let result = void 0;
+  let pendingAt = null;
+  const _debounced = debounce$1(function(...args) {
+    result = func.apply(this, args);
+    pendingAt = null;
+  }, debounceMs, { edges });
+  const debounced = function(...args) {
+    if (maxWait != null) {
+      if (pendingAt === null) {
+        pendingAt = Date.now();
+      }
+      if (Date.now() - pendingAt >= maxWait) {
+        result = func.apply(this, args);
+        pendingAt = Date.now();
+        _debounced.cancel();
+        _debounced.schedule();
+        return result;
+      }
+    }
+    _debounced.apply(this, args);
+    return result;
+  };
+  const flush = () => {
+    _debounced.flush();
+    return result;
+  };
+  debounced.cancel = _debounced.cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+function throttle(func, throttleMs = 0, options = {}) {
+  const { leading = true, trailing = true } = options;
+  return debounce(func, throttleMs, {
+    leading,
+    maxWait: throttleMs,
+    trailing
+  });
+}
+
+const check = (key) => key in env && env[key] !== "0" && env[key] !== "false";
+const isInCi = check("CI") || check("CONTINUOUS_INTEGRATION");
+
+const signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push(
+    "SIGALRM",
+    "SIGABRT",
+    "SIGVTALRM",
+    "SIGXCPU",
+    "SIGXFSZ",
+    "SIGUSR2",
+    "SIGTRAP",
+    "SIGSYS",
+    "SIGQUIT",
+    "SIGIOT"
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+const processOk = (process2) => !!process2 && true && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function";
+const kExitEmitter = /* @__PURE__ */ Symbol.for("signal-exit emitter");
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+class SignalExitBase {
+}
+const signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+class SignalExitFallback extends SignalExitBase {
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
+  }
+  unload() {
+  }
+}
+class SignalExit extends SignalExitBase {
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #hupSig = process$1.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #emitter = new Emitter();
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process2) {
+    super();
+    this.#process = process2;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process2;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process2.kill(process2.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process2.reallyExit;
+    this.#originalProcessEmit = process2.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {
+      };
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {
+      }
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {
+      }
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+}
+const process$1 = globalThis.process;
+const {
+  /**
+   * Called when the process is exiting, whether via signal, explicit
+   * exit, or running out of stuff to do.
+   *
+   * If the global process object is not suitable for instrumentation,
+   * then this will be a no-op.
+   *
+   * Returns a function that may be used to unload signal-exit.
+   */
+  onExit} = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+
+const escape$1 = "\x1B";
+const pasteStart = "\x1B[200~";
+const pasteEnd = "\x1B[201~";
+const isCsiParameterByte = (byte) => byte >= 48 && byte <= 63;
+const isCsiIntermediateByte = (byte) => byte >= 32 && byte <= 47;
+const isCsiFinalByte = (byte) => byte >= 64 && byte <= 126;
+const parseCsiSequence = (input, startIndex, prefixLength) => {
+  const csiPayloadStart = startIndex + prefixLength + 1;
+  let index = csiPayloadStart;
+  for (; index < input.length; index++) {
+    const byte = input.codePointAt(index);
+    if (byte === void 0) {
+      return "pending";
+    }
+    if (isCsiParameterByte(byte) || isCsiIntermediateByte(byte)) {
+      continue;
+    }
+    if (byte === 91 && index === csiPayloadStart) {
+      continue;
+    }
+    if (isCsiFinalByte(byte)) {
+      return {
+        nextIndex: index + 1,
+        sequence: input.slice(startIndex, index + 1)
+      };
+    }
+    return void 0;
+  }
+  return "pending";
+};
+const parseSs3Sequence = (input, startIndex, prefixLength) => {
+  const nextIndex = startIndex + prefixLength + 2;
+  if (nextIndex > input.length) {
+    return "pending";
+  }
+  const finalByte = input.codePointAt(nextIndex - 1);
+  if (finalByte === void 0 || !isCsiFinalByte(finalByte)) {
+    return void 0;
+  }
+  return {
+    nextIndex,
+    sequence: input.slice(startIndex, nextIndex)
+  };
+};
+const parseControlSequence = (input, startIndex, prefixLength) => {
+  const sequenceType = input[startIndex + prefixLength];
+  if (sequenceType === void 0) {
+    return "pending";
+  }
+  if (sequenceType === "[") {
+    return parseCsiSequence(input, startIndex, prefixLength);
+  }
+  if (sequenceType === "O") {
+    return parseSs3Sequence(input, startIndex, prefixLength);
+  }
+  return void 0;
+};
+const parseEscapedCodePoint = (input, escapeIndex) => {
+  const nextCodePoint = input.codePointAt(escapeIndex + 1);
+  const nextCodePointLength = nextCodePoint !== void 0 && nextCodePoint > 65535 ? 2 : 1;
+  const nextIndex = escapeIndex + 1 + nextCodePointLength;
+  return {
+    nextIndex,
+    sequence: input.slice(escapeIndex, nextIndex)
+  };
+};
+const parseEscapeSequence = (input, escapeIndex) => {
+  if (escapeIndex === input.length - 1) {
+    return "pending";
+  }
+  const next = input[escapeIndex + 1];
+  if (next === escape$1) {
+    if (escapeIndex + 2 >= input.length) {
+      return "pending";
+    }
+    const doubleEscapeSequence = parseControlSequence(input, escapeIndex, 2);
+    if (doubleEscapeSequence === "pending") {
+      return "pending";
+    }
+    if (doubleEscapeSequence) {
+      return doubleEscapeSequence;
+    }
+    return {
+      nextIndex: escapeIndex + 2,
+      sequence: input.slice(escapeIndex, escapeIndex + 2)
+    };
+  }
+  const controlSequence = parseControlSequence(input, escapeIndex, 1);
+  if (controlSequence === "pending") {
+    return "pending";
+  }
+  if (controlSequence) {
+    return controlSequence;
+  }
+  return parseEscapedCodePoint(input, escapeIndex);
+};
+const splitDeleteAndBackspace = (text, events) => {
+  let textSegmentStart = 0;
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index];
+    if (character === "" || character === "\b") {
+      if (index > textSegmentStart) {
+        events.push(text.slice(textSegmentStart, index));
+      }
+      events.push(character);
+      textSegmentStart = index + 1;
+    }
+  }
+  if (textSegmentStart < text.length) {
+    events.push(text.slice(textSegmentStart));
+  }
+};
+const parseKeypresses = (input) => {
+  const events = [];
+  let index = 0;
+  const pendingFrom = (pendingStartIndex) => {
+    return {
+      events,
+      pending: input.slice(pendingStartIndex)
+    };
+  };
+  while (index < input.length) {
+    const escapeIndex = input.indexOf(escape$1, index);
+    if (escapeIndex === -1) {
+      splitDeleteAndBackspace(input.slice(index), events);
+      return {
+        events,
+        pending: ""
+      };
+    }
+    if (escapeIndex > index) {
+      splitDeleteAndBackspace(input.slice(index, escapeIndex), events);
+    }
+    const parsedEscapeSequence = parseEscapeSequence(input, escapeIndex);
+    if (parsedEscapeSequence === "pending") {
+      return pendingFrom(escapeIndex);
+    }
+    if (parsedEscapeSequence.sequence === pasteStart) {
+      const afterStart = parsedEscapeSequence.nextIndex;
+      const endIndex = input.indexOf(pasteEnd, afterStart);
+      if (endIndex === -1) {
+        return pendingFrom(escapeIndex);
+      }
+      events.push({ paste: input.slice(afterStart, endIndex) });
+      index = endIndex + pasteEnd.length;
+      continue;
+    }
+    events.push(parsedEscapeSequence.sequence);
+    index = parsedEscapeSequence.nextIndex;
+  }
+  return {
+    events,
+    pending: ""
+  };
+};
+const createInputParser = () => {
+  let pending = "";
+  return {
+    flushPendingEscape() {
+      if (!pending.startsWith(escape$1)) {
+        return void 0;
+      }
+      const pendingEscape = pending;
+      pending = "";
+      return pendingEscape;
+    },
+    hasPendingEscape() {
+      return pending.startsWith(escape$1) && !pending.startsWith(pasteStart) && pending !== "\x1B[200";
+    },
+    push(chunk) {
+      const parsedInput = parseKeypresses(pending + chunk);
+      pending = parsedInput.pending;
+      return parsedInput.events;
+    },
+    reset() {
+      pending = "";
+    }
+  };
+};
+
+const convertToSpaces = (input, spaces = 2) => {
+  return input.replace(/^\t+/gm, ($1) => " ".repeat($1.length * spaces));
+};
+
+const generateLineNumbers = (line, around) => {
+  const lineNumbers = [];
+  const min = line - around;
+  const max = line + around;
+  for (let lineNumber = min; lineNumber <= max; lineNumber++) {
+    lineNumbers.push(lineNumber);
+  }
+  return lineNumbers;
+};
+const codeExcerpt = (source, line, options = {}) => {
+  var _a;
+  if (typeof source !== "string") {
+    throw new TypeError("Source code is missing.");
+  }
+  if (!line || line < 1) {
+    throw new TypeError("Line number must start from `1`.");
+  }
+  const lines = convertToSpaces(source).split(/\r?\n/);
+  if (line > lines.length) {
+    return;
+  }
+  return generateLineNumbers(line, (_a = options.around) !== null && _a !== void 0 ? _a : 3).filter((line2) => lines[line2 - 1] !== void 0).map((line2) => ({ line: line2, value: lines[line2 - 1] }));
+};
+
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+var escapeStringRegexp;
+var hasRequiredEscapeStringRegexp;
+
+function requireEscapeStringRegexp () {
+	if (hasRequiredEscapeStringRegexp) return escapeStringRegexp;
+	hasRequiredEscapeStringRegexp = 1;
+	const matchOperatorsRegex = /[|\\{}()[\]^$+*?.-]/g;
+	escapeStringRegexp = (string) => {
+	  if (typeof string !== "string") {
+	    throw new TypeError("Expected a string");
+	  }
+	  return string.replace(matchOperatorsRegex, "\\$&");
+	};
+	return escapeStringRegexp;
+}
+
+var stackUtils$1;
+var hasRequiredStackUtils;
+
+function requireStackUtils () {
+	if (hasRequiredStackUtils) return stackUtils$1;
+	hasRequiredStackUtils = 1;
+	const escapeStringRegexp = requireEscapeStringRegexp();
+	const cwd = process && typeof process.cwd === "function" ? process.cwd() : ".";
+	const natives = [].concat(
+	  require$$1.builtinModules,
+	  "bootstrap_node",
+	  "node"
+	).map((n) => new RegExp(`(?:\\((?:node:)?${n}(?:\\.js)?:\\d+:\\d+\\)$|^\\s*at (?:node:)?${n}(?:\\.js)?:\\d+:\\d+$)`));
+	natives.push(
+	  /\((?:node:)?internal\/[^:]+:\d+:\d+\)$/,
+	  /\s*at (?:node:)?internal\/[^:]+:\d+:\d+$/,
+	  /\/\.node-spawn-wrap-\w+-\w+\/node:\d+:\d+\)?$/
+	);
+	class StackUtils {
+	  constructor(opts) {
+	    opts = {
+	      ignoredPackages: [],
+	      ...opts
+	    };
+	    if ("internals" in opts === false) {
+	      opts.internals = StackUtils.nodeInternals();
+	    }
+	    if ("cwd" in opts === false) {
+	      opts.cwd = cwd;
+	    }
+	    this._cwd = opts.cwd.replace(/\\/g, "/");
+	    this._internals = [].concat(
+	      opts.internals,
+	      ignoredPackagesRegExp(opts.ignoredPackages)
+	    );
+	    this._wrapCallSite = opts.wrapCallSite || false;
+	  }
+	  static nodeInternals() {
+	    return [...natives];
+	  }
+	  clean(stack, indent = 0) {
+	    indent = " ".repeat(indent);
+	    if (!Array.isArray(stack)) {
+	      stack = stack.split("\n");
+	    }
+	    if (!/^\s*at /.test(stack[0]) && /^\s*at /.test(stack[1])) {
+	      stack = stack.slice(1);
+	    }
+	    let outdent = false;
+	    let lastNonAtLine = null;
+	    const result = [];
+	    stack.forEach((st) => {
+	      st = st.replace(/\\/g, "/");
+	      if (this._internals.some((internal) => internal.test(st))) {
+	        return;
+	      }
+	      const isAtLine = /^\s*at /.test(st);
+	      if (outdent) {
+	        st = st.trimEnd().replace(/^(\s+)at /, "$1");
+	      } else {
+	        st = st.trim();
+	        if (isAtLine) {
+	          st = st.slice(3);
+	        }
+	      }
+	      st = st.replace(`${this._cwd}/`, "");
+	      if (st) {
+	        if (isAtLine) {
+	          if (lastNonAtLine) {
+	            result.push(lastNonAtLine);
+	            lastNonAtLine = null;
+	          }
+	          result.push(st);
+	        } else {
+	          outdent = true;
+	          lastNonAtLine = st;
+	        }
+	      }
+	    });
+	    return result.map((line) => `${indent}${line}
+`).join("");
+	  }
+	  captureString(limit, fn = this.captureString) {
+	    if (typeof limit === "function") {
+	      fn = limit;
+	      limit = Infinity;
+	    }
+	    const { stackTraceLimit } = Error;
+	    if (limit) {
+	      Error.stackTraceLimit = limit;
+	    }
+	    const obj = {};
+	    Error.captureStackTrace(obj, fn);
+	    const { stack } = obj;
+	    Error.stackTraceLimit = stackTraceLimit;
+	    return this.clean(stack);
+	  }
+	  capture(limit, fn = this.capture) {
+	    if (typeof limit === "function") {
+	      fn = limit;
+	      limit = Infinity;
+	    }
+	    const { prepareStackTrace, stackTraceLimit } = Error;
+	    Error.prepareStackTrace = (obj2, site) => {
+	      if (this._wrapCallSite) {
+	        return site.map(this._wrapCallSite);
+	      }
+	      return site;
+	    };
+	    if (limit) {
+	      Error.stackTraceLimit = limit;
+	    }
+	    const obj = {};
+	    Error.captureStackTrace(obj, fn);
+	    const { stack } = obj;
+	    Object.assign(Error, { prepareStackTrace, stackTraceLimit });
+	    return stack;
+	  }
+	  at(fn = this.at) {
+	    const [site] = this.capture(1, fn);
+	    if (!site) {
+	      return {};
+	    }
+	    const res = {
+	      line: site.getLineNumber(),
+	      column: site.getColumnNumber()
+	    };
+	    setFile(res, site.getFileName(), this._cwd);
+	    if (site.isConstructor()) {
+	      Object.defineProperty(res, "constructor", {
+	        value: true,
+	        configurable: true
+	      });
+	    }
+	    if (site.isEval()) {
+	      res.evalOrigin = site.getEvalOrigin();
+	    }
+	    if (site.isNative()) {
+	      res.native = true;
+	    }
+	    let typename;
+	    try {
+	      typename = site.getTypeName();
+	    } catch (_) {
+	    }
+	    if (typename && typename !== "Object" && typename !== "[object Object]") {
+	      res.type = typename;
+	    }
+	    const fname = site.getFunctionName();
+	    if (fname) {
+	      res.function = fname;
+	    }
+	    const meth = site.getMethodName();
+	    if (meth && fname !== meth) {
+	      res.method = meth;
+	    }
+	    return res;
+	  }
+	  parseLine(line) {
+	    const match = line && line.match(re);
+	    if (!match) {
+	      return null;
+	    }
+	    const ctor = match[1] === "new";
+	    let fname = match[2];
+	    const evalOrigin = match[3];
+	    const evalFile = match[4];
+	    const evalLine = Number(match[5]);
+	    const evalCol = Number(match[6]);
+	    let file = match[7];
+	    const lnum = match[8];
+	    const col = match[9];
+	    const native = match[10] === "native";
+	    const closeParen = match[11] === ")";
+	    let method;
+	    const res = {};
+	    if (lnum) {
+	      res.line = Number(lnum);
+	    }
+	    if (col) {
+	      res.column = Number(col);
+	    }
+	    if (closeParen && file) {
+	      let closes = 0;
+	      for (let i = file.length - 1; i > 0; i--) {
+	        if (file.charAt(i) === ")") {
+	          closes++;
+	        } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
+	          closes--;
+	          if (closes === -1 && file.charAt(i - 1) === " ") {
+	            const before = file.slice(0, i - 1);
+	            const after = file.slice(i + 1);
+	            file = after;
+	            fname += ` (${before}`;
+	            break;
+	          }
+	        }
+	      }
+	    }
+	    if (fname) {
+	      const methodMatch = fname.match(methodRe);
+	      if (methodMatch) {
+	        fname = methodMatch[1];
+	        method = methodMatch[2];
+	      }
+	    }
+	    setFile(res, file, this._cwd);
+	    if (ctor) {
+	      Object.defineProperty(res, "constructor", {
+	        value: true,
+	        configurable: true
+	      });
+	    }
+	    if (evalOrigin) {
+	      res.evalOrigin = evalOrigin;
+	      res.evalLine = evalLine;
+	      res.evalColumn = evalCol;
+	      res.evalFile = evalFile && evalFile.replace(/\\/g, "/");
+	    }
+	    if (native) {
+	      res.native = true;
+	    }
+	    if (fname) {
+	      res.function = fname;
+	    }
+	    if (method && fname !== method) {
+	      res.method = method;
+	    }
+	    return res;
+	  }
+	}
+	function setFile(result, filename, cwd2) {
+	  if (filename) {
+	    filename = filename.replace(/\\/g, "/");
+	    if (filename.startsWith(`${cwd2}/`)) {
+	      filename = filename.slice(cwd2.length + 1);
+	    }
+	    result.file = filename;
+	  }
+	}
+	function ignoredPackagesRegExp(ignoredPackages) {
+	  if (ignoredPackages.length === 0) {
+	    return [];
+	  }
+	  const packages = ignoredPackages.map((mod) => escapeStringRegexp(mod));
+	  return new RegExp(`[/\\\\]node_modules[/\\\\](?:${packages.join("|")})[/\\\\][^:]+:\\d+:\\d+`);
+	}
+	const re = new RegExp(
+	  "^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$"
+	);
+	const methodRe = /^(.*?) \[as (.*?)\]$/;
+	stackUtils$1 = StackUtils;
+	return stackUtils$1;
+}
+
+var stackUtilsExports = requireStackUtils();
+const StackUtils = /*@__PURE__*/getDefaultExportFromCjs(stackUtilsExports);
+
+const cleanupPath = (path) => path?.replace(`file://${cwd()}/`, "");
+const stackUtils = new StackUtils({
+  cwd: cwd(),
+  internals: StackUtils.nodeInternals()
+});
+function ErrorOverview({ error }) {
+  const stack = error.stack ? error.stack.split("\n").slice(1) : void 0;
+  const origin = stack ? stackUtils.parseLine(stack[0]) : void 0;
+  const filePath = cleanupPath(origin?.file);
+  let excerpt;
+  let lineWidth = 0;
+  if (filePath && origin?.line && existsSync(filePath)) {
+    const sourceCode = readFileSync(filePath, "utf8");
+    excerpt = codeExcerpt(sourceCode, origin.line);
+    if (excerpt) {
+      for (const { line } of excerpt) {
+        lineWidth = Math.max(lineWidth, String(line).length);
+      }
+    }
+  }
+  return jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    jsxs(Box, { children: [
+      jsxs(Text, { backgroundColor: "red", color: "white", children: [
+        " ",
+        "ERROR",
+        " "
+      ] }),
+      jsxs(Text, { children: [
+        " ",
+        error.message
+      ] })
+    ] }),
+    origin && filePath ? jsx(Box, { marginTop: 1, children: jsxs(Text, { dimColor: true, children: [
+      filePath,
+      ":",
+      origin.line,
+      ":",
+      origin.column
+    ] }) }) : null,
+    origin && excerpt ? jsx(Box, { flexDirection: "column", marginTop: 1, children: excerpt.map(({ line, value }) => jsxs(Box, { children: [
+      jsx(Box, { width: lineWidth + 1, children: jsxs(
+        Text,
+        {
+          "aria-label": line === origin.line ? `Line ${line}, error` : `Line ${line}`,
+          backgroundColor: line === origin.line ? "red" : void 0,
+          color: line === origin.line ? "white" : void 0,
+          dimColor: line !== origin.line,
+          children: [
+            String(line).padStart(lineWidth, " "),
+            ":"
+          ]
+        }
+      ) }),
+      jsx(Text, { backgroundColor: line === origin.line ? "red" : void 0, color: line === origin.line ? "white" : void 0, children: ` ${value}` }, line)
+    ] }, line)) }) : null,
+    stack ? jsx(Box, { flexDirection: "column", marginTop: 1, children: stack.map((line) => {
+      const parsedLine = stackUtils.parseLine(line);
+      if (!parsedLine) {
+        return jsxs(Box, { children: [
+          jsx(Text, { dimColor: true, children: "- " }),
+          jsxs(Text, { bold: true, dimColor: true, children: [
+            line,
+            "\\t",
+            " "
+          ] })
+        ] }, line);
+      }
+      return jsxs(Box, { children: [
+        jsx(Text, { dimColor: true, children: "- " }),
+        jsx(Text, { bold: true, dimColor: true, children: parsedLine.function }),
+        jsxs(
+          Text,
+          {
+            "aria-label": `at ${cleanupPath(parsedLine.file) ?? ""} line ${parsedLine.line} column ${parsedLine.column}`,
+            color: "gray",
+            dimColor: true,
+            children: [
+              " ",
+              "(",
+              cleanupPath(parsedLine.file) ?? "",
+              ":",
+              parsedLine.line,
+              ":",
+              parsedLine.column,
+              ")"
+            ]
+          }
+        )
+      ] }, line);
+    }) }) : null
+  ] });
+}
+
+class ErrorBoundary extends PureComponent {
+  static displayName = "InternalErrorBoundary";
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  state = {
+    error: void 0
+  };
+  componentDidCatch(error) {
+    this.props.onError(error);
+  }
+  render() {
+    if (this.state.error) {
+      return jsx(ErrorOverview, { error: this.state.error });
+    }
+    return this.props.children;
+  }
+}
+
+const tab = "	";
+const shiftTab = "\x1B[Z";
+const escape = "\x1B";
+const App = ({
+  children,
+  exitOnCtrlC,
+  interactive,
+  onExit,
+  onWaitUntilRenderFlush,
+  renderThrottleMs,
+  setCursorPosition,
+  stderr,
+  stdin,
+  stdout,
+  writeToStderr,
+  writeToStdout
+}) => {
+  const [isFocusEnabled, setIsFocusEnabled] = useState(true);
+  const [activeFocusId, setActiveFocusId] = useState(void 0);
+  const [, setFocusables] = useState([]);
+  const focusablesCountRef = useRef(0);
+  const animationSubscribersRef = useRef(/* @__PURE__ */ new Map());
+  const animationTimerRef = useRef(void 0);
+  const rawModeEnabledCount = useRef(0);
+  const bracketedPasteModeEnabledCount = useRef(0);
+  const [internal_eventEmitter] = useState(() => {
+    const emitter = new EventEmitter();
+    emitter.setMaxListeners(Infinity);
+    return emitter;
+  });
+  const readableListenerRef = useRef(void 0);
+  const inputParserRef = useRef(void 0);
+  inputParserRef.current ??= createInputParser();
+  const pendingInputFlushRef = useRef(void 0);
+  const didWarnAboutDeprecatedPasteFallbackRef = useRef(false);
+  const pendingInputFlushDelayMilliseconds = 20;
+  const clearPendingInputFlush = useCallback(() => {
+    if (!pendingInputFlushRef.current) {
+      return;
+    }
+    clearTimeout(pendingInputFlushRef.current);
+    pendingInputFlushRef.current = void 0;
+  }, []);
+  const clearAnimationTimer = useCallback(() => {
+    if (!animationTimerRef.current) {
+      return;
+    }
+    clearTimeout(animationTimerRef.current);
+    animationTimerRef.current = void 0;
+  }, []);
+  const scheduleAnimationTick = useCallback(() => {
+    clearAnimationTimer();
+    if (animationSubscribersRef.current.size === 0) {
+      return;
+    }
+    let nextDueTime = Number.POSITIVE_INFINITY;
+    for (const subscriber of animationSubscribersRef.current.values()) {
+      nextDueTime = Math.min(nextDueTime, subscriber.nextDueTime);
+    }
+    const delay = Math.max(0, nextDueTime - performance.now());
+    animationTimerRef.current = setTimeout(() => {
+      animationTimerRef.current = void 0;
+      const currentTime = performance.now();
+      const subscribers = [...animationSubscribersRef.current.values()];
+      for (const subscriber of subscribers) {
+        if (currentTime < subscriber.nextDueTime) {
+          continue;
+        }
+        subscriber.callback(currentTime);
+        const elapsedTime = currentTime - subscriber.startTime;
+        const elapsedFrames = Math.floor(elapsedTime / subscriber.interval) + 1;
+        subscriber.nextDueTime = subscriber.startTime + elapsedFrames * subscriber.interval;
+      }
+      scheduleAnimationTick();
+    }, delay);
+  }, [clearAnimationTimer]);
+  const animationSubscribe = useCallback(
+    (callback, interval) => {
+      const startTime = performance.now();
+      animationSubscribersRef.current.set(callback, {
+        callback,
+        interval,
+        nextDueTime: startTime + interval,
+        startTime
+      });
+      scheduleAnimationTick();
+      return {
+        startTime,
+        unsubscribe() {
+          animationSubscribersRef.current.delete(callback);
+          if (animationSubscribersRef.current.size === 0) {
+            clearAnimationTimer();
+            return;
+          }
+          scheduleAnimationTick();
+        }
+      };
+    },
+    [clearAnimationTimer, scheduleAnimationTick]
+  );
+  useEffect(() => {
+    return () => {
+      clearAnimationTimer();
+    };
+  }, [clearAnimationTimer]);
+  const isRawModeSupported = stdin.isTTY;
+  const detachReadableListener = useCallback(() => {
+    if (!readableListenerRef.current) {
+      return;
+    }
+    stdin.removeListener("readable", readableListenerRef.current);
+    readableListenerRef.current = void 0;
+  }, [stdin]);
+  const disableRawMode = useCallback(() => {
+    stdin.setRawMode(false);
+    detachReadableListener();
+    stdin.unref();
+    rawModeEnabledCount.current = 0;
+    inputParserRef.current?.reset();
+    clearPendingInputFlush();
+  }, [stdin, detachReadableListener, clearPendingInputFlush]);
+  const handleExit = useCallback(
+    (errorOrResult) => {
+      if (isRawModeSupported && rawModeEnabledCount.current > 0) {
+        disableRawMode();
+      }
+      onExit(errorOrResult);
+    },
+    [isRawModeSupported, disableRawMode, onExit]
+  );
+  const handleInput = useCallback(
+    (input) => {
+      if (input.includes("") && exitOnCtrlC) {
+        handleExit();
+        return;
+      }
+      if (input === escape) {
+        setActiveFocusId((currentActiveFocusId) => {
+          if (currentActiveFocusId) {
+            return void 0;
+          }
+          return currentActiveFocusId;
+        });
+      }
+    },
+    [exitOnCtrlC, handleExit]
+  );
+  const emitInput = useCallback(
+    (input) => {
+      handleInput(input);
+      internal_eventEmitter.emit("input", input);
+    },
+    [handleInput, internal_eventEmitter]
+  );
+  const schedulePendingInputFlush = useCallback(() => {
+    clearPendingInputFlush();
+    pendingInputFlushRef.current = setTimeout(() => {
+      pendingInputFlushRef.current = void 0;
+      const pendingEscape = inputParserRef.current.flushPendingEscape();
+      if (!pendingEscape) {
+        return;
+      }
+      emitInput(pendingEscape);
+    }, pendingInputFlushDelayMilliseconds);
+  }, [clearPendingInputFlush, emitInput]);
+  const handleReadable = useCallback(() => {
+    clearPendingInputFlush();
+    let chunk;
+    while ((chunk = stdin.read()) !== null) {
+      const inputEvents = inputParserRef.current.push(chunk);
+      for (const event of inputEvents) {
+        if (typeof event === "string") {
+          emitInput(event);
+        } else {
+          if (internal_eventEmitter.listenerCount("paste") === 0) {
+            if (!didWarnAboutDeprecatedPasteFallbackRef.current) {
+              didWarnAboutDeprecatedPasteFallbackRef.current = true;
+              writeToStderr(
+                "Warning: useInput() received bracketed paste because no usePaste() handler is active. This fallback is deprecated and will be removed in the next major version. Migrate paste handling to usePaste().\n"
+              );
+            }
+            emitInput(event.paste);
+            continue;
+          }
+          internal_eventEmitter.emit("paste", event.paste);
+        }
+      }
+    }
+    if (inputParserRef.current.hasPendingEscape()) {
+      schedulePendingInputFlush();
+    }
+  }, [stdin, emitInput, clearPendingInputFlush, schedulePendingInputFlush, writeToStderr, internal_eventEmitter]);
+  const handleSetRawMode = useCallback(
+    (isEnabled) => {
+      if (!isRawModeSupported) {
+        if (stdin === process$2.stdin) {
+          throw new Error(
+            "Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported"
+          );
+        } else {
+          throw new Error(
+            "Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported"
+          );
+        }
+      }
+      stdin.setEncoding("utf8");
+      if (isEnabled) {
+        if (rawModeEnabledCount.current === 0) {
+          stdin.ref();
+          stdin.setRawMode(true);
+          readableListenerRef.current = handleReadable;
+          stdin.addListener("readable", handleReadable);
+        }
+        rawModeEnabledCount.current++;
+        return;
+      }
+      if (rawModeEnabledCount.current === 0) {
+        return;
+      }
+      if (--rawModeEnabledCount.current === 0) {
+        disableRawMode();
+      }
+    },
+    [isRawModeSupported, stdin, handleReadable, disableRawMode]
+  );
+  const handleSetBracketedPasteMode = useCallback(
+    (isEnabled) => {
+      if (!stdout.isTTY) {
+        return;
+      }
+      if (isEnabled) {
+        if (bracketedPasteModeEnabledCount.current === 0) {
+          stdout.write("\x1B[?2004h");
+        }
+        bracketedPasteModeEnabledCount.current++;
+        return;
+      }
+      if (bracketedPasteModeEnabledCount.current === 0) {
+        return;
+      }
+      if (--bracketedPasteModeEnabledCount.current === 0) {
+        stdout.write("\x1B[?2004l");
+      }
+    },
+    [stdout]
+  );
+  const findNextFocusable = useCallback((currentFocusables, currentActiveFocusId) => {
+    const activeIndex = currentFocusables.findIndex((focusable) => focusable.id === currentActiveFocusId);
+    for (let index = activeIndex + 1; index < currentFocusables.length; index++) {
+      const focusable = currentFocusables[index];
+      if (focusable?.isActive) {
+        return focusable.id;
+      }
+    }
+    return void 0;
+  }, []);
+  const findPreviousFocusable = useCallback((currentFocusables, currentActiveFocusId) => {
+    const activeIndex = currentFocusables.findIndex((focusable) => focusable.id === currentActiveFocusId);
+    for (let index = activeIndex - 1; index >= 0; index--) {
+      const focusable = currentFocusables[index];
+      if (focusable?.isActive) {
+        return focusable.id;
+      }
+    }
+    return void 0;
+  }, []);
+  const focusNext = useCallback(() => {
+    setFocusables((currentFocusables) => {
+      setActiveFocusId((currentActiveFocusId) => {
+        const firstFocusableId = currentFocusables.find((focusable) => focusable.isActive)?.id;
+        const nextFocusableId = findNextFocusable(currentFocusables, currentActiveFocusId);
+        return nextFocusableId ?? firstFocusableId;
+      });
+      return currentFocusables;
+    });
+  }, [findNextFocusable]);
+  const focusPrevious = useCallback(() => {
+    setFocusables((currentFocusables) => {
+      setActiveFocusId((currentActiveFocusId) => {
+        const lastFocusableId = currentFocusables.findLast((focusable) => focusable.isActive)?.id;
+        const previousFocusableId = findPreviousFocusable(currentFocusables, currentActiveFocusId);
+        return previousFocusableId ?? lastFocusableId;
+      });
+      return currentFocusables;
+    });
+  }, [findPreviousFocusable]);
+  useEffect(() => {
+    const handleTabNavigation = (input) => {
+      if (!isFocusEnabled || focusablesCountRef.current === 0) {
+        return;
+      }
+      if (input === tab) {
+        focusNext();
+      }
+      if (input === shiftTab) {
+        focusPrevious();
+      }
+    };
+    internal_eventEmitter.on("input", handleTabNavigation);
+    const emitter = internal_eventEmitter;
+    return () => {
+      emitter.off("input", handleTabNavigation);
+    };
+  }, [isFocusEnabled, focusNext, focusPrevious, internal_eventEmitter]);
+  const enableFocus = useCallback(() => {
+    setIsFocusEnabled(true);
+  }, []);
+  const disableFocus = useCallback(() => {
+    setIsFocusEnabled(false);
+  }, []);
+  const focus = useCallback((id) => {
+    setFocusables((currentFocusables) => {
+      const hasFocusableId = currentFocusables.some((focusable) => focusable?.id === id);
+      if (hasFocusableId) {
+        setActiveFocusId(id);
+      }
+      return currentFocusables;
+    });
+  }, []);
+  const addFocusable = useCallback((id, { autoFocus }) => {
+    setFocusables((currentFocusables) => {
+      focusablesCountRef.current = currentFocusables.length + 1;
+      return [
+        ...currentFocusables,
+        {
+          id,
+          isActive: true
+        }
+      ];
+    });
+    if (autoFocus) {
+      setActiveFocusId((currentActiveFocusId) => {
+        if (!currentActiveFocusId) {
+          return id;
+        }
+        return currentActiveFocusId;
+      });
+    }
+  }, []);
+  const removeFocusable = useCallback((id) => {
+    setActiveFocusId((currentActiveFocusId) => {
+      if (currentActiveFocusId === id) {
+        return void 0;
+      }
+      return currentActiveFocusId;
+    });
+    setFocusables((currentFocusables) => {
+      const filtered = currentFocusables.filter((focusable) => focusable.id !== id);
+      focusablesCountRef.current = filtered.length;
+      return filtered;
+    });
+  }, []);
+  const activateFocusable = useCallback((id) => {
+    setFocusables(
+      (currentFocusables) => currentFocusables.map((focusable) => {
+        if (focusable.id !== id) {
+          return focusable;
+        }
+        return {
+          id,
+          isActive: true
+        };
+      })
+    );
+  }, []);
+  const deactivateFocusable = useCallback((id) => {
+    setActiveFocusId((currentActiveFocusId) => {
+      if (currentActiveFocusId === id) {
+        return void 0;
+      }
+      return currentActiveFocusId;
+    });
+    setFocusables(
+      (currentFocusables) => currentFocusables.map((focusable) => {
+        if (focusable.id !== id) {
+          return focusable;
+        }
+        return {
+          id,
+          isActive: false
+        };
+      })
+    );
+  }, []);
+  useEffect(
+    () => () => {
+      const canWriteToStdout = !stdout.destroyed && !stdout.writableEnded;
+      if (interactive && canWriteToStdout) {
+        stdout.write(cursorShow);
+      }
+      if (isRawModeSupported && rawModeEnabledCount.current > 0) {
+        disableRawMode();
+      }
+      if (bracketedPasteModeEnabledCount.current > 0) {
+        if (stdout.isTTY && canWriteToStdout) {
+          stdout.write("\x1B[?2004l");
+        }
+        bracketedPasteModeEnabledCount.current = 0;
+      }
+    },
+    [stdout, isRawModeSupported, disableRawMode, interactive]
+  );
+  const appContextValue = useMemo(() => {
+    return {
+      exit: handleExit,
+      waitUntilRenderFlush: onWaitUntilRenderFlush
+    };
+  }, [handleExit, onWaitUntilRenderFlush]);
+  const stdinContextValue = useMemo(() => {
+    return {
+      internal_eventEmitter,
+      internal_exitOnCtrlC: exitOnCtrlC,
+      isRawModeSupported,
+      setBracketedPasteMode: handleSetBracketedPasteMode,
+      setRawMode: handleSetRawMode,
+      stdin
+    };
+  }, [stdin, handleSetRawMode, handleSetBracketedPasteMode, isRawModeSupported, exitOnCtrlC, internal_eventEmitter]);
+  const stdoutContextValue = useMemo(
+    () => {
+      return {
+        stdout,
+        write: writeToStdout
+      };
+    },
+    [stdout, writeToStdout]
+  );
+  const stderrContextValue = useMemo(
+    () => {
+      return {
+        stderr,
+        write: writeToStderr
+      };
+    },
+    [stderr, writeToStderr]
+  );
+  const cursorContextValue = useMemo(
+    () => {
+      return {
+        setCursorPosition
+      };
+    },
+    [setCursorPosition]
+  );
+  const focusContextValue = useMemo(() => {
+    return {
+      activate: activateFocusable,
+      activeId: activeFocusId,
+      add: addFocusable,
+      deactivate: deactivateFocusable,
+      disableFocus,
+      enableFocus,
+      focus,
+      focusNext,
+      focusPrevious,
+      remove: removeFocusable
+    };
+  }, [activeFocusId, addFocusable, removeFocusable, activateFocusable, deactivateFocusable, enableFocus, disableFocus, focusNext, focusPrevious, focus]);
+  const animationContextValue = useMemo(
+    () => ({
+      renderThrottleMs,
+      subscribe: animationSubscribe
+    }),
+    [animationSubscribe, renderThrottleMs]
+  );
+  return jsx(AppContext.Provider, { value: appContextValue, children: jsx(StdinContext.Provider, { value: stdinContextValue, children: jsx(StdoutContext.Provider, { value: stdoutContextValue, children: jsx(StderrContext.Provider, { value: stderrContextValue, children: jsx(FocusContext.Provider, { value: focusContextValue, children: jsx(animationContext.Provider, { value: animationContextValue, children: jsx(CursorContext.Provider, { value: cursorContextValue, children: jsx(ErrorBoundary, { onError: handleExit, children }) }) }) }) }) }) }) });
+};
+App.displayName = "InternalApp";
+
+const showCursorEscape = "\x1B[?25h";
+const hideCursorEscape = "\x1B[?25l";
+const cursorPositionChanged = (a, b) => a?.x !== b?.x || a?.y !== b?.y;
+const buildCursorSuffix = (visibleLineCount, cursorPosition) => {
+  if (!cursorPosition) {
+    return "";
+  }
+  const moveUp = visibleLineCount - cursorPosition.y;
+  return (moveUp > 0 ? cursorUp(moveUp) : "") + cursorTo(cursorPosition.x) + showCursorEscape;
+};
+const buildReturnToBottom = (previousLineCount, previousCursorPosition) => {
+  if (!previousCursorPosition) {
+    return "";
+  }
+  const down = previousLineCount - 1 - previousCursorPosition.y;
+  return (down > 0 ? cursorDown(down) : "") + cursorTo(0);
+};
+const buildCursorOnlySequence = (input) => {
+  const hidePrefix = input.cursorWasShown ? hideCursorEscape : "";
+  const returnToBottom = buildReturnToBottom(input.previousLineCount, input.previousCursorPosition);
+  const cursorSuffix = buildCursorSuffix(input.visibleLineCount, input.cursorPosition);
+  return hidePrefix + returnToBottom + cursorSuffix;
+};
+const buildReturnToBottomPrefix = (cursorWasShown, previousLineCount, previousCursorPosition) => {
+  if (!cursorWasShown) {
+    return "";
+  }
+  return hideCursorEscape + buildReturnToBottom(previousLineCount, previousCursorPosition);
+};
+
+const instances = /* @__PURE__ */ new WeakMap();
+
+const visibleLineCount = (lines, string_) => string_.endsWith("\n") ? lines.length - 1 : lines.length;
+const getViewportRows = (stream) => stream.rows || Infinity;
+const clampToViewport = (lineCount, stream) => Math.min(lineCount, getViewportRows(stream));
+const createStandard = (stream, { showCursor = false } = {}) => {
+  let previousLineCount = 0;
+  let previousOutput = "";
+  let hasHiddenCursor = false;
+  let cursorPosition;
+  let cursorDirty = false;
+  let previousCursorPosition;
+  let cursorWasShown = false;
+  const getActiveCursor = () => cursorDirty ? cursorPosition : void 0;
+  const hasChanges = (string_, activeCursor) => {
+    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+    return string_ !== previousOutput || cursorChanged;
+  };
+  const render = (string_) => {
+    if (!showCursor && !hasHiddenCursor) {
+      stream.write(cursorHide);
+      hasHiddenCursor = true;
+    }
+    const activeCursor = getActiveCursor();
+    cursorDirty = false;
+    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+    if (!hasChanges(string_, activeCursor)) {
+      return false;
+    }
+    const lines = string_.split("\n");
+    const visibleCount = visibleLineCount(lines, string_);
+    const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+    if (string_ === previousOutput && cursorChanged) {
+      stream.write(
+        buildCursorOnlySequence({
+          cursorPosition: activeCursor,
+          cursorWasShown,
+          previousCursorPosition,
+          previousLineCount,
+          visibleLineCount: visibleCount
+        })
+      );
+    } else {
+      previousOutput = string_;
+      const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
+      stream.write(returnPrefix + eraseLines(clampToViewport(previousLineCount, stream)) + string_ + cursorSuffix);
+      previousLineCount = lines.length;
+    }
+    previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+    cursorWasShown = activeCursor !== void 0;
+    return true;
+  };
+  render.clear = () => {
+    const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
+    stream.write(prefix + eraseLines(clampToViewport(previousLineCount, stream)));
+    previousOutput = "";
+    previousLineCount = 0;
+    previousCursorPosition = void 0;
+    cursorWasShown = false;
+  };
+  render.done = () => {
+    previousOutput = "";
+    previousLineCount = 0;
+    previousCursorPosition = void 0;
+    cursorWasShown = false;
+    if (!showCursor) {
+      stream.write(cursorShow);
+      hasHiddenCursor = false;
+    }
+  };
+  render.reset = () => {
+    previousOutput = "";
+    previousLineCount = 0;
+    previousCursorPosition = void 0;
+    cursorWasShown = false;
+  };
+  render.sync = (string_) => {
+    const activeCursor = cursorDirty ? cursorPosition : void 0;
+    cursorDirty = false;
+    const lines = string_.split("\n");
+    previousOutput = string_;
+    previousLineCount = lines.length;
+    if (!activeCursor && cursorWasShown) {
+      stream.write(hideCursorEscape);
+    }
+    if (activeCursor) {
+      stream.write(buildCursorSuffix(visibleLineCount(lines, string_), activeCursor));
+    }
+    previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+    cursorWasShown = activeCursor !== void 0;
+  };
+  render.setCursorPosition = (position) => {
+    cursorPosition = position;
+    cursorDirty = true;
+  };
+  render.isCursorDirty = () => cursorDirty;
+  render.willRender = (string_) => hasChanges(string_, getActiveCursor());
+  return render;
+};
+const createIncremental = (stream, { showCursor = false } = {}) => {
+  let previousLines = [];
+  let previousOutput = "";
+  let hasHiddenCursor = false;
+  let cursorPosition;
+  let cursorDirty = false;
+  let previousCursorPosition;
+  let cursorWasShown = false;
+  const getActiveCursor = () => cursorDirty ? cursorPosition : void 0;
+  const hasChanges = (string_, activeCursor) => {
+    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+    return string_ !== previousOutput || cursorChanged;
+  };
+  const render = (string_) => {
+    if (!showCursor && !hasHiddenCursor) {
+      stream.write(cursorHide);
+      hasHiddenCursor = true;
+    }
+    const activeCursor = getActiveCursor();
+    cursorDirty = false;
+    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+    if (!hasChanges(string_, activeCursor)) {
+      return false;
+    }
+    const nextLines = string_.split("\n");
+    const visibleCount = visibleLineCount(nextLines, string_);
+    const previousVisible = visibleLineCount(previousLines, previousOutput);
+    if (string_ === previousOutput && cursorChanged) {
+      stream.write(
+        buildCursorOnlySequence({
+          cursorPosition: activeCursor,
+          cursorWasShown,
+          previousCursorPosition,
+          previousLineCount: previousLines.length,
+          visibleLineCount: visibleCount
+        })
+      );
+      previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+      cursorWasShown = activeCursor !== void 0;
+      return true;
+    }
+    const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+    if (string_ === "\n" || previousOutput.length === 0) {
+      const cursorSuffix2 = buildCursorSuffix(visibleCount, activeCursor);
+      stream.write(returnPrefix + eraseLines(clampToViewport(previousLines.length, stream)) + string_ + cursorSuffix2);
+      cursorWasShown = activeCursor !== void 0;
+      previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+      previousOutput = string_;
+      previousLines = nextLines;
+      return true;
+    }
+    const hasTrailingNewline = string_.endsWith("\n");
+    const buffer = [returnPrefix];
+    const viewportRows = getViewportRows(stream);
+    if (visibleCount < previousVisible) {
+      const previousHadTrailingNewline = previousOutput.endsWith("\n");
+      const extraSlot = previousHadTrailingNewline ? 1 : 0;
+      buffer.push(eraseLines(Math.min(previousVisible - visibleCount + extraSlot, viewportRows)), cursorUp(Math.min(visibleCount, viewportRows - 1)));
+    } else {
+      buffer.push(cursorUp(Math.min(previousVisible - 1, viewportRows - 1)));
+    }
+    for (let i = 0; i < visibleCount; i++) {
+      const isLastLine = i === visibleCount - 1;
+      if (nextLines[i] === previousLines[i]) {
+        if (!isLastLine || hasTrailingNewline) {
+          buffer.push(cursorNextLine());
+        }
+        continue;
+      }
+      buffer.push(
+        cursorTo(0) + nextLines[i] + eraseLineEnd + (isLastLine && !hasTrailingNewline ? "" : "\n")
+      );
+    }
+    const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+    buffer.push(cursorSuffix);
+    stream.write(buffer.join(""));
+    cursorWasShown = activeCursor !== void 0;
+    previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+    previousOutput = string_;
+    previousLines = nextLines;
+    return true;
+  };
+  render.clear = () => {
+    const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+    stream.write(prefix + eraseLines(clampToViewport(previousLines.length, stream)));
+    previousOutput = "";
+    previousLines = [];
+    previousCursorPosition = void 0;
+    cursorWasShown = false;
+  };
+  render.done = () => {
+    previousOutput = "";
+    previousLines = [];
+    previousCursorPosition = void 0;
+    cursorWasShown = false;
+    if (!showCursor) {
+      stream.write(cursorShow);
+      hasHiddenCursor = false;
+    }
+  };
+  render.reset = () => {
+    previousOutput = "";
+    previousLines = [];
+    previousCursorPosition = void 0;
+    cursorWasShown = false;
+  };
+  render.sync = (string_) => {
+    const activeCursor = cursorDirty ? cursorPosition : void 0;
+    cursorDirty = false;
+    const lines = string_.split("\n");
+    previousOutput = string_;
+    previousLines = lines;
+    if (!activeCursor && cursorWasShown) {
+      stream.write(hideCursorEscape);
+    }
+    if (activeCursor) {
+      stream.write(buildCursorSuffix(visibleLineCount(lines, string_), activeCursor));
+    }
+    previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+    cursorWasShown = activeCursor !== void 0;
+  };
+  render.setCursorPosition = (position) => {
+    cursorPosition = position;
+    cursorDirty = true;
+  };
+  render.isCursorDirty = () => cursorDirty;
+  render.willRender = (string_) => hasChanges(string_, getActiveCursor());
+  return render;
+};
+const create = (stream, { incremental = false, showCursor = false } = {}) => {
+  if (incremental) {
+    return createIncremental(stream, { showCursor });
+  }
+  return createStandard(stream, { showCursor });
+};
+const logUpdate = { create };
+
+let cachedRendererClass;
+const getRendererClass = () => {
+  if (cachedRendererClass === false) {
+    return void 0;
+  }
+  if (cachedRendererClass !== void 0) {
+    return cachedRendererClass;
+  }
+  try {
+    const binding = require("../../index.js");
+    cachedRendererClass = binding.Renderer;
+    return cachedRendererClass;
+  } catch {
+    cachedRendererClass = false;
+    return void 0;
+  }
+};
+const createNative = (stream) => {
+  const RendererClass = getRendererClass();
+  if (!RendererClass) {
+    return void 0;
+  }
+  let renderer;
+  let currentWidth = 0;
+  let currentHeight = 0;
+  const ensureRenderer = (width, height) => {
+    if (!renderer || currentWidth !== width || currentHeight !== height) {
+      if (renderer) {
+        renderer.resize(width, height);
+      } else {
+        renderer = new RendererClass(width, height);
+      }
+      currentWidth = width;
+      currentHeight = height;
+    }
+  };
+  return {
+    clear() {
+      if (renderer) {
+        const blank = new Uint32Array(currentWidth * currentHeight * 2);
+        const defaultAttribute = 0 << 16 | 255 << 8 | 255;
+        for (let index = 0; index < blank.length; index += 2) {
+          blank[index] = 32;
+          blank[index + 1] = defaultAttribute;
+        }
+        renderer.render(blank);
+      }
+    },
+    destroy() {
+      renderer = void 0;
+    },
+    render(buffer, width, height) {
+      ensureRenderer(width, height);
+      if (!renderer) {
+        return;
+      }
+      if (stream.isTTY) {
+        renderer.writeRaw("\x1B[?2026h");
+      }
+      try {
+        renderer.render(buffer);
+      } finally {
+        if (stream.isTTY) {
+          renderer.writeRaw("\x1B[?2026l");
+        }
+      }
+    },
+    resize(width, height) {
+      ensureRenderer(width, height);
+    }
+  };
+};
+
+const bsu = "\x1B[?2026h";
+const esu = "\x1B[?2026l";
+function shouldSynchronize(stream, interactive) {
+  return "isTTY" in stream && stream.isTTY && (interactive ?? !isInCi);
+}
+
+if (!console.Console) {
+  console.Console = Console;
+}
+const noop = () => {
+};
+const yieldImmediate = async () => new Promise((resolve) => {
+  setImmediate(resolve);
+});
+const kittyQueryEscapeByte = 27;
+const kittyQueryOpenBracketByte = 91;
+const kittyQueryQuestionMarkByte = 63;
+const kittyQueryLetterByte = 117;
+const zeroByte = 48;
+const nineByte = 57;
+const isDigitByte = (byte) => byte >= zeroByte && byte <= nineByte;
+const matchKittyQueryResponse = (buffer, startIndex) => {
+  if (buffer[startIndex] !== kittyQueryEscapeByte || buffer[startIndex + 1] !== kittyQueryOpenBracketByte || buffer[startIndex + 2] !== kittyQueryQuestionMarkByte) {
+    return void 0;
+  }
+  let index = startIndex + 3;
+  const digitsStartIndex = index;
+  while (index < buffer.length && isDigitByte(buffer[index])) {
+    index++;
+  }
+  if (index === digitsStartIndex) {
+    return void 0;
+  }
+  if (index === buffer.length) {
+    return { state: "partial" };
+  }
+  if (buffer[index] === kittyQueryLetterByte) {
+    return { endIndex: index, state: "complete" };
+  }
+  return void 0;
+};
+const hasCompleteKittyQueryResponse = (buffer) => {
+  for (let index = 0; index < buffer.length; index++) {
+    const match = matchKittyQueryResponse(buffer, index);
+    if (match?.state === "complete") {
+      return true;
+    }
+  }
+  return false;
+};
+const stripKittyQueryResponsesAndTrailingPartial = (buffer) => {
+  const keptBytes = [];
+  let index = 0;
+  while (index < buffer.length) {
+    const match = matchKittyQueryResponse(buffer, index);
+    if (match?.state === "complete") {
+      index = match.endIndex + 1;
+      continue;
+    }
+    if (match?.state === "partial") {
+      break;
+    }
+    keptBytes.push(buffer[index]);
+    index++;
+  }
+  return keptBytes;
+};
+const shouldClearTerminalForFrame = ({
+  isTty,
+  isUnmounting,
+  nextOutputHeight,
+  previousOutputHeight,
+  viewportRows
+}) => {
+  if (!isTty) {
+    return false;
+  }
+  const hadPreviousFrame = previousOutputHeight > 0;
+  const wasFullscreen = previousOutputHeight >= viewportRows;
+  const wasOverflowing = previousOutputHeight > viewportRows;
+  const isOverflowing = nextOutputHeight > viewportRows;
+  const isLeavingFullscreen = wasFullscreen && nextOutputHeight < viewportRows;
+  const shouldClearOnUnmount = isUnmounting && wasFullscreen;
+  return (
+    // Overflowing frames still need full clear fallback.
+    wasOverflowing || isOverflowing && hadPreviousFrame || isLeavingFullscreen || shouldClearOnUnmount
+  );
+};
+const isErrorInput = (value) => value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
+const getWritableStreamState = (stdout) => {
+  const canWriteToStdout = !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true);
+  const hasWritableState = stdout._writableState !== void 0 || stdout.writableLength !== void 0;
+  return {
+    canWriteToStdout,
+    hasWritableState
+  };
+};
+const settleThrottle = (throttled, canWriteToStdout) => {
+  if (!throttled || typeof throttled.flush !== "function") {
+    return;
+  }
+  const throttledValue = throttled;
+  if (canWriteToStdout) {
+    throttledValue.flush();
+  } else if (typeof throttledValue.cancel === "function") {
+    throttledValue.cancel();
+  }
+};
+class Ink {
+  /**
+   * Whether this instance is using concurrent rendering mode.
+   */
+  isConcurrent;
+  options;
+  log;
+  manualCursorPosition;
+  renderedCursorPosition;
+  renderedCursorRequested;
+  throttledLog;
+  isScreenReaderEnabled;
+  interactive;
+  renderThrottleMs;
+  alternateScreen;
+  // Ignore last render after unmounting a tree to prevent empty output before exit
+  isUnmounted;
+  isUnmounting;
+  lastOutput;
+  lastOutputToRender;
+  lastOutputHeight;
+  lastTerminalWidth;
+  nativeLog;
+  useNativeRenderer;
+  container;
+  rootNode;
+  // This variable is used only in debug mode to store full static output
+  // so that it's rerendered every time, not just new static parts, like in non-debug mode
+  fullStaticOutput;
+  exitPromise;
+  exitResult;
+  beforeExitHandler;
+  restoreConsole;
+  unsubscribeResize;
+  throttledOnRender;
+  hasPendingThrottledRender = false;
+  kittyProtocolEnabled = false;
+  cancelKittyDetection;
+  nextRenderCommit;
+  deferredInitDone = false;
+  constructor(options) {
+    this.options = options;
+    this.rootNode = createNode("ink-root");
+    this.rootNode.onComputeLayout = this.calculateLayout;
+    this.isScreenReaderEnabled = options.isScreenReaderEnabled ?? process$2.env["INK_SCREEN_READER"] === "true";
+    this.interactive = this.resolveInteractiveOption(options.interactive);
+    this.alternateScreen = false;
+    const unthrottled = options.debug || this.isScreenReaderEnabled;
+    const maxFps = options.maxFps ?? 30;
+    const renderThrottleMs = maxFps > 0 ? Math.max(1, Math.ceil(1e3 / maxFps)) : 0;
+    this.renderThrottleMs = unthrottled ? 0 : renderThrottleMs;
+    const baseOnRender = unthrottled ? this.onRender : (() => {
+      const throttled = throttle(this.onRender, renderThrottleMs, {
+        leading: true,
+        trailing: true
+      });
+      this.throttledOnRender = throttled;
+      return () => {
+        this.hasPendingThrottledRender = true;
+        throttled();
+      };
+    })();
+    if (unthrottled) {
+      this.throttledOnRender = void 0;
+    }
+    if (options.standardReactLayoutTiming) {
+      let isRenderScheduled = false;
+      const deferredRender = () => {
+        if (isRenderScheduled) {
+          return;
+        }
+        isRenderScheduled = true;
+        queueMicrotask(() => {
+          isRenderScheduled = false;
+          this.onRender();
+        });
+      };
+      this.rootNode.onRender = deferredRender;
+      this.rootNode.onImmediateRender = deferredRender;
+    } else {
+      this.rootNode.onRender = baseOnRender;
+      this.rootNode.onImmediateRender = this.onRender;
+    }
+    this.log = logUpdate.create(options.stdout, {
+      incremental: options.incrementalRendering
+    });
+    this.useNativeRenderer = options.useNativeRenderer ?? false;
+    if (this.useNativeRenderer) {
+      this.nativeLog = createNative(options.stdout);
+      if (!this.nativeLog) {
+        this.useNativeRenderer = false;
+      }
+    }
+    this.manualCursorPosition = void 0;
+    this.renderedCursorPosition = void 0;
+    this.renderedCursorRequested = false;
+    this.throttledLog = unthrottled ? this.log : throttle(
+      (output) => {
+        const shouldWrite = this.log.willRender(output);
+        const sync = this.shouldSync();
+        if (sync && shouldWrite) {
+          this.options.stdout.write(bsu);
+        }
+        this.log(output);
+        if (sync && shouldWrite) {
+          this.options.stdout.write(esu);
+        }
+      },
+      void 0,
+      {
+        leading: true,
+        trailing: true
+      }
+    );
+    this.isUnmounted = false;
+    this.isUnmounting = false;
+    this.isConcurrent = options.concurrent ?? false;
+    this.lastOutput = "";
+    this.lastOutputToRender = "";
+    this.lastOutputHeight = 0;
+    this.lastTerminalWidth = getWindowSize(this.options.stdout).columns;
+    this.fullStaticOutput = "";
+    const rootTag = options.concurrent ? ConcurrentRoot : LegacyRoot;
+    this.container = reconcilerInstance.createContainer(
+      this.rootNode,
+      rootTag,
+      null,
+      false,
+      null,
+      "id",
+      () => {
+      },
+      () => {
+      },
+      () => {
+      },
+      () => {
+      }
+    );
+    this.unsubscribeExit = onExit(this.unmount, { alwaysLast: false });
+    this.setAlternateScreen(Boolean(options.alternateScreen));
+    if (options.patchConsole) {
+      this.patchConsole();
+    }
+    if (this.interactive) {
+      options.stdout.on("resize", this.resized);
+      this.unsubscribeResize = () => {
+        options.stdout.off("resize", this.resized);
+      };
+    }
+    this.initImmediateKittyKeyboard();
+    if (process$2.env["DEV"] === "true") {
+      reconcilerInstance.injectIntoDevTools();
+    }
+    this.exitPromise = new Promise((resolve, reject) => {
+      this.resolveExitPromise = resolve;
+      this.rejectExitPromise = reject;
+    });
+    void this.exitPromise.catch(noop);
+  }
+  /**
+   * Perform deferred initialization on the first render frame.
+   * Kitty keyboard auto-detection is deferred here because the CSI ? u
+   * query sets up a synchronous stdin listener with a 200ms timeout.
+   * "enabled" mode runs immediately in the constructor (it's just a write).
+   */
+  runDeferredInit() {
+    if (this.deferredInitDone) {
+      return;
+    }
+    this.deferredInitDone = true;
+    this.initDeferredKittyKeyboard();
+  }
+  resized = () => {
+    const currentWidth = getWindowSize(this.options.stdout).columns;
+    if (currentWidth < this.lastTerminalWidth) {
+      this.log.clear();
+      this.lastOutput = "";
+      this.lastOutputToRender = "";
+    }
+    clearStyledLineCache();
+    this.calculateLayout();
+    this.onRender();
+    this.lastTerminalWidth = currentWidth;
+  };
+  resolveExitPromise = () => {
+  };
+  rejectExitPromise = () => {
+  };
+  unsubscribeExit = () => {
+  };
+  handleAppExit = (errorOrResult) => {
+    if (this.isUnmounted || this.isUnmounting) {
+      return;
+    }
+    if (isErrorInput(errorOrResult)) {
+      this.unmount(errorOrResult);
+      return;
+    }
+    this.exitResult = errorOrResult;
+    this.unmount();
+  };
+  getActiveCursorPosition = () => {
+    if (this.renderedCursorRequested) {
+      return this.renderedCursorPosition;
+    }
+    return this.manualCursorPosition;
+  };
+  setCursorPosition = (position) => {
+    this.manualCursorPosition = position;
+    this.log.setCursorPosition(this.getActiveCursorPosition());
+  };
+  restoreLastOutput = () => {
+    if (!this.interactive) {
+      return;
+    }
+    this.log.setCursorPosition(this.getActiveCursorPosition());
+    this.log(this.lastOutputToRender || `${this.lastOutput}
+`);
+  };
+  calculateLayout = () => {
+    const flushLayoutObservers = (node) => {
+      const observerEntries = /* @__PURE__ */ new Map();
+      this.calculateScrollAndTriggerObservers(node, observerEntries);
+      for (const [observer, entries] of observerEntries) {
+        observer.internalTrigger(entries);
+      }
+    };
+    this.prepareYogaTree(this.rootNode, flushLayoutObservers);
+    const terminalWidth = getWindowSize(this.options.stdout).columns;
+    this.rootNode.yogaNode.setWidth(terminalWidth);
+    this.rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+    flushLayoutObservers(this.rootNode);
+  };
+  calculateScrollAndTriggerObservers(node, observerEntries) {
+    if (node.nodeName === "ink-box") {
+      const { style } = node;
+      const overflow = style.overflow ?? "visible";
+      const overflowX = style.overflowX ?? overflow;
+      const overflowY = style.overflowY ?? overflow;
+      if (overflowX === "scroll" || overflowY === "scroll") {
+        calculateScroll(node);
+      } else if (node.internal_scrollState) {
+        delete node.internal_scrollState;
+      }
+    }
+    measureAndExtractObservers(node, observerEntries);
+    if (node.internal_static) {
+      return;
+    }
+    for (const child of node.childNodes) {
+      if (child.nodeName !== "#text") {
+        this.calculateScrollAndTriggerObservers(child, observerEntries);
+      }
+    }
+  }
+  /**
+   * Force a full layout recalculation by marking all text nodes dirty.
+   * Useful when the string width function changes or terminal font changes.
+   */
+  recalculateLayout() {
+    this.markAllTextNodesDirty(this.rootNode);
+    this.calculateLayout();
+    this.onRender();
+  }
+  /**
+   * Walk the DOM tree before Yoga layout to handle StaticRender nodes:
+   * - Re-attach Yoga children if a cached render was invalidated
+   * - Pre-render ink-static-render nodes that don't have a cached render yet
+   */
+  prepareYogaTree(node, flushLayoutObservers) {
+    if (node.isYogaTreeDetached && !node.cachedRender && node.yogaNode) {
+      node.yogaNode.setWidthAuto();
+      node.yogaNode.setHeightAuto();
+      styles(node.yogaNode, node.style);
+      while (node.yogaNode.getChildCount() > 0) {
+        node.yogaNode.removeChild(node.yogaNode.getChild(0));
+      }
+      let yogaIndex = 0;
+      for (const child of node.childNodes) {
+        const domChild = child;
+        if (child.nodeName !== "#text" && domChild.yogaNode) {
+          node.yogaNode.insertChild(domChild.yogaNode, yogaIndex);
+          yogaIndex++;
+        }
+      }
+      node.isYogaTreeDetached = false;
+      this.markAllTextNodesDirty(node);
+    }
+    for (const child of node.childNodes) {
+      if (child.nodeName !== "#text") {
+        this.prepareYogaTree(child, flushLayoutObservers);
+      }
+    }
+    if (node.nodeName === "ink-static-render" && !node.cachedRender) {
+      const terminalWidth = getWindowSize(this.options.stdout).columns;
+      const { width } = node.style;
+      if (node.yogaNode) {
+        node.yogaNode.setWidth(typeof width === "number" ? width : terminalWidth);
+        node.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+      }
+      flushLayoutObservers(node);
+      renderToStatic(node, {
+        skipStaticElements: false});
+      node.internal_onRendered?.();
+    }
+  }
+  markAllTextNodesDirty(node) {
+    if (node.cachedRender) {
+      return;
+    }
+    if (node.nodeName === "ink-text" && node.yogaNode) {
+      node.yogaNode.markDirty();
+    }
+    for (const child of node.childNodes) {
+      if (child.nodeName !== "#text") {
+        this.markAllTextNodesDirty(child);
+      }
+    }
+  }
+  onRender = () => {
+    this.hasPendingThrottledRender = false;
+    if (this.isUnmounted) {
+      return;
+    }
+    if (!this.deferredInitDone) {
+      this.runDeferredInit();
+    }
+    if (this.nextRenderCommit) {
+      this.nextRenderCommit.resolve();
+      this.nextRenderCommit = void 0;
+    }
+    const renderResult = renderer(this.rootNode, this.isScreenReaderEnabled, {
+      useNativeRenderer: this.useNativeRenderer
+    });
+    const { cursorPosition, cursorRequested, output, outputBuffer, outputHeight, outputWidth, staticOutput } = renderResult;
+    this.renderedCursorRequested = cursorRequested;
+    this.renderedCursorPosition = cursorPosition;
+    if (this.useNativeRenderer && this.nativeLog && outputBuffer && outputWidth) {
+      if (staticOutput && staticOutput !== "\n") {
+        this.options.stdout.write(staticOutput);
+      }
+      this.nativeLog.render(outputBuffer, outputWidth, outputHeight);
+      this.lastOutputHeight = outputHeight;
+      return;
+    }
+    if (cursorRequested) {
+      this.log.setCursorPosition(this.getActiveCursorPosition());
+    }
+    const hasStaticOutput = staticOutput && staticOutput !== "\n";
+    if (this.options.debug) {
+      if (hasStaticOutput) {
+        this.fullStaticOutput += staticOutput;
+      }
+      this.lastOutput = output;
+      this.lastOutputToRender = output;
+      this.lastOutputHeight = outputHeight;
+      this.options.stdout.write(this.fullStaticOutput + output);
+      return;
+    }
+    if (!this.interactive) {
+      if (hasStaticOutput) {
+        this.options.stdout.write(staticOutput);
+      }
+      this.lastOutput = output;
+      this.lastOutputToRender = `${output}
+`;
+      this.lastOutputHeight = outputHeight;
+      return;
+    }
+    if (this.isScreenReaderEnabled) {
+      const sync = this.shouldSync();
+      if (sync) {
+        this.options.stdout.write(bsu);
+      }
+      if (hasStaticOutput) {
+        const erase = this.lastOutputHeight > 0 ? eraseLines(this.lastOutputHeight) : "";
+        this.options.stdout.write(erase + staticOutput);
+        this.lastOutputHeight = 0;
+      }
+      if (output === this.lastOutput && !hasStaticOutput) {
+        if (sync) {
+          this.options.stdout.write(esu);
+        }
+        return;
+      }
+      const terminalWidth = getWindowSize(this.options.stdout).columns;
+      const wrappedOutput = wordWrap(output, {
+        trim: false,
+        width: terminalWidth,
+        wrapMode: "BREAK_WORDS"
+      }).replace(/\n$/, "");
+      if (hasStaticOutput) {
+        this.options.stdout.write(wrappedOutput);
+      } else {
+        const erase = this.lastOutputHeight > 0 ? eraseLines(this.lastOutputHeight) : "";
+        this.options.stdout.write(erase + wrappedOutput);
+      }
+      this.lastOutput = output;
+      this.lastOutputToRender = wrappedOutput;
+      this.lastOutputHeight = wrappedOutput === "" ? 0 : wrappedOutput.split("\n").length;
+      if (sync) {
+        this.options.stdout.write(esu);
+      }
+      return;
+    }
+    if (hasStaticOutput) {
+      this.fullStaticOutput += staticOutput;
+    }
+    this.renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : "");
+  };
+  // Cache AccessibilityContext value to avoid creating a new object
+  // on every render() call, which would force all consumers to re-render.
+  accessibilityContextValue;
+  render(node) {
+    this.accessibilityContextValue ??= { isScreenReaderEnabled: this.isScreenReaderEnabled };
+    const tree = jsx(accessibilityContext.Provider, { value: this.accessibilityContextValue, children: jsx(
+      App,
+      {
+        exitOnCtrlC: this.options.exitOnCtrlC,
+        interactive: this.interactive,
+        onExit: this.handleAppExit,
+        onWaitUntilRenderFlush: this.waitUntilRenderFlush,
+        renderThrottleMs: this.renderThrottleMs,
+        setCursorPosition: this.setCursorPosition,
+        stderr: this.options.stderr,
+        stdin: this.options.stdin,
+        stdout: this.options.stdout,
+        writeToStderr: this.writeToStderr,
+        writeToStdout: this.writeToStdout,
+        children: node
+      }
+    ) });
+    if (this.options.concurrent) {
+      reconcilerInstance.updateContainer(tree, this.container, null, noop);
+    } else {
+      reconcilerInstance.updateContainerSync(tree, this.container, null, noop);
+      reconcilerInstance.flushSyncWork();
+    }
+  }
+  writeToStdout = (data) => {
+    if (this.isUnmounted) {
+      return;
+    }
+    if (this.options.debug) {
+      this.options.stdout.write(data + this.fullStaticOutput + this.lastOutput);
+      return;
+    }
+    if (!this.interactive) {
+      this.options.stdout.write(data);
+      return;
+    }
+    const sync = this.shouldSync();
+    if (sync) {
+      this.options.stdout.write(bsu);
+    }
+    this.log.clear();
+    this.options.stdout.write(data);
+    this.restoreLastOutput();
+    if (sync) {
+      this.options.stdout.write(esu);
+    }
+  };
+  writeToStderr = (data) => {
+    if (this.isUnmounted) {
+      return;
+    }
+    if (this.options.debug) {
+      this.options.stderr.write(data);
+      this.options.stdout.write(this.fullStaticOutput + this.lastOutput);
+      return;
+    }
+    if (!this.interactive) {
+      this.options.stderr.write(data);
+      return;
+    }
+    const sync = this.shouldSync();
+    if (sync) {
+      this.options.stdout.write(bsu);
+    }
+    this.log.clear();
+    this.options.stderr.write(data);
+    this.restoreLastOutput();
+    if (sync) {
+      this.options.stdout.write(esu);
+    }
+  };
+  unmount = (error) => {
+    if (this.isUnmounted || this.isUnmounting) {
+      return;
+    }
+    this.isUnmounting = true;
+    if (this.beforeExitHandler) {
+      process$2.off("beforeExit", this.beforeExitHandler);
+      this.beforeExitHandler = void 0;
+    }
+    const stdout = this.options.stdout;
+    const { canWriteToStdout, hasWritableState } = getWritableStreamState(stdout);
+    settleThrottle(this.throttledOnRender, canWriteToStdout);
+    if (canWriteToStdout && !this.alternateScreen) {
+      const shouldRenderFinalFrame = !this.throttledOnRender || !this.hasPendingThrottledRender && this.fullStaticOutput === "";
+      if (shouldRenderFinalFrame) {
+        this.calculateLayout();
+        this.onRender();
+      }
+    }
+    this.isUnmounted = true;
+    this.unsubscribeExit();
+    settleThrottle(this.throttledLog, canWriteToStdout);
+    if (typeof this.restoreConsole === "function") {
+      this.restoreConsole();
+    }
+    const finishUnmount = () => {
+      if (typeof this.unsubscribeResize === "function") {
+        this.unsubscribeResize();
+      }
+      if (this.cancelKittyDetection) {
+        this.cancelKittyDetection();
+      }
+      if (canWriteToStdout) {
+        if (this.kittyProtocolEnabled) {
+          this.writeBestEffort(this.options.stdout, "\x1B[<u");
+        }
+        if (this.alternateScreen) {
+          this.log.clear();
+          this.log.done();
+          this.lastOutput = "";
+          this.lastOutputToRender = "";
+          this.lastOutputHeight = 0;
+          this.fullStaticOutput = "";
+          this.writeBestEffort(this.options.stdout, ALT_SCREEN_OFF);
+          this.writeBestEffort(this.options.stdout, showCursorEscape);
+          this.alternateScreen = false;
+        } else if (!this.interactive) {
+          this.options.stdout.write(this.options.debug ? "\n" : `${this.lastOutput}
+`);
+        } else if (!this.options.debug) {
+          this.log.done();
+        }
+      }
+      this.kittyProtocolEnabled = false;
+      instances.delete(this.options.stdout);
+      const { exitResult } = this;
+      const resolveOrReject = () => {
+        if (isErrorInput(error)) {
+          this.rejectExitPromise(error);
+        } else {
+          this.resolveExitPromise(exitResult);
+        }
+      };
+      const isProcessExiting = error !== void 0 && !isErrorInput(error);
+      if (isProcessExiting) {
+        resolveOrReject();
+      } else if (canWriteToStdout && hasWritableState) {
+        this.options.stdout.write("", resolveOrReject);
+      } else {
+        setImmediate(resolveOrReject);
+      }
+    };
+    const concurrentReconciler = reconcilerInstance;
+    if (this.options.concurrent) {
+      reconcilerInstance.updateContainerSync(null, this.container, null, noop);
+      reconcilerInstance.flushSyncWork();
+      concurrentReconciler.flushPassiveEffects?.();
+      finishUnmount();
+    } else {
+      reconcilerInstance.updateContainerSync(null, this.container, null, noop);
+      reconcilerInstance.flushSyncWork();
+      finishUnmount();
+    }
+  };
+  async waitUntilExit() {
+    if (!this.beforeExitHandler) {
+      this.beforeExitHandler = () => {
+        this.unmount();
+      };
+      process$2.on("beforeExit", this.beforeExitHandler);
+    }
+    return this.exitPromise;
+  }
+  async waitUntilRenderFlush() {
+    if (this.isUnmounted || this.isUnmounting) {
+      await this.awaitExit();
+      return;
+    }
+    await yieldImmediate();
+    if (this.isUnmounted || this.isUnmounting) {
+      await this.awaitExit();
+      return;
+    }
+    if (this.isConcurrent && this.hasPendingConcurrentWork()) {
+      await Promise.race([this.awaitNextRender(), this.awaitExit()]);
+      if (this.isUnmounted || this.isUnmounting) {
+        this.nextRenderCommit = void 0;
+        await this.awaitExit();
+        return;
+      }
+    }
+    reconcilerInstance.flushSyncWork();
+    const stdout = this.options.stdout;
+    const { canWriteToStdout, hasWritableState } = getWritableStreamState(stdout);
+    settleThrottle(this.throttledOnRender, canWriteToStdout);
+    settleThrottle(this.throttledLog, canWriteToStdout);
+    if (canWriteToStdout && hasWritableState) {
+      await new Promise((resolve) => {
+        this.options.stdout.write("", () => {
+          resolve();
+        });
+      });
+      return;
+    }
+    await yieldImmediate();
+  }
+  clear() {
+    if (this.interactive && !this.options.debug) {
+      this.log.clear();
+      this.log.sync(this.lastOutputToRender || `${this.lastOutput}
+`);
+    }
+  }
+  patchConsole() {
+    if (this.options.debug) {
+      return;
+    }
+    this.restoreConsole = patchConsole((stream, data) => {
+      if (stream === "stdout") {
+        this.writeToStdout(data);
+      }
+      if (stream === "stderr") {
+        const isReactMessage = data.startsWith("The above error occurred");
+        if (!isReactMessage) {
+          this.writeToStderr(data);
+        }
+      }
+    });
+  }
+  setAlternateScreen(enabled) {
+    this.alternateScreen = this.resolveAlternateScreenOption(enabled, this.interactive);
+    if (this.alternateScreen) {
+      this.writeBestEffort(this.options.stdout, ALT_SCREEN_ON);
+      this.writeBestEffort(this.options.stdout, hideCursorEscape);
+    }
+  }
+  resolveInteractiveOption(interactive) {
+    return interactive ?? (!isInCi && Boolean(this.options.stdout.isTTY));
+  }
+  resolveAlternateScreenOption(alternateScreen, interactive) {
+    return Boolean(alternateScreen) && interactive && Boolean(this.options.stdout.isTTY);
+  }
+  shouldSync() {
+    return shouldSynchronize(this.options.stdout, this.interactive);
+  }
+  // Best-effort write: streams may already be destroyed during shutdown.
+  writeBestEffort(stream, data) {
+    try {
+      stream.write(data);
+    } catch {
+    }
+  }
+  // Waits for the exit promise to settle, suppressing any rejection.
+  // Errors are surfaced via waitUntilExit() instead.
+  async awaitExit() {
+    try {
+      await this.exitPromise;
+    } catch {
+    }
+  }
+  hasPendingConcurrentWork() {
+    const concurrentContainer = this.container;
+    return (concurrentContainer.pendingLanes ?? 0) !== 0 && concurrentContainer.callbackNode !== void 0 && concurrentContainer.callbackNode !== null;
+  }
+  async awaitNextRender() {
+    if (!this.nextRenderCommit) {
+      let resolveRender;
+      const promise = new Promise((resolve) => {
+        resolveRender = resolve;
+      });
+      this.nextRenderCommit = { promise, resolve: resolveRender };
+    }
+    return this.nextRenderCommit.promise;
+  }
+  renderInteractiveFrame(output, outputHeight, staticOutput) {
+    const hasStaticOutput = staticOutput !== "";
+    const isTty = this.options.stdout.isTTY;
+    const viewportRows = isTty ? getWindowSize(this.options.stdout).rows : 24;
+    const isFullscreen = isTty && outputHeight >= viewportRows;
+    const outputToRender = isFullscreen ? output : `${output}
+`;
+    const shouldClearTerminal = shouldClearTerminalForFrame({
+      isTty,
+      isUnmounting: this.isUnmounting,
+      nextOutputHeight: outputHeight,
+      previousOutputHeight: this.lastOutputHeight,
+      viewportRows
+    });
+    if (shouldClearTerminal) {
+      if (this.options.incrementalRendering) {
+        if (hasStaticOutput) {
+          this.log.clear();
+          this.options.stdout.write(staticOutput);
+        }
+        if (output !== this.lastOutput || this.log.isCursorDirty() || hasStaticOutput) {
+          this.throttledLog(outputToRender);
+        }
+        this.lastOutput = output;
+        this.lastOutputToRender = outputToRender;
+        this.lastOutputHeight = outputHeight;
+        return;
+      }
+      const sync = this.shouldSync();
+      if (sync) {
+        this.options.stdout.write(bsu);
+      }
+      this.options.stdout.write(resetTerminal + this.fullStaticOutput + output);
+      this.lastOutput = output;
+      this.lastOutputToRender = outputToRender;
+      this.lastOutputHeight = outputHeight;
+      this.log.sync(outputToRender);
+      if (sync) {
+        this.options.stdout.write(esu);
+      }
+      return;
+    }
+    if (hasStaticOutput) {
+      const sync = this.shouldSync();
+      if (sync) {
+        this.options.stdout.write(bsu);
+      }
+      this.log.clear();
+      this.options.stdout.write(staticOutput);
+      this.log(outputToRender);
+      if (sync) {
+        this.options.stdout.write(esu);
+      }
+    } else if (output !== this.lastOutput || this.log.isCursorDirty()) {
+      this.throttledLog(outputToRender);
+    }
+    this.lastOutput = output;
+    this.lastOutputToRender = outputToRender;
+    this.lastOutputHeight = outputHeight;
+  }
+  /**
+   * Handle kitty keyboard "enabled" mode immediately (just a stdout.write).
+   * Called from the constructor.
+   */
+  initImmediateKittyKeyboard() {
+    if (!this.options.kittyKeyboard) {
+      return;
+    }
+    const options = this.options.kittyKeyboard;
+    const mode = options.mode ?? "auto";
+    if (mode !== "enabled") {
+      return;
+    }
+    const flags = options.flags ?? ["disambiguateEscapeCodes"];
+    if (this.options.stdin.isTTY && this.options.stdout.isTTY) {
+      this.enableKittyProtocol(flags);
+    }
+  }
+  /**
+   * Handle kitty keyboard "auto" mode detection. Deferred to first render
+   * because the CSI ? u query sets up a stdin listener with a 200ms timeout.
+   */
+  initDeferredKittyKeyboard() {
+    if (!this.options.kittyKeyboard) {
+      return;
+    }
+    const options = this.options.kittyKeyboard;
+    const mode = options.mode ?? "auto";
+    if (mode !== "auto") {
+      return;
+    }
+    const flags = options.flags ?? ["disambiguateEscapeCodes"];
+    if (!this.interactive || !this.options.stdin.isTTY || !this.options.stdout.isTTY) {
+      return;
+    }
+    this.confirmKittySupport(flags);
+  }
+  confirmKittySupport(flags) {
+    const { stdin, stdout } = this.options;
+    let responseBuffer = [];
+    const cleanup = () => {
+      this.cancelKittyDetection = void 0;
+      clearTimeout(timer);
+      stdin.removeListener("data", onData);
+      const remaining = stripKittyQueryResponsesAndTrailingPartial(responseBuffer);
+      responseBuffer = [];
+      if (remaining.length > 0) {
+        stdin.unshift(Buffer.from(remaining));
+      }
+    };
+    const onData = (data) => {
+      const chunk = typeof data === "string" ? Buffer.from(data) : data;
+      for (const byte of chunk) {
+        responseBuffer.push(byte);
+      }
+      if (hasCompleteKittyQueryResponse(responseBuffer)) {
+        cleanup();
+        if (!this.isUnmounted) {
+          this.enableKittyProtocol(flags);
+        }
+      }
+    };
+    stdin.on("data", onData);
+    const timer = setTimeout(cleanup, 200);
+    this.cancelKittyDetection = cleanup;
+    stdout.write("\x1B[?u");
+  }
+  enableKittyProtocol(flags) {
+    this.options.stdout.write(`\x1B[>${resolveFlags(flags)}u`);
+    this.kittyProtocolEnabled = true;
+  }
+}
+
+const render = (node, options) => {
+  const inkOptions = {
+    alternateScreen: false,
+    concurrent: false,
+    debug: false,
+    exitOnCtrlC: true,
+    incrementalRendering: false,
+    maxFps: 30,
+    patchConsole: true,
+    stderr: process$2.stderr,
+    stdin: process$2.stdin,
+    stdout: process$2.stdout,
+    ...getOptions(options)
+  };
+  const instance = getInstance(inkOptions.stdout, () => new Ink(inkOptions));
+  instance.render(node);
+  return {
+    cleanup() {
+      instance.unmount();
+    },
+    clear() {
+      instance.clear();
+    },
+    rerender(n) {
+      instance.render(n);
+    },
+    rootNode: instance.rootNode,
+    unmount() {
+      instance.unmount();
+    },
+    waitUntilExit() {
+      return instance.waitUntilExit();
+    },
+    waitUntilRenderFlush() {
+      return instance.waitUntilRenderFlush();
+    }
+  };
+};
+const getOptions = (stdout = {}) => {
+  if (stdout instanceof Stream) {
+    return {
+      stdin: process$2.stdin,
+      stdout
+    };
+  }
+  return stdout;
+};
+const getInstance = (stdout, createInstance) => {
+  const instance = instances.get(stdout);
+  if (instance === void 0) {
+    const newInstance = createInstance();
+    instances.set(stdout, newInstance);
+    return newInstance;
+  }
+  process$2.stderr.write(
+    "Warning: render() was called again for the same stdout before the previous Ink instance was unmounted. Reusing stdout across multiple render() calls is unsupported. Call unmount() first.\n"
+  );
+  return instance;
+};
+
+export { render as default };