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

package/dist/use-focus-C2sciZOo.js

@@ -0,0 +1,1335 @@
+import { U as kittyQuery } from "./sgr-BhwaWAJB.js";
+import { d as tokenize, h as tokenizeAnsi, l as styledCharsFromTokens, m as hasAnsiControlCharacters } from "./tokenize-AjqbvtiT.js";
+import { n as widestLine } from "./string-width-CijQwpIk.js";
+import { r as wrapAnsi, t as cliTruncate } from "./truncate-D31fhU6i.js";
+import { i as isSigilDev } from "./env-YVw64yZS.js";
+import { t as Yoga } from "./yoga-5jKhYCJC.js";
+import { t as cellAttributes } from "./cell-_ZVhbfl0.js";
+import { r as parseSemanticColor } from "./semantic-text-style-DIMzC7xt.js";
+import { createContext, useContext, useEffect, useEffectEvent, useId } from "react";
+import createReconciler from "react-reconciler";
+import { DefaultEventPriority, NoEventPriority } from "react-reconciler/constants.js";
+import { EventEmitter } from "node:events";
+import { jsx } from "react/jsx-runtime";
+import * as Scheduler from "scheduler";
+//#region src/components/AccessibilityContext.ts
+const accessibilityContext = createContext({ isScreenReaderEnabled: false });
+//#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/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/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/transform-adapter.ts
+/** The single ANSI compatibility boundary used by Transform and external styled strings. */
+function transformAnsiLine(serializedSubtree, lineIndex, transformers) {
+	let transformed = serializedSubtree;
+	for (const transformer of transformers) transformed = transformer(transformed, lineIndex);
+	return styledCharsFromTokens(tokenize(transformed));
+}
+//#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((width) => measureTextNode(node, width));
+	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/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 childrenOrAriaLabel = isScreenReaderEnabled && ariaLabel ? ariaLabel : children;
+	if (childrenOrAriaLabel === void 0 || childrenOrAriaLabel === null) return null;
+	const foreground = typeof color === "object" ? color : parseSemanticColor(color);
+	const background = typeof backgroundColor === "object" ? backgroundColor : parseSemanticColor(backgroundColor);
+	const semanticStyle = {
+		...foreground ? { foreground } : {},
+		...background ? { background } : {},
+		...color === "" ? { resetForeground: true } : {},
+		...backgroundColor === "" ? { resetBackground: true } : {},
+		...underline ? { underline: "single" } : {},
+		attributes: (dimColor ? cellAttributes.faint : 0) + (bold ? cellAttributes.bold : 0) + (italic ? cellAttributes.italic : 0) + (strikethrough ? cellAttributes.strikethrough : 0) + (inverse ? cellAttributes.inverse : 0)
+	};
+	if (isScreenReaderEnabled && ariaHidden) return null;
+	return /* @__PURE__ */ jsx("ink-text", {
+		style: {
+			flexGrow: 0,
+			flexShrink: 1,
+			flexDirection: "row",
+			textWrap: wrap
+		},
+		internal_textStyle: semanticStyle,
+		children: childrenOrAriaLabel
+	});
+}
+//#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/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/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
+};
+const textEncoder = new TextEncoder();
+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 detectKittySupport = (stdin, stdout, onSupported) => {
+	let responseBuffer = [];
+	const cleanup = () => {
+		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();
+			onSupported();
+		}
+	};
+	stdin.on("data", onData);
+	const timer = setTimeout(cleanup, 200);
+	stdout.write(kittyQuery);
+	return cleanup;
+};
+//#endregion
+//#region package.json
+var name = "@alchemy.run/sigil";
+var version = "0.0.0-alpha.5";
+//#endregion
+//#region src/reconciler.ts
+if (isSigilDev) await import("./devtools-DbthxoD1.js").catch(() => {});
+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 = (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;
+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_ansi") {
+				node.internal_ansi = value === true;
+				continue;
+			}
+			if (key === "internal_textStyle") {
+				node.internal_textStyle = 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(node), removeNode);
+		removeChildNode(node, removeNode);
+		detachYogaSubtree(removeNode);
+	},
+	commitUpdate(node, _type, oldProps, newProps) {
+		if (node.internal_static) {
+			const rootNode = findRootNode(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_ansi") {
+				node.internal_ansi = value === true;
+				continue;
+			}
+			if (key === "internal_textStyle") {
+				node.internal_textStyle = 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(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: name,
+	rendererVersion: version
+});
+//#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/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 = "\x1B" + textDecoder.decode(Uint8Array.of(s[0] - 128));
+		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 = Number(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-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-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 autoId = useId();
+	const id = customId ?? autoId;
+	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
+export { squashTextNodes as _, reconciler as a, kittyModifiers as c, FocusContext as d, Text as f, transformAnsiLine as g, emitLayoutListeners as h, useStdinContext as i, resolveFlags as l, createNode as m, useInput as n, detectKittySupport as o, addLayoutListener as p, useStdin as r, kittyFlags as s, useFocus as t, StdinContext as u, accessibilityContext as v };