@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.3

package/dist/index.js

@@ -0,0 +1,4652 @@
+import { At as esu, Ft as pasteStart, Pt as pasteEnd, b as wrapAnsi, ct as CSI, d as styledCharsFromTokens, f as styledCharsToString, g as chalk, h as widestLine, mt as bsu, n as sliceAnsi, p as tokenize, pt as ansiEscapes, t as cliTruncate, v as cliCursor, x as stringWidth, y as signalExit } from "./truncate-CBiyyZzw.js";
+import { t as Yoga } from "./yoga-5jKhYCJC.js";
+import process, { cwd } from "node:process";
+import { PassThrough, Stream } from "node:stream";
+import { ConcurrentRoot, DefaultEventPriority, LegacyRoot, NoEventPriority } from "react-reconciler/constants.js";
+import { PureComponent, createContext, forwardRef, useCallback, useContext, useEffect, useEffectEvent, useInsertionEffect, useLayoutEffect, useMemo, useRef, useState, version } from "react";
+import { EventEmitter } from "node:events";
+import * as fs$1 from "node:fs";
+import fs from "node:fs";
+import { jsx, jsxs } from "react/jsx-runtime";
+import tty from "node:tty";
+import { Console } from "node:console";
+import createReconciler from "react-reconciler";
+import * as Scheduler from "scheduler";
+//#region src/auto-bind.ts
+const getAllProperties = (object) => {
+	const properties = [];
+	let current = object;
+	do {
+		for (const key of Reflect.ownKeys(current)) properties.push([current, key]);
+		current = Reflect.getPrototypeOf(current);
+	} while (current && current !== Object.prototype);
+	return properties;
+};
+const autoBind = (self) => {
+	for (const [object, key] of getAllProperties(self.constructor.prototype)) {
+		if (key === "constructor") continue;
+		const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+		if (descriptor && typeof descriptor.value === "function") {
+			const value = self[key];
+			if (typeof value === "function") self[key] = value.bind(self);
+		}
+	}
+	return self;
+};
+//#endregion
+//#region src/components/AccessibilityContext.ts
+const accessibilityContext = createContext({ isScreenReaderEnabled: false });
+//#endregion
+//#region src/input-parser.ts
+const escape$1 = "\x1B";
+const isCsiParameterByte = (byte) => {
+	return byte >= 48 && byte <= 63;
+};
+const isCsiIntermediateByte = (byte) => {
+	return byte >= 32 && byte <= 47;
+};
+const isCsiFinalByte = (byte) => {
+	return 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 {
+			sequence: input.slice(startIndex, index + 1),
+			nextIndex: index + 1
+		};
+		return;
+	}
+	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;
+	return {
+		sequence: input.slice(startIndex, nextIndex),
+		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);
+};
+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 {
+		sequence: input.slice(escapeIndex, nextIndex),
+		nextIndex
+	};
+};
+const parseEscapeSequence = (input, escapeIndex) => {
+	if (escapeIndex === input.length - 1) return "pending";
+	if (input[escapeIndex + 1] === 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 {
+			sequence: input.slice(escapeIndex, escapeIndex + 2),
+			nextIndex: escapeIndex + 2
+		};
+	}
+	const controlSequence = parseControlSequence(input, escapeIndex, 1);
+	if (controlSequence === "pending") return "pending";
+	if (controlSequence) return controlSequence;
+	return parseEscapedCodePoint(input, escapeIndex);
+};
+/**
+Split a chunk of non-escape text so that backspace bytes (`0x7F` and `0x08`) become individual events. When a user holds the backspace key, the terminal sends repeated bytes in a single stdin chunk. Without splitting, `parseKeypress` receives the multi-byte string and fails to recognize it as a key event, corrupting the input state.
+
+Other control characters like `\r` and `\t` are NOT split because they can legitimately appear inside pasted text.
+*/
+const splitBackspaceBytes = (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) => ({
+		events,
+		pending: input.slice(pendingStartIndex)
+	});
+	while (index < input.length) {
+		const escapeIndex = input.indexOf(escape$1, index);
+		if (escapeIndex === -1) {
+			splitBackspaceBytes(input.slice(index), events);
+			return {
+				events,
+				pending: ""
+			};
+		}
+		if (escapeIndex > index) splitBackspaceBytes(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 {
+		push(chunk) {
+			const parsedInput = parseKeypresses(pending + chunk);
+			pending = parsedInput.pending;
+			return parsedInput.events;
+		},
+		hasPendingEscape() {
+			return pending.startsWith(escape$1) && !pending.startsWith(pasteStart) && pending !== pasteStart.slice(0, -1);
+		},
+		flushPendingEscape() {
+			if (!pending.startsWith(escape$1)) return;
+			const pendingEscape = pending;
+			pending = "";
+			return pendingEscape;
+		},
+		reset() {
+			pending = "";
+		}
+	};
+};
+//#endregion
+//#region src/stream.ts
+const isTty = (stream) => {
+	return "isTTY" in stream && stream.isTTY === true;
+};
+const isRawModeStream = (stdin) => {
+	return isTty(stdin) && "setRawMode" in stdin && typeof stdin.setRawMode === "function";
+};
+const getRawModeStream = (stdin) => {
+	if (!isRawModeStream(stdin)) return;
+	return stdin;
+};
+//#endregion
+//#region src/components/AnimationContext.ts
+const animationContext = createContext({
+	renderThrottleMs: 0,
+	subscribe() {
+		return {
+			startTime: 0,
+			unsubscribe() {}
+		};
+	}
+});
+animationContext.displayName = "InternalAnimationContext";
+//#endregion
+//#region src/components/AppContext.ts
+/**
+`AppContext` is a React context that exposes lifecycle methods for the app.
+*/
+const noopSuspension = {
+	async resume() {},
+	async [Symbol.asyncDispose]() {}
+};
+const AppContext = createContext({
+	exit(_errorOrResult) {},
+	async waitUntilRenderFlush() {},
+	suspendTerminal: (async (callback) => {
+		if (callback) {
+			await callback();
+			return;
+		}
+		return noopSuspension;
+	})
+});
+AppContext.displayName = "InternalAppContext";
+//#endregion
+//#region src/components/CursorContext.ts
+const CursorContext = createContext({ setCursorPosition() {} });
+CursorContext.displayName = "InternalCursorContext";
+//#endregion
+//#region src/code-excerpt.ts
+const tabsToSpaces = (input, spaces = 2) => input.replaceAll(/^\t+/gm, (tabs) => " ".repeat(tabs.length * spaces));
+const generateLineNumbers = (line, around) => {
+	const lineNumbers = [];
+	for (let lineNumber = line - around; lineNumber <= line + around; lineNumber++) lineNumbers.push(lineNumber);
+	return lineNumbers;
+};
+const codeExcerpt = (source, line, options = {}) => {
+	if (!line || line < 1) throw new TypeError("Line number must start from `1`.");
+	const lines = tabsToSpaces(source).split(/\r?\n/);
+	if (line > lines.length) return;
+	return generateLineNumbers(line, options.around ?? 3).filter((lineNumber) => lines[lineNumber - 1] !== void 0).map((lineNumber) => ({
+		line: lineNumber,
+		value: lines[lineNumber - 1]
+	}));
+};
+//#endregion
+//#region src/parse-stack-line.ts
+const lineRegExp = new RegExp("^" + String.raw`(?:\s*at )?` + "(?:(new) )?" + String.raw`(?:(.*?) \()?` + String.raw`(?:eval at ([^ ]+) \((.+?):(\d+):(\d+)\), )?` + String.raw`(?:(.+?):(\d+):(\d+)|(native))` + String.raw`(\)?)$`);
+const methodRegExp = /^(.*?) \[as (.*?)]$/;
+const cwd$1 = process.cwd().replaceAll("\\", "/");
+const setFile = (result, filename) => {
+	if (filename) {
+		filename = filename.replaceAll("\\", "/");
+		if (filename.startsWith(`${cwd$1}/`)) filename = filename.slice(cwd$1.length + 1);
+		result.file = filename;
+	}
+};
+const parseStackLine = (line) => {
+	const match = lineRegExp.exec(line);
+	if (!match) return;
+	let functionName = match[2];
+	const evalOrigin = match[3];
+	const evalFile = match[4];
+	const evalLine = Number(match[5]);
+	const evalColumn = Number(match[6]);
+	let file = match[7];
+	const lineNumber = match[8];
+	const columnNumber = match[9];
+	const native = match[10] === "native";
+	const closeParen = match[11] === ")";
+	let method;
+	const result = {};
+	if (lineNumber) result.line = Number(lineNumber);
+	if (columnNumber) result.column = Number(columnNumber);
+	if (closeParen && file) {
+		let closes = 0;
+		for (let index = file.length - 1; index > 0; index--) if (file.charAt(index) === ")") closes++;
+		else if (file.charAt(index) === "(" && file.charAt(index - 1) === " ") {
+			closes--;
+			if (closes === -1 && file.charAt(index - 1) === " ") {
+				const before = file.slice(0, index - 1);
+				file = file.slice(index + 1);
+				functionName += ` (${before}`;
+				break;
+			}
+		}
+	}
+	if (functionName) {
+		const methodMatch = methodRegExp.exec(functionName);
+		if (methodMatch) {
+			functionName = methodMatch[1];
+			method = methodMatch[2];
+		}
+	}
+	if (file) setFile(result, file);
+	if (evalOrigin) {
+		result.evalOrigin = evalOrigin;
+		result.evalLine = evalLine;
+		result.evalColumn = evalColumn;
+		result.evalFile = evalFile?.replaceAll("\\", "/");
+	}
+	if (native) result.native = true;
+	if (functionName) result.function = functionName;
+	if (method && functionName !== method) result.method = method;
+	return result;
+};
+//#endregion
+//#region src/components/BackgroundContext.ts
+const backgroundContext = createContext(void 0);
+//#endregion
+//#region src/components/Box.tsx
+/** @jsxImportSource react */
+/**
+`<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
+*/
+const Box = forwardRef(({ children, backgroundColor, "aria-label": ariaLabel, "aria-hidden": ariaHidden, "aria-role": role, "aria-state": ariaState, ...style }, ref) => {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	const label = ariaLabel ? /* @__PURE__ */ jsx("ink-text", { children: ariaLabel }) : void 0;
+	if (isScreenReaderEnabled && ariaHidden) return null;
+	const boxElement = /* @__PURE__ */ jsx("ink-box", {
+		ref,
+		style: {
+			flexWrap: "nowrap",
+			flexDirection: "row",
+			flexGrow: 0,
+			flexShrink: 1,
+			...style,
+			backgroundColor,
+			overflowX: style.overflowX ?? style.overflow ?? "visible",
+			overflowY: style.overflowY ?? style.overflow ?? "visible"
+		},
+		internal_accessibility: {
+			role,
+			state: ariaState
+		},
+		children: isScreenReaderEnabled && label ? label : children
+	});
+	if (backgroundColor) return /* @__PURE__ */ jsx(backgroundContext.Provider, {
+		value: backgroundColor,
+		children: boxElement
+	});
+	return boxElement;
+});
+Box.displayName = "Box";
+//#endregion
+//#region src/colorize.ts
+const rgbRegex = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
+const ansiRegex = /^ansi256\(\s?(\d+)\s?\)$/;
+const isNamedColor = (color) => {
+	return color in chalk;
+};
+const colorize = (str, color, type) => {
+	if (!color) return str;
+	if (isNamedColor(color)) {
+		if (type === "foreground") return chalk[color](str);
+		const methodName = `bg${color[0].toUpperCase() + color.slice(1)}`;
+		return chalk[methodName](str);
+	}
+	if (color.startsWith("#")) return type === "foreground" ? chalk.hex(color)(str) : chalk.bgHex(color)(str);
+	if (color.startsWith("ansi256")) {
+		const matches = ansiRegex.exec(color);
+		if (!matches) return str;
+		const value = Number(matches[1]);
+		return type === "foreground" ? chalk.ansi256(value)(str) : chalk.bgAnsi256(value)(str);
+	}
+	if (color.startsWith("rgb")) {
+		const matches = rgbRegex.exec(color);
+		if (!matches) return str;
+		const firstValue = Number(matches[1]);
+		const secondValue = Number(matches[2]);
+		const thirdValue = Number(matches[3]);
+		return type === "foreground" ? chalk.rgb(firstValue, secondValue, thirdValue)(str) : chalk.bgRgb(firstValue, secondValue, thirdValue)(str);
+	}
+	return str;
+};
+//#endregion
+//#region src/components/Text.tsx
+/** @jsxImportSource react */
+/**
+This component can display text and change its style to make it bold, underlined, italic, or strikethrough.
+*/
+function Text({ color, backgroundColor, dimColor = false, bold = false, italic = false, underline = false, strikethrough = false, inverse = false, wrap = "wrap", children, "aria-label": ariaLabel, "aria-hidden": ariaHidden = false }) {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	const inheritedBackgroundColor = useContext(backgroundContext);
+	const childrenOrAriaLabel = isScreenReaderEnabled && ariaLabel ? ariaLabel : children;
+	if (childrenOrAriaLabel === void 0 || childrenOrAriaLabel === null) return null;
+	const transform = (text) => {
+		if (dimColor) text = chalk.dim(text);
+		if (color) text = colorize(text, color, "foreground");
+		const effectiveBackgroundColor = backgroundColor ?? inheritedBackgroundColor;
+		if (effectiveBackgroundColor) text = colorize(text, effectiveBackgroundColor, "background");
+		if (bold) text = chalk.bold(text);
+		if (italic) text = chalk.italic(text);
+		if (underline) text = chalk.underline(text);
+		if (strikethrough) text = chalk.strikethrough(text);
+		if (inverse) text = chalk.inverse(text);
+		return text;
+	};
+	if (isScreenReaderEnabled && ariaHidden) return null;
+	return /* @__PURE__ */ jsx("ink-text", {
+		style: {
+			flexGrow: 0,
+			flexShrink: 1,
+			flexDirection: "row",
+			textWrap: wrap
+		},
+		internal_transform: transform,
+		children: childrenOrAriaLabel
+	});
+}
+//#endregion
+//#region src/components/ErrorOverview.tsx
+/** @jsxImportSource react */
+const cleanupPath = (path) => {
+	return path?.replace(`file://${cwd()}/`, "");
+};
+function ErrorOverview({ error }) {
+	const stack = error.stack ? error.stack.split("\n").slice(1) : void 0;
+	const origin = stack ? parseStackLine(stack[0]) : void 0;
+	const filePath = cleanupPath(origin?.file);
+	let excerpt;
+	let lineWidth = 0;
+	const stackLineCounts = /* @__PURE__ */ new Map();
+	if (filePath && origin?.line && fs$1.existsSync(filePath)) {
+		const sourceCode = fs$1.readFileSync(filePath, "utf8");
+		excerpt = codeExcerpt(sourceCode, origin.line);
+		if (excerpt) for (const { line } of excerpt) lineWidth = Math.max(lineWidth, String(line).length);
+	}
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsxs(Text, {
+				backgroundColor: "red",
+				color: "white",
+				children: [
+					" ",
+					"ERROR",
+					" "
+				]
+			}), /* @__PURE__ */ jsxs(Text, { children: [" ", error.message] })] }),
+			origin && filePath ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						filePath,
+						":",
+						origin.line,
+						":",
+						origin.column
+					]
+				})
+			}) : null,
+			origin && excerpt ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				children: excerpt.map(({ line, value }) => /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Box, {
+					width: lineWidth + 1,
+					children: /* @__PURE__ */ jsxs(Text, {
+						dimColor: line !== origin.line,
+						backgroundColor: line === origin.line ? "red" : void 0,
+						color: line === origin.line ? "white" : void 0,
+						"aria-label": line === origin.line ? `Line ${line}, error` : `Line ${line}`,
+						children: [String(line).padStart(lineWidth, " "), ":"]
+					})
+				}), /* @__PURE__ */ jsx(Text, {
+					backgroundColor: line === origin.line ? "red" : void 0,
+					color: line === origin.line ? "white" : void 0,
+					children: " " + value
+				}, line)] }, line))
+			}) : null,
+			error.stack ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				children: error.stack.split("\n").slice(1).map((line) => {
+					const parsedLine = parseStackLine(line);
+					const lineCount = stackLineCounts.get(line) ?? 0;
+					stackLineCounts.set(line, lineCount + 1);
+					const key = `${line}-${lineCount}`;
+					if (!parsedLine?.file || !parsedLine.line || !parsedLine.column) return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "- "
+					}), /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						bold: true,
+						children: [
+							line,
+							"\\t",
+							" "
+						]
+					})] }, key);
+					return /* @__PURE__ */ jsxs(Box, { children: [
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: "- "
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							bold: true,
+							children: parsedLine.function
+						}),
+						/* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							color: "gray",
+							"aria-label": `at ${cleanupPath(parsedLine.file) ?? ""} line ${parsedLine.line} column ${parsedLine.column}`,
+							children: [
+								" ",
+								"(",
+								cleanupPath(parsedLine.file) ?? "",
+								":",
+								parsedLine.line,
+								":",
+								parsedLine.column,
+								")"
+							]
+						})
+					] }, key);
+				})
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/ErrorBoundary.tsx
+/** @jsxImportSource react */
+var ErrorBoundary = class 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 /* @__PURE__ */ jsx(ErrorOverview, { error: this.state.error });
+		return this.props.children;
+	}
+};
+//#endregion
+//#region src/components/FocusContext.ts
+const FocusContext = createContext({
+	activeId: void 0,
+	add() {},
+	remove() {},
+	activate() {},
+	deactivate() {},
+	enableFocus() {},
+	disableFocus() {},
+	focusNext() {},
+	focusPrevious() {},
+	focus() {}
+});
+FocusContext.displayName = "InternalFocusContext";
+//#endregion
+//#region src/components/StderrContext.ts
+/**
+`StderrContext` is a React context that exposes the stderr stream.
+*/
+const StderrContext = createContext({
+	stderr: process.stderr,
+	write() {}
+});
+StderrContext.displayName = "InternalStderrContext";
+//#endregion
+//#region src/components/StdinContext.ts
+/**
+`StdinContext` is a React context that exposes the input stream.
+*/
+const StdinContext = createContext({
+	stdin: process.stdin,
+	internal_eventEmitter: new EventEmitter(),
+	setRawMode() {},
+	setBracketedPasteMode() {},
+	isRawModeSupported: false,
+	internal_exitOnCtrlC: true
+});
+StdinContext.displayName = "InternalStdinContext";
+//#endregion
+//#region src/components/StdoutContext.ts
+/**
+`StdoutContext` is a React context that exposes the stdout stream where Ink renders your app.
+*/
+const StdoutContext = createContext({
+	stdout: process.stdout,
+	write() {}
+});
+StdoutContext.displayName = "InternalStdoutContext";
+//#endregion
+//#region src/components/App.tsx
+/** @jsxImportSource react */
+const tab = "	";
+const shiftTab = `${CSI}Z`;
+const escape = "\x1B";
+function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, exitOnCtrlC, onExit, onWaitUntilRenderFlush, onSuspendTerminal, onRegisterInputControl, setCursorPosition, interactive, renderThrottleMs }) {
+	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 pendingDisableRawModeRef = useRef(false);
+	const bracketedPasteModeEnabledCount = useRef(0);
+	const internal_eventEmitter = useRef(new EventEmitter());
+	internal_eventEmitter.current.setMaxListeners(Infinity);
+	const readableListenerRef = useRef(void 0);
+	const inputParserRef = useRef(createInputParser());
+	const pendingInputFlushRef = useRef(void 0);
+	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();
+			for (const subscriber of animationSubscribersRef.current.values()) {
+				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,
+			startTime,
+			nextDueTime: startTime + interval
+		});
+		scheduleAnimationTick();
+		return {
+			startTime,
+			unsubscribe() {
+				animationSubscribersRef.current.delete(callback);
+				if (animationSubscribersRef.current.size === 0) {
+					clearAnimationTimer();
+					return;
+				}
+				scheduleAnimationTick();
+			}
+		};
+	}, [clearAnimationTimer, scheduleAnimationTick]);
+	useEffect(() => {
+		return () => {
+			clearAnimationTimer();
+		};
+	}, [clearAnimationTimer]);
+	const rawModeStdin = getRawModeStream(stdin);
+	const isRawModeSupported = rawModeStdin !== void 0;
+	const detachReadableListener = useCallback(() => {
+		if (!readableListenerRef.current) return;
+		stdin.removeListener("readable", readableListenerRef.current);
+		readableListenerRef.current = void 0;
+	}, [stdin]);
+	const clearInputState = useCallback(() => {
+		inputParserRef.current.reset();
+		clearPendingInputFlush();
+		detachReadableListener();
+	}, [clearPendingInputFlush, detachReadableListener]);
+	const disableRawMode = useCallback(() => {
+		if (!rawModeStdin) return;
+		pendingDisableRawModeRef.current = false;
+		rawModeStdin.setRawMode(false);
+		rawModeStdin.unref?.();
+		rawModeEnabledCount.current = 0;
+		clearInputState();
+	}, [rawModeStdin, clearInputState]);
+	const handleExit = useCallback((errorOrResult) => {
+		if (isRawModeSupported && (rawModeEnabledCount.current > 0 || pendingDisableRawModeRef.current)) disableRawMode();
+		onExit(errorOrResult);
+	}, [
+		isRawModeSupported,
+		disableRawMode,
+		onExit
+	]);
+	const handleInput = useCallback((input) => {
+		if (input === "" && exitOnCtrlC) {
+			handleExit();
+			return;
+		}
+		if (input === escape && isFocusEnabled) setActiveFocusId(void 0);
+	}, [
+		exitOnCtrlC,
+		handleExit,
+		isFocusEnabled
+	]);
+	const emitInput = useCallback((input) => {
+		handleInput(input);
+		internal_eventEmitter.current.emit("input", input);
+	}, [handleInput]);
+	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.current.listenerCount("paste") === 0) {
+					emitInput(event.paste);
+					continue;
+				}
+				internal_eventEmitter.current.emit("paste", event.paste);
+			}
+		}
+		if (inputParserRef.current.hasPendingEscape()) schedulePendingInputFlush();
+	}, [
+		stdin,
+		emitInput,
+		clearPendingInputFlush,
+		schedulePendingInputFlush
+	]);
+	const attachReadableListener = useCallback(() => {
+		if (readableListenerRef.current) return;
+		readableListenerRef.current = handleReadable;
+		stdin.addListener("readable", handleReadable);
+	}, [stdin, handleReadable]);
+	const handleSetRawMode = useCallback((isEnabled) => {
+		if (!rawModeStdin) {
+			if (stdin === process.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");
+		}
+		rawModeStdin.setEncoding("utf8");
+		if (isEnabled) {
+			if (rawModeEnabledCount.current === 0) {
+				const isRawModeAlreadyEnabled = pendingDisableRawModeRef.current;
+				pendingDisableRawModeRef.current = false;
+				if (!isRawModeAlreadyEnabled) {
+					rawModeStdin.ref?.();
+					rawModeStdin.setRawMode(true);
+				}
+				attachReadableListener();
+			}
+			rawModeEnabledCount.current++;
+			return;
+		}
+		if (rawModeEnabledCount.current === 0) return;
+		if (--rawModeEnabledCount.current === 0) {
+			clearInputState();
+			pendingDisableRawModeRef.current = true;
+			queueMicrotask(() => {
+				if (!pendingDisableRawModeRef.current) return;
+				disableRawMode();
+			});
+		}
+	}, [
+		rawModeStdin,
+		stdin,
+		attachReadableListener,
+		clearInputState,
+		disableRawMode
+	]);
+	const handleSetBracketedPasteMode = useCallback((isEnabled) => {
+		if (!stdout.isTTY) return;
+		if (isEnabled) {
+			if (bracketedPasteModeEnabledCount.current === 0) stdout.write(ansiEscapes.enableBracketedPaste);
+			bracketedPasteModeEnabledCount.current++;
+			return;
+		}
+		if (bracketedPasteModeEnabledCount.current === 0) return;
+		if (--bracketedPasteModeEnabledCount.current === 0) stdout.write(ansiEscapes.disableBracketedPaste);
+	}, [stdout]);
+	const suspendedInputStateRef = useRef({
+		rawMode: false,
+		bracketedPaste: false
+	});
+	const pauseInput = useCallback(() => {
+		const wasRawMode = isRawModeSupported && rawModeEnabledCount.current > 0;
+		const wasBracketedPaste = bracketedPasteModeEnabledCount.current > 0;
+		suspendedInputStateRef.current = {
+			rawMode: wasRawMode,
+			bracketedPaste: wasBracketedPaste
+		};
+		if (wasBracketedPaste && stdout.isTTY) try {
+			stdout.write(ansiEscapes.disableBracketedPaste);
+		} catch {}
+		if (wasRawMode) {
+			rawModeStdin?.setRawMode(false);
+			rawModeStdin?.unref?.();
+			clearInputState();
+		}
+	}, [
+		isRawModeSupported,
+		rawModeStdin,
+		stdout,
+		clearInputState
+	]);
+	const resumeInput = useCallback(() => {
+		const { rawMode, bracketedPaste } = suspendedInputStateRef.current;
+		if (rawMode) {
+			rawModeStdin?.setEncoding("utf8");
+			rawModeStdin?.ref?.();
+			rawModeStdin?.setRawMode(true);
+			attachReadableListener();
+		}
+		if (bracketedPaste && stdout.isTTY) try {
+			stdout.write(ansiEscapes.enableBracketedPaste);
+		} catch {}
+	}, [
+		rawModeStdin,
+		stdout,
+		attachReadableListener
+	]);
+	useInsertionEffect(() => {
+		onRegisterInputControl(pauseInput, resumeInput);
+	}, [
+		onRegisterInputControl,
+		pauseInput,
+		resumeInput
+	]);
+	const findNextFocusable = useCallback((currentFocusables, currentActiveFocusId) => {
+		const activeIndex = currentFocusables.findIndex((focusable) => {
+			return focusable.id === currentActiveFocusId;
+		});
+		for (let index = activeIndex + 1; index < currentFocusables.length; index++) {
+			const focusable = currentFocusables[index];
+			if (focusable?.isActive) return focusable.id;
+		}
+	}, []);
+	const findPreviousFocusable = useCallback((currentFocusables, currentActiveFocusId) => {
+		const activeIndex = currentFocusables.findIndex((focusable) => {
+			return focusable.id === currentActiveFocusId;
+		});
+		for (let index = activeIndex - 1; index >= 0; index--) {
+			const focusable = currentFocusables[index];
+			if (focusable?.isActive) return focusable.id;
+		}
+	}, []);
+	const focusNext = useCallback(() => {
+		setFocusables((currentFocusables) => {
+			setActiveFocusId((currentActiveFocusId) => {
+				const firstFocusableId = currentFocusables.find((focusable) => focusable.isActive)?.id;
+				return findNextFocusable(currentFocusables, currentActiveFocusId) ?? firstFocusableId;
+			});
+			return currentFocusables;
+		});
+	}, [findNextFocusable]);
+	const focusPrevious = useCallback(() => {
+		setFocusables((currentFocusables) => {
+			setActiveFocusId((currentActiveFocusId) => {
+				const lastFocusableId = currentFocusables.findLast((focusable) => focusable.isActive)?.id;
+				return findPreviousFocusable(currentFocusables, currentActiveFocusId) ?? lastFocusableId;
+			});
+			return currentFocusables;
+		});
+	}, [findPreviousFocusable]);
+	useEffect(() => {
+		const handleTabNavigation = (input) => {
+			if (!isFocusEnabled || focusablesCountRef.current === 0) return;
+			if (input === tab) focusNext();
+			if (input === shiftTab) focusPrevious();
+		};
+		internal_eventEmitter.current.on("input", handleTabNavigation);
+		const emitter = internal_eventEmitter.current;
+		return () => {
+			emitter.off("input", handleTabNavigation);
+		};
+	}, [
+		isFocusEnabled,
+		focusNext,
+		focusPrevious
+	]);
+	const enableFocus = useCallback(() => {
+		setIsFocusEnabled(true);
+	}, []);
+	const disableFocus = useCallback(() => {
+		setIsFocusEnabled(false);
+	}, []);
+	const focus = useCallback((id) => {
+		setFocusables((currentFocusables) => {
+			if (currentFocusables.some((focusable) => focusable?.id === id)) 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;
+			return currentActiveFocusId;
+		});
+		setFocusables((currentFocusables) => {
+			const filtered = currentFocusables.filter((focusable) => {
+				return 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;
+			return currentActiveFocusId;
+		});
+		setFocusables((currentFocusables) => currentFocusables.map((focusable) => {
+			if (focusable.id !== id) return focusable;
+			return {
+				id,
+				isActive: false
+			};
+		}));
+	}, []);
+	useEffect(() => {
+		return () => {
+			const canWriteToStdout = !stdout.destroyed && !stdout.writableEnded;
+			if (interactive && canWriteToStdout) cliCursor.show(stdout);
+			if (isRawModeSupported && (rawModeEnabledCount.current > 0 || pendingDisableRawModeRef.current)) disableRawMode();
+			if (bracketedPasteModeEnabledCount.current > 0) {
+				if (stdout.isTTY && canWriteToStdout) stdout.write(ansiEscapes.disableBracketedPaste);
+				bracketedPasteModeEnabledCount.current = 0;
+			}
+		};
+	}, [
+		stdout,
+		isRawModeSupported,
+		disableRawMode,
+		interactive
+	]);
+	const appContextValue = useMemo(() => ({
+		exit: handleExit,
+		waitUntilRenderFlush: onWaitUntilRenderFlush,
+		suspendTerminal: onSuspendTerminal
+	}), [
+		handleExit,
+		onWaitUntilRenderFlush,
+		onSuspendTerminal
+	]);
+	const stdinContextValue = useMemo(() => ({
+		stdin,
+		setRawMode: handleSetRawMode,
+		setBracketedPasteMode: handleSetBracketedPasteMode,
+		isRawModeSupported,
+		internal_exitOnCtrlC: exitOnCtrlC,
+		internal_eventEmitter: internal_eventEmitter.current
+	}), [
+		stdin,
+		handleSetRawMode,
+		handleSetBracketedPasteMode,
+		isRawModeSupported,
+		exitOnCtrlC
+	]);
+	const stdoutContextValue = useMemo(() => ({
+		stdout,
+		write: writeToStdout
+	}), [stdout, writeToStdout]);
+	const stderrContextValue = useMemo(() => ({
+		stderr,
+		write: writeToStderr
+	}), [stderr, writeToStderr]);
+	const cursorContextValue = useMemo(() => ({ setCursorPosition }), [setCursorPosition]);
+	const focusContextValue = useMemo(() => ({
+		activeId: activeFocusId,
+		add: addFocusable,
+		remove: removeFocusable,
+		activate: activateFocusable,
+		deactivate: deactivateFocusable,
+		enableFocus,
+		disableFocus,
+		focusNext,
+		focusPrevious,
+		focus
+	}), [
+		activeFocusId,
+		addFocusable,
+		removeFocusable,
+		activateFocusable,
+		deactivateFocusable,
+		enableFocus,
+		disableFocus,
+		focusNext,
+		focusPrevious,
+		focus
+	]);
+	const animationContextValue = useMemo(() => ({
+		renderThrottleMs,
+		subscribe: animationSubscribe
+	}), [animationSubscribe, renderThrottleMs]);
+	return /* @__PURE__ */ jsx(AppContext.Provider, {
+		value: appContextValue,
+		children: /* @__PURE__ */ jsx(StdinContext.Provider, {
+			value: stdinContextValue,
+			children: /* @__PURE__ */ jsx(StdoutContext.Provider, {
+				value: stdoutContextValue,
+				children: /* @__PURE__ */ jsx(StderrContext.Provider, {
+					value: stderrContextValue,
+					children: /* @__PURE__ */ jsx(FocusContext.Provider, {
+						value: focusContextValue,
+						children: /* @__PURE__ */ jsx(animationContext.Provider, {
+							value: animationContextValue,
+							children: /* @__PURE__ */ jsx(CursorContext.Provider, {
+								value: cursorContextValue,
+								children: /* @__PURE__ */ jsx(ErrorBoundary, {
+									onError: handleExit,
+									children
+								})
+							})
+						})
+					})
+				})
+			})
+		})
+	});
+}
+App.displayName = "InternalApp";
+//#endregion
+//#region src/cursor-position.ts
+const showCursorEscape = ansiEscapes.cursorShow;
+const hideCursorEscape = ansiEscapes.cursorHide;
+/**
+Compare two cursor positions. Returns true if they differ.
+*/
+const cursorPositionChanged = (a, b) => a?.x !== b?.x || a?.y !== b?.y;
+/**
+Build escape sequence to move cursor from the bottom of the output to the target position and show it.
+
+`bottomLine` is the row the renderer left the cursor on, counted from the top of the output.
+That is always `lines.length - 1` for `lines = str.split('\n')`, whether or not the output ends
+with a newline:
+
+- With a trailing newline, `split` yields one extra empty element and the renderer stops just
+past the last visible line — which is `lines.length - 1`.
+- Without one, there is no extra element and the renderer deliberately stops on the last visible
+line instead of moving past it — which is also `lines.length - 1`.
+
+This is the same row basis `buildReturnToBottom` measures from, so the two stay in step.
+*/
+const buildCursorSuffix = (bottomLine, cursorPosition) => {
+	if (!cursorPosition) return "";
+	const moveUp = bottomLine - cursorPosition.y;
+	return (moveUp > 0 ? ansiEscapes.cursorUp(moveUp) : "") + ansiEscapes.cursorTo(cursorPosition.x) + showCursorEscape;
+};
+/**
+Build escape sequence to move cursor from previousCursorPosition back to the bottom of output.
+This must be done before eraseLines or any operation that assumes cursor is at the bottom.
+*/
+const buildReturnToBottom = (previousLineCount, previousCursorPosition) => {
+	if (!previousCursorPosition) return "";
+	const down = previousLineCount - 1 - previousCursorPosition.y;
+	return (down > 0 ? ansiEscapes.cursorDown(down) : "") + ansiEscapes.cursorTo(0);
+};
+/**
+Build the escape sequence for cursor-only updates (output unchanged, cursor moved).
+Hides cursor if it was previously shown, returns to bottom, then repositions.
+
+`buildReturnToBottom` has just placed the cursor on row `previousLineCount - 1`, so the
+suffix measures from there rather than recomputing the row from the output.
+*/
+const buildCursorOnlySequence = (input) => {
+	const hidePrefix = input.cursorWasShown ? hideCursorEscape : "";
+	const returnToBottom = buildReturnToBottom(input.previousLineCount, input.previousCursorPosition);
+	const cursorSuffix = buildCursorSuffix(input.previousLineCount - 1, input.cursorPosition);
+	return hidePrefix + returnToBottom + cursorSuffix;
+};
+/**
+Build the prefix that hides cursor and returns to bottom before erasing or rewriting.
+Returns empty string if cursor was not shown.
+*/
+const buildReturnToBottomPrefix = (cursorWasShown, previousLineCount, previousCursorPosition) => {
+	if (!cursorWasShown) return "";
+	return hideCursorEscape + buildReturnToBottom(previousLineCount, previousCursorPosition);
+};
+//#endregion
+//#region src/quick-lru.ts
+var QuickLru = class {
+	#size = 0;
+	#cache = /* @__PURE__ */ new Map();
+	#oldCache = /* @__PURE__ */ new Map();
+	#maxSize;
+	constructor({ maxSize }) {
+		if (!(maxSize && maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+		this.#maxSize = maxSize;
+	}
+	get size() {
+		let oldCacheSize = 0;
+		for (const key of this.#oldCache.keys()) if (!this.#cache.has(key)) oldCacheSize++;
+		return Math.min(this.#size + oldCacheSize, this.#maxSize);
+	}
+	get(key) {
+		if (this.#cache.has(key)) return this.#cache.get(key);
+		if (this.#oldCache.has(key)) {
+			const value = this.#oldCache.get(key);
+			this.#oldCache.delete(key);
+			this.#set(key, value);
+			return value;
+		}
+	}
+	set(key, value) {
+		if (this.#cache.has(key)) this.#cache.set(key, value);
+		else this.#set(key, value);
+		return this;
+	}
+	has(key) {
+		return this.#cache.has(key) || this.#oldCache.has(key);
+	}
+	delete(key) {
+		const deleted = this.#cache.delete(key);
+		if (deleted) this.#size--;
+		return this.#oldCache.delete(key) || deleted;
+	}
+	clear() {
+		this.#cache.clear();
+		this.#oldCache.clear();
+		this.#size = 0;
+	}
+	#set(key, value) {
+		this.#cache.set(key, value);
+		this.#size++;
+		if (this.#size >= this.#maxSize) {
+			this.#size = 0;
+			this.#oldCache = this.#cache;
+			this.#cache = /* @__PURE__ */ new Map();
+		}
+	}
+};
+//#endregion
+//#region src/measure-text.ts
+const cache = new QuickLru({ maxSize: 4096 });
+const measureText = (text) => {
+	if (text.length === 0) return {
+		width: 0,
+		height: 0
+	};
+	const cachedDimensions = cache.get(text);
+	if (cachedDimensions) return cachedDimensions;
+	const dimensions = {
+		width: widestLine(text),
+		height: text.split("\n").length
+	};
+	cache.set(text, dimensions);
+	return dimensions;
+};
+//#endregion
+//#region src/ansi-tokenizer.ts
+const bellCharacter = "\x07";
+const escapeCharacter = "\x1B";
+const stringTerminatorCharacter = "œ";
+const csiCharacter = "›";
+const oscCharacter = "";
+const dcsCharacter = "";
+const pmCharacter = "ž";
+const apcCharacter = "Ÿ";
+const sosCharacter = "˜";
+const isCsiParameterCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 63;
+};
+const isCsiIntermediateCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isCsiFinalCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 64 && codePoint <= 126;
+};
+const isEscapeIntermediateCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isEscapeFinalCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 126;
+};
+const isC1ControlCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 128 && codePoint <= 159;
+};
+const readCsiSequence = (text, fromIndex) => {
+	let index = fromIndex;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isCsiParameterCharacter(character)) break;
+		index++;
+	}
+	const parameterString = text.slice(fromIndex, index);
+	const intermediateStartIndex = index;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isCsiIntermediateCharacter(character)) break;
+		index++;
+	}
+	const intermediateString = text.slice(intermediateStartIndex, index);
+	const finalCharacter = text[index];
+	if (finalCharacter === void 0 || !isCsiFinalCharacter(finalCharacter)) return;
+	return {
+		endIndex: index + 1,
+		parameterString,
+		intermediateString,
+		finalCharacter
+	};
+};
+const findControlStringTerminatorIndex = (text, fromIndex, allowBellTerminator) => {
+	for (let index = fromIndex; index < text.length; index++) {
+		const character = text[index];
+		if (allowBellTerminator && character === bellCharacter) return index + 1;
+		if (character === stringTerminatorCharacter) return index + 1;
+		if (character === escapeCharacter) {
+			const followingCharacter = text[index + 1];
+			if (followingCharacter === escapeCharacter) {
+				index++;
+				continue;
+			}
+			if (followingCharacter === "\\") return index + 2;
+		}
+	}
+};
+const readEscapeSequence = (text, fromIndex) => {
+	let index = fromIndex;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isEscapeIntermediateCharacter(character)) break;
+		index++;
+	}
+	const intermediateString = text.slice(fromIndex, index);
+	const finalCharacter = text[index];
+	if (finalCharacter === void 0 || !isEscapeFinalCharacter(finalCharacter)) return;
+	return {
+		endIndex: index + 1,
+		intermediateString,
+		finalCharacter
+	};
+};
+const getControlStringFromEscapeIntroducer = (character) => {
+	switch (character) {
+		case "]": return {
+			type: "osc",
+			allowBellTerminator: true
+		};
+		case "P": return {
+			type: "dcs",
+			allowBellTerminator: false
+		};
+		case "^": return {
+			type: "pm",
+			allowBellTerminator: false
+		};
+		case "_": return {
+			type: "apc",
+			allowBellTerminator: false
+		};
+		case "X": return {
+			type: "sos",
+			allowBellTerminator: false
+		};
+		default: return;
+	}
+};
+const getControlStringFromC1Introducer = (character) => {
+	switch (character) {
+		case oscCharacter: return {
+			type: "osc",
+			allowBellTerminator: true
+		};
+		case dcsCharacter: return {
+			type: "dcs",
+			allowBellTerminator: false
+		};
+		case pmCharacter: return {
+			type: "pm",
+			allowBellTerminator: false
+		};
+		case apcCharacter: return {
+			type: "apc",
+			allowBellTerminator: false
+		};
+		case sosCharacter: return {
+			type: "sos",
+			allowBellTerminator: false
+		};
+		default: return;
+	}
+};
+const hasAnsiControlCharacters = (text) => {
+	if (text.includes(escapeCharacter)) return true;
+	for (const character of text) if (isC1ControlCharacter(character)) return true;
+	return false;
+};
+const malformedFromIndex = (tokens, text, textStartIndex, fromIndex) => {
+	if (fromIndex > textStartIndex) tokens.push({
+		type: "text",
+		value: text.slice(textStartIndex, fromIndex)
+	});
+	tokens.push({
+		type: "invalid",
+		value: text.slice(fromIndex)
+	});
+	return tokens;
+};
+const tokenizeAnsi = (text) => {
+	if (!hasAnsiControlCharacters(text)) return [{
+		type: "text",
+		value: text
+	}];
+	const tokens = [];
+	let textStartIndex = 0;
+	for (let index = 0; index < text.length;) {
+		const character = text[index];
+		if (character === void 0) break;
+		if (character === escapeCharacter) {
+			const followingCharacter = text[index + 1];
+			if (followingCharacter === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (followingCharacter === "[") {
+				const csiSequence = readCsiSequence(text, index + 2);
+				if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				tokens.push({
+					type: "csi",
+					value: text.slice(index, csiSequence.endIndex),
+					parameterString: csiSequence.parameterString,
+					intermediateString: csiSequence.intermediateString,
+					finalCharacter: csiSequence.finalCharacter
+				});
+				index = csiSequence.endIndex;
+				textStartIndex = index;
+				continue;
+			}
+			const escapeControlString = getControlStringFromEscapeIntroducer(followingCharacter);
+			if (escapeControlString !== void 0) {
+				const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 2, escapeControlString.allowBellTerminator);
+				if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				tokens.push({
+					type: escapeControlString.type,
+					value: text.slice(index, controlStringTerminatorIndex)
+				});
+				index = controlStringTerminatorIndex;
+				textStartIndex = index;
+				continue;
+			}
+			const escapeSequence = readEscapeSequence(text, index + 1);
+			if (escapeSequence === void 0) {
+				if (isEscapeIntermediateCharacter(followingCharacter)) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				index++;
+				textStartIndex = index;
+				continue;
+			}
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "esc",
+				value: text.slice(index, escapeSequence.endIndex),
+				intermediateString: escapeSequence.intermediateString,
+				finalCharacter: escapeSequence.finalCharacter
+			});
+			index = escapeSequence.endIndex;
+			textStartIndex = index;
+			continue;
+		}
+		if (character === csiCharacter) {
+			const csiSequence = readCsiSequence(text, index + 1);
+			if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "csi",
+				value: text.slice(index, csiSequence.endIndex),
+				parameterString: csiSequence.parameterString,
+				intermediateString: csiSequence.intermediateString,
+				finalCharacter: csiSequence.finalCharacter
+			});
+			index = csiSequence.endIndex;
+			textStartIndex = index;
+			continue;
+		}
+		const c1ControlString = getControlStringFromC1Introducer(character);
+		if (c1ControlString !== void 0) {
+			const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 1, c1ControlString.allowBellTerminator);
+			if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: c1ControlString.type,
+				value: text.slice(index, controlStringTerminatorIndex)
+			});
+			index = controlStringTerminatorIndex;
+			textStartIndex = index;
+			continue;
+		}
+		if (character === stringTerminatorCharacter) {
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "st",
+				value: character
+			});
+			index++;
+			textStartIndex = index;
+			continue;
+		}
+		if (isC1ControlCharacter(character)) {
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "c1",
+				value: character
+			});
+			index++;
+			textStartIndex = index;
+			continue;
+		}
+		index++;
+	}
+	if (textStartIndex < text.length) tokens.push({
+		type: "text",
+		value: text.slice(textStartIndex)
+	});
+	return tokens;
+};
+//#endregion
+//#region src/sanitize-ansi.ts
+const sgrParametersRegex = /^[\d:;]*$/;
+const sanitizeAnsi = (text) => {
+	if (!hasAnsiControlCharacters(text)) return text;
+	let output = "";
+	for (const token of tokenizeAnsi(text)) {
+		if (token.type === "text" || token.type === "osc") {
+			output += token.value;
+			continue;
+		}
+		if (token.type === "csi" && token.finalCharacter === "m" && token.intermediateString === "" && sgrParametersRegex.test(token.parameterString)) output += token.value;
+	}
+	return output;
+};
+//#endregion
+//#region src/squash-text-nodes.ts
+const squashTextNodes = (node) => {
+	let text = "";
+	for (let index = 0; index < node.childNodes.length; index++) {
+		const childNode = node.childNodes[index];
+		if (childNode === void 0) continue;
+		let nodeText = "";
+		if (childNode.nodeName === "#text") nodeText = childNode.nodeValue;
+		else {
+			if (childNode.nodeName === "ink-text" || childNode.nodeName === "ink-virtual-text") nodeText = squashTextNodes(childNode);
+			if (nodeText.length > 0 && typeof childNode.internal_transform === "function") nodeText = childNode.internal_transform(nodeText, index);
+		}
+		text += nodeText;
+	}
+	return sanitizeAnsi(text);
+};
+//#endregion
+//#region src/wrap-text.ts
+const wrapTextCache = new QuickLru({ maxSize: 4096 });
+const wrapText = (text, maxWidth, wrapType) => {
+	const cacheKey = text + String(maxWidth) + String(wrapType);
+	const cachedText = wrapTextCache.get(cacheKey);
+	if (cachedText !== void 0) return cachedText;
+	let wrappedText = text;
+	if (wrapType === "wrap") wrappedText = wrapAnsi(text, maxWidth, {
+		trim: false,
+		hard: true
+	});
+	if (wrapType === "hard") wrappedText = wrapAnsi(text, maxWidth, {
+		trim: false,
+		hard: true,
+		wordWrap: false
+	});
+	if (wrapType.startsWith("truncate")) {
+		let position = "end";
+		if (wrapType === "truncate-middle") position = "middle";
+		if (wrapType === "truncate-start") position = "start";
+		wrappedText = cliTruncate(text, maxWidth, { position });
+	}
+	wrapTextCache.set(cacheKey, wrappedText);
+	return wrappedText;
+};
+//#endregion
+//#region src/dom.ts
+const createNode = (nodeName) => {
+	const node = {
+		nodeName,
+		style: {},
+		attributes: {},
+		childNodes: [],
+		parentNode: void 0,
+		yogaNode: nodeName === "ink-virtual-text" ? void 0 : Yoga.Node.create(),
+		internal_accessibility: {}
+	};
+	if (nodeName === "ink-text") node.yogaNode?.setMeasureFunc(measureTextNode.bind(null, node));
+	return node;
+};
+const appendChildNode = (node, childNode) => {
+	if (childNode.parentNode) removeChildNode(childNode.parentNode, childNode);
+	childNode.parentNode = node;
+	node.childNodes.push(childNode);
+	if (childNode.yogaNode) node.yogaNode?.insertChild(childNode.yogaNode, node.yogaNode.getChildCount());
+	if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") markNodeAsDirty(node);
+};
+const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
+	if (newChildNode.parentNode) removeChildNode(newChildNode.parentNode, newChildNode);
+	newChildNode.parentNode = node;
+	const index = node.childNodes.indexOf(beforeChildNode);
+	if (index >= 0) {
+		node.childNodes.splice(index, 0, newChildNode);
+		if (newChildNode.yogaNode) node.yogaNode?.insertChild(newChildNode.yogaNode, index);
+	} else {
+		node.childNodes.push(newChildNode);
+		if (newChildNode.yogaNode) node.yogaNode?.insertChild(newChildNode.yogaNode, node.yogaNode.getChildCount());
+	}
+	if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") markNodeAsDirty(node);
+};
+const removeChildNode = (node, removeNode) => {
+	if (removeNode.yogaNode) removeNode.parentNode?.yogaNode?.removeChild(removeNode.yogaNode);
+	removeNode.parentNode = void 0;
+	const index = node.childNodes.indexOf(removeNode);
+	if (index >= 0) node.childNodes.splice(index, 1);
+	if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") markNodeAsDirty(node);
+};
+const nullifyYogaNodes = (node) => {
+	node.yogaNode = void 0;
+	if (node.nodeName !== "#text") for (const childNode of node.childNodes) nullifyYogaNodes(childNode);
+};
+/**
+Detach a removed subtree from the layout engine: drop the measure callback
+and null the `yogaNode` reference on every DOM node within it.
+
+Nulling the references makes every `?.yogaNode` guard in the codebase
+effective for removed nodes, turns lingering access into a safe no-op (see
+QwenLM/qwen-code#6820), and lets the garbage collector reclaim the Yoga
+tree along with its closures.
+*/
+const detachYogaSubtree = (removeNode) => {
+	removeNode.yogaNode?.unsetMeasureFunc();
+	nullifyYogaNodes(removeNode);
+};
+const setAttribute = (node, key, value) => {
+	if (key === "internal_accessibility") {
+		node.internal_accessibility = value;
+		return;
+	}
+	node.attributes[key] = value;
+};
+const setStyle = (node, style) => {
+	node.style = style ?? {};
+};
+const createTextNode = (text) => {
+	const node = {
+		nodeName: "#text",
+		nodeValue: text,
+		yogaNode: void 0,
+		parentNode: void 0,
+		style: {}
+	};
+	setTextNodeValue(node, text);
+	return node;
+};
+const measureTextNode = function(node, width) {
+	const text = node.nodeName === "#text" ? node.nodeValue : squashTextNodes(node);
+	const dimensions = measureText(text);
+	if (dimensions.width <= width) return dimensions;
+	if (dimensions.width >= 1 && width > 0 && width < 1) return dimensions;
+	const textWrap = node.style?.textWrap ?? "wrap";
+	const wrappedText = wrapText(text, width, textWrap);
+	return measureText(wrappedText);
+};
+const findClosestYogaNode = (node) => {
+	if (!node?.parentNode) return;
+	return node.yogaNode ?? findClosestYogaNode(node.parentNode);
+};
+const markNodeAsDirty = (node) => {
+	findClosestYogaNode(node)?.markDirty();
+};
+const setTextNodeValue = (node, text) => {
+	if (typeof text !== "string") text = String(text);
+	node.nodeValue = text;
+	markNodeAsDirty(node);
+};
+const addLayoutListener = (rootNode, listener) => {
+	if (rootNode.nodeName !== "ink-root") return () => {};
+	rootNode.internal_layoutListeners ??= /* @__PURE__ */ new Set();
+	rootNode.internal_layoutListeners.add(listener);
+	return () => {
+		rootNode.internal_layoutListeners?.delete(listener);
+	};
+};
+const emitLayoutListeners = (rootNode) => {
+	if (rootNode.nodeName !== "ink-root" || !rootNode.internal_layoutListeners) return;
+	for (const listener of rootNode.internal_layoutListeners) listener();
+};
+//#endregion
+//#region src/instances.ts
+const instances = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/is-in-ci.ts
+const check = (key) => key in process.env && process.env[key] !== "0" && process.env[key] !== "false";
+const isInCi = check("CI") || check("CONTINUOUS_INTEGRATION");
+//#endregion
+//#region src/kitty-keyboard.ts
+const kittyFlags = {
+	disambiguateEscapeCodes: 1,
+	reportEventTypes: 2,
+	reportAlternateKeys: 4,
+	reportAllKeysAsEscapeCodes: 8,
+	reportAssociatedText: 16
+};
+function resolveFlags(flags) {
+	let result = 0;
+	for (const flag of flags) result |= kittyFlags[flag];
+	return result;
+}
+const kittyModifiers = {
+	shift: 1,
+	alt: 2,
+	ctrl: 4,
+	super: 8,
+	hyper: 16,
+	meta: 32,
+	capsLock: 64,
+	numLock: 128
+};
+//#endregion
+//#region src/log-update.ts
+const visibleLineCount = (lines, str) => str.endsWith("\n") ? lines.length - 1 : lines.length;
+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 = (str, activeCursor) => {
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		return str !== previousOutput || cursorChanged;
+	};
+	const render = (str) => {
+		if (!showCursor && !hasHiddenCursor) {
+			cliCursor.hide(stream);
+			hasHiddenCursor = true;
+		}
+		const activeCursor = getActiveCursor();
+		cursorDirty = false;
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		if (!hasChanges(str, activeCursor)) return false;
+		const lines = str.split("\n");
+		const cursorSuffix = buildCursorSuffix(lines.length - 1, activeCursor);
+		if (str === previousOutput && cursorChanged) stream.write(buildCursorOnlySequence({
+			cursorWasShown,
+			previousLineCount,
+			previousCursorPosition,
+			cursorPosition: activeCursor
+		}));
+		else {
+			previousOutput = str;
+			const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
+			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLineCount) + str + 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 + ansiEscapes.eraseLines(previousLineCount));
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.done = () => {
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+		if (!showCursor) {
+			cliCursor.show(stream);
+			hasHiddenCursor = false;
+		}
+	};
+	render.reset = () => {
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.sync = (str) => {
+		const activeCursor = cursorDirty ? cursorPosition : void 0;
+		cursorDirty = false;
+		const lines = str.split("\n");
+		previousOutput = str;
+		previousLineCount = lines.length;
+		if (!activeCursor && cursorWasShown) stream.write(hideCursorEscape);
+		if (activeCursor) stream.write(buildCursorSuffix(lines.length - 1, activeCursor));
+		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+		cursorWasShown = activeCursor !== void 0;
+	};
+	render.setCursorPosition = (position) => {
+		cursorPosition = position;
+		cursorDirty = true;
+	};
+	render.isCursorDirty = () => cursorDirty;
+	render.willRender = (str) => hasChanges(str, 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 = (str, activeCursor) => {
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		return str !== previousOutput || cursorChanged;
+	};
+	const render = (str) => {
+		if (!showCursor && !hasHiddenCursor) {
+			cliCursor.hide(stream);
+			hasHiddenCursor = true;
+		}
+		const activeCursor = getActiveCursor();
+		cursorDirty = false;
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		if (!hasChanges(str, activeCursor)) return false;
+		const nextLines = str.split("\n");
+		const visibleCount = visibleLineCount(nextLines, str);
+		const previousVisible = visibleLineCount(previousLines, previousOutput);
+		if (str === previousOutput && cursorChanged) {
+			stream.write(buildCursorOnlySequence({
+				cursorWasShown,
+				previousLineCount: previousLines.length,
+				previousCursorPosition,
+				cursorPosition: activeCursor
+			}));
+			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+			cursorWasShown = activeCursor !== void 0;
+			return true;
+		}
+		const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+		if (str === "\n" || previousOutput.length === 0) {
+			const cursorSuffix = buildCursorSuffix(nextLines.length - 1, activeCursor);
+			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLines.length) + str + cursorSuffix);
+			cursorWasShown = activeCursor !== void 0;
+			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+			previousOutput = str;
+			previousLines = nextLines;
+			return true;
+		}
+		if (visibleCount > previousVisible) {
+			const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLines.length) + str + cursorSuffix);
+			cursorWasShown = activeCursor !== void 0;
+			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+			previousOutput = str;
+			previousLines = nextLines;
+			return true;
+		}
+		const hasTrailingNewline = str.endsWith("\n");
+		const buffer = [];
+		buffer.push(returnPrefix);
+		if (visibleCount < previousVisible) {
+			const extraSlot = previousOutput.endsWith("\n") ? 1 : 0;
+			buffer.push(ansiEscapes.eraseLines(previousVisible - visibleCount + extraSlot), ansiEscapes.cursorUp(visibleCount));
+		} else buffer.push(ansiEscapes.cursorUp(previousLines.length - 1));
+		for (let i = 0; i < visibleCount; i++) {
+			const isLastLine = i === visibleCount - 1;
+			if (nextLines[i] === previousLines[i]) {
+				if (!isLastLine || hasTrailingNewline) buffer.push(ansiEscapes.cursorNextLine);
+				continue;
+			}
+			buffer.push(ansiEscapes.cursorTo(0) + nextLines[i] + ansiEscapes.eraseEndLine + (isLastLine && !hasTrailingNewline ? "" : "\n"));
+		}
+		const cursorSuffix = buildCursorSuffix(nextLines.length - 1, activeCursor);
+		buffer.push(cursorSuffix);
+		stream.write(buffer.join(""));
+		cursorWasShown = activeCursor !== void 0;
+		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+		previousOutput = str;
+		previousLines = nextLines;
+		return true;
+	};
+	render.clear = () => {
+		const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+		stream.write(prefix + ansiEscapes.eraseLines(previousLines.length));
+		previousOutput = "";
+		previousLines = [];
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.done = () => {
+		previousOutput = "";
+		previousLines = [];
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+		if (!showCursor) {
+			cliCursor.show(stream);
+			hasHiddenCursor = false;
+		}
+	};
+	render.reset = () => {
+		previousOutput = "";
+		previousLines = [];
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.sync = (str) => {
+		const activeCursor = cursorDirty ? cursorPosition : void 0;
+		cursorDirty = false;
+		const lines = str.split("\n");
+		previousOutput = str;
+		previousLines = lines;
+		if (!activeCursor && cursorWasShown) stream.write(hideCursorEscape);
+		if (activeCursor) stream.write(buildCursorSuffix(lines.length - 1, activeCursor));
+		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+		cursorWasShown = activeCursor !== void 0;
+	};
+	render.setCursorPosition = (position) => {
+		cursorPosition = position;
+		cursorDirty = true;
+	};
+	render.isCursorDirty = () => cursorDirty;
+	render.willRender = (str) => hasChanges(str, getActiveCursor());
+	return render;
+};
+const create$1 = (stream, { showCursor = false, incremental = false } = {}) => {
+	if (incremental) return createIncremental(stream, { showCursor });
+	return createStandard(stream, { showCursor });
+};
+const logUpdate = { create: create$1 };
+//#endregion
+//#region src/patch-console.ts
+const consoleMethods = [
+	"assert",
+	"count",
+	"countReset",
+	"debug",
+	"dir",
+	"dirxml",
+	"error",
+	"group",
+	"groupCollapsed",
+	"groupEnd",
+	"info",
+	"log",
+	"table",
+	"time",
+	"timeEnd",
+	"timeLog",
+	"trace",
+	"warn"
+];
+const patchConsole = (callback) => {
+	const stdout = new PassThrough();
+	const stderr = new PassThrough();
+	stdout.write = (data) => {
+		callback("stdout", String(data));
+		return true;
+	};
+	stderr.write = (data) => {
+		callback("stderr", String(data));
+		return true;
+	};
+	const internalConsole = new Console(stdout, stderr);
+	const originalMethods = /* @__PURE__ */ new Map();
+	for (const method of consoleMethods) {
+		originalMethods.set(method, console[method]);
+		console[method] = internalConsole[method];
+	}
+	return () => {
+		for (const method of consoleMethods) console[method] = originalMethods.get(method);
+		originalMethods.clear();
+	};
+};
+//#endregion
+//#region src/styles.ts
+const positionEdges = [
+	["top", Yoga.EDGE_TOP],
+	["right", Yoga.EDGE_RIGHT],
+	["bottom", Yoga.EDGE_BOTTOM],
+	["left", Yoga.EDGE_LEFT]
+];
+const applyPositionStyles = (node, style) => {
+	if ("position" in style) {
+		let positionType = Yoga.POSITION_TYPE_RELATIVE;
+		if (style.position === "absolute") positionType = Yoga.POSITION_TYPE_ABSOLUTE;
+		else if (style.position === "static") positionType = Yoga.POSITION_TYPE_STATIC;
+		node.setPositionType(positionType);
+	}
+	for (const [property, edge] of positionEdges) {
+		if (!(property in style)) continue;
+		const value = style[property];
+		if (typeof value === "string") {
+			node.setPositionPercent(edge, Number.parseFloat(value));
+			continue;
+		}
+		node.setPosition(edge, value);
+	}
+};
+const applyMarginStyles = (node, style) => {
+	if ("margin" in style) node.setMargin(Yoga.EDGE_ALL, style.margin ?? 0);
+	if ("marginX" in style) node.setMargin(Yoga.EDGE_HORIZONTAL, style.marginX ?? 0);
+	if ("marginY" in style) node.setMargin(Yoga.EDGE_VERTICAL, style.marginY ?? 0);
+	if ("marginLeft" in style) node.setMargin(Yoga.EDGE_START, style.marginLeft ?? 0);
+	if ("marginRight" in style) node.setMargin(Yoga.EDGE_END, style.marginRight ?? 0);
+	if ("marginTop" in style) node.setMargin(Yoga.EDGE_TOP, style.marginTop ?? 0);
+	if ("marginBottom" in style) node.setMargin(Yoga.EDGE_BOTTOM, style.marginBottom ?? 0);
+};
+const applyPaddingStyles = (node, style) => {
+	if ("padding" in style) node.setPadding(Yoga.EDGE_ALL, style.padding ?? 0);
+	if ("paddingX" in style) node.setPadding(Yoga.EDGE_HORIZONTAL, style.paddingX ?? 0);
+	if ("paddingY" in style) node.setPadding(Yoga.EDGE_VERTICAL, style.paddingY ?? 0);
+	if ("paddingLeft" in style) node.setPadding(Yoga.EDGE_LEFT, style.paddingLeft ?? 0);
+	if ("paddingRight" in style) node.setPadding(Yoga.EDGE_RIGHT, style.paddingRight ?? 0);
+	if ("paddingTop" in style) node.setPadding(Yoga.EDGE_TOP, style.paddingTop ?? 0);
+	if ("paddingBottom" in style) node.setPadding(Yoga.EDGE_BOTTOM, style.paddingBottom ?? 0);
+};
+const applyFlexStyles = (node, style) => {
+	if ("flexGrow" in style) node.setFlexGrow(style.flexGrow ?? 0);
+	if ("flexShrink" in style) node.setFlexShrink(typeof style.flexShrink === "number" ? style.flexShrink : 1);
+	if ("flexWrap" in style) {
+		if (style.flexWrap === "nowrap") node.setFlexWrap(Yoga.WRAP_NO_WRAP);
+		if (style.flexWrap === "wrap") node.setFlexWrap(Yoga.WRAP_WRAP);
+		if (style.flexWrap === "wrap-reverse") node.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
+	}
+	if ("flexDirection" in style) {
+		if (style.flexDirection === "row") node.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
+		if (style.flexDirection === "row-reverse") node.setFlexDirection(Yoga.FLEX_DIRECTION_ROW_REVERSE);
+		if (style.flexDirection === "column") node.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN);
+		if (style.flexDirection === "column-reverse") node.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN_REVERSE);
+	}
+	if ("flexBasis" in style) {
+		if (typeof style.flexBasis === "number") node.setFlexBasis(style.flexBasis);
+		else if (typeof style.flexBasis === "string") node.setFlexBasisPercent(Number.parseInt(style.flexBasis, 10));
+		else node.setFlexBasisAuto();
+	}
+	if ("alignItems" in style) {
+		if (style.alignItems === "stretch" || !style.alignItems) node.setAlignItems(Yoga.ALIGN_STRETCH);
+		if (style.alignItems === "flex-start") node.setAlignItems(Yoga.ALIGN_FLEX_START);
+		if (style.alignItems === "center") node.setAlignItems(Yoga.ALIGN_CENTER);
+		if (style.alignItems === "flex-end") node.setAlignItems(Yoga.ALIGN_FLEX_END);
+		if (style.alignItems === "baseline") node.setAlignItems(Yoga.ALIGN_BASELINE);
+	}
+	if ("alignSelf" in style) {
+		if (style.alignSelf === "auto" || !style.alignSelf) node.setAlignSelf(Yoga.ALIGN_AUTO);
+		if (style.alignSelf === "flex-start") node.setAlignSelf(Yoga.ALIGN_FLEX_START);
+		if (style.alignSelf === "center") node.setAlignSelf(Yoga.ALIGN_CENTER);
+		if (style.alignSelf === "flex-end") node.setAlignSelf(Yoga.ALIGN_FLEX_END);
+		if (style.alignSelf === "stretch") node.setAlignSelf(Yoga.ALIGN_STRETCH);
+		if (style.alignSelf === "baseline") node.setAlignSelf(Yoga.ALIGN_BASELINE);
+	}
+	if ("alignContent" in style) {
+		if (style.alignContent === "flex-start" || !style.alignContent) node.setAlignContent(Yoga.ALIGN_FLEX_START);
+		if (style.alignContent === "center") node.setAlignContent(Yoga.ALIGN_CENTER);
+		if (style.alignContent === "flex-end") node.setAlignContent(Yoga.ALIGN_FLEX_END);
+		if (style.alignContent === "space-between") node.setAlignContent(Yoga.ALIGN_SPACE_BETWEEN);
+		if (style.alignContent === "space-around") node.setAlignContent(Yoga.ALIGN_SPACE_AROUND);
+		if (style.alignContent === "space-evenly") node.setAlignContent(Yoga.ALIGN_SPACE_EVENLY);
+		if (style.alignContent === "stretch") node.setAlignContent(Yoga.ALIGN_STRETCH);
+	}
+	if ("justifyContent" in style) {
+		if (style.justifyContent === "flex-start" || !style.justifyContent) node.setJustifyContent(Yoga.JUSTIFY_FLEX_START);
+		if (style.justifyContent === "center") node.setJustifyContent(Yoga.JUSTIFY_CENTER);
+		if (style.justifyContent === "flex-end") node.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
+		if (style.justifyContent === "space-between") node.setJustifyContent(Yoga.JUSTIFY_SPACE_BETWEEN);
+		if (style.justifyContent === "space-around") node.setJustifyContent(Yoga.JUSTIFY_SPACE_AROUND);
+		if (style.justifyContent === "space-evenly") node.setJustifyContent(Yoga.JUSTIFY_SPACE_EVENLY);
+	}
+};
+const applyDimensionStyles = (node, style) => {
+	if ("width" in style) {
+		if (typeof style.width === "number") node.setWidth(style.width);
+		else if (typeof style.width === "string") node.setWidthPercent(Number.parseInt(style.width, 10));
+		else node.setWidthAuto();
+	}
+	if ("height" in style) {
+		if (typeof style.height === "number") node.setHeight(style.height);
+		else if (typeof style.height === "string") node.setHeightPercent(Number.parseInt(style.height, 10));
+		else node.setHeightAuto();
+	}
+	if ("minWidth" in style) {
+		if (typeof style.minWidth === "string") node.setMinWidthPercent(Number.parseInt(style.minWidth, 10));
+		else node.setMinWidth(style.minWidth ?? 0);
+	}
+	if ("minHeight" in style) {
+		if (typeof style.minHeight === "string") node.setMinHeightPercent(Number.parseInt(style.minHeight, 10));
+		else node.setMinHeight(style.minHeight ?? 0);
+	}
+	if ("maxWidth" in style) {
+		if (typeof style.maxWidth === "string") node.setMaxWidthPercent(Number.parseInt(style.maxWidth, 10));
+		else node.setMaxWidth(style.maxWidth);
+	}
+	if ("maxHeight" in style) {
+		if (typeof style.maxHeight === "string") node.setMaxHeightPercent(Number.parseInt(style.maxHeight, 10));
+		else node.setMaxHeight(style.maxHeight);
+	}
+	if ("aspectRatio" in style) node.setAspectRatio(style.aspectRatio);
+};
+const applyDisplayStyles = (node, style) => {
+	if ("display" in style) node.setDisplay(style.display === "flex" ? Yoga.DISPLAY_FLEX : Yoga.DISPLAY_NONE);
+};
+const applyBorderStyles = (node, style, currentStyle) => {
+	if (!("borderStyle" in style || "borderTop" in style || "borderBottom" in style || "borderLeft" in style || "borderRight" in style)) return;
+	const borderWidth = currentStyle.borderStyle ? 1 : 0;
+	node.setBorder(Yoga.EDGE_TOP, currentStyle.borderTop === false ? 0 : borderWidth);
+	node.setBorder(Yoga.EDGE_BOTTOM, currentStyle.borderBottom === false ? 0 : borderWidth);
+	node.setBorder(Yoga.EDGE_LEFT, currentStyle.borderLeft === false ? 0 : borderWidth);
+	node.setBorder(Yoga.EDGE_RIGHT, currentStyle.borderRight === false ? 0 : borderWidth);
+};
+const applyGapStyles = (node, style) => {
+	if ("gap" in style) node.setGap(Yoga.GUTTER_ALL, style.gap ?? 0);
+	if ("columnGap" in style) node.setGap(Yoga.GUTTER_COLUMN, style.columnGap ?? 0);
+	if ("rowGap" in style) node.setGap(Yoga.GUTTER_ROW, style.rowGap ?? 0);
+};
+const styles = (node, style = {}, currentStyle = style) => {
+	applyPositionStyles(node, style);
+	applyMarginStyles(node, style);
+	applyPaddingStyles(node, style);
+	applyFlexStyles(node, style);
+	applyDimensionStyles(node, style);
+	applyDisplayStyles(node, style);
+	applyBorderStyles(node, style, currentStyle);
+	applyGapStyles(node, style);
+};
+//#endregion
+//#region src/reconciler.ts
+if (process.env["SIGIL_DEV"] === "true") {
+	let isDevtoolsInstalled = false;
+	try {
+		import.meta.resolve("react-devtools-core");
+		isDevtoolsInstalled = true;
+	} catch {}
+	if (isDevtoolsInstalled) await import("./devtools-BhYGjb7h.js");
+}
+const diff = (before, after) => {
+	if (before === after) return;
+	if (!before) return after;
+	const changed = {};
+	let isChanged = false;
+	for (const key of Object.keys(before)) if (after ? !Object.hasOwn(after, key) : true) {
+		changed[key] = void 0;
+		isChanged = true;
+	}
+	if (after) {
+		for (const key of Object.keys(after)) if (after[key] !== before[key]) {
+			changed[key] = after[key];
+			isChanged = true;
+		}
+	}
+	return isChanged ? changed : void 0;
+};
+const findRootNode$1 = (node) => {
+	let current = node;
+	while (current) {
+		if (current.nodeName === "ink-root") return current;
+		current = current.parentNode;
+	}
+};
+/**
+* Clear the root's cached `staticNode` when the node it points at is being
+* removed as part of a larger subtree.
+*
+* The previous identity check (`staticNode === removeNode`) only caught direct
+* removal of the `<Static>` element. When an *ancestor* of `<Static>` is
+* removed, the stale `staticNode` reference survives and the next render would
+* replay stale static output (and, before `detachYogaSubtree`, trap on detached
+* WASM memory — see QwenLM/qwen-code#6820).
+*
+* The owning root is derived from the host parent passed to the removal hook,
+* not a module-level global, so instances with separate stdout streams don't
+* clobber each other's pointers.
+*/
+const clearStaticNodeIfContained = (rootNode, removeNode) => {
+	if (!rootNode?.staticNode) return;
+	let current = rootNode.staticNode;
+	while (current) {
+		if (current === removeNode) {
+			rootNode.staticNode = void 0;
+			return;
+		}
+		current = current.parentNode;
+	}
+};
+let currentUpdatePriority = NoEventPriority;
+async function loadPackageJson() {
+	const content = (await import("node:fs")).readFileSync(new URL("../package.json", import.meta.url), "utf8");
+	const parsedContent = JSON.parse(content);
+	return {
+		name: parsedContent?.name,
+		version: parsedContent?.version
+	};
+}
+let packageInfo = {
+	name: "ink",
+	version
+};
+if (process.env["DEV"] === "true") try {
+	const loaded = await loadPackageJson();
+	packageInfo = {
+		name: loaded.name || packageInfo.name,
+		version: loaded.version || packageInfo.version
+	};
+} catch (error) {
+	console.warn("Failed to load package.json in development mode. Falling back to default renderer metadata.", error);
+}
+const reconciler = createReconciler({
+	getRootHostContext: () => ({ isInsideText: false }),
+	prepareForCommit: () => null,
+	preparePortalMount: () => null,
+	clearContainer: () => false,
+	resetAfterCommit(rootNode) {
+		if (typeof rootNode.onComputeLayout === "function") rootNode.onComputeLayout();
+		emitLayoutListeners(rootNode);
+		if (rootNode.staticNode !== rootNode.previousStaticNode) {
+			rootNode.previousStaticNode = rootNode.staticNode;
+			if (typeof rootNode.onStaticChange === "function") rootNode.onStaticChange();
+		}
+		if (rootNode.isStaticDirty) {
+			rootNode.isStaticDirty = false;
+			if (typeof rootNode.onImmediateRender === "function") rootNode.onImmediateRender();
+			return;
+		}
+		if (typeof rootNode.onRender === "function") rootNode.onRender();
+	},
+	getChildHostContext(parentHostContext, type) {
+		const previousIsInsideText = parentHostContext.isInsideText;
+		const isInsideText = type === "ink-text" || type === "ink-virtual-text";
+		if (previousIsInsideText === isInsideText) return parentHostContext;
+		return { isInsideText };
+	},
+	shouldSetTextContent: () => false,
+	createInstance(originalType, newProps, rootNode, hostContext) {
+		if (hostContext.isInsideText && originalType === "ink-box") throw new Error(`<Box> can’t be nested inside <Text> component`);
+		const type = originalType === "ink-text" && hostContext.isInsideText ? "ink-virtual-text" : originalType;
+		const node = createNode(type);
+		for (const [key, value] of Object.entries(newProps)) {
+			if (key === "children") continue;
+			if (key === "style") {
+				setStyle(node, value);
+				if (node.yogaNode) styles(node.yogaNode, value);
+				continue;
+			}
+			if (key === "internal_transform") {
+				node.internal_transform = value;
+				continue;
+			}
+			if (key === "internal_static") {
+				node.internal_static = true;
+				rootNode.isStaticDirty = true;
+				rootNode.staticNode = node;
+				continue;
+			}
+			setAttribute(node, key, value);
+		}
+		return node;
+	},
+	createTextInstance(text, _root, hostContext) {
+		if (!hostContext.isInsideText) throw new Error(`Text string "${text}" must be rendered inside <Text> component`);
+		return createTextNode(text);
+	},
+	resetTextContent() {},
+	hideTextInstance(node) {
+		setTextNodeValue(node, "");
+	},
+	unhideTextInstance(node, text) {
+		setTextNodeValue(node, text);
+	},
+	getPublicInstance: (instance) => instance,
+	hideInstance(node) {
+		node.yogaNode?.setDisplay(Yoga.DISPLAY_NONE);
+	},
+	unhideInstance(node) {
+		node.yogaNode?.setDisplay(Yoga.DISPLAY_FLEX);
+	},
+	appendInitialChild: appendChildNode,
+	appendChild: appendChildNode,
+	insertBefore: insertBeforeNode,
+	finalizeInitialChildren() {
+		return false;
+	},
+	isPrimaryRenderer: true,
+	supportsMutation: true,
+	supportsPersistence: false,
+	supportsHydration: false,
+	supportsMicrotasks: true,
+	scheduleMicrotask: queueMicrotask,
+	scheduleCallback: Scheduler.unstable_scheduleCallback,
+	cancelCallback: Scheduler.unstable_cancelCallback,
+	shouldYield: Scheduler.unstable_shouldYield,
+	now: Scheduler.unstable_now,
+	scheduleTimeout: setTimeout,
+	cancelTimeout: clearTimeout,
+	noTimeout: -1,
+	beforeActiveInstanceBlur() {},
+	afterActiveInstanceBlur() {},
+	detachDeletedInstance() {},
+	getInstanceFromNode: () => null,
+	prepareScopeUpdate() {},
+	getInstanceFromScope: () => null,
+	appendChildToContainer: appendChildNode,
+	insertInContainerBefore: insertBeforeNode,
+	removeChildFromContainer(node, removeNode) {
+		clearStaticNodeIfContained(findRootNode$1(node), removeNode);
+		removeChildNode(node, removeNode);
+		detachYogaSubtree(removeNode);
+	},
+	commitUpdate(node, _type, oldProps, newProps) {
+		if (node.internal_static) {
+			const rootNode = findRootNode$1(node);
+			if (rootNode) rootNode.isStaticDirty = true;
+		}
+		const props = diff(oldProps, newProps);
+		const style = diff(oldProps["style"], newProps["style"]);
+		if (!props && !style) return;
+		if (props) for (const [key, value] of Object.entries(props)) {
+			if (key === "style") {
+				setStyle(node, value);
+				continue;
+			}
+			if (key === "internal_transform") {
+				node.internal_transform = value;
+				continue;
+			}
+			if (key === "internal_static") {
+				node.internal_static = true;
+				continue;
+			}
+			setAttribute(node, key, value);
+		}
+		if (style && node.yogaNode) styles(node.yogaNode, style, newProps["style"] ?? {});
+	},
+	commitTextUpdate(node, _oldText, newText) {
+		setTextNodeValue(node, newText);
+	},
+	removeChild(node, removeNode) {
+		clearStaticNodeIfContained(findRootNode$1(node), removeNode);
+		removeChildNode(node, removeNode);
+		detachYogaSubtree(removeNode);
+	},
+	setCurrentUpdatePriority(newPriority) {
+		currentUpdatePriority = newPriority;
+	},
+	getCurrentUpdatePriority: () => currentUpdatePriority,
+	resolveUpdatePriority() {
+		if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
+		return DefaultEventPriority;
+	},
+	maySuspendCommit() {
+		return true;
+	},
+	NotPendingTransition: void 0,
+	HostTransitionContext: createContext(null),
+	resetFormInstance() {},
+	requestPostPaintCallback() {},
+	shouldAttemptEagerTransition() {
+		return false;
+	},
+	trackSchedulerEvent() {},
+	resolveEventType() {
+		return null;
+	},
+	resolveEventTimeStamp() {
+		return -1.1;
+	},
+	preloadInstance() {
+		return true;
+	},
+	startSuspendingCommit() {},
+	suspendInstance() {},
+	waitForCommitToBeReady() {
+		return null;
+	},
+	rendererPackageName: packageInfo.name,
+	rendererVersion: packageInfo.version
+});
+//#endregion
+//#region src/output.ts
+var OutputCaches = class {
+	widths = /* @__PURE__ */ new Map();
+	blockWidths = /* @__PURE__ */ new Map();
+	styledChars = /* @__PURE__ */ new Map();
+	getStyledChars(line) {
+		let cached = this.styledChars.get(line);
+		if (cached === void 0) {
+			cached = styledCharsFromTokens(tokenize(line));
+			this.styledChars.set(line, cached);
+		}
+		return cached;
+	}
+	getStringWidth(text) {
+		let cached = this.widths.get(text);
+		if (cached === void 0) {
+			cached = stringWidth(text);
+			this.widths.set(text, cached);
+		}
+		return cached;
+	}
+	getWidestLine(text) {
+		let cached = this.blockWidths.get(text);
+		if (cached === void 0) {
+			let lineWidth = 0;
+			for (const line of text.split("\n")) lineWidth = Math.max(lineWidth, this.getStringWidth(line));
+			cached = lineWidth;
+			this.blockWidths.set(text, cached);
+		}
+		return cached;
+	}
+};
+var Output = class {
+	width;
+	height;
+	operations = [];
+	caches = new OutputCaches();
+	constructor(options) {
+		const { width, height } = options;
+		this.width = width;
+		this.height = height;
+	}
+	write(x, y, text, options) {
+		const { transformers } = options;
+		if (!text) return;
+		this.operations.push({
+			type: "write",
+			x,
+			y,
+			text,
+			transformers
+		});
+	}
+	clip(clip) {
+		this.operations.push({
+			type: "clip",
+			clip
+		});
+	}
+	unclip() {
+		this.operations.push({ type: "unclip" });
+	}
+	get() {
+		const output = [];
+		for (let y = 0; y < this.height; y++) {
+			const row = [];
+			for (let x = 0; x < this.width; x++) row.push({
+				type: "char",
+				value: " ",
+				fullWidth: false,
+				styles: []
+			});
+			output.push(row);
+		}
+		const clips = [];
+		for (const operation of this.operations) {
+			if (operation.type === "clip") clips.push(operation.clip);
+			if (operation.type === "unclip") clips.pop();
+			if (operation.type === "write") {
+				const { text, transformers } = operation;
+				let { x, y } = operation;
+				let lines = text.split("\n");
+				const clip = clips.at(-1);
+				if (clip) {
+					const clipHorizontally = typeof clip?.x1 === "number" && typeof clip?.x2 === "number";
+					const clipVertically = typeof clip?.y1 === "number" && typeof clip?.y2 === "number";
+					if (clipHorizontally) {
+						const width = this.caches.getWidestLine(text);
+						if (x + width < clip.x1 || x > clip.x2) continue;
+					}
+					if (clipVertically) {
+						const height = lines.length;
+						if (y + height < clip.y1 || y > clip.y2) continue;
+					}
+					if (clipHorizontally) {
+						lines = lines.map((line) => {
+							const from = x < clip.x1 ? clip.x1 - x : 0;
+							const width = this.caches.getStringWidth(line);
+							const to = x + width > clip.x2 ? clip.x2 - x : width;
+							return sliceAnsi(line, from, to);
+						});
+						if (x < clip.x1) x = clip.x1;
+					}
+					if (clipVertically) {
+						const from = y < clip.y1 ? clip.y1 - y : 0;
+						const height = lines.length;
+						const to = y + height > clip.y2 ? clip.y2 - y : height;
+						lines = lines.slice(from, to);
+						if (y < clip.y1) y = clip.y1;
+					}
+				}
+				let offsetY = 0;
+				for (let [index, line] of lines.entries()) {
+					const currentLine = output[y + offsetY];
+					if (!currentLine) continue;
+					for (const transformer of transformers) line = transformer(line, index);
+					const characters = this.caches.getStyledChars(line);
+					let offsetX = x;
+					if (characters.length === 0) {
+						offsetY++;
+						continue;
+					}
+					const spaceCell = {
+						type: "char",
+						value: " ",
+						fullWidth: false,
+						styles: []
+					};
+					if (currentLine[offsetX]?.value === "" && offsetX > 0 && this.caches.getStringWidth(currentLine[offsetX - 1]?.value ?? "") > 1) currentLine[offsetX - 1] = spaceCell;
+					for (const character of characters) {
+						currentLine[offsetX] = character;
+						const characterWidth = Math.max(1, this.caches.getStringWidth(character.value));
+						if (characterWidth > 1) for (let columnOffset = 1; columnOffset < characterWidth; columnOffset++) currentLine[offsetX + columnOffset] = {
+							type: "char",
+							value: "",
+							fullWidth: false,
+							styles: character.styles
+						};
+						offsetX += characterWidth;
+					}
+					if (currentLine[offsetX]?.value === "") currentLine[offsetX] = spaceCell;
+					offsetY++;
+				}
+			}
+		}
+		return {
+			output: output.map((line) => {
+				const lineWithoutEmptyItems = line.filter((item) => item !== void 0);
+				return styledCharsToString(lineWithoutEmptyItems).trimEnd();
+			}).join("\n"),
+			height: output.length
+		};
+	}
+};
+//#endregion
+//#region src/get-max-width.ts
+const getMaxWidth = (yogaNode) => {
+	return yogaNode.getComputedWidth() - yogaNode.getComputedPadding(Yoga.EDGE_LEFT) - yogaNode.getComputedPadding(Yoga.EDGE_RIGHT) - yogaNode.getComputedBorder(Yoga.EDGE_LEFT) - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT);
+};
+//#endregion
+//#region src/indent-string.ts
+const indentString = (string, count = 1, options = {}) => {
+	const { indent = " ", includeEmptyLines = false } = options;
+	if (count === 0) return string;
+	const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+	return string.replace(regex, indent.repeat(count));
+};
+//#endregion
+//#region src/render-background.ts
+const renderBackground = (x, y, node, output) => {
+	if (!node.style.backgroundColor) return;
+	const width = node.yogaNode.getComputedWidth();
+	const height = node.yogaNode.getComputedHeight();
+	const leftBorderWidth = node.style.borderStyle && node.style.borderLeft !== false ? 1 : 0;
+	const rightBorderWidth = node.style.borderStyle && node.style.borderRight !== false ? 1 : 0;
+	const topBorderHeight = node.style.borderStyle && node.style.borderTop !== false ? 1 : 0;
+	const bottomBorderHeight = node.style.borderStyle && node.style.borderBottom !== false ? 1 : 0;
+	const contentWidth = width - leftBorderWidth - rightBorderWidth;
+	const contentHeight = height - topBorderHeight - bottomBorderHeight;
+	if (!(contentWidth > 0 && contentHeight > 0)) return;
+	const backgroundLine = colorize(" ".repeat(contentWidth), node.style.backgroundColor, "background");
+	for (let row = 0; row < contentHeight; row++) output.write(x + leftBorderWidth, y + topBorderHeight + row, backgroundLine, { transformers: [] });
+};
+//#endregion
+//#region src/boxes.ts
+const boxes = {
+	single: {
+		topLeft: "┌",
+		top: "─",
+		topRight: "┐",
+		right: "│",
+		bottomRight: "┘",
+		bottom: "─",
+		bottomLeft: "└",
+		left: "│"
+	},
+	double: {
+		topLeft: "╔",
+		top: "═",
+		topRight: "╗",
+		right: "║",
+		bottomRight: "╝",
+		bottom: "═",
+		bottomLeft: "╚",
+		left: "║"
+	},
+	round: {
+		topLeft: "╭",
+		top: "─",
+		topRight: "╮",
+		right: "│",
+		bottomRight: "╯",
+		bottom: "─",
+		bottomLeft: "╰",
+		left: "│"
+	},
+	bold: {
+		topLeft: "┏",
+		top: "━",
+		topRight: "┓",
+		right: "┃",
+		bottomRight: "┛",
+		bottom: "━",
+		bottomLeft: "┗",
+		left: "┃"
+	},
+	singleDouble: {
+		topLeft: "╓",
+		top: "─",
+		topRight: "╖",
+		right: "║",
+		bottomRight: "╜",
+		bottom: "─",
+		bottomLeft: "╙",
+		left: "║"
+	},
+	doubleSingle: {
+		topLeft: "╒",
+		top: "═",
+		topRight: "╕",
+		right: "│",
+		bottomRight: "╛",
+		bottom: "═",
+		bottomLeft: "╘",
+		left: "│"
+	},
+	classic: {
+		topLeft: "+",
+		top: "-",
+		topRight: "+",
+		right: "|",
+		bottomRight: "+",
+		bottom: "-",
+		bottomLeft: "+",
+		left: "|"
+	},
+	arrow: {
+		topLeft: "↘",
+		top: "↓",
+		topRight: "↙",
+		right: "←",
+		bottomRight: "↖",
+		bottom: "↑",
+		bottomLeft: "↗",
+		left: "→"
+	}
+};
+//#endregion
+//#region src/render-border.ts
+const stylePiece = (segment, fg, bg, dim) => {
+	let styled = colorize(segment, fg, "foreground");
+	styled = colorize(styled, bg, "background");
+	if (dim) styled = chalk.dim(styled);
+	return styled;
+};
+const renderBorder = (x, y, node, output) => {
+	if (node.style.borderStyle) {
+		const width = node.yogaNode.getComputedWidth();
+		const height = node.yogaNode.getComputedHeight();
+		const box = typeof node.style.borderStyle === "string" ? boxes[node.style.borderStyle] : node.style.borderStyle;
+		const topBorderColor = node.style.borderTopColor ?? node.style.borderColor;
+		const bottomBorderColor = node.style.borderBottomColor ?? node.style.borderColor;
+		const leftBorderColor = node.style.borderLeftColor ?? node.style.borderColor;
+		const rightBorderColor = node.style.borderRightColor ?? node.style.borderColor;
+		const topBorderBackgroundColor = node.style.borderTopBackgroundColor ?? node.style.borderBackgroundColor;
+		const bottomBorderBackgroundColor = node.style.borderBottomBackgroundColor ?? node.style.borderBackgroundColor;
+		const leftBorderBackgroundColor = node.style.borderLeftBackgroundColor ?? node.style.borderBackgroundColor;
+		const rightBorderBackgroundColor = node.style.borderRightBackgroundColor ?? node.style.borderBackgroundColor;
+		const dimTopBorderColor = node.style.borderTopDimColor ?? node.style.borderDimColor;
+		const dimBottomBorderColor = node.style.borderBottomDimColor ?? node.style.borderDimColor;
+		const dimLeftBorderColor = node.style.borderLeftDimColor ?? node.style.borderDimColor;
+		const dimRightBorderColor = node.style.borderRightDimColor ?? node.style.borderDimColor;
+		const showTopBorder = node.style.borderTop !== false;
+		const showBottomBorder = node.style.borderBottom !== false;
+		const showLeftBorder = node.style.borderLeft !== false;
+		const showRightBorder = node.style.borderRight !== false;
+		const contentWidth = width - (showLeftBorder ? 1 : 0) - (showRightBorder ? 1 : 0);
+		let topBorder = showTopBorder ? (showLeftBorder ? box.topLeft : "") + box.top.repeat(contentWidth) + (showRightBorder ? box.topRight : "") : void 0;
+		topBorder &&= stylePiece(topBorder, topBorderColor, topBorderBackgroundColor, dimTopBorderColor);
+		let verticalBorderHeight = height;
+		if (showTopBorder) verticalBorderHeight -= 1;
+		if (showBottomBorder) verticalBorderHeight -= 1;
+		let leftBorder = "";
+		if (showLeftBorder) leftBorder = (stylePiece(box.left, leftBorderColor, leftBorderBackgroundColor, dimLeftBorderColor) + "\n").repeat(verticalBorderHeight);
+		let rightBorder = "";
+		if (showRightBorder) rightBorder = (stylePiece(box.right, rightBorderColor, rightBorderBackgroundColor, dimRightBorderColor) + "\n").repeat(verticalBorderHeight);
+		let bottomBorder = showBottomBorder ? (showLeftBorder ? box.bottomLeft : "") + box.bottom.repeat(contentWidth) + (showRightBorder ? box.bottomRight : "") : void 0;
+		bottomBorder &&= stylePiece(bottomBorder, bottomBorderColor, bottomBorderBackgroundColor, dimBottomBorderColor);
+		const offsetY = showTopBorder ? 1 : 0;
+		if (topBorder) output.write(x, y, topBorder, { transformers: [] });
+		if (leftBorder) output.write(x, y + offsetY, leftBorder, { transformers: [] });
+		if (rightBorder) output.write(x + width - 1, y + offsetY, rightBorder, { transformers: [] });
+		if (bottomBorder) output.write(x, y + height - 1, bottomBorder, { transformers: [] });
+	}
+};
+//#endregion
+//#region src/render-node-to-output.ts
+const applyPaddingToText = (node, text) => {
+	const yogaNode = node.childNodes[0]?.yogaNode;
+	if (yogaNode) {
+		const offsetX = yogaNode.getComputedLeft();
+		const offsetY = yogaNode.getComputedTop();
+		text = "\n".repeat(offsetY) + indentString(text, offsetX);
+	}
+	return text;
+};
+const renderNodeToScreenReaderOutput = (node, options = {}) => {
+	if (options.skipStaticElements && node.internal_static) return "";
+	if (node.yogaNode?.getDisplay() === Yoga.DISPLAY_NONE) return "";
+	let output = "";
+	if (node.nodeName === "ink-text") output = squashTextNodes(node);
+	else if (node.nodeName === "ink-box" || node.nodeName === "ink-root") {
+		const separator = node.style.flexDirection === "row" || node.style.flexDirection === "row-reverse" ? " " : "\n";
+		output = (node.style.flexDirection === "row-reverse" || node.style.flexDirection === "column-reverse" ? [...node.childNodes].reverse() : [...node.childNodes]).map((childNode) => {
+			return renderNodeToScreenReaderOutput(childNode, {
+				parentRole: node.internal_accessibility?.role,
+				skipStaticElements: options.skipStaticElements
+			});
+		}).filter(Boolean).join(separator);
+	}
+	if (node.internal_accessibility) {
+		const { role, state } = node.internal_accessibility;
+		if (state) {
+			const stateDescription = Object.keys(state).filter((key) => state[key]).join(", ");
+			if (stateDescription) output = `(${stateDescription}) ${output}`;
+		}
+		if (role && role !== options.parentRole) output = `${role}: ${output}`;
+	}
+	return output;
+};
+const renderNodeToOutput = (node, output, options) => {
+	const { offsetX = 0, offsetY = 0, transformers = [], skipStaticElements } = options;
+	if (skipStaticElements && node.internal_static) return;
+	const { yogaNode } = node;
+	if (yogaNode) {
+		if (yogaNode.getDisplay() === Yoga.DISPLAY_NONE) return;
+		const x = offsetX + yogaNode.getComputedLeft();
+		const y = offsetY + yogaNode.getComputedTop();
+		let newTransformers = transformers;
+		if (typeof node.internal_transform === "function") newTransformers = [node.internal_transform, ...transformers];
+		if (node.nodeName === "ink-text") {
+			let text = squashTextNodes(node);
+			if (text.length > 0) {
+				const currentWidth = widestLine(text);
+				const maxWidth = getMaxWidth(yogaNode);
+				if (currentWidth > maxWidth) {
+					const textWrap = node.style.textWrap ?? "wrap";
+					text = wrapText(text, maxWidth, textWrap);
+				}
+				text = applyPaddingToText(node, text);
+				output.write(x, y, text, { transformers: newTransformers });
+			}
+			return;
+		}
+		let clipped = false;
+		if (node.nodeName === "ink-box") {
+			renderBackground(x, y, node, output);
+			renderBorder(x, y, node, output);
+			const clipHorizontally = node.style.overflowX === "hidden" || node.style.overflow === "hidden";
+			const clipVertically = node.style.overflowY === "hidden" || node.style.overflow === "hidden";
+			if (clipHorizontally || clipVertically) {
+				const x1 = clipHorizontally ? x + yogaNode.getComputedBorder(Yoga.EDGE_LEFT) : void 0;
+				const x2 = clipHorizontally ? x + yogaNode.getComputedWidth() - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT) : void 0;
+				const y1 = clipVertically ? y + yogaNode.getComputedBorder(Yoga.EDGE_TOP) : void 0;
+				const y2 = clipVertically ? y + yogaNode.getComputedHeight() - yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM) : void 0;
+				output.clip({
+					x1,
+					x2,
+					y1,
+					y2
+				});
+				clipped = true;
+			}
+		}
+		if (node.nodeName === "ink-root" || node.nodeName === "ink-box") {
+			for (const childNode of node.childNodes) renderNodeToOutput(childNode, output, {
+				offsetX: x,
+				offsetY: y,
+				transformers: newTransformers,
+				skipStaticElements
+			});
+			if (clipped) output.unclip();
+		}
+	}
+};
+//#endregion
+//#region src/renderer.ts
+const renderer = (node, isScreenReaderEnabled) => {
+	if (node.yogaNode) {
+		if (isScreenReaderEnabled) {
+			const output = renderNodeToScreenReaderOutput(node, { skipStaticElements: true });
+			const outputHeight = output === "" ? 0 : output.split("\n").length;
+			let staticOutput = "";
+			if (node.staticNode) staticOutput = renderNodeToScreenReaderOutput(node.staticNode, { skipStaticElements: false });
+			return {
+				output,
+				outputHeight,
+				staticOutput: staticOutput ? `${staticOutput}\n` : ""
+			};
+		}
+		const output = new Output({
+			width: node.yogaNode.getComputedWidth(),
+			height: node.yogaNode.getComputedHeight()
+		});
+		renderNodeToOutput(node, output, { skipStaticElements: true });
+		let staticOutput;
+		if (node.staticNode?.yogaNode) {
+			staticOutput = new Output({
+				width: node.staticNode.yogaNode.getComputedWidth(),
+				height: node.staticNode.yogaNode.getComputedHeight()
+			});
+			renderNodeToOutput(node.staticNode, staticOutput, { skipStaticElements: false });
+		}
+		const { output: generatedOutput, height: outputHeight } = output.get();
+		return {
+			output: generatedOutput,
+			outputHeight,
+			staticOutput: staticOutput ? `${staticOutput.get().output}\n` : ""
+		};
+	}
+	return {
+		output: "",
+		outputHeight: 0,
+		staticOutput: ""
+	};
+};
+//#endregion
+//#region src/throttle.ts
+/**
+Invokes `fn` at most once per `wait` milliseconds.
+
+The first call in a window fires immediately (leading edge). Calls made while
+the window is open are coalesced into a single trailing invocation with the
+latest arguments. Matches the lodash semantics Ink relied on: a single call
+produces only a leading invocation, no trailing one.
+*/
+const throttle = (fn, wait = 0) => {
+	let timer;
+	let pendingArgs;
+	const invokePending = () => {
+		const args = pendingArgs;
+		pendingArgs = void 0;
+		fn(...args);
+	};
+	const onTimer = () => {
+		if (pendingArgs) {
+			invokePending();
+			timer = setTimeout(onTimer, wait);
+		} else timer = void 0;
+	};
+	const throttled = (...args) => {
+		if (timer) {
+			pendingArgs = args;
+			return;
+		}
+		fn(...args);
+		timer = setTimeout(onTimer, wait);
+	};
+	throttled.cancel = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+		pendingArgs = void 0;
+	};
+	throttled.flush = () => {
+		if (!pendingArgs) return;
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+		invokePending();
+	};
+	return throttled;
+};
+//#endregion
+//#region src/terminal-size.ts
+const create = (columns, rows) => ({
+	columns: Number.parseInt(String(columns), 10),
+	rows: Number.parseInt(String(rows), 10)
+});
+const devTty = () => {
+	try {
+		const { O_EVTONLY: evtOnly } = fs.constants;
+		const flags = process.platform === "darwin" && evtOnly !== void 0 ? evtOnly | fs.constants.O_NONBLOCK : fs.constants.O_NONBLOCK;
+		const { columns, rows } = new tty.WriteStream(fs.openSync("/dev/tty", flags));
+		if (columns && rows) return {
+			columns,
+			rows
+		};
+	} catch {}
+};
+const terminalSize = () => {
+	const { env, stdout, stderr } = process;
+	if (stdout?.columns && stdout?.rows) return create(stdout.columns, stdout.rows);
+	if (stderr?.columns && stderr?.rows) return create(stderr.columns, stderr.rows);
+	if (env["COLUMNS"] && env["LINES"]) return create(env["COLUMNS"], env["LINES"]);
+	return devTty() ?? {
+		columns: 80,
+		rows: 24
+	};
+};
+//#endregion
+//#region src/utils.ts
+const resolveDimension = (value, fallback, defaultValue) => {
+	if (value !== void 0 && value > 0) return value;
+	if (fallback !== void 0 && fallback > 0) return fallback;
+	return defaultValue;
+};
+/**
+Get the effective terminal dimensions from the given stdout stream.
+
+Falls back to `terminal-size` for columns in piped processes where `stdout.columns` is 0, and uses standard defaults (80×24) when dimensions cannot be determined.
+*/
+const getWindowSize = (stdout) => {
+	const columns = stdout.columns ?? 0;
+	const rows = stdout.rows ?? 0;
+	if (columns && rows) return {
+		columns,
+		rows
+	};
+	const fallbackSize = terminalSize();
+	return {
+		columns: resolveDimension(columns, fallbackSize.columns, 80),
+		rows: resolveDimension(rows, fallbackSize.rows, 24)
+	};
+};
+//#endregion
+//#region src/write-synchronized.ts
+function shouldSynchronize(stream, interactive) {
+	return "isTTY" in stream && stream.isTTY && (interactive ?? !isInCi);
+}
+//#endregion
+//#region src/ink.tsx
+/** @jsxImportSource react */
+const noop = () => {};
+const textEncoder = new TextEncoder();
+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;
+	let index = startIndex + 3;
+	const digitsStartIndex = index;
+	while (index < buffer.length && isDigitByte(buffer[index])) index++;
+	if (index === digitsStartIndex) return;
+	if (index === buffer.length) return { state: "partial" };
+	if (buffer[index] === kittyQueryLetterByte) return {
+		state: "complete",
+		endIndex: index
+	};
+};
+const hasCompleteKittyQueryResponse = (buffer) => {
+	for (let index = 0; index < buffer.length; index++) if (matchKittyQueryResponse(buffer, index)?.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 isWindowsConsole = process.platform === "win32";
+const shouldClearTerminalForFrame = ({ isTTY, viewportRows, previousOutputHeight, nextOutputHeight, isUnmounting }) => {
+	if (!isTTY) return false;
+	const hadPreviousFrame = previousOutputHeight > 0;
+	const wasFullscreen = previousOutputHeight >= viewportRows;
+	const wasOverflowing = previousOutputHeight > viewportRows;
+	const isOverflowing = nextOutputHeight > viewportRows;
+	const isFullscreen = nextOutputHeight >= viewportRows;
+	const isLeavingFullscreen = wasOverflowing && nextOutputHeight < viewportRows;
+	const shouldClearOnUnmount = isUnmounting && wasFullscreen;
+	if (isWindowsConsole && (wasFullscreen || isFullscreen)) return true;
+	return wasOverflowing || isOverflowing && hadPreviousFrame || isLeavingFullscreen || shouldClearOnUnmount;
+};
+const isErrorInput = (value) => {
+	return value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
+};
+const getWritableStreamState = (stdout) => {
+	return { canWriteToStdout: !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true) };
+};
+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();
+};
+const createRenderPassthrough = (stream) => {
+	const passthrough = Object.create(stream);
+	passthrough.write = stream.write.bind(stream);
+	passthrough.on = stream.on.bind(stream);
+	passthrough.off = stream.off.bind(stream);
+	passthrough.once = stream.once.bind(stream);
+	passthrough.addListener = stream.addListener.bind(stream);
+	passthrough.removeListener = stream.removeListener.bind(stream);
+	passthrough.emit = stream.emit.bind(stream);
+	return passthrough;
+};
+var Ink = class {
+	/**
+	Whether this instance is using concurrent rendering mode.
+	*/
+	isConcurrent;
+	options;
+	log;
+	cursorPosition;
+	throttledLog;
+	isScreenReaderEnabled;
+	interactive;
+	renderThrottleMs;
+	alternateScreen;
+	isUnmounted;
+	isUnmounting;
+	lastOutput;
+	lastOutputToRender;
+	lastOutputHeight;
+	lastTerminalWidth;
+	lastTerminalHeight;
+	container;
+	rootNode;
+	fullStaticOutput;
+	exitPromise;
+	exitResult;
+	beforeExitHandler;
+	restoreConsole;
+	captureTargets;
+	capturedStdioTails = {
+		stdout: "",
+		stderr: ""
+	};
+	unsubscribeResize;
+	throttledOnRender;
+	hasPendingThrottledRender = false;
+	kittyProtocolEnabled = false;
+	kittyFlags;
+	cancelKittyDetection;
+	nextRenderCommit;
+	isSuspended = false;
+	pauseInput;
+	resumeInput;
+	constructor(options) {
+		autoBind(this);
+		if (options.patchConsole === "stdio") {
+			this.captureTargets = {
+				stdout: options.stdout,
+				stderr: options.stderr
+			};
+			options = {
+				...options,
+				stdout: createRenderPassthrough(options.stdout),
+				stderr: createRenderPassthrough(options.stderr)
+			};
+		}
+		this.options = options;
+		this.rootNode = createNode("ink-root");
+		this.rootNode.onComputeLayout = this.calculateLayout;
+		this.isScreenReaderEnabled = options.isScreenReaderEnabled ?? process.env["SIGIL_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;
+		if (unthrottled) {
+			this.rootNode.onRender = this.onRender;
+			this.throttledOnRender = void 0;
+		} else {
+			const throttled = throttle(this.onRender, renderThrottleMs);
+			this.rootNode.onRender = () => {
+				this.hasPendingThrottledRender = true;
+				throttled();
+			};
+			this.throttledOnRender = throttled;
+		}
+		this.rootNode.onImmediateRender = this.onRender;
+		this.rootNode.onStaticChange = this.handleStaticChange;
+		this.log = logUpdate.create(options.stdout, { incremental: options.incrementalRendering });
+		this.cursorPosition = void 0;
+		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);
+		});
+		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.lastTerminalHeight = getWindowSize(this.options.stdout).rows;
+		this.fullStaticOutput = "";
+		const rootTag = options.concurrent ? ConcurrentRoot : LegacyRoot;
+		this.container = reconciler.createContainer(this.rootNode, rootTag, null, false, null, "id", () => {}, () => {}, () => {}, () => {});
+		this.unsubscribeExit = signalExit(this.unmount.bind(this), { alwaysLast: false });
+		this.setAlternateScreen(Boolean(options.alternateScreen));
+		if (process.env["SIGIL_DEV"] === "true") reconciler.injectIntoDevTools();
+		if (options.patchConsole) this.patchConsole();
+		if (this.interactive) {
+			options.stdout.on("resize", this.resized);
+			this.unsubscribeResize = () => {
+				options.stdout.off("resize", this.resized);
+			};
+		}
+		this.initKittyKeyboard();
+		this.exitPromise = new Promise((resolve, reject) => {
+			this.resolveExitPromise = resolve;
+			this.rejectExitPromise = reject;
+		});
+		this.exitPromise.catch(noop);
+	}
+	resized = () => {
+		const currentWidth = getWindowSize(this.options.stdout).columns;
+		const currentHeight = getWindowSize(this.options.stdout).rows;
+		if (currentWidth < this.lastTerminalWidth || currentHeight !== this.lastTerminalHeight) {
+			this.log.clear();
+			this.lastOutput = "";
+			this.lastOutputToRender = "";
+			this.lastOutputHeight = 0;
+		}
+		this.calculateLayout();
+		emitLayoutListeners(this.rootNode);
+		this.onRender();
+		this.lastTerminalWidth = currentWidth;
+		this.lastTerminalHeight = currentHeight;
+	};
+	resolveExitPromise = () => {};
+	rejectExitPromise = () => {};
+	unsubscribeExit = () => {};
+	handleAppExit = (errorOrResult) => {
+		if (this.isUnmounted || this.isUnmounting) return;
+		if (isErrorInput(errorOrResult)) {
+			this.unmount(errorOrResult);
+			return;
+		}
+		this.exitResult = errorOrResult;
+		this.unmount();
+	};
+	setCursorPosition = (position) => {
+		this.cursorPosition = position;
+		this.log.setCursorPosition(position);
+	};
+	restoreLastOutput = () => {
+		if (!this.interactive) return;
+		this.log.setCursorPosition(this.cursorPosition);
+		this.log(this.lastOutputToRender || this.lastOutput + "\n");
+	};
+	calculateLayout = () => {
+		const terminalWidth = getWindowSize(this.options.stdout).columns;
+		this.rootNode.yogaNode.setWidth(terminalWidth);
+		this.rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+	};
+	handleStaticChange = () => {
+		this.fullStaticOutput = "";
+	};
+	onRender = () => {
+		this.hasPendingThrottledRender = false;
+		if (this.isUnmounted) return;
+		if (this.isSuspended) {
+			if (this.nextRenderCommit) {
+				this.nextRenderCommit.resolve();
+				this.nextRenderCommit = void 0;
+			}
+			return;
+		}
+		if (this.nextRenderCommit) {
+			this.nextRenderCommit.resolve();
+			this.nextRenderCommit = void 0;
+		}
+		const startTime = performance.now();
+		const { output, outputHeight, staticOutput } = renderer(this.rootNode, this.isScreenReaderEnabled);
+		this.options.onRender?.({ renderTime: performance.now() - startTime });
+		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 + "\n";
+			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 ? ansiEscapes.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 = wrapAnsi(output, terminalWidth, {
+				trim: false,
+				hard: true
+			});
+			if (hasStaticOutput) this.options.stdout.write(wrappedOutput);
+			else {
+				const erase = this.lastOutputHeight > 0 ? ansiEscapes.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 : "");
+	};
+	render(node) {
+		const tree = /* @__PURE__ */ jsx(accessibilityContext.Provider, {
+			value: { isScreenReaderEnabled: this.isScreenReaderEnabled },
+			children: /* @__PURE__ */ jsx(App, {
+				stdin: this.options.stdin,
+				stdout: this.options.stdout,
+				stderr: this.options.stderr,
+				exitOnCtrlC: this.options.exitOnCtrlC,
+				interactive: this.interactive,
+				renderThrottleMs: this.renderThrottleMs,
+				writeToStdout: this.writeToStdout.bind(this),
+				writeToStderr: this.writeToStderr.bind(this),
+				setCursorPosition: this.setCursorPosition.bind(this),
+				onExit: this.handleAppExit.bind(this),
+				onWaitUntilRenderFlush: this.waitUntilRenderFlush.bind(this),
+				onSuspendTerminal: this.suspendTerminal.bind(this),
+				onRegisterInputControl: this.registerInputControl.bind(this),
+				children: node
+			})
+		});
+		if (this.options.concurrent) reconciler.updateContainer(tree, this.container, null, noop);
+		else {
+			reconciler.updateContainerSync(tree, this.container, null, noop);
+			reconciler.flushSyncWork();
+		}
+	}
+	writeToStdout(data) {
+		if (this.isUnmounted) return;
+		if (this.isSuspended) 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.isSuspended) 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.off("beforeExit", this.beforeExitHandler);
+			this.beforeExitHandler = void 0;
+		}
+		const { stdout } = this.options;
+		const { canWriteToStdout } = getWritableStreamState(stdout);
+		if (canWriteToStdout) this.flushCapturedStdio();
+		settleThrottle(this.throttledOnRender, canWriteToStdout);
+		if (canWriteToStdout) {
+			if (!this.throttledOnRender || !this.hasPendingThrottledRender && this.fullStaticOutput === "") {
+				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, ansiEscapes.popKittyKeyboard);
+				if (this.alternateScreen) {
+					this.writeBestEffort(this.options.stdout, ansiEscapes.exitAlternativeScreen);
+					this.writeBestEffort(this.options.stdout, showCursorEscape);
+					this.alternateScreen = false;
+				}
+				if (!this.interactive) this.options.stdout.write(this.options.debug ? "\n" : this.lastOutput + "\n");
+				else if (!this.options.debug) this.log.done();
+			}
+			this.kittyProtocolEnabled = false;
+			instances.delete(this.captureTargets?.stdout ?? this.options.stdout);
+			const { exitResult } = this;
+			const resolveOrReject = () => {
+				if (isErrorInput(error)) this.rejectExitPromise(error);
+				else this.resolveExitPromise(exitResult);
+			};
+			if (error !== void 0 && !isErrorInput(error)) resolveOrReject();
+			else if (canWriteToStdout) this.options.stdout.write("", resolveOrReject);
+			else setImmediate(resolveOrReject);
+		};
+		const concurrentReconciler = reconciler;
+		if (this.options.concurrent) {
+			reconciler.updateContainerSync(null, this.container, null, noop);
+			reconciler.flushSyncWork();
+			concurrentReconciler.flushPassiveEffects?.();
+			finishUnmount();
+		} else {
+			reconciler.updateContainerSync(null, this.container, null, noop);
+			reconciler.flushSyncWork();
+			finishUnmount();
+		}
+	}
+	async waitUntilExit() {
+		if (!this.beforeExitHandler) {
+			this.beforeExitHandler = () => {
+				this.unmount();
+			};
+			process.once("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;
+			}
+		}
+		reconciler.flushSyncWork();
+		const { stdout } = this.options;
+		const { canWriteToStdout } = getWritableStreamState(stdout);
+		settleThrottle(this.throttledOnRender, canWriteToStdout);
+		settleThrottle(this.throttledLog, canWriteToStdout);
+		if (canWriteToStdout) {
+			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 + "\n");
+		}
+	}
+	patchConsole() {
+		if (this.options.debug) return;
+		const restoreConsoleMethods = patchConsole((stream, data) => {
+			if (this.options.onCapturedOutput?.(stream, data, "console") === true) return;
+			if (stream === "stdout") this.writeToStdout(data);
+			if (stream === "stderr") {
+				if (!data.startsWith("The above error occurred")) this.writeToStderr(data);
+			}
+		});
+		const restoreDirectStdio = this.patchDirectStdio();
+		this.restoreConsole = () => {
+			restoreConsoleMethods();
+			restoreDirectStdio?.();
+		};
+	}
+	patchDirectStdio() {
+		const targets = this.captureTargets;
+		if (!targets) return;
+		const patch = (name, stream) => {
+			const originalWrite = stream.write;
+			const patchedWrite = (chunk, encodingOrCallback, callback) => {
+				const data = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk).toString() : String(chunk);
+				this.handleCapturedStdio(name, data);
+				(typeof encodingOrCallback === "function" ? encodingOrCallback : typeof callback === "function" ? callback : void 0)?.();
+				return true;
+			};
+			stream.write = patchedWrite;
+			return () => {
+				stream.write = originalWrite;
+			};
+		};
+		const restoreStdout = patch("stdout", targets.stdout);
+		const restoreStderr = patch("stderr", targets.stderr);
+		return () => {
+			restoreStdout();
+			restoreStderr();
+		};
+	}
+	handleCapturedStdio(stream, data) {
+		if (this.options.onCapturedOutput?.(stream, data, "stdio") === true) return;
+		const parts = (this.capturedStdioTails[stream] + data).split(/\r?\n/);
+		this.capturedStdioTails[stream] = parts.pop() ?? "";
+		if (parts.length === 0) return;
+		const payload = parts.join("\n") + "\n";
+		if (stream === "stdout") this.writeToStdout(payload);
+		else this.writeToStderr(payload);
+	}
+	flushCapturedStdio() {
+		for (const stream of ["stdout", "stderr"]) {
+			const tail = this.capturedStdioTails[stream];
+			if (tail === "") continue;
+			this.capturedStdioTails[stream] = "";
+			if (stream === "stdout") this.writeToStdout(tail + "\n");
+			else this.writeToStderr(tail + "\n");
+		}
+	}
+	registerInputControl(pauseInput, resumeInput) {
+		this.pauseInput = pauseInput;
+		this.resumeInput = resumeInput;
+	}
+	async suspendTerminal(callback) {
+		this.beginSuspend();
+		if (callback) {
+			try {
+				await callback();
+			} finally {
+				await this.endSuspend();
+			}
+			return;
+		}
+		const resume = async () => {
+			await this.endSuspend();
+		};
+		return {
+			resume,
+			[Symbol.asyncDispose]: resume
+		};
+	}
+	setAlternateScreen(enabled) {
+		this.alternateScreen = this.resolveAlternateScreenOption(enabled, this.interactive);
+		if (this.alternateScreen) {
+			this.writeBestEffort(this.options.stdout, ansiEscapes.enterAlternativeScreen);
+			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);
+	}
+	writeBestEffort(stream, data) {
+		try {
+			stream.write(data);
+		} catch {}
+	}
+	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 = Boolean(this.options.stdout.isTTY);
+		const viewportRows = isTTY ? getWindowSize(this.options.stdout).rows : 24;
+		if (isTTY && outputHeight > viewportRows) {
+			const lines = output.split("\n");
+			output = lines.slice(lines.length - viewportRows).join("\n");
+			outputHeight = viewportRows;
+		}
+		const outputToRender = isTTY && outputHeight >= viewportRows ? output : output + "\n";
+		if (shouldClearTerminalForFrame({
+			isTTY,
+			viewportRows,
+			previousOutputHeight: this.lastOutputHeight,
+			nextOutputHeight: outputHeight,
+			isUnmounting: this.isUnmounting
+		})) {
+			const sync = this.shouldSync();
+			if (sync) this.options.stdout.write(bsu);
+			this.options.stdout.write(ansiEscapes.clearTerminal + this.fullStaticOutput + outputToRender);
+			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;
+	}
+	initKittyKeyboard() {
+		if (!this.options.kittyKeyboard) return;
+		const opts = this.options.kittyKeyboard;
+		const mode = opts.mode ?? "auto";
+		if (mode === "disabled") return;
+		const flags = opts.flags ?? ["disambiguateEscapeCodes"];
+		if (mode === "enabled") {
+			if (isTty(this.options.stdin) && this.options.stdout.isTTY) this.enableKittyProtocol(flags);
+			return;
+		}
+		if (!this.interactive || !isTty(this.options.stdin) || !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(Uint8Array.from(remaining));
+		};
+		const onData = (data) => {
+			const chunk = typeof data === "string" ? textEncoder.encode(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(ansiEscapes.kittyQuery);
+	}
+	enableKittyProtocol(flags) {
+		this.options.stdout.write(ansiEscapes.pushKittyKeyboard(resolveFlags(flags)));
+		this.kittyProtocolEnabled = true;
+		this.kittyFlags = flags;
+	}
+	beginSuspend() {
+		if (this.isSuspended) throw new Error("The terminal is already suspended. Resume the current suspension before suspending again.");
+		this.isSuspended = true;
+		if (!this.interactive || this.isUnmounted || this.isUnmounting) return;
+		try {
+			const { stdout } = this.options;
+			const { canWriteToStdout } = getWritableStreamState(stdout);
+			settleThrottle(this.throttledOnRender, canWriteToStdout);
+			settleThrottle(this.throttledLog, canWriteToStdout);
+			if (canWriteToStdout) this.flushCapturedStdio();
+			if (canWriteToStdout) {
+				this.log.clear();
+				this.log.done();
+				if (this.kittyProtocolEnabled) this.writeBestEffort(this.options.stdout, ansiEscapes.popKittyKeyboard);
+				if (this.alternateScreen) this.writeBestEffort(this.options.stdout, ansiEscapes.exitAlternativeScreen);
+			}
+			this.pauseInput?.();
+		} catch (error) {
+			this.isSuspended = false;
+			try {
+				this.resumeInput?.();
+			} catch {}
+			throw error;
+		}
+	}
+	async endSuspend() {
+		if (!this.isSuspended) return;
+		this.isSuspended = false;
+		this.resumeInput?.();
+		if (!this.interactive || this.isUnmounted || this.isUnmounting) return;
+		const { stdout } = this.options;
+		const { canWriteToStdout } = getWritableStreamState(stdout);
+		if (canWriteToStdout) {
+			if (this.alternateScreen) this.writeBestEffort(this.options.stdout, ansiEscapes.enterAlternativeScreen);
+			if (this.kittyProtocolEnabled && this.kittyFlags) this.writeBestEffort(this.options.stdout, ansiEscapes.pushKittyKeyboard(resolveFlags(this.kittyFlags)));
+		}
+		this.lastOutput = "";
+		this.lastOutputToRender = "";
+		this.lastOutputHeight = 0;
+		this.log.reset();
+		try {
+			this.calculateLayout();
+			this.onRender();
+			await this.waitUntilRenderFlush();
+		} catch {}
+	}
+};
+//#endregion
+//#region src/render.ts
+/**
+Mount a component and render the output.
+*/
+const render = (node, options) => {
+	const inkOptions = {
+		stdout: process.stdout,
+		stdin: process.stdin,
+		stderr: process.stderr,
+		debug: false,
+		exitOnCtrlC: true,
+		patchConsole: true,
+		maxFps: 30,
+		incrementalRendering: false,
+		concurrent: false,
+		alternateScreen: false,
+		...getOptions(options)
+	};
+	const instance = getInstance(inkOptions.stdout, () => new Ink(inkOptions));
+	instance.render(node);
+	return {
+		rerender: instance.render.bind(instance),
+		unmount() {
+			instance.unmount();
+		},
+		waitUntilExit: instance.waitUntilExit.bind(instance),
+		waitUntilRenderFlush: instance.waitUntilRenderFlush.bind(instance),
+		cleanup() {
+			instance.unmount();
+		},
+		clear: instance.clear.bind(instance)
+	};
+};
+const getOptions = (stdout = {}) => {
+	if (stdout instanceof Stream) return {
+		stdout,
+		stdin: process.stdin
+	};
+	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.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;
+};
+//#endregion
+//#region src/render-to-string.ts
+/**
+Render a React element to a string synchronously. Unlike `render()`, this function does not write to stdout, does not set up any terminal event listeners, and returns the rendered output as a string.
+
+Useful for generating documentation, writing output to files, testing, or any scenario where you need the rendered output as a string without starting a persistent terminal application.
+
+**Notes:**
+
+- Terminal-specific hooks (`useInput`, `useStdin`, `useStdout`, `useStderr`, `useApp`, `useFocus`, `useFocusManager`) return default no-op values since there is no terminal session. They will not throw, but they will not function as in a live terminal.
+- `useEffect` callbacks will execute during rendering (due to synchronous rendering mode), but state updates they trigger will not affect the returned output, which reflects the initial render.
+- `useLayoutEffect` callbacks fire synchronously during commit, so state updates they trigger **will** be reflected in the output.
+- The `<Static>` component is supported — its output is prepended to the dynamic output.
+- If a component throws during rendering, the error is propagated to the caller after cleanup.
+
+@example
+```
+import {renderToString, Text, Box} from 'ink';
+
+const output = renderToString(
+<Box padding={1}>
+<Text color="green">Hello World</Text>
+</Box>,
+{columns: 40}
+);
+
+console.log(output);
+```
+*/
+const renderToString = (node, options) => {
+	const columns = options?.columns ?? 80;
+	const rootNode = createNode("ink-root");
+	let capturedStaticOutput = "";
+	rootNode.onComputeLayout = () => {
+		rootNode.yogaNode.setWidth(columns);
+		rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+	};
+	rootNode.onImmediateRender = () => {
+		const { staticOutput } = renderer(rootNode, false);
+		if (staticOutput && staticOutput !== "\n") capturedStaticOutput += staticOutput;
+	};
+	let uncaughtError;
+	const container = reconciler.createContainer(rootNode, LegacyRoot, null, false, null, "render-to-string", (error) => {
+		uncaughtError ??= error;
+	}, () => {}, () => {}, () => {});
+	reconciler.updateContainerSync(node, container, null, () => {});
+	reconciler.flushSyncWork();
+	const { output } = renderer(rootNode, false);
+	reconciler.updateContainerSync(null, container, null, () => {});
+	reconciler.flushSyncWork();
+	if (uncaughtError !== void 0) throw uncaughtError instanceof Error ? uncaughtError : new Error(String(uncaughtError));
+	const normalizedStaticOutput = capturedStaticOutput.endsWith("\n") ? capturedStaticOutput.slice(0, -1) : capturedStaticOutput;
+	if (normalizedStaticOutput && output) return normalizedStaticOutput + "\n" + output;
+	return normalizedStaticOutput || output;
+};
+//#endregion
+//#region src/components/Static.tsx
+/** @jsxImportSource react */
+/**
+`<Static>` component permanently renders its output above everything else. It's useful for displaying activity like completed tasks or logs—things that don't change after they're rendered (hence the name "Static").
+
+It's preferred to use `<Static>` for use cases like these when you can't know or control the number of items that need to be rendered.
+
+For example, [Tap](https://github.com/tapjs/node-tap) uses `<Static>` to display a list of completed tests. [Gatsby](https://github.com/gatsbyjs/gatsby) uses it to display a list of generated pages while still displaying a live progress bar.
+*/
+function Static(props) {
+	const { items, children: render, style: customStyle } = props;
+	const [index, setIndex] = useState(0);
+	const itemsToRender = useMemo(() => {
+		return items.slice(index);
+	}, [items, index]);
+	useLayoutEffect(() => {
+		setIndex(items.length);
+	}, [items.length]);
+	const children = itemsToRender.map((item, itemIndex) => {
+		return render(item, index + itemIndex);
+	});
+	const style = useMemo(() => ({
+		position: "absolute",
+		flexDirection: "column",
+		...customStyle
+	}), [customStyle]);
+	return /* @__PURE__ */ jsx("ink-box", {
+		internal_static: true,
+		style,
+		children
+	});
+}
+//#endregion
+//#region src/components/Transform.tsx
+/** @jsxImportSource react */
+/**
+Transform a string representation of React components before they're written to output. For example, you might want to apply a gradient to text, add a clickable link, or create some text effects. These use cases can't accept React nodes as input; they expect a string. That's what the <Transform> component does: it gives you an output string of its child components and lets you transform it in any way.
+*/
+function Transform({ children, transform, accessibilityLabel }) {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	if (children === void 0 || children === null) return null;
+	return /* @__PURE__ */ jsx("ink-text", {
+		style: {
+			flexGrow: 0,
+			flexShrink: 1,
+			flexDirection: "row"
+		},
+		internal_transform: transform,
+		children: isScreenReaderEnabled && accessibilityLabel ? accessibilityLabel : children
+	});
+}
+//#endregion
+//#region src/components/Newline.tsx
+/**
+Adds one or more newline (`\n`) characters. Must be used within `<Text>` components.
+*/
+function Newline({ count = 1 }) {
+	return /* @__PURE__ */ jsx("ink-text", { children: "\n".repeat(count) });
+}
+//#endregion
+//#region src/components/Spacer.tsx
+/** @jsxImportSource react */
+/**
+A flexible space that expands along the major axis of its containing layout.
+
+It's useful as a shortcut for filling all the available space between elements.
+*/
+function Spacer() {
+	return /* @__PURE__ */ jsx(Box, { flexGrow: 1 });
+}
+//#endregion
+//#region src/parse-keypress.ts
+const textDecoder = new TextDecoder();
+const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
+const fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+const keyName = {
+	OP: "f1",
+	OQ: "f2",
+	OR: "f3",
+	OS: "f4",
+	"[P": "f1",
+	"[Q": "f2",
+	"[R": "f3",
+	"[S": "f4",
+	"[11~": "f1",
+	"[12~": "f2",
+	"[13~": "f3",
+	"[14~": "f4",
+	"[[A": "f1",
+	"[[B": "f2",
+	"[[C": "f3",
+	"[[D": "f4",
+	"[[E": "f5",
+	"[15~": "f5",
+	"[17~": "f6",
+	"[18~": "f7",
+	"[19~": "f8",
+	"[20~": "f9",
+	"[21~": "f10",
+	"[23~": "f11",
+	"[24~": "f12",
+	"[A": "up",
+	"[B": "down",
+	"[C": "right",
+	"[D": "left",
+	"[E": "clear",
+	"[F": "end",
+	"[H": "home",
+	OA: "up",
+	OB: "down",
+	OC: "right",
+	OD: "left",
+	OE: "clear",
+	OF: "end",
+	OH: "home",
+	"[1~": "home",
+	"[2~": "insert",
+	"[3~": "delete",
+	"[4~": "end",
+	"[5~": "pageup",
+	"[6~": "pagedown",
+	"[[5~": "pageup",
+	"[[6~": "pagedown",
+	"[7~": "home",
+	"[8~": "end",
+	"[a": "up",
+	"[b": "down",
+	"[c": "right",
+	"[d": "left",
+	"[e": "clear",
+	"[2$": "insert",
+	"[3$": "delete",
+	"[5$": "pageup",
+	"[6$": "pagedown",
+	"[7$": "home",
+	"[8$": "end",
+	Oa: "up",
+	Ob: "down",
+	Oc: "right",
+	Od: "left",
+	Oe: "clear",
+	"[2^": "insert",
+	"[3^": "delete",
+	"[5^": "pageup",
+	"[6^": "pagedown",
+	"[7^": "home",
+	"[8^": "end",
+	"[Z": "tab"
+};
+const nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
+const isShiftKey = (code) => {
+	return [
+		"[a",
+		"[b",
+		"[c",
+		"[d",
+		"[e",
+		"[2$",
+		"[3$",
+		"[5$",
+		"[6$",
+		"[7$",
+		"[8$",
+		"[Z"
+	].includes(code);
+};
+const isCtrlKey = (code) => {
+	return [
+		"Oa",
+		"Ob",
+		"Oc",
+		"Od",
+		"Oe",
+		"[2^",
+		"[3^",
+		"[5^",
+		"[6^",
+		"[7^",
+		"[8^"
+	].includes(code);
+};
+const kittyKeyRe = /^\x1b\[(\d+)(?:;(\d+)(?::(\d+))?(?:;([\d:]+))?)?u$/;
+const kittySpecialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Za-z~])$/;
+const kittySpecialLetterKeys = {
+	A: "up",
+	B: "down",
+	C: "right",
+	D: "left",
+	E: "clear",
+	F: "end",
+	H: "home",
+	P: "f1",
+	Q: "f2",
+	R: "f3",
+	S: "f4"
+};
+const kittySpecialNumberKeys = {
+	2: "insert",
+	3: "delete",
+	5: "pageup",
+	6: "pagedown",
+	7: "home",
+	8: "end",
+	11: "f1",
+	12: "f2",
+	13: "f3",
+	14: "f4",
+	15: "f5",
+	17: "f6",
+	18: "f7",
+	19: "f8",
+	20: "f9",
+	21: "f10",
+	23: "f11",
+	24: "f12"
+};
+const kittyCodepointNames = {
+	27: "escape",
+	9: "tab",
+	127: "backspace",
+	8: "backspace",
+	57358: "capslock",
+	57359: "scrolllock",
+	57360: "numlock",
+	57361: "printscreen",
+	57362: "pause",
+	57363: "menu",
+	57376: "f13",
+	57377: "f14",
+	57378: "f15",
+	57379: "f16",
+	57380: "f17",
+	57381: "f18",
+	57382: "f19",
+	57383: "f20",
+	57384: "f21",
+	57385: "f22",
+	57386: "f23",
+	57387: "f24",
+	57388: "f25",
+	57389: "f26",
+	57390: "f27",
+	57391: "f28",
+	57392: "f29",
+	57393: "f30",
+	57394: "f31",
+	57395: "f32",
+	57396: "f33",
+	57397: "f34",
+	57398: "f35",
+	57399: "kp0",
+	57400: "kp1",
+	57401: "kp2",
+	57402: "kp3",
+	57403: "kp4",
+	57404: "kp5",
+	57405: "kp6",
+	57406: "kp7",
+	57407: "kp8",
+	57408: "kp9",
+	57409: "kpdecimal",
+	57410: "kpdivide",
+	57411: "kpmultiply",
+	57412: "kpsubtract",
+	57413: "kpadd",
+	57414: "kpenter",
+	57415: "kpequal",
+	57416: "kpseparator",
+	57417: "kpleft",
+	57418: "kpright",
+	57419: "kpup",
+	57420: "kpdown",
+	57421: "kppageup",
+	57422: "kppagedown",
+	57423: "kphome",
+	57424: "kpend",
+	57425: "kpinsert",
+	57426: "kpdelete",
+	57427: "kpbegin",
+	57428: "mediaplay",
+	57429: "mediapause",
+	57430: "mediaplaypause",
+	57431: "mediareverse",
+	57432: "mediastop",
+	57433: "mediafastforward",
+	57434: "mediarewind",
+	57435: "mediatracknext",
+	57436: "mediatrackprevious",
+	57437: "mediarecord",
+	57438: "lowervolume",
+	57439: "raisevolume",
+	57440: "mutevolume",
+	57441: "leftshift",
+	57442: "leftcontrol",
+	57443: "leftalt",
+	57444: "leftsuper",
+	57445: "lefthyper",
+	57446: "leftmeta",
+	57447: "rightshift",
+	57448: "rightcontrol",
+	57449: "rightalt",
+	57450: "rightsuper",
+	57451: "righthyper",
+	57452: "rightmeta",
+	57453: "isoLevel3Shift",
+	57454: "isoLevel5Shift"
+};
+const isValidCodepoint = (cp) => cp >= 0 && cp <= 1114111 && !(cp >= 55296 && cp <= 57343);
+const safeFromCodePoint = (cp) => isValidCodepoint(cp) ? String.fromCodePoint(cp) : "?";
+function resolveEventType(value) {
+	if (value === 3) return "release";
+	if (value === 2) return "repeat";
+	return "press";
+}
+function parseKittyModifiers(modifiers) {
+	return {
+		ctrl: !!(modifiers & kittyModifiers.ctrl),
+		shift: !!(modifiers & kittyModifiers.shift),
+		meta: !!(modifiers & (kittyModifiers.meta | kittyModifiers.alt)),
+		super: !!(modifiers & kittyModifiers.super),
+		hyper: !!(modifiers & kittyModifiers.hyper),
+		capsLock: !!(modifiers & kittyModifiers.capsLock),
+		numLock: !!(modifiers & kittyModifiers.numLock)
+	};
+}
+const parseKittyKeypress = (s) => {
+	const match = kittyKeyRe.exec(s);
+	if (!match) return null;
+	const codepoint = parseInt(match[1], 10);
+	const modifiers = match[2] ? Math.max(0, parseInt(match[2], 10) - 1) : 0;
+	const eventType = match[3] ? parseInt(match[3], 10) : 1;
+	const textField = match[4];
+	if (!isValidCodepoint(codepoint)) return null;
+	let text;
+	if (textField) text = textField.split(":").map((cp) => safeFromCodePoint(parseInt(cp, 10))).join("");
+	let name;
+	let isPrintable;
+	if (codepoint === 32) {
+		name = "space";
+		isPrintable = true;
+	} else if (codepoint === 13) {
+		name = "return";
+		isPrintable = true;
+	} else if (kittyCodepointNames[codepoint]) {
+		name = kittyCodepointNames[codepoint];
+		isPrintable = false;
+	} else if (codepoint >= 1 && codepoint <= 26) {
+		name = String.fromCodePoint(codepoint + 96);
+		isPrintable = false;
+	} else {
+		name = safeFromCodePoint(codepoint).toLowerCase();
+		isPrintable = true;
+	}
+	if (isPrintable && !text) text = safeFromCodePoint(codepoint);
+	return {
+		name,
+		...parseKittyModifiers(modifiers),
+		eventType: resolveEventType(eventType),
+		sequence: s,
+		raw: s,
+		isKittyProtocol: true,
+		isPrintable,
+		text
+	};
+};
+const parseKittySpecialKey = (s) => {
+	const match = kittySpecialKeyRe.exec(s);
+	if (!match) return null;
+	const number = parseInt(match[1], 10);
+	const modifiers = Math.max(0, parseInt(match[2], 10) - 1);
+	const eventType = parseInt(match[3], 10);
+	const terminator = match[4];
+	const name = terminator === "~" ? kittySpecialNumberKeys[number] : kittySpecialLetterKeys[terminator];
+	if (!name) return null;
+	return {
+		name,
+		...parseKittyModifiers(modifiers),
+		eventType: resolveEventType(eventType),
+		sequence: s,
+		raw: s,
+		isKittyProtocol: true,
+		isPrintable: false
+	};
+};
+const parseKeypress = (s = "") => {
+	let parts;
+	if (s instanceof Uint8Array) {
+		if (s[0] > 127 && s[1] === void 0) {
+			s[0] -= 128;
+			s = "\x1B" + textDecoder.decode(s);
+		} else s = textDecoder.decode(s);
+	} else if (s !== void 0 && typeof s !== "string") s = String(s);
+	else if (!s) s = "";
+	const kittyResult = parseKittyKeypress(s);
+	if (kittyResult) return kittyResult;
+	const kittySpecialResult = parseKittySpecialKey(s);
+	if (kittySpecialResult) return kittySpecialResult;
+	if (kittyKeyRe.test(s)) return {
+		name: "",
+		ctrl: false,
+		meta: false,
+		shift: false,
+		sequence: s,
+		raw: s,
+		isKittyProtocol: true,
+		isPrintable: false
+	};
+	const key = {
+		name: "",
+		ctrl: false,
+		meta: false,
+		shift: false,
+		sequence: s,
+		raw: s
+	};
+	key.sequence = key.sequence || s || key.name;
+	if (s === "\r" || s === "\x1B\r") {
+		key.raw = void 0;
+		key.name = "return";
+		key.meta = s.length === 2;
+	} else if (s === "\n") key.name = "enter";
+	else if (s === "	") key.name = "tab";
+	else if (s === "\b" || s === "\x1B\b") {
+		key.name = "backspace";
+		key.meta = s.charAt(0) === "\x1B";
+	} else if (s === "" || s === "\x1B") {
+		key.name = "backspace";
+		key.meta = s.charAt(0) === "\x1B";
+	} else if (s === "\x1B" || s === "\x1B\x1B") {
+		key.name = "escape";
+		key.meta = s.length === 2;
+	} else if (s === " " || s === "\x1B ") {
+		key.name = "space";
+		key.meta = s.length === 2;
+	} else if (s.length === 1 && s <= "") {
+		key.name = String.fromCharCode(s.charCodeAt(0) + "a".charCodeAt(0) - 1);
+		key.ctrl = true;
+	} else if (s.length === 1 && s >= "0" && s <= "9") key.name = "number";
+	else if (s.length === 1 && s >= "a" && s <= "z") key.name = s;
+	else if (s.length === 1 && s >= "A" && s <= "Z") {
+		key.name = s.toLowerCase();
+		key.shift = true;
+	} else if (parts = metaKeyCodeRe.exec(s)) {
+		key.name = parts[1].toLowerCase();
+		key.meta = true;
+		key.shift = /^[A-Z]$/.test(parts[1]);
+	} else if (parts = fnKeyRe.exec(s)) {
+		const segs = [...s];
+		if (segs[0] === "\x1B" && segs[1] === "\x1B") key.meta = true;
+		const code = [
+			parts[1],
+			parts[2],
+			parts[4],
+			parts[6]
+		].filter(Boolean).join("");
+		const modifier = (parts[3] || parts[5] || 1) - 1;
+		key.ctrl = !!(modifier & 4);
+		key.meta = key.meta || !!(modifier & 10);
+		key.shift = !!(modifier & 1);
+		key.code = code;
+		key.name = keyName[code] ?? "";
+		key.shift = isShiftKey(code) || key.shift;
+		key.ctrl = isCtrlKey(code) || key.ctrl;
+	}
+	return key;
+};
+//#endregion
+//#region src/hooks/use-stdin.ts
+/**
+A React hook that returns the stdin stream and stdin-related utilities.
+*/
+const useStdin = () => useContext(StdinContext);
+const useStdinContext = () => useContext(StdinContext);
+//#endregion
+//#region src/hooks/use-input.ts
+/**
+A React hook that returns `void` and handles user input.
+It's a more convenient alternative to using `StdinContext` and listening for `data` events. The callback you pass to `useInput` is called for each character when the user enters any input. However, if the user pastes text and it's more than one character, the callback will be called only once, and the whole string will be passed as `input`.
+
+```
+import {useInput} from 'ink';
+
+const UserInput = () => {
+useInput((input, key) => {
+if (input === 'q') {
+// Exit program
+}
+
+if (key.leftArrow) {
+// Left arrow key pressed
+}
+});
+
+return …
+};
+```
+*/
+const useInput = (inputHandler, options = {}) => {
+	const { setRawMode, internal_exitOnCtrlC, internal_eventEmitter } = useStdinContext();
+	useEffect(() => {
+		if (options.isActive === false) return;
+		setRawMode(true);
+		return () => {
+			setRawMode(false);
+		};
+	}, [options.isActive, setRawMode]);
+	const handleData = useEffectEvent((data) => {
+		const keypress = parseKeypress(data);
+		const key = {
+			upArrow: keypress.name === "up",
+			downArrow: keypress.name === "down",
+			leftArrow: keypress.name === "left",
+			rightArrow: keypress.name === "right",
+			pageDown: keypress.name === "pagedown",
+			pageUp: keypress.name === "pageup",
+			home: keypress.name === "home",
+			end: keypress.name === "end",
+			return: keypress.name === "return",
+			escape: keypress.name === "escape",
+			ctrl: keypress.ctrl,
+			shift: keypress.shift,
+			tab: keypress.name === "tab",
+			backspace: keypress.name === "backspace",
+			delete: keypress.name === "delete",
+			meta: keypress.meta,
+			super: keypress.super ?? false,
+			hyper: keypress.hyper ?? false,
+			capsLock: keypress.capsLock ?? false,
+			numLock: keypress.numLock ?? false,
+			eventType: keypress.eventType
+		};
+		let input;
+		if (keypress.isKittyProtocol) {
+			if (keypress.isPrintable) input = keypress.text ?? keypress.name;
+			else if (keypress.ctrl && keypress.name.length === 1) input = keypress.name;
+			else input = "";
+		} else if (keypress.ctrl) input = keypress.name ?? "";
+		else input = keypress.sequence;
+		if (!keypress.isKittyProtocol && nonAlphanumericKeys.includes(keypress.name)) input = "";
+		if (input.startsWith("\x1B")) input = input.slice(1);
+		if (input.length === 1 && /[A-Z]/.test(input)) key.shift = true;
+		if (input === "c" && key.ctrl && internal_exitOnCtrlC) return;
+		reconciler.discreteUpdates(() => {
+			inputHandler(input, key);
+		});
+	});
+	useEffect(() => {
+		if (options.isActive === false) return;
+		internal_eventEmitter.on("input", handleData);
+		return () => {
+			internal_eventEmitter.removeListener("input", handleData);
+		};
+	}, [options.isActive, internal_eventEmitter]);
+};
+//#endregion
+//#region src/hooks/use-paste.ts
+/**
+A React hook that calls `handler` whenever the user pastes text in the terminal. Bracketed paste mode (`\x1b[?2004h`) is automatically enabled while the hook is active, so pasted text arrives as a single string rather than being misinterpreted as individual key presses.
+
+`usePaste` and `useInput` can be used together in the same component. They operate on separate event channels, so paste content is never forwarded to `useInput` handlers when `usePaste` is active.
+
+```
+import {useInput, usePaste} from 'ink';
+
+const MyInput = () => {
+useInput((input, key) => {
+// Only receives typed characters and key events, not pasted text.
+if (key.return) {
+// Submit
+}
+});
+
+usePaste((text) => {
+// Receives the full pasted string, including newlines.
+console.log('Pasted:', text);
+});
+
+return …
+};
+```
+*/
+const usePaste = (handler, options = {}) => {
+	const { setRawMode, setBracketedPasteMode, internal_eventEmitter } = useStdinContext();
+	useEffect(() => {
+		if (options.isActive === false) return;
+		setRawMode(true);
+		setBracketedPasteMode(true);
+		return () => {
+			setRawMode(false);
+			setBracketedPasteMode(false);
+		};
+	}, [
+		options.isActive,
+		setRawMode,
+		setBracketedPasteMode
+	]);
+	const handlePaste = useEffectEvent((text) => {
+		reconciler.discreteUpdates(() => {
+			handler(text);
+		});
+	});
+	useEffect(() => {
+		if (options.isActive === false) return;
+		internal_eventEmitter.on("paste", handlePaste);
+		return () => {
+			internal_eventEmitter.removeListener("paste", handlePaste);
+		};
+	}, [options.isActive, internal_eventEmitter]);
+};
+//#endregion
+//#region src/hooks/use-app.ts
+/**
+A React hook that returns app lifecycle methods like `exit()` and `waitUntilRenderFlush()`.
+*/
+const useApp = () => useContext(AppContext);
+//#endregion
+//#region src/hooks/use-stdout.ts
+/**
+A React hook that returns the stdout stream where Ink renders your app.
+*/
+const useStdout = () => useContext(StdoutContext);
+//#endregion
+//#region src/hooks/use-stderr.ts
+/**
+A React hook that returns the stderr stream.
+*/
+const useStderr = () => useContext(StderrContext);
+//#endregion
+//#region src/hooks/use-focus.ts
+/**
+A React hook that returns focus state and focus controls for the current component.
+A component that uses the `useFocus` hook becomes "focusable" to Ink, so when the user presses <kbd>Tab</kbd>, Ink will switch focus to this component. If there are multiple components that execute the `useFocus` hook, focus will be given to them in the order in which these components are rendered.
+*/
+const useFocus = ({ isActive = true, autoFocus = false, id: customId } = {}) => {
+	const { isRawModeSupported, setRawMode } = useStdin();
+	const { activeId, add, remove, activate, deactivate, focus } = useContext(FocusContext);
+	const id = useMemo(() => {
+		return customId ?? Math.random().toString().slice(2, 7);
+	}, [customId]);
+	useEffect(() => {
+		add(id, { autoFocus });
+		return () => {
+			remove(id);
+		};
+	}, [
+		id,
+		autoFocus,
+		add,
+		remove
+	]);
+	useEffect(() => {
+		if (isActive) activate(id);
+		else deactivate(id);
+	}, [
+		isActive,
+		id,
+		activate,
+		deactivate
+	]);
+	useEffect(() => {
+		if (!isRawModeSupported || !isActive) return;
+		setRawMode(true);
+		return () => {
+			setRawMode(false);
+		};
+	}, [
+		isActive,
+		isRawModeSupported,
+		setRawMode
+	]);
+	return {
+		isFocused: Boolean(id) && activeId === id,
+		focus
+	};
+};
+//#endregion
+//#region src/hooks/use-focus-manager.ts
+/**
+A React hook that returns methods to enable or disable focus management for all components or manually switch focus to the next or previous components.
+*/
+const useFocusManager = () => {
+	const focusContext = useContext(FocusContext);
+	return {
+		enableFocus: focusContext.enableFocus,
+		disableFocus: focusContext.disableFocus,
+		focusNext: focusContext.focusNext,
+		focusPrevious: focusContext.focusPrevious,
+		focus: focusContext.focus,
+		activeId: focusContext.activeId
+	};
+};
+//#endregion
+//#region src/hooks/use-is-screen-reader-enabled.ts
+/**
+A React hook that returns whether a screen reader is enabled.
+This is useful when you want to render different output for screen readers.
+*/
+const useIsScreenReaderEnabled = () => {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	return isScreenReaderEnabled;
+};
+//#endregion
+//#region src/hooks/use-cursor.ts
+/**
+A React hook that returns methods to control the terminal cursor position.
+
+Setting a cursor position makes the cursor visible at the specified coordinates (relative to the Ink output origin). This is useful for IME (Input Method Editor) support, where the composing character is displayed at the cursor location.
+
+Pass `undefined` to hide the cursor.
+*/
+const useCursor = () => {
+	const context = useContext(CursorContext);
+	const positionRef = useRef(void 0);
+	const setCursorPosition = useCallback((position) => {
+		positionRef.current = position;
+	}, []);
+	useInsertionEffect(() => {
+		context.setCursorPosition(positionRef.current);
+		return () => {
+			context.setCursorPosition(void 0);
+		};
+	});
+	return { setCursorPosition };
+};
+//#endregion
+//#region src/hooks/use-animation.ts
+const defaultAnimationInterval = 100;
+const maximumTimerInterval = 2147483647;
+const zeroAnimState = {
+	frame: 0,
+	time: 0,
+	delta: 0
+};
+/**
+A React hook that drives animations. Returns a frame counter, elapsed time, frame delta, and a reset function. All animations share a single timer internally, so multiple animated components consolidate into one render cycle.
+
+@example
+```
+import {Text, useAnimation} from 'ink';
+
+const Spinner = () => {
+const {frame} = useAnimation({interval: 80});
+const characters = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+return <Text>{characters[frame % characters.length]}</Text>;
+};
+```
+*/
+function useAnimation(options) {
+	const { interval = defaultAnimationInterval, isActive = true } = options ?? {};
+	const safeInterval = normalizeAnimationInterval(interval);
+	const { subscribe, renderThrottleMs } = useContext(animationContext);
+	const [resetKey, setResetKey] = useState(0);
+	const [animState, setAnimState] = useState(zeroAnimState);
+	const nextRenderTimeRef = useRef(0);
+	const lastRenderTimeRef = useRef(0);
+	const previousOptionsRef = useRef({
+		isActive,
+		safeInterval,
+		resetKey
+	});
+	const previousOptions = previousOptionsRef.current;
+	const shouldReset = isActive && (safeInterval !== previousOptions.safeInterval || !previousOptions.isActive || resetKey !== previousOptions.resetKey);
+	const reset = useCallback(() => {
+		setResetKey((k) => k + 1);
+	}, []);
+	useLayoutEffect(() => {
+		if (!isActive) return;
+		setAnimState(zeroAnimState);
+		let startTime = 0;
+		const { startTime: subscriberStartTime, unsubscribe } = subscribe((currentTime) => {
+			if (renderThrottleMs > 0 && currentTime < nextRenderTimeRef.current) return;
+			const elapsed = currentTime - startTime;
+			const nextDelta = currentTime - lastRenderTimeRef.current;
+			lastRenderTimeRef.current = currentTime;
+			nextRenderTimeRef.current = currentTime + renderThrottleMs;
+			setAnimState({
+				frame: Math.floor(elapsed / safeInterval),
+				time: elapsed,
+				delta: nextDelta
+			});
+		}, safeInterval);
+		startTime = subscriberStartTime;
+		lastRenderTimeRef.current = subscriberStartTime;
+		nextRenderTimeRef.current = startTime + renderThrottleMs;
+		return unsubscribe;
+	}, [
+		safeInterval,
+		isActive,
+		subscribe,
+		renderThrottleMs,
+		resetKey
+	]);
+	useLayoutEffect(() => {
+		previousOptionsRef.current = {
+			isActive,
+			safeInterval,
+			resetKey
+		};
+	}, [
+		isActive,
+		safeInterval,
+		resetKey
+	]);
+	if (shouldReset) return {
+		...zeroAnimState,
+		reset
+	};
+	return {
+		...animState,
+		reset
+	};
+}
+function normalizeAnimationInterval(interval) {
+	if (!Number.isFinite(interval)) return defaultAnimationInterval;
+	return Math.min(maximumTimerInterval, Math.max(1, interval));
+}
+//#endregion
+//#region src/hooks/use-window-size.ts
+/**
+A React hook that returns the current terminal window dimensions and re-renders the component whenever the terminal is resized.
+*/
+const useWindowSize = () => {
+	const { stdout } = useStdout();
+	const [size, setSize] = useState(() => getWindowSize(stdout));
+	useEffect(() => {
+		const onResize = () => {
+			setSize(getWindowSize(stdout));
+		};
+		stdout.on("resize", onResize);
+		return () => {
+			stdout.off("resize", onResize);
+		};
+	}, [stdout]);
+	return size;
+};
+//#endregion
+//#region src/hooks/use-box-metrics.ts
+const emptyMetrics = {
+	width: 0,
+	height: 0,
+	left: 0,
+	top: 0
+};
+const findRootNode = (node) => {
+	if (!node) return;
+	if (!node.parentNode) return node.nodeName === "ink-root" ? node : void 0;
+	return findRootNode(node.parentNode);
+};
+/**
+A React hook that returns the current layout metrics for a tracked box element.
+It updates when layout changes (for example terminal resize, sibling/content changes, or position changes).
+
+The hook returns `{width: 0, height: 0, left: 0, top: 0}` until the first layout pass completes. It also returns zeros when the tracked ref is detached.
+
+Use `hasMeasured` to detect when the currently tracked element has been measured.
+
+@example
+```tsx
+import {useRef} from 'react';
+import {Box, Text, useBoxMetrics} from 'ink';
+
+const Example = () => {
+const ref = useRef(null);
+const {width, height, left, top, hasMeasured} = useBoxMetrics(ref);
+return (
+<Box ref={ref}>
+<Text>
+{hasMeasured ? `${width}x${height} at ${left},${top}` : 'Measuring...'}
+</Text>
+</Box>
+);
+};
+```
+*/
+const useBoxMetrics = (ref) => {
+	const [metrics, setMetrics] = useState(emptyMetrics);
+	const [hasMeasured, setHasMeasured] = useState(false);
+	const updateMetrics = useCallback(() => {
+		const layout = ref.current?.yogaNode?.getComputedLayout() ?? emptyMetrics;
+		setMetrics((previousMetrics) => {
+			return previousMetrics.width !== layout.width || previousMetrics.height !== layout.height || previousMetrics.left !== layout.left || previousMetrics.top !== layout.top ? layout : previousMetrics;
+		});
+		setHasMeasured(Boolean(ref.current));
+	}, [ref]);
+	useEffect(updateMetrics);
+	useEffect(() => {
+		const rootNode = findRootNode(ref.current);
+		if (!rootNode) return;
+		return addLayoutListener(rootNode, updateMetrics);
+	});
+	return useMemo(() => ({
+		...metrics,
+		hasMeasured
+	}), [metrics, hasMeasured]);
+};
+//#endregion
+//#region src/measure-element.ts
+/**
+Measure the layout metrics of a particular `<Box>` element.
+Returns an object with `x`, `y`, `width`, and `height` properties.
+
+`x` and `y` are the element's position within the live layout region, computed by walking up the layout tree and accumulating each ancestor's offset. These are layout-tree coordinates, not terminal viewport coordinates. To compare them with mouse events, convert the event coordinates using the live region's viewport position. This is necessary even in alternate-screen mode when output, such as `<Static>` content, appears above the live region.
+
+Note: `measureElement()` returns `{x: 0, y: 0, width: 0, height: 0}` when called during render (before layout is calculated). Call it from post-render code, such as `useEffect`, `useLayoutEffect`, input handlers, or timer callbacks. When content changes, pass the relevant dependency to your effect so it re-measures after each update.
+*/
+const measureElement = (node) => {
+	const { yogaNode } = node;
+	if (!yogaNode) return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	let x = yogaNode.getComputedLeft();
+	let y = yogaNode.getComputedTop();
+	let current = node.parentNode;
+	while (current) {
+		if (current.yogaNode) {
+			x += current.yogaNode.getComputedLeft();
+			y += current.yogaNode.getComputedTop();
+		}
+		current = current.parentNode;
+	}
+	return {
+		x,
+		y,
+		width: yogaNode.getComputedWidth(),
+		height: yogaNode.getComputedHeight()
+	};
+};
+//#endregion
+export { Box, Newline, Spacer, Static, Text, Transform, kittyFlags, kittyModifiers, measureElement, render, renderToString, useAnimation, useApp, useBoxMetrics, useCursor, useFocus, useFocusManager, useInput, useIsScreenReaderEnabled, usePaste, useStderr, useStdin, useStdout, useWindowSize };