@visulima/tui 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/render-BAwdjfki.js

@@ -1,2806 +0,0 @@
-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 };