@vizejs/fresco 0.101.0 → 0.104.0

package/dist/useInput-DrlvpGkS.mjs

@@ -0,0 +1,1463 @@
+import { format } from "node:util";
+import { computed, createRenderer, defineComponent, h, inject, isRef, onUnmounted, ref, shallowRef, watch } from "@vue/runtime-core";
+//#region src/accessibility.ts
+const SCREEN_READER_KEY = Symbol("fresco-screen-reader");
+function isScreenReaderEnabledByDefault() {
+	return process.env.INK_SCREEN_READER === "true" || process.env.FRESCO_SCREEN_READER === "true";
+}
+function stringValue$1(value) {
+	if (typeof value === "string" || typeof value === "number") return String(value);
+}
+function nodeText$1(node) {
+	const ariaLabel = stringValue$1(node.props["aria-label"]);
+	if (ariaLabel !== void 0) return ariaLabel;
+	if (node.text !== void 0) return node.text;
+	const propText = node.props.text ?? node.props.content;
+	if (typeof propText === "string" || typeof propText === "number") return String(propText);
+	if (node.type === "input") {
+		const value = node.props.value;
+		const placeholder = node.props.placeholder;
+		if (typeof value === "string" || typeof value === "number") return String(value);
+		if (typeof placeholder === "string" || typeof placeholder === "number") return String(placeholder);
+	}
+	return "";
+}
+function flexDirection(node) {
+	const style = node.props.style ?? {};
+	return stringValue$1(style.flexDirection ?? style.flex_direction) ?? "column";
+}
+function ariaRole(node) {
+	return stringValue$1(node.props["aria-role"]);
+}
+function ariaState(node) {
+	const state = node.props["aria-state"];
+	if (!state || typeof state !== "object") return void 0;
+	return state;
+}
+function isAriaHidden(node) {
+	return node.props["aria-hidden"] === true;
+}
+function treeToScreenReaderString(node, options = {}) {
+	if (isAriaHidden(node)) return "";
+	let output = "";
+	const text = nodeText$1(node);
+	if (node.type === "text" || node.type === "input") output = `${text}${node.children.map((child) => treeToScreenReaderString(child, options)).join("")}`;
+	else if (text) output = text;
+	else {
+		const direction = flexDirection(node);
+		const separator = direction === "row" || direction === "row-reverse" ? " " : "\n";
+		const children = direction === "row-reverse" || direction === "column-reverse" ? [...node.children].reverse() : node.children;
+		const role = ariaRole(node);
+		output = children.map((child) => treeToScreenReaderString(child, { parentRole: role })).filter(Boolean).join(separator);
+	}
+	const state = ariaState(node);
+	if (state) {
+		const stateDescription = Object.keys(state).filter((key) => state[key]).join(", ");
+		if (stateDescription) output = `(${stateDescription}) ${output}`;
+	}
+	const role = ariaRole(node);
+	if (role && role !== options.parentRole) output = `${role}: ${output}`;
+	return output;
+}
+function treeToScreenReaderRenderNodes(root) {
+	const output = treeToScreenReaderString(root);
+	const rootStyle = root.props.style ?? {};
+	const nodes = [{
+		id: root.id,
+		nodeType: "root",
+		style: {
+			...rootStyle,
+			flexDirection: "column"
+		}
+	}];
+	if (!output) return nodes;
+	const textId = root.id - 1;
+	nodes[0].children = [textId];
+	nodes.push({
+		id: textId,
+		nodeType: "text",
+		text: output,
+		wrap: true,
+		wrapMode: "wrap"
+	});
+	return nodes;
+}
+//#endregion
+//#region src/composables/useApp.ts
+/**
+* useApp - App context composable
+*/
+const APP_KEY = Symbol("fresco-app");
+/**
+* Create app context (use at app root)
+*/
+function createAppContext(controls = {}) {
+	const width = ref(controls.width ?? 80);
+	const height = ref(controls.height ?? 24);
+	const isRunning = ref(true);
+	const exit = (errorOrResult) => {
+		isRunning.value = false;
+		controls.exit?.(errorOrResult);
+	};
+	const render = () => {
+		controls.render?.();
+	};
+	const clear = () => {
+		controls.clear?.();
+	};
+	const waitUntilRenderFlush = () => {
+		return controls.waitUntilRenderFlush?.() ?? Promise.resolve();
+	};
+	const stdout = controls.stdout ?? (typeof process !== "undefined" ? process.stdout : void 0);
+	if (stdout) {
+		width.value = controls.width ?? stdout.columns ?? 80;
+		height.value = controls.height ?? stdout.rows ?? 24;
+		stdout.on?.("resize", () => {
+			width.value = stdout.columns ?? 80;
+			height.value = stdout.rows ?? 24;
+		});
+	}
+	return {
+		width,
+		height,
+		isRunning,
+		exit,
+		render,
+		clear,
+		waitUntilRenderFlush
+	};
+}
+/**
+* Use app context
+*/
+function useApp() {
+	const context = inject(APP_KEY);
+	if (!context) return {
+		width: ref(80),
+		height: ref(24),
+		isRunning: ref(false),
+		exit: () => {},
+		render: () => {},
+		clear: () => {},
+		waitUntilRenderFlush: () => Promise.resolve()
+	};
+	return context;
+}
+//#endregion
+//#region src/composables/useFocus.ts
+/**
+* useFocus - Focus management composable
+*/
+const FOCUS_KEY = Symbol("fresco-focus");
+function activeFocusables(focusables) {
+	return focusables.filter((focusable) => focusable.isActive);
+}
+/**
+* Create a focus manager (use at app root)
+*/
+function createFocusManager() {
+	const focusedId = ref(null);
+	const activeId = computed(() => focusedId.value ?? void 0);
+	const focusables = ref([]);
+	const focusableIds = computed(() => activeFocusables(focusables.value).map(({ id }) => id));
+	const isEnabled = ref(true);
+	const focus = (id) => {
+		const target = focusables.value.find((focusable) => focusable.id === id);
+		if (isEnabled.value && target?.isActive) focusedId.value = id;
+	};
+	const focusNext = () => {
+		const active = activeFocusables(focusables.value);
+		if (!isEnabled.value || active.length === 0) return;
+		const currentIndex = focusedId.value ? focusables.value.findIndex((focusable) => focusable.id === focusedId.value) : -1;
+		focusedId.value = focusables.value.slice(currentIndex + 1).find((focusable) => focusable.isActive)?.id ?? active[0]?.id ?? null;
+	};
+	const focusPrevious = () => {
+		const active = activeFocusables(focusables.value);
+		if (!isEnabled.value || active.length === 0) return;
+		const currentIndex = focusedId.value ? focusables.value.findIndex((focusable) => focusable.id === focusedId.value) : focusables.value.length;
+		focusedId.value = focusables.value.slice(0, currentIndex < 0 ? 0 : currentIndex).findLast((focusable) => focusable.isActive)?.id ?? active.at(-1)?.id ?? null;
+	};
+	const register = (id, options = {}) => {
+		const existing = focusables.value.find((focusable) => focusable.id === id);
+		if (existing) existing.isActive = options.isActive ?? existing.isActive;
+		else focusables.value.push({
+			id,
+			isActive: options.isActive ?? true
+		});
+		if (options.autoFocus && !focusedId.value && options.isActive !== false) focus(id);
+	};
+	const unregister = (id) => {
+		const index = focusables.value.findIndex((focusable) => focusable.id === id);
+		if (index !== -1) {
+			focusables.value.splice(index, 1);
+			if (focusedId.value === id) focusedId.value = null;
+		}
+	};
+	const setActive = (id, isActive) => {
+		const focusable = focusables.value.find((item) => item.id === id);
+		if (!focusable) return;
+		focusable.isActive = isActive;
+		if (!isActive && focusedId.value === id) focusedId.value = null;
+	};
+	const enableFocus = () => {
+		isEnabled.value = true;
+	};
+	const disableFocus = () => {
+		isEnabled.value = false;
+		focusedId.value = null;
+	};
+	return {
+		focusedId,
+		activeId,
+		focusableIds,
+		isEnabled,
+		enableFocus,
+		disableFocus,
+		focus,
+		focusNext,
+		focusPrevious,
+		register,
+		unregister,
+		setActive
+	};
+}
+/**
+* Use focus management
+*/
+function useFocus(options = {}) {
+	const { autoFocus = false, id = `focus-${Math.random().toString(36).slice(2)}`, isActive: isActiveOption = true } = options;
+	const manager = inject(FOCUS_KEY, null);
+	const localFocused = ref(autoFocus);
+	const active = isRef(isActiveOption) ? isActiveOption : ref(isActiveOption);
+	const isFocused = computed(() => {
+		if (manager) return manager.isEnabled.value && manager.focusedId.value === id;
+		return active.value && localFocused.value;
+	});
+	const focus = (targetId = id) => {
+		if (manager) manager.focus(targetId);
+		else if (targetId === id) localFocused.value = true;
+	};
+	const blur = () => {
+		if (manager) {
+			if (manager.focusedId.value === id) manager.focusedId.value = null;
+		} else localFocused.value = false;
+	};
+	if (manager) {
+		manager.register(id, {
+			isActive: active.value,
+			autoFocus
+		});
+		watch(active, (enabled) => {
+			manager.setActive(id, enabled);
+			if (enabled && autoFocus && !manager.focusedId.value) manager.focus(id);
+		}, { immediate: false });
+		onUnmounted(() => {
+			manager.unregister(id);
+		});
+	}
+	return {
+		id,
+		isFocused,
+		focus,
+		blur
+	};
+}
+/**
+* Use global focus manager controls.
+*/
+function useFocusManager() {
+	const manager = inject(FOCUS_KEY, null);
+	if (!manager) {
+		const empty = ref([]);
+		return {
+			enableFocus: () => {},
+			disableFocus: () => {},
+			focusNext: () => {},
+			focusPrevious: () => {},
+			focus: (_id) => {},
+			activeId: ref(void 0),
+			focusableIds: empty
+		};
+	}
+	return {
+		enableFocus: manager.enableFocus,
+		disableFocus: manager.disableFocus,
+		focusNext: manager.focusNext,
+		focusPrevious: manager.focusPrevious,
+		focus: manager.focus,
+		activeId: manager.activeId,
+		focusableIds: manager.focusableIds
+	};
+}
+//#endregion
+//#region src/composables/useStreams.ts
+/**
+* Stream composables matching Ink's stdin/stdout/stderr helpers.
+*/
+const BRACKETED_PASTE_ENABLE = "\x1B[?2004h";
+const BRACKETED_PASTE_DISABLE = "\x1B[?2004l";
+const STREAMS_KEY = Symbol("fresco-streams");
+function createStreamsContext(options = {}) {
+	const stdin = options.stdin ?? process.stdin;
+	const stdout = options.stdout ?? process.stdout;
+	const stderr = options.stderr ?? process.stderr;
+	const isInteractive = options.interactive ?? true;
+	const writeToStdout = options.writeToStdout ?? ((data) => stdout.write(data));
+	const writeToStderr = options.writeToStderr ?? ((data) => stderr.write(data));
+	let rawModeDepth = 0;
+	let pendingRawModeDisable = false;
+	let bracketedPasteDepth = 0;
+	return {
+		stdin,
+		stdout,
+		stderr,
+		setRawMode: (isRawMode) => {
+			if (!isInteractive || typeof stdin.setRawMode !== "function") return;
+			stdin.setEncoding?.("utf8");
+			if (isRawMode) {
+				pendingRawModeDisable = false;
+				if (rawModeDepth === 0) {
+					stdin.ref?.();
+					stdin.setRawMode(true);
+				}
+				rawModeDepth += 1;
+				return;
+			}
+			if (rawModeDepth === 0) return;
+			rawModeDepth -= 1;
+			if (rawModeDepth > 0) return;
+			pendingRawModeDisable = true;
+			queueMicrotask(() => {
+				if (!pendingRawModeDisable || rawModeDepth > 0) return;
+				pendingRawModeDisable = false;
+				stdin.setRawMode?.(false);
+				stdin.unref?.();
+			});
+		},
+		isRawModeSupported: isInteractive && typeof stdin.setRawMode === "function",
+		setBracketedPasteMode: (isEnabled) => {
+			if (!isInteractive) return;
+			if (isEnabled) {
+				bracketedPasteDepth += 1;
+				if (bracketedPasteDepth === 1) stdout.write(BRACKETED_PASTE_ENABLE);
+				return;
+			}
+			if (bracketedPasteDepth === 0) return;
+			bracketedPasteDepth -= 1;
+			if (bracketedPasteDepth === 0) stdout.write(BRACKETED_PASTE_DISABLE);
+		},
+		writeToStdout,
+		writeToStderr,
+		internal_exitOnCtrlC: options.exitOnCtrlC ?? true
+	};
+}
+function useStreamsContext() {
+	return inject(STREAMS_KEY) ?? createStreamsContext();
+}
+function useStdin() {
+	const streams = useStreamsContext();
+	return {
+		stdin: streams.stdin,
+		setRawMode: streams.setRawMode,
+		isRawModeSupported: streams.isRawModeSupported,
+		internal_exitOnCtrlC: streams.internal_exitOnCtrlC
+	};
+}
+function useStdout() {
+	const { stdout, writeToStdout } = useStreamsContext();
+	return {
+		stdout,
+		write: writeToStdout
+	};
+}
+function useStderr() {
+	const { stderr, writeToStderr } = useStreamsContext();
+	return {
+		stderr,
+		write: writeToStderr
+	};
+}
+//#endregion
+//#region src/composables/useCursor.ts
+/**
+* useCursor - terminal cursor positioning.
+*/
+const CURSOR_KEY = Symbol("fresco-cursor");
+async function loadNative$1() {
+	return import("@vizejs/fresco-native");
+}
+function createCursorContext(setCursorPosition) {
+	return { setCursorPosition };
+}
+function setNativeCursorPosition(position) {
+	loadNative$1().then((native) => {
+		if (position) {
+			native.setCursor(position.x, position.y);
+			native.showCursor();
+		} else native.hideCursor();
+	}).catch(() => {});
+}
+function useCursor() {
+	const context = inject(CURSOR_KEY, null);
+	let didSetCursor = false;
+	const setCursorPosition = (position) => {
+		didSetCursor = true;
+		if (context) {
+			context.setCursorPosition(position);
+			return;
+		}
+		setNativeCursorPosition(position);
+	};
+	onUnmounted(() => {
+		if (didSetCursor) context?.setCursorPosition(void 0);
+	});
+	return { setCursorPosition };
+}
+//#endregion
+//#region src/layoutMetrics.ts
+let lastRenderLayouts = [];
+function updateLastRenderLayouts(layouts) {
+	lastRenderLayouts = layouts;
+}
+function getLastRenderLayout(node) {
+	const id = node?.id ?? node?.$el?.id;
+	if (id === void 0) return null;
+	return lastRenderLayouts.find((layout) => layout.id === id) ?? null;
+}
+function measureElement(node) {
+	const layout = getLastRenderLayout(node);
+	return {
+		width: layout?.width ?? 0,
+		height: layout?.height ?? 0
+	};
+}
+//#endregion
+//#region src/renderer.ts
+/**
+* Fresco Vue Custom Renderer
+*/
+let nextId = 0;
+function createNode(type) {
+	return {
+		id: nextId++,
+		type,
+		props: {},
+		children: [],
+		parent: null
+	};
+}
+/**
+* Renderer options for Fresco
+*/
+const rendererOptions = {
+	patchProp(el, key, _prevValue, nextValue) {
+		if (nextValue == null) delete el.props[key];
+		else el.props[key] = nextValue;
+	},
+	insert(child, parent, anchor) {
+		child.parent = parent;
+		if (anchor) {
+			const index = parent.children.indexOf(anchor);
+			if (index !== -1) {
+				parent.children.splice(index, 0, child);
+				return;
+			}
+		}
+		parent.children.push(child);
+	},
+	remove(child) {
+		if (child.parent) {
+			const index = child.parent.children.indexOf(child);
+			if (index !== -1) child.parent.children.splice(index, 1);
+			child.parent = null;
+		}
+	},
+	createElement(type) {
+		return createNode(mapElementType(type));
+	},
+	createText(text) {
+		const node = createNode("text");
+		node.text = text;
+		return node;
+	},
+	createComment() {
+		return createNode("text");
+	},
+	setText(node, text) {
+		node.text = text;
+	},
+	setElementText(el, text) {
+		el.text = text;
+		el.children = [];
+	},
+	parentNode(node) {
+		return node.parent;
+	},
+	nextSibling(node) {
+		if (!node.parent) return null;
+		const index = node.parent.children.indexOf(node);
+		return node.parent.children[index + 1] || null;
+	}
+};
+/**
+* Map Vue element types to Fresco node types
+*/
+function mapElementType(type) {
+	switch (type.toLowerCase()) {
+		case "box":
+		case "div":
+		case "view": return "box";
+		case "text":
+		case "span": return "text";
+		case "input":
+		case "textinput": return "input";
+		default: return "box";
+	}
+}
+/**
+* Create the Fresco renderer
+*/
+function createRenderer$1() {
+	return createRenderer(rendererOptions);
+}
+function stringValue(value) {
+	if (typeof value === "string" || typeof value === "number") return String(value);
+}
+function styleValue(style, ...keys) {
+	for (const key of keys) if (style[key] !== void 0) return style[key];
+}
+function copyStringStyle(output, style, nativeKey, ...sourceKeys) {
+	const normalized = stringValue(styleValue(style, ...sourceKeys));
+	if (normalized !== void 0) output[nativeKey] = normalized;
+}
+function copyNumberStyle(output, style, nativeKey, ...sourceKeys) {
+	const value = styleValue(style, ...sourceKeys);
+	if (typeof value === "number") output[nativeKey] = value;
+}
+function copyRawStyle(output, style, nativeKey, ...sourceKeys) {
+	const value = styleValue(style, ...sourceKeys);
+	if (value !== void 0) output[nativeKey] = value;
+}
+function isWrappingEnabled(value) {
+	if (value === void 0) return false;
+	if (value === false) return false;
+	if (typeof value === "string" && value.startsWith("truncate")) return false;
+	return true;
+}
+function textWrapMode(value) {
+	if (value === void 0) return void 0;
+	if (value === false) return "none";
+	if (value === true) return "wrap";
+	if (value === "end") return "truncate-end";
+	if (value === "middle") return "truncate-middle";
+	if (typeof value === "string") return value;
+}
+/**
+* Convert Fresco tree to render nodes for native
+*/
+function treeToRenderNodes(root) {
+	const nodes = [];
+	function visit(node) {
+		const renderNode = {
+			id: node.id,
+			nodeType: node.type
+		};
+		const text = node.text ?? stringValue(node.props.text) ?? stringValue(node.props.content);
+		if (text !== void 0) renderNode.text = text;
+		if (node.props.wrap !== void 0) {
+			renderNode.wrap = isWrappingEnabled(node.props.wrap);
+			renderNode.wrapMode = textWrapMode(node.props.wrap);
+		}
+		if (node.props.value !== void 0) renderNode.value = stringValue(node.props.value) ?? "";
+		if (node.props.placeholder !== void 0) renderNode.placeholder = stringValue(node.props.placeholder) ?? "";
+		if (node.props.focused !== void 0 || node.props.focus !== void 0) renderNode.focused = Boolean(node.props.focused ?? node.props.focus);
+		if (node.props.cursor !== void 0) renderNode.cursor = Number(node.props.cursor);
+		if (node.props.mask !== void 0) renderNode.mask = Boolean(node.props.mask);
+		if (node.props.maskChar !== void 0 || node.props["mask-char"] !== void 0) renderNode.maskChar = stringValue(node.props.maskChar ?? node.props["mask-char"]);
+		if (node.props.border !== void 0) renderNode.border = stringValue(node.props.border) ?? "";
+		if (node.props.style) {
+			const s = node.props.style;
+			const style = {};
+			copyRawStyle(style, s, "display", "display");
+			copyRawStyle(style, s, "position", "position");
+			copyStringStyle(style, s, "top", "top");
+			copyStringStyle(style, s, "right", "right");
+			copyStringStyle(style, s, "bottom", "bottom");
+			copyStringStyle(style, s, "left", "left");
+			copyRawStyle(style, s, "flexDirection", "flexDirection", "flex_direction");
+			copyRawStyle(style, s, "flexWrap", "flexWrap", "flex_wrap");
+			copyRawStyle(style, s, "justifyContent", "justifyContent", "justify_content");
+			copyRawStyle(style, s, "alignItems", "alignItems", "align_items");
+			copyRawStyle(style, s, "alignSelf", "alignSelf", "align_self");
+			copyRawStyle(style, s, "alignContent", "alignContent", "align_content");
+			copyNumberStyle(style, s, "flexGrow", "flexGrow", "flex_grow");
+			copyNumberStyle(style, s, "flexShrink", "flexShrink", "flex_shrink");
+			copyStringStyle(style, s, "flexBasis", "flexBasis", "flex_basis");
+			copyStringStyle(style, s, "width", "width");
+			copyStringStyle(style, s, "height", "height");
+			copyStringStyle(style, s, "minWidth", "minWidth", "min_width");
+			copyStringStyle(style, s, "minHeight", "minHeight", "min_height");
+			copyStringStyle(style, s, "maxWidth", "maxWidth", "max_width");
+			copyStringStyle(style, s, "maxHeight", "maxHeight", "max_height");
+			copyNumberStyle(style, s, "aspectRatio", "aspectRatio", "aspect_ratio");
+			copyNumberStyle(style, s, "padding", "padding");
+			copyNumberStyle(style, s, "paddingTop", "paddingTop", "padding_top");
+			copyNumberStyle(style, s, "paddingRight", "paddingRight", "padding_right");
+			copyNumberStyle(style, s, "paddingBottom", "paddingBottom", "padding_bottom");
+			copyNumberStyle(style, s, "paddingLeft", "paddingLeft", "padding_left");
+			copyNumberStyle(style, s, "margin", "margin");
+			copyNumberStyle(style, s, "marginTop", "marginTop", "margin_top");
+			copyNumberStyle(style, s, "marginRight", "marginRight", "margin_right");
+			copyNumberStyle(style, s, "marginBottom", "marginBottom", "margin_bottom");
+			copyNumberStyle(style, s, "marginLeft", "marginLeft", "margin_left");
+			copyNumberStyle(style, s, "gap", "gap");
+			copyNumberStyle(style, s, "columnGap", "columnGap", "column_gap");
+			copyNumberStyle(style, s, "rowGap", "rowGap", "row_gap");
+			copyRawStyle(style, s, "overflow", "overflow");
+			copyRawStyle(style, s, "overflowX", "overflowX", "overflow_x");
+			copyRawStyle(style, s, "overflowY", "overflowY", "overflow_y");
+			if (Object.keys(style).length > 0) renderNode.style = style;
+		}
+		const appearance = {};
+		const fg = node.props.fg ?? node.props.color;
+		const bg = node.props.bg ?? node.props.backgroundColor;
+		if (fg) appearance.fg = fg;
+		if (bg) appearance.bg = bg;
+		if (node.props.bold) appearance.bold = node.props.bold;
+		if (node.props.dim || node.props.dimColor) appearance.dim = Boolean(node.props.dim || node.props.dimColor);
+		if (node.props.italic) appearance.italic = node.props.italic;
+		if (node.props.underline) appearance.underline = node.props.underline;
+		if (node.props.strikethrough) appearance.strikethrough = node.props.strikethrough;
+		if (node.props.inverse) appearance.inverse = node.props.inverse;
+		if (Object.keys(appearance).length > 0) renderNode.appearance = appearance;
+		if (node.children.length > 0) renderNode.children = node.children.map((c) => c.id);
+		nodes.push(renderNode);
+		for (const child of node.children) visit(child);
+	}
+	visit(root);
+	return nodes;
+}
+//#endregion
+//#region src/app.ts
+/**
+* Fresco App - Application instance management
+*/
+const lastKeyEvent = ref(null);
+const lastPasteEvent = ref(null);
+const lastResizeEvent = ref(null);
+const lastMouseEvent = ref(null);
+const lastFocusEvent = ref(null);
+const lastCompositionEvent = ref(null);
+let native = null;
+const consoleMethods = [
+	"debug",
+	"error",
+	"info",
+	"log",
+	"warn"
+];
+async function loadNative() {
+	if (!native) native = await import("@vizejs/fresco-native");
+	return native;
+}
+function createNoopWriteStream(columns, rows) {
+	const stream = {
+		isTTY: false,
+		columns,
+		rows,
+		write: () => true,
+		on: (_event, _listener) => stream,
+		off: (_event, _listener) => stream,
+		once: (_event, _listener) => stream,
+		removeListener: (_event, _listener) => stream
+	};
+	return stream;
+}
+function createNoopReadStream() {
+	const stream = {
+		isTTY: false,
+		isPaused: () => true,
+		pause: () => stream,
+		resume: () => stream,
+		ref: () => stream,
+		unref: () => stream,
+		setEncoding: () => stream,
+		setRawMode: () => stream,
+		on: (_event, _listener) => stream,
+		off: (_event, _listener) => stream,
+		once: (_event, _listener) => stream,
+		removeListener: (_event, _listener) => stream
+	};
+	return stream;
+}
+function isWritableStream(value) {
+	return typeof value === "object" && value !== null && "write" in value && typeof value.write === "function";
+}
+function normalizeRenderOptions(options) {
+	return isWritableStream(options) ? { stdout: options } : options;
+}
+function isVNodeRoot(root) {
+	return typeof root === "object" && root !== null && "__v_isVNode" in root;
+}
+function componentFromRoot(root) {
+	if (!isVNodeRoot(root)) return root;
+	return defineComponent({
+		name: "FrescoVNodeRoot",
+		setup() {
+			return () => root;
+		}
+	});
+}
+function createRootElement(width = "100%", height = "100%") {
+	return {
+		id: -1,
+		type: "root",
+		props: { style: {
+			width,
+			height,
+			flexDirection: "column",
+			justifyContent: "flex-start",
+			alignItems: "flex-start",
+			alignContent: "flex-start"
+		} },
+		children: [],
+		parent: null
+	};
+}
+function nodeText(node) {
+	if (node.text !== void 0) return node.text;
+	const propText = node.props.text ?? node.props.content;
+	if (typeof propText === "string" || typeof propText === "number") return String(propText);
+	if (node.type === "input") {
+		const value = node.props.value;
+		const placeholder = node.props.placeholder;
+		if (typeof value === "string" || typeof value === "number") return String(value);
+		if (typeof placeholder === "string" || typeof placeholder === "number") return String(placeholder);
+	}
+	return "";
+}
+function isStaticNode(node) {
+	return node.props.internal_static === true || node.props.internalStatic === true;
+}
+function joinOutput(parts, separator = "\n") {
+	return parts.filter(Boolean).join(separator);
+}
+function treeToString(node, options = {}) {
+	if (options.skipStatic && isStaticNode(node)) return "";
+	const ownText = nodeText(node);
+	const childOutput = node.children.map((child) => treeToString(child, options));
+	if (node.type === "text" || node.type === "input") return `${ownText}${childOutput.join("")}`;
+	const style = node.props.style ?? {};
+	return joinOutput(childOutput, (style.flexDirection ?? style.flex_direction) === "column" ? "\n" : "");
+}
+function normalizeOutput(output) {
+	return output.endsWith("\n") ? output.slice(0, -1) : output;
+}
+function appendOutput(previous, next) {
+	const normalized = normalizeOutput(next);
+	if (!normalized) return previous;
+	return previous ? `${previous}\n${normalized}` : normalized;
+}
+function captureStaticOutput(node, renderedStaticItems) {
+	const output = [];
+	function visit(current) {
+		if (isStaticNode(current)) {
+			const renderedItems = renderedStaticItems.get(current.id) ?? 0;
+			const nextOutput = joinOutput(current.children.slice(renderedItems).map((child) => treeToString(child)), "\n");
+			if (nextOutput) output.push(nextOutput);
+			renderedStaticItems.set(current.id, current.children.length);
+			return;
+		}
+		for (const child of current.children) visit(child);
+	}
+	visit(node);
+	return joinOutput(output, "\n");
+}
+function createStaticOutputNode(output) {
+	const normalized = normalizeOutput(output);
+	if (!normalized) return null;
+	const staticRoot = {
+		id: -1,
+		type: "box",
+		props: { style: { flexDirection: "column" } },
+		children: [],
+		parent: null
+	};
+	staticRoot.children = normalized.split("\n").map((line, index) => ({
+		id: -2 - index,
+		type: "text",
+		props: { text: line },
+		children: [],
+		parent: staticRoot
+	}));
+	return staticRoot;
+}
+function cloneDynamicTree(node) {
+	if (isStaticNode(node)) return null;
+	const clone = {
+		id: node.id,
+		type: node.type,
+		props: node.props,
+		children: [],
+		parent: null,
+		text: node.text
+	};
+	clone.children = node.children.map((child) => cloneDynamicTree(child)).filter((child) => child !== null);
+	for (const child of clone.children) child.parent = clone;
+	return clone;
+}
+function createRenderTree(root, staticOutput) {
+	const dynamicRoot = cloneDynamicTree(root) ?? createRootElement();
+	const staticOutputNode = createStaticOutputNode(staticOutput);
+	if (staticOutputNode) {
+		staticOutputNode.parent = dynamicRoot;
+		dynamicRoot.children = [staticOutputNode, ...dynamicRoot.children];
+	}
+	return dynamicRoot;
+}
+function renderPlainOutput(root, staticOutput) {
+	return joinOutput([staticOutput, treeToString(root, { skipStatic: true })], "\n");
+}
+function updateAppSize(context, width, height) {
+	if (!context) return;
+	context.width.value = width;
+	context.height.value = height;
+}
+const CI_ENVIRONMENT_KEYS = [
+	"CI",
+	"CONTINUOUS_INTEGRATION",
+	"BUILD_NUMBER",
+	"RUN_ID"
+];
+function isTruthyEnvironmentValue(value) {
+	if (!value) return false;
+	return ![
+		"0",
+		"false",
+		"no"
+	].includes(value.toLowerCase());
+}
+function isCiEnvironment(env = process.env) {
+	return CI_ENVIRONMENT_KEYS.some((key) => isTruthyEnvironmentValue(env[key]));
+}
+function detectInteractiveMode(options) {
+	const stdout = options.stdout ?? process.stdout;
+	return options.interactive ?? (stdout.isTTY === true && !isCiEnvironment());
+}
+/**
+* Create a Fresco TUI app
+*/
+function createApp(rootComponent, options = {}) {
+	const { mouse = false, exitOnCtrlC = true, onError } = options;
+	const interactive = detectInteractiveMode(options);
+	const screenReaderEnabled = ref(options.isScreenReaderEnabled ?? isScreenReaderEnabledByDefault());
+	const frameDelay = Math.max(1, Math.floor(1e3 / Math.max(1, options.maxFps ?? 30)));
+	let streamsContext;
+	const writeToStdout = (data) => {
+		writeExternalOutput(streamsContext.stdout, data);
+	};
+	const writeToStderr = (data) => {
+		writeExternalOutput(streamsContext.stderr, data);
+	};
+	streamsContext = createStreamsContext({
+		stdin: options.stdin,
+		stdout: options.stdout,
+		stderr: options.stderr,
+		exitOnCtrlC,
+		interactive,
+		writeToStdout,
+		writeToStderr
+	});
+	let vueApp = null;
+	let rootElement = null;
+	let mounted = false;
+	let running = false;
+	let needsRender = true;
+	let appContext = null;
+	let focusManager = null;
+	let consoleRestore = null;
+	let isWritingExternalOutput = false;
+	let nonInteractiveOutput = "";
+	let staticOutput = "";
+	const renderedStaticItems = /* @__PURE__ */ new Map();
+	let cursorPosition;
+	let hasCursorOverride = false;
+	let exitSettled = false;
+	let resolveExit = null;
+	let rejectExit = null;
+	const exitPromise = new Promise((resolve, reject) => {
+		resolveExit = resolve;
+		rejectExit = reject;
+	});
+	const { createApp: createVueApp } = createRenderer$1();
+	async function mount() {
+		if (mounted) return;
+		const n = interactive ? await loadNative() : null;
+		if (n) {
+			if (typeof n.initTerminalWithOptions === "function") n.initTerminalWithOptions({
+				alternateScreen: options.alternateScreen === true,
+				bracketedPaste: true,
+				hideCursor: true,
+				mouse,
+				rawMode: true
+			});
+			else if (mouse) n.initTerminalWithMouse();
+			else n.initTerminal();
+			n.enableIme?.();
+			n.initLayout();
+		}
+		const app = createVueApp(componentFromRoot(rootComponent));
+		const info = n?.getTerminalInfo() ?? {
+			width: streamsContext.stdout.columns ?? 80,
+			height: streamsContext.stdout.rows ?? 24
+		};
+		appContext = createAppContext({
+			width: info.width,
+			height: info.height,
+			exit: (value) => {
+				unmount(value);
+			},
+			render,
+			clear,
+			waitUntilRenderFlush,
+			stdout: streamsContext.stdout
+		});
+		focusManager = createFocusManager();
+		app.provide(APP_KEY, appContext);
+		app.provide(FOCUS_KEY, focusManager);
+		app.provide(SCREEN_READER_KEY, screenReaderEnabled);
+		app.provide(STREAMS_KEY, streamsContext);
+		app.provide(CURSOR_KEY, createCursorContext((position) => {
+			hasCursorOverride = true;
+			cursorPosition = position;
+			needsRender = true;
+		}));
+		rootElement = createRootElement();
+		patchConsoleMethods();
+		try {
+			app.mount(rootElement);
+		} catch (error) {
+			restoreConsoleMethods();
+			throw error;
+		}
+		vueApp = app;
+		mounted = true;
+		running = true;
+		needsRender = true;
+		eventLoop();
+	}
+	async function unmount(errorOrResult) {
+		if (!mounted) return;
+		running = false;
+		if (!interactive && rootElement) {
+			staticOutput = appendOutput(staticOutput, captureStaticOutput(rootElement, renderedStaticItems));
+			nonInteractiveOutput = renderPlainOutput(rootElement, staticOutput);
+		}
+		if (native && interactive) {
+			native.disableIme?.();
+			native.restoreTerminal();
+		}
+		restoreConsoleMethods();
+		if (vueApp) {
+			vueApp.unmount();
+			vueApp = null;
+		}
+		if (!interactive && nonInteractiveOutput) {
+			streamsContext.stdout.write(nonInteractiveOutput.endsWith("\n") ? nonInteractiveOutput : `${nonInteractiveOutput}\n`);
+			nonInteractiveOutput = "";
+		}
+		rootElement = null;
+		mounted = false;
+		appContext = null;
+		focusManager = null;
+		cursorPosition = void 0;
+		hasCursorOverride = false;
+		if (!exitSettled) {
+			exitSettled = true;
+			if (errorOrResult instanceof Error) rejectExit?.(errorOrResult);
+			else resolveExit?.(errorOrResult);
+		}
+	}
+	async function waitUntilExit() {
+		return exitPromise;
+	}
+	async function waitUntilRenderFlush() {
+		return Promise.resolve();
+	}
+	function clear() {
+		if (!mounted) return;
+		staticOutput = "";
+		if (!interactive) {
+			nonInteractiveOutput = "";
+			return;
+		}
+		if (!native) return;
+		native.clearScreen();
+		native.flushTerminal();
+	}
+	function writeExternalOutput(stream, data) {
+		if (!mounted || !interactive || !native || isWritingExternalOutput) {
+			stream.write(data);
+			return;
+		}
+		try {
+			isWritingExternalOutput = true;
+			native.clearScreen();
+			native.flushTerminal();
+			stream.write(data);
+			needsRender = true;
+			render();
+		} finally {
+			isWritingExternalOutput = false;
+		}
+	}
+	function patchConsoleMethods() {
+		if (options.patchConsole === false || consoleRestore) return;
+		const target = console;
+		const original = {};
+		const patch = (method, writer) => {
+			original[method] = target[method];
+			target[method] = (...args) => {
+				writer(`${format(...args)}\n`);
+			};
+		};
+		patch("debug", writeToStdout);
+		patch("info", writeToStdout);
+		patch("log", writeToStdout);
+		patch("warn", writeToStderr);
+		patch("error", writeToStderr);
+		consoleRestore = () => {
+			for (const method of consoleMethods) {
+				const originalMethod = original[method];
+				if (originalMethod) target[method] = originalMethod;
+			}
+			consoleRestore = null;
+		};
+	}
+	function restoreConsoleMethods() {
+		consoleRestore?.();
+	}
+	function applyCursorOverride() {
+		if (!hasCursorOverride || !native) return;
+		if (cursorPosition) {
+			native.setCursor(cursorPosition.x, cursorPosition.y);
+			native.showCursor();
+		} else native.hideCursor();
+	}
+	function render() {
+		if (!mounted || !rootElement) return;
+		const start = performance.now();
+		try {
+			if (!interactive) {
+				staticOutput = appendOutput(staticOutput, captureStaticOutput(rootElement, renderedStaticItems));
+				nonInteractiveOutput = renderPlainOutput(rootElement, staticOutput);
+				options.onRender?.({ renderTime: performance.now() - start });
+				return;
+			}
+			if (!native) return;
+			staticOutput = appendOutput(staticOutput, captureStaticOutput(rootElement, renderedStaticItems));
+			const renderRoot = createRenderTree(rootElement, staticOutput);
+			const renderNodes = screenReaderEnabled.value ? treeToScreenReaderRenderNodes(renderRoot) : treeToRenderNodes(renderRoot);
+			if (renderNodes.length > 0) {
+				if (options.debug) streamsContext.stderr.write(`${JSON.stringify(renderNodes, null, 2)}\n`);
+				native.renderTree(renderNodes);
+				if ("getLastRenderLayouts" in native) updateLastRenderLayouts(native.getLastRenderLayouts());
+				applyCursorOverride();
+				native.flushTerminal();
+				options.onRender?.({ renderTime: performance.now() - start });
+			}
+		} catch (error) {
+			if (onError) onError(error);
+			else console.error("Render error:", error);
+		}
+	}
+	async function getTerminalInfo() {
+		const info = (await loadNative()).getTerminalInfo();
+		return {
+			width: info.width,
+			height: info.height
+		};
+	}
+	function dispatchEvent(event) {
+		if (event.eventType === "resize") {
+			const resizeEvent = {
+				type: "resize",
+				width: event.width ?? 0,
+				height: event.height ?? 0
+			};
+			lastResizeEvent.value = resizeEvent;
+			updateAppSize(appContext, resizeEvent.width, resizeEvent.height);
+			return;
+		}
+		if (event.eventType === "paste") {
+			lastPasteEvent.value = {
+				type: "paste",
+				text: event.text ?? ""
+			};
+			return;
+		}
+		if (event.eventType === "mouse") {
+			lastMouseEvent.value = {
+				type: "mouse",
+				button: event.button ?? void 0,
+				x: event.x ?? 0,
+				y: event.y ?? 0
+			};
+			return;
+		}
+		if (event.eventType === "focus") {
+			lastFocusEvent.value = {
+				type: "focus",
+				focused: event.key === "gained"
+			};
+			return;
+		}
+		if (event.eventType === "compositionstart" || event.eventType === "compositionupdate" || event.eventType === "compositionend") {
+			lastCompositionEvent.value = {
+				type: event.eventType,
+				text: event.text ?? "",
+				cursor: event.cursor ?? 0
+			};
+			return;
+		}
+		if (event.eventType === "key") {
+			const modifiers = event.modifiers ?? {};
+			lastKeyEvent.value = {
+				type: "key",
+				key: event.key ?? void 0,
+				char: event.char ?? void 0,
+				ctrl: modifiers.ctrl ?? false,
+				alt: modifiers.alt ?? false,
+				shift: modifiers.shift ?? false,
+				meta: modifiers.meta ?? false,
+				super: modifiers.super ?? false,
+				hyper: modifiers.hyper ?? false,
+				capsLock: modifiers.capsLock ?? false,
+				numLock: modifiers.numLock ?? false,
+				eventType: event.keyEventType ?? void 0
+			};
+		}
+	}
+	async function eventLoop() {
+		const n = interactive ? await loadNative() : null;
+		while (running) {
+			try {
+				const event = n?.pollEvent(16);
+				if (event) {
+					if (event.eventType === "resize") {
+						n?.syncTerminalSize();
+						n?.clearScreen();
+						needsRender = true;
+					}
+					dispatchEvent(event);
+					if (event.eventType === "key" && event.key === "tab") {
+						focusManager?.focusNext();
+						needsRender = true;
+					} else if (event.eventType === "key" && event.key === "backtab") {
+						focusManager?.focusPrevious();
+						needsRender = true;
+					}
+					if (exitOnCtrlC && event.eventType === "key" && event.char === "c" && event.modifiers?.ctrl) {
+						await unmount();
+						break;
+					}
+				}
+				if (needsRender) {
+					render();
+					needsRender = false;
+				}
+				needsRender = true;
+			} catch (error) {
+				if (onError) onError(error);
+			}
+			await new Promise((resolve) => setTimeout(resolve, frameDelay));
+		}
+	}
+	return {
+		mount,
+		unmount,
+		waitUntilExit,
+		waitUntilRenderFlush,
+		render,
+		clear,
+		getTerminalInfo
+	};
+}
+/**
+* Ink-compatible helper that mounts immediately.
+*/
+function render(root, options = {}) {
+	const renderOptions = normalizeRenderOptions(options);
+	const rootRef = shallowRef(root);
+	const app = createApp(defineComponent({
+		name: "FrescoRenderRoot",
+		setup() {
+			return () => {
+				const current = rootRef.value;
+				return isVNodeRoot(current) ? current : h(current);
+			};
+		}
+	}), renderOptions);
+	app.mount();
+	return {
+		rerender(nextRoot) {
+			rootRef.value = nextRoot;
+			app.render();
+		},
+		unmount: (value) => app.unmount(value),
+		waitUntilExit: () => app.waitUntilExit(),
+		waitUntilRenderFlush: () => app.waitUntilRenderFlush(),
+		cleanup: () => app.unmount(),
+		clear: () => app.clear()
+	};
+}
+/**
+* Render a Fresco component to a plain string without starting a terminal app.
+*/
+function renderToString(root, options = {}) {
+	const { createApp: createVueApp } = createRenderer$1();
+	const app = createVueApp(componentFromRoot(root));
+	const columns = options.columns ?? 80;
+	const stdout = createNoopWriteStream(columns, 24);
+	const stderr = createNoopWriteStream(columns, 24);
+	const stdin = createNoopReadStream();
+	const rootElement = createRootElement(String(columns), "auto");
+	app.provide(APP_KEY, createAppContext({
+		width: columns,
+		height: 24,
+		stdout
+	}));
+	app.provide(FOCUS_KEY, createFocusManager());
+	app.provide(SCREEN_READER_KEY, ref(false));
+	app.provide(CURSOR_KEY, createCursorContext(() => {}));
+	app.provide(STREAMS_KEY, createStreamsContext({
+		stdin,
+		stdout,
+		stderr,
+		interactive: false,
+		writeToStdout: () => {},
+		writeToStderr: () => {}
+	}));
+	app.mount(rootElement);
+	const output = renderPlainOutput(rootElement, captureStaticOutput(rootElement, /* @__PURE__ */ new Map()));
+	app.unmount();
+	return output;
+}
+//#endregion
+//#region src/composables/useIsScreenReaderEnabled.ts
+/**
+* useIsScreenReaderEnabled - screen reader mode flag.
+*/
+function useIsScreenReaderEnabled() {
+	return inject(SCREEN_READER_KEY, null)?.value ?? isScreenReaderEnabledByDefault();
+}
+//#endregion
+//#region src/composables/usePaste.ts
+/**
+* usePaste - bracketed paste handling.
+*/
+let activePasteHandlerCount = 0;
+function hasActivePasteHandlers() {
+	return activePasteHandlerCount > 0;
+}
+function toRef$1(value) {
+	return isRef(value) ? value : ref(value);
+}
+function usePaste(handler, options = {}) {
+	const isActive = toRef$1(options.isActive ?? true);
+	const streams = useStreamsContext();
+	let rawModeEnabled = false;
+	let bracketedPasteEnabled = false;
+	let pasteHandlerRegistered = false;
+	const syncRawMode = (isEnabled) => {
+		if (rawModeEnabled === isEnabled) return;
+		streams.setRawMode(isEnabled);
+		rawModeEnabled = isEnabled;
+	};
+	const syncBracketedPasteMode = (isEnabled) => {
+		if (bracketedPasteEnabled === isEnabled) return;
+		streams.setBracketedPasteMode(isEnabled);
+		bracketedPasteEnabled = isEnabled;
+	};
+	const syncPasteRegistration = (isEnabled) => {
+		if (pasteHandlerRegistered === isEnabled) return;
+		activePasteHandlerCount += isEnabled ? 1 : -1;
+		pasteHandlerRegistered = isEnabled;
+	};
+	const syncActiveState = (isEnabled) => {
+		syncRawMode(isEnabled);
+		syncBracketedPasteMode(isEnabled);
+		syncPasteRegistration(isEnabled);
+	};
+	watch(lastPasteEvent, (event) => {
+		if (!event || !isActive.value) return;
+		handler(event.text);
+	});
+	watch(isActive, syncActiveState, { immediate: true });
+	onUnmounted(() => syncActiveState(false));
+	return {
+		isActive,
+		enable: () => {
+			isActive.value = true;
+		},
+		disable: () => {
+			isActive.value = false;
+		}
+	};
+}
+//#endregion
+//#region src/composables/useInput.ts
+/**
+* useInput - Input handling composable
+*/
+function toRef(value) {
+	return isRef(value) ? value : ref(value);
+}
+function keyName(event) {
+	return event.char ?? event.key ?? "";
+}
+function toInkKey(event) {
+	const key = event.key;
+	return {
+		upArrow: key === "up",
+		downArrow: key === "down",
+		leftArrow: key === "left",
+		rightArrow: key === "right",
+		pageDown: key === "pagedown" || key === "pageDown",
+		pageUp: key === "pageup" || key === "pageUp",
+		home: key === "home",
+		end: key === "end",
+		return: key === "enter" || key === "return",
+		escape: key === "escape" || key === "esc",
+		ctrl: event.ctrl,
+		shift: event.shift,
+		tab: key === "tab" || key === "backtab",
+		backspace: key === "backspace",
+		delete: key === "delete",
+		meta: event.meta,
+		super: event.super,
+		hyper: event.hyper,
+		capsLock: event.capsLock,
+		numLock: event.numLock,
+		eventType: event.eventType
+	};
+}
+function emptyKey() {
+	return {
+		upArrow: false,
+		downArrow: false,
+		leftArrow: false,
+		rightArrow: false,
+		pageDown: false,
+		pageUp: false,
+		home: false,
+		end: false,
+		return: false,
+		escape: false,
+		ctrl: false,
+		shift: false,
+		tab: false,
+		backspace: false,
+		delete: false,
+		meta: false,
+		super: false,
+		hyper: false,
+		capsLock: false,
+		numLock: false
+	};
+}
+function inputValue(event, key) {
+	if (event.char) return event.char;
+	if (key.return) return "\r";
+	return "";
+}
+function handleStructuredOptions(event, options, lastKey) {
+	const modifiers = {
+		ctrl: event.ctrl,
+		alt: event.alt,
+		shift: event.shift,
+		meta: event.meta
+	};
+	const pressedKey = keyName(event);
+	const inkKey = toInkKey(event);
+	if (event.char) {
+		lastKey.value = event.char;
+		options.onChar?.(event.char);
+		options.onKey?.(event.char, modifiers);
+		return;
+	}
+	if (pressedKey) {
+		lastKey.value = pressedKey;
+		options.onKey?.(pressedKey, modifiers);
+	}
+	if (inkKey.return) options.onSubmit?.();
+	if (inkKey.escape) options.onEscape?.();
+	if (inkKey.upArrow) options.onArrow?.("up");
+	if (inkKey.downArrow) options.onArrow?.("down");
+	if (inkKey.leftArrow) options.onArrow?.("left");
+	if (inkKey.rightArrow) options.onArrow?.("right");
+}
+function useInput(handlerOrOptions = {}, handlerOptions = {}) {
+	const options = typeof handlerOrOptions === "function" ? {
+		handler: handlerOrOptions,
+		isActive: handlerOptions.isActive
+	} : handlerOrOptions;
+	const isActive = toRef(options.isActive ?? options.active ?? true);
+	const lastKey = ref(null);
+	const streams = useStreamsContext();
+	let rawModeEnabled = false;
+	const syncRawMode = (isEnabled) => {
+		if (rawModeEnabled === isEnabled) return;
+		streams.setRawMode(isEnabled);
+		rawModeEnabled = isEnabled;
+	};
+	watch(lastKeyEvent, (event) => {
+		if (!event || !isActive.value) return;
+		const inkKey = toInkKey(event);
+		const input = inputValue(event, inkKey);
+		const pressedKey = keyName(event);
+		if (input === "c" && inkKey.ctrl && streams.internal_exitOnCtrlC) return;
+		lastKey.value = pressedKey || null;
+		options.handler?.(input, inkKey);
+		handleStructuredOptions(event, options, lastKey);
+	});
+	watch(lastPasteEvent, (event) => {
+		if (!event || !isActive.value || hasActivePasteHandlers()) return;
+		lastKey.value = event.text;
+		options.handler?.(event.text, emptyKey());
+		options.onChar?.(event.text);
+	});
+	watch(lastCompositionEvent, (event) => {
+		if (!event || !isActive.value) return;
+		if (event.type === "compositionstart") options.onCompositionStart?.();
+		else if (event.type === "compositionupdate") options.onCompositionUpdate?.(event.text, event.cursor);
+		else options.onCompositionEnd?.(event.text);
+	});
+	watch(isActive, syncRawMode, { immediate: true });
+	onUnmounted(() => syncRawMode(false));
+	const enable = () => {
+		isActive.value = true;
+	};
+	const disable = () => {
+		isActive.value = false;
+	};
+	return {
+		isActive,
+		lastKey,
+		enable,
+		disable
+	};
+}
+/**
+* Shorthand for handling specific key combinations
+*/
+function useKeyPress(key, handler, options = {}) {
+	const { ctrl = false, alt = false, shift = false, meta = false } = options;
+	useInput({ onKey: (pressedKey, modifiers) => {
+		if (pressedKey.toLowerCase() === key.toLowerCase() && modifiers.ctrl === ctrl && modifiers.alt === alt && modifiers.shift === shift && modifiers.meta === meta) handler();
+	} });
+}
+//#endregion
+export { useFocusManager as C, useFocus as S, updateLastRenderLayouts as _, createApp as a, useStdin as b, lastKeyEvent as c, lastResizeEvent as d, render as f, measureElement as g, getLastRenderLayout as h, useIsScreenReaderEnabled as i, lastMouseEvent as l, createRenderer$1 as m, useKeyPress as n, lastCompositionEvent as o, renderToString as p, usePaste as r, lastFocusEvent as s, useInput as t, lastPasteEvent as u, useCursor as v, useApp as w, useStdout as x, useStderr as y };
+
+//# sourceMappingURL=useInput-DrlvpGkS.mjs.map