@hatchway/cli 0.51.3 → 0.51.4

package/dist/chunks/{theme-CzLXk_6s.js → theme-BmodcXss.js}

@@ -3,10 +3,13 @@ import { PassThrough, Stream } from 'node:stream';
 import process$1, { env, cwd } from 'node:process';
 import require$$0$1 from 'assert';
 import require$$2 from 'events';
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import fs__default from 'node:fs';
+import tty from 'node:tty';
 import chalk from 'chalk';
 import os from 'node:os';
 import { EventEmitter } from 'node:events';
-import * as fs from 'node:fs';
 import require$$1 from 'module';
 import { Buffer as Buffer$1 } from 'node:buffer';
 
@@ -1882,117 +1885,170 @@ function requireReact () {
 var reactExports = requireReact();
 var React = /*@__PURE__*/getDefaultExportFromCjs(reactExports);
 
+//#region src/function/debounce.ts
+/**
+* Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+* have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+* method to cancel any pending execution.
+*
+* @template F - The type of function.
+* @param func - The function to debounce.
+* @param debounceMs - The number of milliseconds to delay.
+* @param options - The options object
+* @param options.signal - An optional AbortSignal to cancel the debounced function.
+* @param options.edges - An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+* @returns A new debounced function with a `cancel` method.
+*
+* @example
+* const debouncedFunction = debounce(() => {
+*   console.log('Function executed');
+* }, 1000);
+*
+* // Will log 'Function executed' after 1 second if not called again in that time
+* debouncedFunction();
+*
+* // Will not log anything as the previous call is canceled
+* debouncedFunction.cancel();
+*
+* // With AbortSignal
+* const controller = new AbortController();
+* const signal = controller.signal;
+* const debouncedWithSignal = debounce(() => {
+*  console.log('Function executed');
+* }, 1000, { signal });
+*
+* debouncedWithSignal();
+*
+* // Will cancel the debounced function call
+* controller.abort();
+*/
 function debounce$1(func, debounceMs, { signal, edges } = {}) {
-    let pendingThis = undefined;
-    let pendingArgs = null;
-    const leading = edges != null && edges.includes('leading');
-    const trailing = edges == null || edges.includes('trailing');
-    const invoke = () => {
-        if (pendingArgs !== null) {
-            func.apply(pendingThis, pendingArgs);
-            pendingThis = undefined;
-            pendingArgs = null;
-        }
-    };
-    const onTimerEnd = () => {
-        if (trailing) {
-            invoke();
-        }
-        cancel();
-    };
-    let timeoutId = null;
-    const schedule = () => {
-        if (timeoutId != null) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = setTimeout(() => {
-            timeoutId = null;
-            onTimerEnd();
-        }, debounceMs);
-    };
-    const cancelTimer = () => {
-        if (timeoutId !== null) {
-            clearTimeout(timeoutId);
-            timeoutId = null;
-        }
-    };
-    const cancel = () => {
-        cancelTimer();
-        pendingThis = undefined;
-        pendingArgs = null;
-    };
-    const flush = () => {
-        invoke();
-    };
-    const debounced = function (...args) {
-        if (signal?.aborted) {
-            return;
-        }
-        pendingThis = this;
-        pendingArgs = args;
-        const isFirstCall = timeoutId == null;
-        schedule();
-        if (leading && isFirstCall) {
-            invoke();
-        }
-    };
-    debounced.schedule = schedule;
-    debounced.cancel = cancel;
-    debounced.flush = flush;
-    signal?.addEventListener('abort', cancel, { once: true });
-    return debounced;
+	let pendingThis = void 0;
+	let pendingArgs = null;
+	const leading = edges != null && edges.includes("leading");
+	const trailing = edges == null || edges.includes("trailing");
+	const invoke = () => {
+		if (pendingArgs !== null) {
+			func.apply(pendingThis, pendingArgs);
+			pendingThis = void 0;
+			pendingArgs = null;
+		}
+	};
+	const onTimerEnd = () => {
+		if (trailing) invoke();
+		cancel();
+	};
+	let timeoutId = null;
+	const schedule = () => {
+		if (timeoutId != null) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			timeoutId = null;
+			onTimerEnd();
+		}, debounceMs);
+	};
+	const cancelTimer = () => {
+		if (timeoutId !== null) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+	};
+	const cancel = () => {
+		cancelTimer();
+		pendingThis = void 0;
+		pendingArgs = null;
+	};
+	const flush = () => {
+		invoke();
+	};
+	const debounced = function(...args) {
+		if (signal?.aborted) return;
+		pendingThis = this;
+		pendingArgs = args;
+		const isFirstCall = timeoutId == null;
+		schedule();
+		if (leading && isFirstCall) invoke();
+	};
+	debounced.schedule = schedule;
+	debounced.cancel = cancel;
+	debounced.flush = flush;
+	signal?.addEventListener("abort", cancel, { once: true });
+	return debounced;
 }
 
+//#region src/compat/function/debounce.ts
 function debounce(func, debounceMs = 0, options = {}) {
-    if (typeof options !== 'object') {
-        options = {};
-    }
-    const { leading = false, trailing = true, maxWait } = options;
-    const edges = Array(2);
-    if (leading) {
-        edges[0] = 'leading';
-    }
-    if (trailing) {
-        edges[1] = 'trailing';
-    }
-    let result = undefined;
-    let pendingAt = null;
-    const _debounced = debounce$1(function (...args) {
-        result = func.apply(this, args);
-        pendingAt = null;
-    }, debounceMs, { edges });
-    const debounced = function (...args) {
-        if (maxWait != null) {
-            if (pendingAt === null) {
-                pendingAt = Date.now();
-            }
-            if (Date.now() - pendingAt >= maxWait) {
-                result = func.apply(this, args);
-                pendingAt = Date.now();
-                _debounced.cancel();
-                _debounced.schedule();
-                return result;
-            }
-        }
-        _debounced.apply(this, args);
-        return result;
-    };
-    const flush = () => {
-        _debounced.flush();
-        return result;
-    };
-    debounced.cancel = _debounced.cancel;
-    debounced.flush = flush;
-    return debounced;
+	if (typeof options !== "object") options = {};
+	const { leading = false, trailing = true, maxWait } = options;
+	const edges = Array(2);
+	if (leading) edges[0] = "leading";
+	if (trailing) edges[1] = "trailing";
+	let result = void 0;
+	let pendingAt = null;
+	const _debounced = debounce$1(function(...args) {
+		result = func.apply(this, args);
+		pendingAt = null;
+	}, debounceMs, { edges });
+	const debounced = function(...args) {
+		if (maxWait != null) {
+			if (pendingAt === null) pendingAt = Date.now();
+			if (Date.now() - pendingAt >= maxWait) {
+				result = func.apply(this, args);
+				pendingAt = Date.now();
+				_debounced.cancel();
+				_debounced.schedule();
+				return result;
+			}
+		}
+		_debounced.apply(this, args);
+		return result;
+	};
+	const flush = () => {
+		_debounced.flush();
+		return result;
+	};
+	debounced.cancel = _debounced.cancel;
+	debounced.flush = flush;
+	return debounced;
 }
 
+//#region src/compat/function/throttle.ts
+/**
+* Creates a throttled function that only invokes the provided function at most once
+* per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+* within the wait time will not trigger the execution of the original function.
+*
+* @template F - The type of function.
+* @param func - The function to throttle.
+* @param throttleMs - The number of milliseconds to throttle executions to.
+* @param options - The options object
+* @param options.signal - An optional AbortSignal to cancel the throttled function.
+* @param options.leading - If `true`, the function will be invoked on the leading edge of the timeout.
+* @param options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout.
+* @returns A new throttled function that accepts the same parameters as the original function.
+*
+* @example
+* const throttledFunction = throttle(() => {
+*   console.log('Function executed');
+* }, 1000);
+*
+* // Will log 'Function executed' immediately
+* throttledFunction();
+*
+* // Will not log anything as it is within the throttle time
+* throttledFunction();
+*
+* // After 1 second
+* setTimeout(() => {
+*   throttledFunction(); // Will log 'Function executed'
+* }, 1000);
+*/
 function throttle(func, throttleMs = 0, options = {}) {
-    const { leading = true, trailing = true } = options;
-    return debounce(func, throttleMs, {
-        leading,
-        maxWait: throttleMs,
-        trailing,
-    });
+	const { leading = true, trailing = true } = options;
+	return debounce(func, throttleMs, {
+		leading,
+		maxWait: throttleMs,
+		trailing
+	});
 }
 
 /* globals WorkerGlobalScope, DedicatedWorkerGlobalScope, SharedWorkerGlobalScope, ServiceWorkerGlobalScope */
@@ -2049,7 +2105,18 @@ isBrowser ? () => {
 	throw new Error('`process.cwd()` only works in Node.js, not the browser.');
 } : process$1.cwd;
 
+const cursorTo = (x, y) => {
+	if (typeof x !== 'number') {
+		throw new TypeError('The `x` argument is required');
+	}
+
+	{
+		return ESC + (x + 1) + 'G';
+	}
+};
+
 const cursorUp = (count = 1) => ESC + count + 'A';
+const cursorDown = (count = 1) => ESC + count + 'B';
 
 const cursorLeft = ESC + 'G';
 const cursorNextLine = ESC + 'E';
@@ -2067,6 +2134,8 @@ const eraseLines = count => {
 
 	return clear;
 };
+
+const eraseEndLine = ESC + 'K';
 const eraseLine = ESC + '2K';
 const eraseScreen = ESC + '2J';
 
@@ -2987,7 +3056,7 @@ function stripAnsi(string) {
 
 // Generated code.
 
-function isAmbiguous(x) {
+function isAmbiguous$1(x) {
 	return x === 0xA1
 		|| x === 0xA4
 		|| x === 0xA7
@@ -3205,13 +3274,13 @@ function isAmbiguous(x) {
 		|| x >= 0x100000 && x <= 0x10FFFD;
 }
 
-function isFullWidth(x) {
+function isFullWidth$1(x) {
 	return x === 0x3000
 		|| x >= 0xFF01 && x <= 0xFF60
 		|| x >= 0xFFE0 && x <= 0xFFE6;
 }
 
-function isWide(x) {
+function isWide$1(x) {
 	return x >= 0x1100 && x <= 0x115F
 		|| x === 0x231A
 		|| x === 0x231B
@@ -3350,19 +3419,19 @@ function isWide(x) {
 		|| x >= 0x30000 && x <= 0x3FFFD;
 }
 
-function validate(codePoint) {
+function validate$1(codePoint) {
 	if (!Number.isSafeInteger(codePoint)) {
 		throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
 	}
 }
 
-function eastAsianWidth(codePoint, {ambiguousAsWide = false} = {}) {
-	validate(codePoint);
+function eastAsianWidth$1(codePoint, {ambiguousAsWide = false} = {}) {
+	validate$1(codePoint);
 
 	if (
-		isFullWidth(codePoint)
-		|| isWide(codePoint)
-		|| (ambiguousAsWide && isAmbiguous(codePoint))
+		isFullWidth$1(codePoint)
+		|| isWide$1(codePoint)
+		|| (ambiguousAsWide && isAmbiguous$1(codePoint))
 	) {
 		return 2;
 	}
@@ -3375,7 +3444,7 @@ var emojiRegex = () => {
 	return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E-\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED8\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFE])))?))?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3C-\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE8A\uDE8E-\uDEC2\uDEC6\uDEC8\uDECD-\uDEDC\uDEDF-\uDEEA\uDEEF]|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
 };
 
-const segmenter$1 = new Intl.Segmenter();
+const segmenter$2 = new Intl.Segmenter();
 
 const defaultIgnorableCodePointRegex = /^\p{Default_Ignorable_Code_Point}$/u;
 
@@ -3400,7 +3469,7 @@ function stringWidth$1(string, options = {}) {
 	let width = 0;
 	const eastAsianWidthOptions = {ambiguousAsWide: !ambiguousIsNarrow};
 
-	for (const {segment: character} of segmenter$1.segment(string)) {
+	for (const {segment: character} of segmenter$2.segment(string)) {
 		const codePoint = character.codePointAt(0);
 
 		// Ignore control characters
@@ -3448,7 +3517,7 @@ function stringWidth$1(string, options = {}) {
 			continue;
 		}
 
-		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+		width += eastAsianWidth$1(codePoint, eastAsianWidthOptions);
 	}
 
 	return width;
@@ -3683,12 +3752,12 @@ const ESCAPES$2 = new Set([
 
 const END_CODE = 39;
 const ANSI_ESCAPE_BELL = '\u0007';
-const ANSI_CSI = '[';
-const ANSI_OSC = ']';
-const ANSI_SGR_TERMINATOR = 'm';
-const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const ANSI_CSI$1 = '[';
+const ANSI_OSC$1 = ']';
+const ANSI_SGR_TERMINATOR$1 = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC$1}8;;`;
 
-const wrapAnsiCode = code => `${ESCAPES$2.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiCode = code => `${ESCAPES$2.values().next().value}${ANSI_CSI$1}${code}${ANSI_SGR_TERMINATOR$1}`;
 const wrapAnsiHyperlink = url => `${ESCAPES$2.values().next().value}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
 
 // Calculate the length of words split on ' ', ignoring
@@ -3727,7 +3796,7 @@ const wrapWord = (rows, word, columns) => {
 					isInsideEscape = false;
 					isInsideLinkEscape = false;
 				}
-			} else if (character === ANSI_SGR_TERMINATOR) {
+			} else if (character === ANSI_SGR_TERMINATOR$1) {
 				isInsideEscape = false;
 			}
 
@@ -3774,7 +3843,7 @@ const stringVisibleTrimSpacesRight = string => {
 // 'hard' will never allow a string to take up more than columns characters.
 //
 // 'soft' allows long words to expand past the column length.
-const exec = (string, columns, options = {}) => {
+const exec$1 = (string, columns, options = {}) => {
 	if (options.trim !== false && string.trim() === '') {
 		return '';
 	}
@@ -3850,7 +3919,7 @@ const exec = (string, columns, options = {}) => {
 		returnValue += character;
 
 		if (ESCAPES$2.has(character)) {
-			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(preString.slice(preStringIndex)) || {groups: {}};
+			const {groups} = new RegExp(`(?:\\${ANSI_CSI$1}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(preString.slice(preStringIndex)) || {groups: {}};
 			if (groups.code !== undefined) {
 				const code = Number.parseFloat(groups.code);
 				escapeCode = code === END_CODE ? undefined : code;
@@ -3891,10 +3960,147 @@ function wrapAnsi(string, columns, options) {
 		.normalize()
 		.replaceAll('\r\n', '\n')
 		.split('\n')
-		.map(line => exec(line, columns, options))
+		.map(line => exec$1(line, columns, options))
 		.join('\n');
 }
 
+const defaultColumns = 80;
+const defaultRows = 24;
+
+const exec = (command, arguments_, {shell, env} = {}) =>
+	execFileSync(command, arguments_, {
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'ignore'],
+		timeout: 500,
+		shell,
+		env,
+	}).trim();
+
+const create$1 = (columns, rows) => ({
+	columns: Number.parseInt(columns, 10),
+	rows: Number.parseInt(rows, 10),
+});
+
+const createIfNotDefault = (maybeColumns, maybeRows) => {
+	const {columns, rows} = create$1(maybeColumns, maybeRows);
+
+	if (Number.isNaN(columns) || Number.isNaN(rows)) {
+		return;
+	}
+
+	if (columns === defaultColumns && rows === defaultRows) {
+		return;
+	}
+
+	return {columns, rows};
+};
+
+const isForegroundProcess = () => {
+	if (process$1.platform !== 'linux') {
+		return true;
+	}
+
+	try {
+		const statContents = fs__default.readFileSync('/proc/self/stat', 'utf8');
+		const closingParenthesisIndex = statContents.lastIndexOf(') ');
+
+		if (closingParenthesisIndex === -1) {
+			return false;
+		}
+
+		const statFields = statContents.slice(closingParenthesisIndex + 2).trim().split(/\s+/);
+		const processGroupId = Number.parseInt(statFields[2], 10);
+		const foregroundProcessGroupId = Number.parseInt(statFields[5], 10);
+
+		if (Number.isNaN(processGroupId) || Number.isNaN(foregroundProcessGroupId)) {
+			return false;
+		}
+
+		if (foregroundProcessGroupId <= 0) {
+			return false;
+		}
+
+		return processGroupId === foregroundProcessGroupId;
+	} catch {
+		return false;
+	}
+};
+
+function terminalSize() {
+	const {env, stdout, stderr} = process$1;
+
+	if (stdout?.columns && stdout?.rows) {
+		return create$1(stdout.columns, stdout.rows);
+	}
+
+	if (stderr?.columns && stderr?.rows) {
+		return create$1(stderr.columns, stderr.rows);
+	}
+
+	// These values are static, so not the first choice.
+	if (env.COLUMNS && env.LINES) {
+		return create$1(env.COLUMNS, env.LINES);
+	}
+
+	const fallback = {
+		columns: defaultColumns,
+		rows: defaultRows,
+	};
+
+	if (process$1.platform === 'win32') {
+		// We include `tput` for Windows users using Git Bash.
+		return tput() ?? fallback;
+	}
+
+	if (process$1.platform === 'darwin') {
+		return devTty() ?? tput() ?? fallback;
+	}
+
+	return devTty() ?? tput() ?? resize() ?? fallback;
+}
+
+const devTty = () => {
+	try {
+		// eslint-disable-next-line no-bitwise
+		const flags = process$1.platform === 'darwin' ? fs__default.constants.O_EVTONLY | fs__default.constants.O_NONBLOCK : fs__default.constants.O_NONBLOCK;
+		// eslint-disable-next-line new-cap
+		const {columns, rows} = tty.WriteStream(fs__default.openSync('/dev/tty', flags));
+		return {columns, rows};
+	} catch {}
+};
+
+// On macOS, this only returns correct values when stdout is not redirected.
+const tput = () => {
+	try {
+		// `tput` requires the `TERM` environment variable to be set.
+		const columns = exec('tput', ['cols'], {env: {TERM: 'dumb', ...process$1.env}});
+		const rows = exec('tput', ['lines'], {env: {TERM: 'dumb', ...process$1.env}});
+
+		if (columns && rows) {
+			return createIfNotDefault(columns, rows);
+		}
+	} catch {}
+};
+
+// Only exists on Linux.
+const resize = () => {
+	// `resize` is preferred as it works even when all file descriptors are redirected
+	// https://linux.die.net/man/1/resize
+	try {
+		if (!isForegroundProcess()) {
+			return;
+		}
+
+		const size = exec('resize', ['-u']).match(/\d+/g);
+
+		if (size.length === 2) {
+			return createIfNotDefault(size[0], size[1]);
+		}
+	} catch {}
+};
+
+const isDev = () => process$1.env['DEV'] === 'true';
+
 var reactReconciler = {exports: {}};
 
 var reactReconciler_production = {exports: {}};
@@ -35970,11 +36176,343 @@ function requireReactReconciler () {
 var reactReconcilerExports = requireReactReconciler();
 var createReconciler = /*@__PURE__*/getDefaultExportFromCjs(reactReconcilerExports);
 
+var schedulerExports = requireScheduler();
+
+// Generated by scripts/build.js
+
+const ambiguousMinimalCodePoint = 161;
+const ambiguousMaximumCodePoint = 1114109;
+const ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+
+const fullwidthMinimalCodePoint = 12288;
+const fullwidthMaximumCodePoint = 65510;
+const fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+
+const wideMinimalCodePoint = 4352;
+const wideMaximumCodePoint = 262141;
+const wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+
+/**
+Binary search on a sorted flat array of [start, end] pairs.
+
+@param {number[]} ranges - Flat array of inclusive [start, end] range pairs, e.g. [0, 5, 10, 20].
+@param {number} codePoint - The value to search for.
+@returns {boolean} Whether the value falls within any of the ranges.
+*/
+const isInRange = (ranges, codePoint) => {
+	let low = 0;
+	let high = Math.floor(ranges.length / 2) - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const i = mid * 2;
+		if (codePoint < ranges[i]) {
+			high = mid - 1;
+		} else if (codePoint > ranges[i + 1]) {
+			low = mid + 1;
+		} else {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const commonCjkCodePoint = 0x4E_00;
+const [wideFastPathStart, wideFastPathEnd] = /* #__PURE__ */ findWideFastPathRange(wideRanges);
+
+// Use a hot-path range so common `isWide` calls can skip binary search.
+// The range containing U+4E00 covers common CJK ideographs;
+// fallback to the largest range for resilience to Unicode table changes.
+function findWideFastPathRange(ranges) {
+	let fastPathStart = ranges[0];
+	let fastPathEnd = ranges[1];
+
+	for (let index = 0; index < ranges.length; index += 2) {
+		const start = ranges[index];
+		const end = ranges[index + 1];
+
+		if (
+			commonCjkCodePoint >= start
+			&& commonCjkCodePoint <= end
+		) {
+			return [start, end];
+		}
+
+		if ((end - start) > (fastPathEnd - fastPathStart)) {
+			fastPathStart = start;
+			fastPathEnd = end;
+		}
+	}
+
+	return [fastPathStart, fastPathEnd];
+}
+
+const isAmbiguous = codePoint => {
+	if (
+		codePoint < ambiguousMinimalCodePoint
+		|| codePoint > ambiguousMaximumCodePoint
+	) {
+		return false;
+	}
+
+	return isInRange(ambiguousRanges, codePoint);
+};
+
+const isFullWidth = codePoint => {
+	if (
+		codePoint < fullwidthMinimalCodePoint
+		|| codePoint > fullwidthMaximumCodePoint
+	) {
+		return false;
+	}
+
+	return isInRange(fullwidthRanges, codePoint);
+};
+
+const isWide = codePoint => {
+	if (
+		codePoint >= wideFastPathStart
+		&& codePoint <= wideFastPathEnd
+	) {
+		return true;
+	}
+
+	if (
+		codePoint < wideMinimalCodePoint
+		|| codePoint > wideMaximumCodePoint
+	) {
+		return false;
+	}
+
+	return isInRange(wideRanges, codePoint);
+};
+
+function validate(codePoint) {
+	if (!Number.isSafeInteger(codePoint)) {
+		throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+	}
+}
+
+function eastAsianWidth(codePoint, {ambiguousAsWide = false} = {}) {
+	validate(codePoint);
+
+	if (
+		isFullWidth(codePoint)
+		|| isWide(codePoint)
+		|| (ambiguousAsWide && isAmbiguous(codePoint))
+	) {
+		return 2;
+	}
+
+	return 1;
+}
+
+/**
+Logic:
+- Segment graphemes to match how terminals render clusters.
+- Width rules:
+	1. Skip non-printing clusters (Default_Ignorable, Control, pure Mark, lone Surrogates). Tabs are ignored by design.
+	2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
+	3. Minimally-qualified/unqualified emoji clusters (ZWJ sequences with 2+ Extended_Pictographic, or keycap sequences) are double-width.
+	4. Hangul jamo collapse each standard modern Hangul L+V or L+V+T syllable piece to width 2.
+	   Unmatched repeated leading/vowel/trailing jamo stay additive because that matches how the terminals we target render them.
+	5. Otherwise use East Asian Width of the cluster's first visible code point, and add widths for trailing Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
+*/
+
+const segmenter$1 = new Intl.Segmenter();
+
+// Whole-cluster zero-width
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})+$/v;
+
+// Pick the base scalar if the cluster starts with Prepend/Format/Marks
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+
+// RGI emoji sequences
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+
+// Detect minimally-qualified/unqualified emoji sequences (missing VS16 but still render as double-width)
+const unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+const extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
+
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+	// Real emoji clusters are < 30 chars; guard against pathological input
+	if (segment.length > 50) {
+		return false;
+	}
+
+	if (unqualifiedKeycapRegex.test(segment)) {
+		return true;
+	}
+
+	// ZWJ sequences with 2+ Extended_Pictographic
+	if (segment.includes('\u200D')) {
+		const pictographics = segment.match(extendedPictographicRegex);
+		return pictographics !== null && pictographics.length >= 2;
+	}
+
+	return false;
+}
+
+function baseVisible(segment) {
+	return segment.replace(leadingNonPrintingRegex, '');
+}
+
+function isZeroWidthCluster(segment) {
+	return zeroWidthClusterRegex.test(segment);
+}
+
+function isHangulLeadingJamo(codePoint) {
+	return (codePoint >= 0x11_00 && codePoint <= 0x11_5F)
+		|| (codePoint >= 0xA9_60 && codePoint <= 0xA9_7C);
+}
+
+function isHangulVowelJamo(codePoint) {
+	return (codePoint >= 0x11_60 && codePoint <= 0x11_A7)
+		|| (codePoint >= 0xD7_B0 && codePoint <= 0xD7_C6);
+}
+
+function isHangulTrailingJamo(codePoint) {
+	return (codePoint >= 0x11_A8 && codePoint <= 0x11_FF)
+		|| (codePoint >= 0xD7_CB && codePoint <= 0xD7_FB);
+}
+
+function isHangulJamo(codePoint) {
+	return isHangulLeadingJamo(codePoint)
+		|| isHangulVowelJamo(codePoint)
+		|| isHangulTrailingJamo(codePoint);
+}
+
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+	const codePoints = [];
+
+	for (const character of visibleSegment) {
+		if (zeroWidthClusterRegex.test(character)) {
+			continue;
+		}
+
+		codePoints.push(character.codePointAt(0));
+	}
+
+	if (codePoints.length === 0) {
+		return undefined;
+	}
+
+	let width = 0;
+
+	for (let index = 0; index < codePoints.length; index++) {
+		const codePoint = codePoints[index];
+		if (!isHangulJamo(codePoint)) {
+			if (width === 0) {
+				return undefined;
+			}
+
+			// Mixed cluster (e.g., L + precomposed syllable): use EAW for non-jamo remainder
+			for (let remaining = index; remaining < codePoints.length; remaining++) {
+				width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+			}
+
+			return width;
+		}
+
+		// Modern Hangul L+V(+T) shapes as one syllable block. Unmatched jamo stay additive:
+		// U+1100 U+1100 U+1161 => U+1100 + (U+1100 U+1161) => 2 + 2.
+		if (
+			isHangulLeadingJamo(codePoint)
+			&& isHangulVowelJamo(codePoints[index + 1])
+		) {
+			width += 2;
+			index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+			continue;
+		}
+
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+	}
+
+	return width;
+}
+
+function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+	let extra = 0;
+	let first = true;
+
+	for (const character of visibleSegment) {
+		if (first) {
+			first = false;
+			continue;
+		}
+
+		if (character >= '\uFF00' && character <= '\uFFEF') {
+			extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+		}
+	}
+
+	return extra;
+}
+
+function stringWidth(input, options = {}) {
+	if (typeof input !== 'string' || input.length === 0) {
+		return 0;
+	}
+
+	const {
+		ambiguousIsNarrow = true,
+		countAnsiEscapeCodes = false,
+	} = options;
+
+	let string = input;
+
+	// Avoid calling stripAnsi when there are no ANSI escape sequences (ESC = 0x1B, CSI = 0x9B)
+	if (!countAnsiEscapeCodes && (string.includes('\u001B') || string.includes('\u009B'))) {
+		string = stripAnsi(string);
+	}
+
+	if (string.length === 0) {
+		return 0;
+	}
+
+	// Fast path: printable ASCII (0x20–0x7E) needs no segmenter, regex, or EAW lookup — width equals length.
+	if (/^[\u0020-\u007E]*$/.test(string)) {
+		return string.length;
+	}
+
+	let width = 0;
+	const eastAsianWidthOptions = {ambiguousAsWide: !ambiguousIsNarrow};
+
+	for (const {segment} of segmenter$1.segment(string)) {
+		// Zero-width / non-printing clusters
+		if (isZeroWidthCluster(segment)) {
+			continue;
+		}
+
+		// Emoji width logic
+		if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+			width += 2;
+			continue;
+		}
+
+		const visibleSegment = baseVisible(segment);
+		const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+		if (hangulWidth !== undefined) {
+			width += hangulWidth;
+			continue;
+		}
+
+		// Everything else: EAW of the cluster’s first visible scalar
+		const codePoint = visibleSegment.codePointAt(0);
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+
+		// Add width for trailing Halfwidth and Fullwidth Forms (e.g., ﾞ, ﾟ, ｰ)
+		width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
+	}
+
+	return width;
+}
+
 function widestLine(string) {
 	let lineWidth = 0;
 
 	for (const line of string.split('\n')) {
-		lineWidth = Math.max(lineWidth, stringWidth$1(line));
+		lineWidth = Math.max(lineWidth, stringWidth(line));
 	}
 
 	return lineWidth;
@@ -36004,74 +36542,609 @@ function isFullwidthCodePoint(codePoint) {
 		return false;
 	}
 
-	return isFullWidth(codePoint) || isWide(codePoint);
+	return isFullWidth$1(codePoint) || isWide$1(codePoint);
 }
 
-// \x1b and \x9b
-const ESCAPES$1 = new Set([27, 155]);
+const ESCAPE_CODE_POINT = 27;
+const C1_DCS_CODE_POINT = 144;
+const C1_SOS_CODE_POINT = 152;
+const C1_CSI_CODE_POINT = 155;
+const C1_ST_CODE_POINT = 156;
+const C1_OSC_CODE_POINT = 157;
+const C1_PM_CODE_POINT = 158;
+const C1_APC_CODE_POINT = 159;
+const ESCAPES$1 = new Set([
+	ESCAPE_CODE_POINT,
+	C1_DCS_CODE_POINT,
+	C1_SOS_CODE_POINT,
+	C1_CSI_CODE_POINT,
+	C1_ST_CODE_POINT,
+	C1_OSC_CODE_POINT,
+	C1_PM_CODE_POINT,
+	C1_APC_CODE_POINT,
+]);
+
+const ESCAPE = '\u001B';
+const ANSI_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_DCS = 'P';
+const ANSI_SOS = 'X';
+const ANSI_PM = '^';
+const ANSI_APC = '_';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_OSC_TERMINATOR = '\\';
+const ANSI_STRING_TERMINATOR = `${ESCAPE}${ANSI_OSC_TERMINATOR}`;
+const C1_OSC = '\u009D';
+const C1_STRING_TERMINATOR = '\u009C';
+const ANSI_HYPERLINK_ESC_PREFIX = `${ESCAPE}${ANSI_OSC}8;`;
+const ANSI_HYPERLINK_C1_PREFIX = `${C1_OSC}8;`;
+const ANSI_HYPERLINK_ESC_CLOSE = `${ANSI_HYPERLINK_ESC_PREFIX};`;
+const ANSI_HYPERLINK_C1_CLOSE = `${ANSI_HYPERLINK_C1_PREFIX};`;
 
 const CODE_POINT_0 = '0'.codePointAt(0);
 const CODE_POINT_9 = '9'.codePointAt(0);
+const CODE_POINT_SEMICOLON = ';'.codePointAt(0);
+const CODE_POINT_COLON = ':'.codePointAt(0);
+// ECMA-48 CSI format: parameter bytes 0x30-0x3F, intermediates 0x20-0x2F, final 0x40-0x7E.
+const CODE_POINT_CSI_PARAMETER_START = '0'.codePointAt(0);
+const CODE_POINT_CSI_PARAMETER_END = '?'.codePointAt(0);
+const CODE_POINT_CSI_INTERMEDIATE_START = ' '.codePointAt(0);
+const CODE_POINT_CSI_INTERMEDIATE_END = '/'.codePointAt(0);
+const CODE_POINT_CSI_FINAL_START = '@'.codePointAt(0);
+const CODE_POINT_CSI_FINAL_END = '~'.codePointAt(0);
+const REGIONAL_INDICATOR_SYMBOL_LETTER_A = 127_462;
+const REGIONAL_INDICATOR_SYMBOL_LETTER_Z = 127_487;
+const SGR_RESET_CODE = 0;
+const SGR_EXTENDED_FOREGROUND_CODE = 38;
+const SGR_DEFAULT_FOREGROUND_CODE = 39;
+const SGR_EXTENDED_BACKGROUND_CODE = 48;
+const SGR_DEFAULT_BACKGROUND_CODE = 49;
+const SGR_COLOR_TYPE_ANSI_256 = 5;
+const SGR_COLOR_TYPE_TRUECOLOR = 2;
+const SGR_ANSI_256_FRAGMENT_LENGTH = 3;
+const SGR_TRUECOLOR_FRAGMENT_LENGTH = 5;
+const SGR_ANSI_256_LAST_PARAMETER_OFFSET = 2;
+const SGR_TRUECOLOR_LAST_PARAMETER_OFFSET = 4;
+const VARIATION_SELECTOR_16_CODE_POINT = 65_039;
+const COMBINING_ENCLOSING_KEYCAP_CODE_POINT = 8419;
+const EMOJI_PRESENTATION_GRAPHEME_REGEX = /\p{Emoji_Presentation}/u;
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, {granularity: 'grapheme'});
+
+const endCodeNumbers = new Set();
+for (const [, end] of ansiStyles.codes) {
+	endCodeNumbers.add(end);
+}
 
-const MAX_ANSI_SEQUENCE_LENGTH = 19;
+function isSgrParameterCharacter(codePoint) {
+	return (
+		(codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9)
+		|| codePoint === CODE_POINT_SEMICOLON
+		|| codePoint === CODE_POINT_COLON
+	);
+}
 
-const endCodesSet$1 = new Set();
-const endCodesMap$1 = new Map();
-for (const [start, end] of ansiStyles.codes) {
-	endCodesSet$1.add(ansiStyles.color.ansi(end));
-	endCodesMap$1.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
+function isCsiParameterCharacter$1(codePoint) {
+	return codePoint >= CODE_POINT_CSI_PARAMETER_START && codePoint <= CODE_POINT_CSI_PARAMETER_END;
+}
+
+function isCsiIntermediateCharacter$1(codePoint) {
+	return codePoint >= CODE_POINT_CSI_INTERMEDIATE_START && codePoint <= CODE_POINT_CSI_INTERMEDIATE_END;
+}
+
+function isCsiFinalCharacter$1(codePoint) {
+	return codePoint >= CODE_POINT_CSI_FINAL_START && codePoint <= CODE_POINT_CSI_FINAL_END;
+}
+
+function isRegionalIndicatorCodePoint(codePoint) {
+	return codePoint >= REGIONAL_INDICATOR_SYMBOL_LETTER_A && codePoint <= REGIONAL_INDICATOR_SYMBOL_LETTER_Z;
+}
+
+function createControlParseResult(code, endIndex) {
+	return {
+		token: {
+			type: 'control',
+			code,
+		},
+		endIndex,
+	};
+}
+
+function isEmojiStyleGrapheme(grapheme) {
+	if (EMOJI_PRESENTATION_GRAPHEME_REGEX.test(grapheme)) {
+		return true;
+	}
+
+	for (const character of grapheme) {
+		const codePoint = character.codePointAt(0);
+		if (
+			codePoint === VARIATION_SELECTOR_16_CODE_POINT
+			|| codePoint === COMBINING_ENCLOSING_KEYCAP_CODE_POINT
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function getGraphemeWidth(grapheme) {
+	let regionalIndicatorCount = 0;
+	for (const character of grapheme) {
+		const codePoint = character.codePointAt(0);
+		if (isFullwidthCodePoint(codePoint)) {
+			return 2;
+		}
+
+		if (isRegionalIndicatorCodePoint(codePoint)) {
+			regionalIndicatorCount++;
+		}
+	}
+
+	if (regionalIndicatorCount >= 1) {
+		return 2;
+	}
+
+	if (isEmojiStyleGrapheme(grapheme)) {
+		return 2;
+	}
+
+	return 1;
+}
+
+function getSgrPrefix(code) {
+	if (code.startsWith('\u009B')) {
+		return '\u009B';
+	}
+
+	return `${ESCAPE}${ANSI_CSI}`;
+}
+
+function createSgrCode(prefix, values) {
+	return `${prefix}${values.join(';')}${ANSI_SGR_TERMINATOR}`;
+}
+
+function getSgrFragments(code) {
+	const fragments = [];
+	const sgrPrefix = getSgrPrefix(code);
+	let parameterString;
+
+	if (code.startsWith(`${ESCAPE}${ANSI_CSI}`)) {
+		parameterString = code.slice(2, -1);
+	} else if (code.startsWith('\u009B')) {
+		parameterString = code.slice(1, -1);
+	} else {
+		return fragments;
+	}
+
+	const rawCodes = parameterString.length === 0 ? [String(SGR_RESET_CODE)] : parameterString.split(';');
+	let index = 0;
+	while (index < rawCodes.length) {
+		const codeNumber = Number.parseInt(rawCodes[index], 10);
+		if (Number.isNaN(codeNumber)) {
+			index++;
+			continue;
+		}
+
+		if (codeNumber === SGR_RESET_CODE) {
+			fragments.push({type: 'reset'});
+			index++;
+			continue;
+		}
+
+		if (codeNumber === SGR_EXTENDED_FOREGROUND_CODE || codeNumber === SGR_EXTENDED_BACKGROUND_CODE) {
+			const colorType = Number.parseInt(rawCodes[index + 1], 10);
+			if (colorType === SGR_COLOR_TYPE_ANSI_256 && index + SGR_ANSI_256_LAST_PARAMETER_OFFSET < rawCodes.length) {
+				const openCode = createSgrCode(sgrPrefix, rawCodes.slice(index, index + SGR_ANSI_256_FRAGMENT_LENGTH));
+				fragments.push({
+					type: 'start',
+					code: openCode,
+					endCode: ansiStyles.color.ansi(codeNumber === SGR_EXTENDED_FOREGROUND_CODE ? SGR_DEFAULT_FOREGROUND_CODE : SGR_DEFAULT_BACKGROUND_CODE),
+				});
+				index += SGR_ANSI_256_FRAGMENT_LENGTH;
+				continue;
+			}
+
+			if (colorType === SGR_COLOR_TYPE_TRUECOLOR && index + SGR_TRUECOLOR_LAST_PARAMETER_OFFSET < rawCodes.length) {
+				const openCode = createSgrCode(sgrPrefix, rawCodes.slice(index, index + SGR_TRUECOLOR_FRAGMENT_LENGTH));
+				fragments.push({
+					type: 'start',
+					code: openCode,
+					endCode: ansiStyles.color.ansi(codeNumber === SGR_EXTENDED_FOREGROUND_CODE ? SGR_DEFAULT_FOREGROUND_CODE : SGR_DEFAULT_BACKGROUND_CODE),
+				});
+				index += SGR_TRUECOLOR_FRAGMENT_LENGTH;
+				continue;
+			}
+
+			const openCode = createSgrCode(sgrPrefix, [rawCodes[index]]);
+			fragments.push({
+				type: 'start',
+				code: openCode,
+				endCode: ansiStyles.color.ansi(codeNumber === SGR_EXTENDED_FOREGROUND_CODE ? SGR_DEFAULT_FOREGROUND_CODE : SGR_DEFAULT_BACKGROUND_CODE),
+			});
+			index++;
+			continue;
+		}
+
+		if (endCodeNumbers.has(codeNumber)) {
+			fragments.push({
+				type: 'end',
+				endCode: ansiStyles.color.ansi(codeNumber),
+			});
+			index++;
+			continue;
+		}
+
+		const mappedEndCode = ansiStyles.codes.get(codeNumber);
+		if (mappedEndCode !== undefined) {
+			const openCode = createSgrCode(sgrPrefix, [rawCodes[index]]);
+			fragments.push({
+				type: 'start',
+				code: openCode,
+				endCode: ansiStyles.color.ansi(mappedEndCode),
+			});
+			index++;
+			continue;
+		}
+
+		const openCode = createSgrCode(sgrPrefix, [rawCodes[index]]);
+		fragments.push({
+			type: 'start',
+			code: openCode,
+			endCode: ansiStyles.reset.open,
+		});
+		index++;
+	}
+
+	if (fragments.length === 0) {
+		fragments.push({type: 'reset'});
+	}
+
+	return fragments;
+}
+
+function parseCsiCode(string, index) {
+	const escapeCodePoint = string.codePointAt(index);
+	let sequenceStartIndex;
+
+	if (escapeCodePoint === ESCAPE_CODE_POINT) {
+		if (string[index + 1] !== ANSI_CSI) {
+			return;
+		}
+
+		sequenceStartIndex = index + 2;
+	} else if (escapeCodePoint === C1_CSI_CODE_POINT) {
+		sequenceStartIndex = index + 1;
+	} else {
+		return;
+	}
+
+	let hasCanonicalSgrParameters = true;
+	for (let sequenceIndex = sequenceStartIndex; sequenceIndex < string.length; sequenceIndex++) {
+		const codePoint = string.codePointAt(sequenceIndex);
+
+		if (isCsiFinalCharacter$1(codePoint)) {
+			const code = string.slice(index, sequenceIndex + 1);
+			if (string[sequenceIndex] !== ANSI_SGR_TERMINATOR || !hasCanonicalSgrParameters) {
+				return createControlParseResult(code, sequenceIndex + 1);
+			}
+
+			return {
+				token: {
+					type: 'sgr',
+					code,
+					fragments: getSgrFragments(code),
+				},
+				endIndex: sequenceIndex + 1,
+			};
+		}
+
+		if (isCsiParameterCharacter$1(codePoint)) {
+			if (!isSgrParameterCharacter(codePoint)) {
+				hasCanonicalSgrParameters = false;
+			}
+
+			continue;
+		}
+
+		if (isCsiIntermediateCharacter$1(codePoint)) {
+			hasCanonicalSgrParameters = false;
+			continue;
+		}
+
+		const endIndex = sequenceIndex;
+		return createControlParseResult(string.slice(index, endIndex), endIndex);
+	}
+
+	return createControlParseResult(string.slice(index), string.length);
+}
+
+function parseHyperlinkCode(string, index) {
+	let hyperlinkPrefix;
+	let hyperlinkClose;
+	const codePoint = string.codePointAt(index);
+
+	if (
+		codePoint === ESCAPE_CODE_POINT
+		&& string.startsWith(ANSI_HYPERLINK_ESC_PREFIX, index)
+	) {
+		hyperlinkPrefix = ANSI_HYPERLINK_ESC_PREFIX;
+		hyperlinkClose = ANSI_HYPERLINK_ESC_CLOSE;
+	} else if (
+		codePoint === C1_OSC_CODE_POINT
+		&& string.startsWith(ANSI_HYPERLINK_C1_PREFIX, index)
+	) {
+		hyperlinkPrefix = ANSI_HYPERLINK_C1_PREFIX;
+		hyperlinkClose = ANSI_HYPERLINK_C1_CLOSE;
+	} else {
+		return;
+	}
+
+	const uriStart = string.indexOf(';', index + hyperlinkPrefix.length);
+	if (uriStart === -1) {
+		return createControlParseResult(string.slice(index), string.length);
+	}
+
+	for (let sequenceIndex = uriStart + 1; sequenceIndex < string.length; sequenceIndex++) {
+		const character = string[sequenceIndex];
+
+		if (character === ANSI_BELL) {
+			const code = string.slice(index, sequenceIndex + 1);
+			const action = sequenceIndex === uriStart + 1 ? 'close' : 'open';
+			return {
+				token: {
+					type: 'hyperlink',
+					code,
+					action,
+					closePrefix: hyperlinkClose,
+					terminator: ANSI_BELL,
+				},
+				endIndex: sequenceIndex + 1,
+			};
+		}
+
+		if (
+			character === ESCAPE
+			&& string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR
+		) {
+			const code = string.slice(index, sequenceIndex + 2);
+			const action = sequenceIndex === uriStart + 1 ? 'close' : 'open';
+			return {
+				token: {
+					type: 'hyperlink',
+					code,
+					action,
+					closePrefix: hyperlinkClose,
+					terminator: ANSI_STRING_TERMINATOR,
+				},
+				endIndex: sequenceIndex + 2,
+			};
+		}
+
+		if (character === C1_STRING_TERMINATOR) {
+			const code = string.slice(index, sequenceIndex + 1);
+			const action = sequenceIndex === uriStart + 1 ? 'close' : 'open';
+			return {
+				token: {
+					type: 'hyperlink',
+					code,
+					action,
+					closePrefix: hyperlinkClose,
+					terminator: C1_STRING_TERMINATOR,
+				},
+				endIndex: sequenceIndex + 1,
+			};
+		}
+	}
+
+	return createControlParseResult(string.slice(index), string.length);
+}
+
+function parseControlStringCode(string, index) {
+	const codePoint = string.codePointAt(index);
+	let sequenceStartIndex;
+	let supportsBellTerminator = false;
+
+	switch (codePoint) {
+		case ESCAPE_CODE_POINT: {
+			const command = string[index + 1];
+			switch (command) {
+				case ANSI_OSC: {
+					// OSC accepts ST (ECMA-48) and BEL (xterm compatibility extension).
+					sequenceStartIndex = index + 2;
+					supportsBellTerminator = true;
+					break;
+				}
+
+				case ANSI_DCS:
+				case ANSI_SOS:
+				case ANSI_PM:
+				case ANSI_APC: {
+					sequenceStartIndex = index + 2;
+					break;
+				}
+
+				case ANSI_OSC_TERMINATOR: {
+					return createControlParseResult(ANSI_STRING_TERMINATOR, index + 2);
+				}
+
+				default: {
+					return;
+				}
+			}
+
+			break;
+		}
+
+		case C1_OSC_CODE_POINT: {
+			sequenceStartIndex = index + 1;
+			supportsBellTerminator = true;
+			break;
+		}
+
+		case C1_DCS_CODE_POINT:
+		case C1_SOS_CODE_POINT:
+		case C1_PM_CODE_POINT:
+		case C1_APC_CODE_POINT: {
+			sequenceStartIndex = index + 1;
+			break;
+		}
+
+		case C1_ST_CODE_POINT: {
+			return createControlParseResult(C1_STRING_TERMINATOR, index + 1);
+		}
+
+		default: {
+			return;
+		}
+	}
+
+	for (let sequenceIndex = sequenceStartIndex; sequenceIndex < string.length; sequenceIndex++) {
+		if (supportsBellTerminator && string[sequenceIndex] === ANSI_BELL) {
+			return createControlParseResult(string.slice(index, sequenceIndex + 1), sequenceIndex + 1);
+		}
+
+		if (
+			string[sequenceIndex] === ESCAPE
+			&& string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR
+		) {
+			return createControlParseResult(string.slice(index, sequenceIndex + 2), sequenceIndex + 2);
+		}
+
+		if (string[sequenceIndex] === C1_STRING_TERMINATOR) {
+			return createControlParseResult(string.slice(index, sequenceIndex + 1), sequenceIndex + 1);
+		}
+	}
+
+	return createControlParseResult(string.slice(index), string.length);
 }
 
-function getEndCode$1(code) {
-	if (endCodesSet$1.has(code)) {
-		return code;
+function parseAnsiCode(string, index) {
+	const codePoint = string.codePointAt(index);
+	if (codePoint === ESCAPE_CODE_POINT || codePoint === C1_OSC_CODE_POINT) {
+		const hyperlinkCode = parseHyperlinkCode(string, index);
+		if (hyperlinkCode) {
+			return hyperlinkCode;
+		}
 	}
 
-	if (endCodesMap$1.has(code)) {
-		return endCodesMap$1.get(code);
+	const controlStringCode = parseControlStringCode(string, index);
+	if (controlStringCode) {
+		return controlStringCode;
 	}
 
-	code = code.slice(2);
-	if (code.includes(';')) {
-		code = code[0] + '0';
+	return parseCsiCode(string, index);
+}
+
+function appendTrailingAnsiTokens(string, index, tokens) {
+	while (index < string.length) {
+		const nextCodePoint = string.codePointAt(index);
+		if (!ESCAPES$1.has(nextCodePoint)) {
+			break;
+		}
+
+		const escapeCode = parseAnsiCode(string, index);
+		if (!escapeCode) {
+			break;
+		}
+
+		tokens.push(escapeCode.token);
+		index = escapeCode.endIndex;
 	}
 
-	const returnValue = ansiStyles.codes.get(Number.parseInt(code, 10));
-	if (returnValue) {
-		return ansiStyles.color.ansi(returnValue);
+	return index;
+}
+
+function parseCharacterTokenWithRawSegmentation(string, index, graphemeSegments) {
+	const segment = graphemeSegments.containing(index);
+	if (!segment || segment.index !== index) {
+		return;
 	}
 
-	return ansiStyles.reset.open;
+	return {
+		token: {
+			type: 'character',
+			// Intentionally preserve UAX29 behavior (GB3): CRLF is one grapheme cluster.
+			value: segment.segment,
+			visibleWidth: getGraphemeWidth(segment.segment),
+			isGraphemeContinuation: false,
+		},
+		endIndex: index + segment.segment.length,
+	};
 }
 
-function findNumberIndex(string) {
-	for (let index = 0; index < string.length; index++) {
+function collectVisibleCharacters(string) {
+	const visibleCharacters = [];
+	let index = 0;
+
+	while (index < string.length) {
 		const codePoint = string.codePointAt(index);
-		if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) {
-			return index;
+		if (ESCAPES$1.has(codePoint)) {
+			const code = parseAnsiCode(string, index);
+			if (code) {
+				index = code.endIndex;
+				continue;
+			}
 		}
+
+		const value = String.fromCodePoint(codePoint);
+		visibleCharacters.push({
+			value,
+			visibleWidth: 1,
+			isGraphemeContinuation: false,
+		});
+		index += value.length;
 	}
 
-	return -1;
+	return visibleCharacters;
 }
 
-function parseAnsiCode(string, offset) {
-	string = string.slice(offset, offset + MAX_ANSI_SEQUENCE_LENGTH);
-	const startIndex = findNumberIndex(string);
-	if (startIndex !== -1) {
-		let endIndex = string.indexOf('m', startIndex);
-		if (endIndex === -1) {
-			endIndex = string.length;
+function applyGraphemeMetadata(visibleCharacters) {
+	if (visibleCharacters.length === 0) {
+		return;
+	}
+
+	const visibleString = visibleCharacters.map(({value}) => value).join('');
+	const scalarOffsets = [];
+	let scalarOffset = 0;
+
+	for (const visibleCharacter of visibleCharacters) {
+		scalarOffsets.push(scalarOffset);
+		scalarOffset += visibleCharacter.value.length;
+	}
+
+	let scalarIndex = 0;
+	for (const segment of GRAPHEME_SEGMENTER.segment(visibleString)) {
+		while (
+			scalarIndex < visibleCharacters.length
+			&& scalarOffsets[scalarIndex] < segment.index
+		) {
+			scalarIndex++;
+		}
+
+		let graphemeIndex = scalarIndex;
+		let isFirstInGrapheme = true;
+		while (
+			graphemeIndex < visibleCharacters.length
+			&& scalarOffsets[graphemeIndex] < segment.index + segment.segment.length
+		) {
+			visibleCharacters[graphemeIndex].visibleWidth = isFirstInGrapheme ? getGraphemeWidth(segment.segment) : 0;
+			visibleCharacters[graphemeIndex].isGraphemeContinuation = !isFirstInGrapheme;
+			isFirstInGrapheme = false;
+			graphemeIndex++;
 		}
 
-		return string.slice(0, endIndex + 1);
+		scalarIndex = graphemeIndex;
 	}
 }
 
-function tokenize$1(string, endCharacter = Number.POSITIVE_INFINITY) {
-	const returnValue = [];
+function tokenizeAnsiWithVisibleSegmentation(string, {endCharacter = Number.POSITIVE_INFINITY} = {}) {
+	const tokens = [];
+	const visibleCharacters = collectVisibleCharacters(string);
+	applyGraphemeMetadata(visibleCharacters);
 
 	let index = 0;
+	let visibleCharacterIndex = 0;
 	let visibleCount = 0;
 	while (index < string.length) {
 		const codePoint = string.codePointAt(index);
@@ -36079,186 +37152,402 @@ function tokenize$1(string, endCharacter = Number.POSITIVE_INFINITY) {
 		if (ESCAPES$1.has(codePoint)) {
 			const code = parseAnsiCode(string, index);
 			if (code) {
-				returnValue.push({
-					type: 'ansi',
-					code,
-					endCode: getEndCode$1(code),
-				});
-				index += code.length;
+				tokens.push(code.token);
+				index = code.endIndex;
 				continue;
 			}
 		}
 
-		const isFullWidth = isFullwidthCodePoint(codePoint);
-		const character = String.fromCodePoint(codePoint);
+		const value = String.fromCodePoint(codePoint);
+		const visibleCharacter = visibleCharacters[visibleCharacterIndex];
+		let visibleWidth = isFullwidthCodePoint(codePoint) ? 2 : value.length;
+		if (visibleCharacter) {
+			visibleWidth = visibleCharacter.visibleWidth;
+		}
 
-		returnValue.push({
+		const token = {
 			type: 'character',
-			value: character,
-			isFullWidth,
-		});
+			value,
+			visibleWidth,
+			isGraphemeContinuation: visibleCharacter ? visibleCharacter.isGraphemeContinuation : false,
+		};
 
-		index += character.length;
-		visibleCount += isFullWidth ? 2 : character.length;
+		tokens.push(token);
+		index += value.length;
+		visibleCharacterIndex++;
+		visibleCount += token.visibleWidth;
 
 		if (visibleCount >= endCharacter) {
-			break;
+			const nextVisibleCharacter = visibleCharacters[visibleCharacterIndex];
+			if (
+				!nextVisibleCharacter
+				|| !nextVisibleCharacter.isGraphemeContinuation
+			) {
+				index = appendTrailingAnsiTokens(string, index, tokens);
+				break;
+			}
 		}
 	}
 
-	return returnValue;
+	return tokens;
 }
 
-function reduceAnsiCodes$1(codes) {
-	let returnValue = [];
+function areValuesInSameGrapheme(leftValue, rightValue) {
+	const pair = `${leftValue}${rightValue}`;
+	const splitIndex = leftValue.length;
 
-	for (const code of codes) {
-		if (code.code === ansiStyles.reset.open) {
-			// Reset code, disable all codes
-			returnValue = [];
-		} else if (endCodesSet$1.has(code.code)) {
-			// This is an end code, disable all matching start codes
-			returnValue = returnValue.filter(returnValueCode => returnValueCode.endCode !== code.code);
-		} else {
-			// This is a start code. Disable all styles this "overrides", then enable it
-			returnValue = returnValue.filter(returnValueCode => returnValueCode.endCode !== code.endCode);
-			returnValue.push(code);
+	for (const segment of GRAPHEME_SEGMENTER.segment(pair)) {
+		if (segment.index === splitIndex) {
+			return false;
+		}
+
+		if (segment.index > splitIndex) {
+			return true;
 		}
 	}
 
-	return returnValue;
+	return true;
 }
 
-function undoAnsiCodes$1(codes) {
-	const reduced = reduceAnsiCodes$1(codes);
-	const endCodes = reduced.map(({endCode}) => endCode);
-	return endCodes.reverse().join('');
+function hasAnsiSplitContinuationAhead(string, startIndex, previousVisibleValue, graphemeSegments) {
+	if (!previousVisibleValue) {
+		return false;
+	}
+
+	let index = startIndex;
+	let hasAnsiCode = false;
+	while (index < string.length) {
+		const codePoint = string.codePointAt(index);
+		if (ESCAPES$1.has(codePoint)) {
+			const code = parseAnsiCode(string, index);
+			if (code) {
+				hasAnsiCode = true;
+				index = code.endIndex;
+				continue;
+			}
+		}
+
+		if (!hasAnsiCode) {
+			return false;
+		}
+
+		const characterToken = parseCharacterTokenWithRawSegmentation(string, index, graphemeSegments);
+		if (!characterToken) {
+			return true;
+		}
+
+		return areValuesInSameGrapheme(previousVisibleValue, characterToken.token.value);
+	}
+
+	return false;
 }
 
-function sliceAnsi(string, start, end) {
-	const tokens = tokenize$1(string, end);
-	let activeCodes = [];
-	let position = 0;
-	let returnValue = '';
-	let include = false;
+function tokenizeAnsi$1(string, {endCharacter = Number.POSITIVE_INFINITY} = {}) {
+	const tokens = [];
+	const graphemeSegments = GRAPHEME_SEGMENTER.segment(string);
+
+	let index = 0;
+	let visibleCount = 0;
+	let previousVisibleValue;
+	let hasAnsiSinceLastVisible = false;
+	while (index < string.length) {
+		const codePoint = string.codePointAt(index);
+
+		if (ESCAPES$1.has(codePoint)) {
+			const code = parseAnsiCode(string, index);
+			if (code) {
+				tokens.push(code.token);
+				index = code.endIndex;
+				hasAnsiSinceLastVisible = true;
+				continue;
+			}
+		}
+
+		const characterToken = parseCharacterTokenWithRawSegmentation(string, index, graphemeSegments);
+		if (!characterToken) {
+			return tokenizeAnsiWithVisibleSegmentation(string, {endCharacter});
+		}
+
+		if (
+			hasAnsiSinceLastVisible
+			&& previousVisibleValue
+			&& areValuesInSameGrapheme(previousVisibleValue, characterToken.token.value)
+		) {
+			return tokenizeAnsiWithVisibleSegmentation(string, {endCharacter});
+		}
+
+		tokens.push(characterToken.token);
+		index = characterToken.endIndex;
+		visibleCount += characterToken.token.visibleWidth;
+		hasAnsiSinceLastVisible = false;
+		previousVisibleValue = characterToken.token.value;
+
+		if (visibleCount >= endCharacter) {
+			if (hasAnsiSplitContinuationAhead(string, index, previousVisibleValue, graphemeSegments)) {
+				return tokenizeAnsiWithVisibleSegmentation(string, {endCharacter});
+			}
 
-	for (const token of tokens) {
-		if (end !== undefined && position >= end) {
+			index = appendTrailingAnsiTokens(string, index, tokens);
 			break;
 		}
+	}
+
+	return tokens;
+}
 
-		if (token.type === 'ansi') {
-			activeCodes.push(token);
-			if (include) {
-				returnValue += token.code;
+function applySgrFragments(activeStyles, fragments) {
+	for (const fragment of fragments) {
+		switch (fragment.type) {
+			case 'reset': {
+				activeStyles.clear();
+				break;
 			}
-		} else {
-			// Character
-			if (!include && position >= start) {
-				include = true;
-				// Simplify active codes
-				activeCodes = reduceAnsiCodes$1(activeCodes);
-				returnValue = activeCodes.map(({code}) => code).join('');
+
+			case 'end': {
+				activeStyles.delete(fragment.endCode);
+				break;
 			}
 
-			if (include) {
-				returnValue += token.value;
+			case 'start': {
+				activeStyles.delete(fragment.endCode);
+				activeStyles.set(fragment.endCode, fragment.code);
+				break;
 			}
+		}
+	}
+
+	return activeStyles;
+}
+
+function undoAnsiCodes$1(activeStyles) {
+	return [...activeStyles.keys()].reverse().join('');
+}
+
+function closeHyperlink(hyperlinkToken) {
+	return `${hyperlinkToken.closePrefix}${hyperlinkToken.terminator}`;
+}
+
+function shouldIncludeSgrAfterEnd(token, activeStyles) {
+	let hasStartFragment = false;
+	let hasClosingEffect = false;
+
+	for (const fragment of token.fragments) {
+		if (fragment.type === 'start') {
+			hasStartFragment = true;
+			continue;
+		}
+
+		if (fragment.type === 'reset' && activeStyles.size > 0) {
+			hasClosingEffect = true;
+			continue;
+		}
 
-			position += token.isFullWidth ? 2 : token.value.length;
+		if (fragment.type === 'end' && activeStyles.has(fragment.endCode)) {
+			hasClosingEffect = true;
 		}
 	}
 
-	// Disable active codes at the end
-	returnValue += undoAnsiCodes$1(activeCodes);
-	return returnValue;
+	return hasClosingEffect && !hasStartFragment;
 }
 
-/**
-Logic:
-- Segment graphemes to match how terminals render clusters.
-- Width rules:
-	1. Skip non-printing clusters (Default_Ignorable, Control, pure Mark, lone Surrogates). Tabs are ignored by design.
-	2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
-	3. Otherwise use East Asian Width of the cluster’s first visible code point, and add widths for trailing Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
-*/
+function applySgrToken({token, isPastEnd, activeStyles, returnValue, include, activeHyperlink, position}) {
+	if (isPastEnd && !shouldIncludeSgrAfterEnd(token, activeStyles)) {
+		return {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		};
+	}
 
-const segmenter = new Intl.Segmenter();
+	activeStyles = applySgrFragments(activeStyles, token.fragments);
+	if (include) {
+		returnValue += token.code;
+	}
 
-// Whole-cluster zero-width
-const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
+}
 
-// Pick the base scalar if the cluster starts with Prepend/Format/Marks
-const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+function applyHyperlinkToken({token, isPastEnd, activeStyles, activeHyperlink, position, returnValue, include}) {
+	if (
+		isPastEnd
+		&& (
+			token.action !== 'close'
+			|| !activeHyperlink
+		)
+	) {
+		return {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		};
+	}
 
-// RGI emoji sequences
-const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+	if (token.action === 'open') {
+		activeHyperlink = token;
+	} else if (token.action === 'close') {
+		activeHyperlink = undefined;
+	}
 
-function baseVisible(segment) {
-	return segment.replace(leadingNonPrintingRegex, '');
+	if (include) {
+		returnValue += token.code;
+	}
+
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
 }
 
-function isZeroWidthCluster(segment) {
-	return zeroWidthClusterRegex.test(segment);
+function applyControlToken({token, isPastEnd, activeStyles, activeHyperlink, position, returnValue, include}) {
+	if (!isPastEnd && include) {
+		returnValue += token.code;
+	}
+
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
 }
 
-function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
-	let extra = 0;
-	if (segment.length > 1) {
-		for (const char of segment.slice(1)) {
-			if (char >= '\uFF00' && char <= '\uFFEF') {
-				extra += eastAsianWidth(char.codePointAt(0), eastAsianWidthOptions);
-			}
+function applyCharacterToken({token, start, activeStyles, activeHyperlink, position, returnValue, include}) {
+	if (
+		!include
+		&& position >= start
+		&& !token.isGraphemeContinuation
+	) {
+		include = true;
+		returnValue = [...activeStyles.values()].join('');
+		if (activeHyperlink) {
+			returnValue += activeHyperlink.code;
 		}
 	}
 
-	return extra;
+	if (include) {
+		returnValue += token.value;
+	}
+
+	position += token.visibleWidth;
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
 }
 
-function stringWidth(input, options = {}) {
-	if (typeof input !== 'string' || input.length === 0) {
-		return 0;
+const tokenHandlers = {
+	sgr: applySgrToken,
+	hyperlink: applyHyperlinkToken,
+	control: applyControlToken,
+	character: applyCharacterToken,
+};
+
+function applyToken(parameters) {
+	const tokenHandler = tokenHandlers[parameters.token.type];
+	if (!tokenHandler) {
+		const {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		} = parameters;
+
+		return {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		};
 	}
 
-	const {
-		ambiguousIsNarrow = true,
-		countAnsiEscapeCodes = false,
-	} = options;
+	return tokenHandler(parameters);
+}
 
-	let string = input;
+function createHasContinuationAheadMap(tokens) {
+	const hasContinuationAhead = Array.from({length: tokens.length}, () => false);
+	let nextCharacterIsContinuation = false;
 
-	if (!countAnsiEscapeCodes) {
-		string = stripAnsi(string);
+	for (let tokenIndex = tokens.length - 1; tokenIndex >= 0; tokenIndex--) {
+		const token = tokens[tokenIndex];
+		hasContinuationAhead[tokenIndex] = nextCharacterIsContinuation;
+		if (token.type === 'character') {
+			nextCharacterIsContinuation = Boolean(token.isGraphemeContinuation);
+		}
 	}
 
-	if (string.length === 0) {
-		return 0;
-	}
+	return hasContinuationAhead;
+}
 
-	let width = 0;
-	const eastAsianWidthOptions = {ambiguousAsWide: !ambiguousIsNarrow};
+function sliceAnsi(string, start, end) {
+	const tokens = tokenizeAnsi$1(string, {endCharacter: end});
+	const hasContinuationAhead = createHasContinuationAheadMap(tokens);
+	let activeStyles = new Map();
+	let activeHyperlink;
+	let position = 0;
+	let returnValue = '';
+	let include = false;
 
-	for (const {segment} of segmenter.segment(string)) {
-		// Zero-width / non-printing clusters
-		if (isZeroWidthCluster(segment)) {
-			continue;
+	for (const [tokenIndex, token] of tokens.entries()) {
+		let isPastEnd = end !== undefined && position >= end;
+		if (
+			isPastEnd
+			&& token.type !== 'character'
+			&& hasContinuationAhead[tokenIndex]
+		) {
+			isPastEnd = false;
 		}
 
-		// Emoji width logic
-		if (rgiEmojiRegex.test(segment)) {
-			width += 2;
-			continue;
+		if (
+			isPastEnd
+			&& token.type === 'character'
+			&& !token.isGraphemeContinuation
+		) {
+			break;
 		}
 
-		// Everything else: EAW of the cluster’s first visible scalar
-		const codePoint = baseVisible(segment).codePointAt(0);
-		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+		({activeStyles, activeHyperlink, position, returnValue, include} = applyToken({
+			token,
+			isPastEnd,
+			start,
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		}));
+	}
 
-		// Add width for trailing Halfwidth and Fullwidth Forms (e.g., ﾞ, ﾟ, ｰ)
-		width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+	if (!include) {
+		return '';
 	}
 
-	return width;
+	if (activeHyperlink) {
+		returnValue += closeHyperlink(activeHyperlink);
+	}
+
+	// Disable active codes at the end
+	returnValue += undoAnsiCodes$1(activeStyles);
+
+	return returnValue;
 }
 
 function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
@@ -36455,6 +37744,347 @@ const wrapText = (text, maxWidth, wrapType) => {
     return wrappedText;
 };
 
+const bellCharacter = '\u0007';
+const escapeCharacter = '\u001B';
+const stringTerminatorCharacter = '\u009C';
+const csiCharacter = '\u009B';
+const oscCharacter = '\u009D';
+const dcsCharacter = '\u0090';
+const pmCharacter = '\u009E';
+const apcCharacter = '\u009F';
+const sosCharacter = '\u0098';
+const isCsiParameterCharacter = (character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x30 && codePoint <= 0x3f;
+};
+const isCsiIntermediateCharacter = (character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x20 && codePoint <= 0x2f;
+};
+const isCsiFinalCharacter = (character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x40 && codePoint <= 0x7e;
+};
+const isEscapeIntermediateCharacter = (character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x20 && codePoint <= 0x2f;
+};
+const isEscapeFinalCharacter = (character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x30 && codePoint <= 0x7e;
+};
+const isC1ControlCharacter = (character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x80 && codePoint <= 0x9f;
+};
+// Standards references:
+// ECMA-48 control functions and CSI byte classes: https://ecma-international.org/publications-and-standards/standards/ecma-48/
+// xterm CSI parameter/intermediate/final format notes: https://invisible-island.net/xterm/ecma-48-parameter-format.html
+// xterm/OSC BEL termination behavior: https://davidrg.github.io/ckwin/dev/ctlseqs.html
+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 === undefined || !isCsiFinalCharacter(finalCharacter)) {
+        return undefined;
+    }
+    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];
+            // Tmux escapes ESC bytes in payload as ESC ESC.
+            if (followingCharacter === escapeCharacter) {
+                index++;
+                continue;
+            }
+            if (followingCharacter === '\\') {
+                return index + 2;
+            }
+        }
+    }
+    return undefined;
+};
+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 === undefined || !isEscapeFinalCharacter(finalCharacter)) {
+        return undefined;
+    }
+    return {
+        endIndex: index + 1,
+        intermediateString,
+        finalCharacter,
+    };
+};
+// Centralize control-string rules so ESC and C1 paths do not diverge.
+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 undefined;
+        }
+    }
+};
+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 undefined;
+        }
+    }
+};
+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) });
+    }
+    // Treat the remainder as invalid so callers can drop it as one unsafe unit.
+    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 === undefined) {
+            break;
+        }
+        if (character === escapeCharacter) {
+            const followingCharacter = text[index + 1];
+            if (followingCharacter === undefined) {
+                return malformedFromIndex(tokens, text, textStartIndex, index);
+            }
+            if (followingCharacter === '[') {
+                const csiSequence = readCsiSequence(text, index + 2);
+                if (csiSequence === undefined) {
+                    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 !== undefined) {
+                const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 2, escapeControlString.allowBellTerminator);
+                if (controlStringTerminatorIndex === undefined) {
+                    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 === undefined) {
+                // Incomplete escape sequences with intermediates are malformed control strings.
+                if (isEscapeIntermediateCharacter(followingCharacter)) {
+                    return malformedFromIndex(tokens, text, textStartIndex, index);
+                }
+                if (index > textStartIndex) {
+                    tokens.push({ type: 'text', value: text.slice(textStartIndex, index) });
+                }
+                // Ignore lone ESC and continue tokenizing the rest.
+                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 === undefined) {
+                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 !== undefined) {
+            const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 1, c1ControlString.allowBellTerminator);
+            if (controlStringTerminatorIndex === undefined) {
+                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;
+        }
+        // Strip remaining C1 controls as standalone functions.
+        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;
+};
+
+const sgrParametersRegex = /^[\d:;]*$/;
+// Strip ANSI escape sequences that would conflict with Ink's layout.
+// Preserved: SGR sequences (colors, bold, etc. - end with 'm') and
+// OSC sequences (hyperlinks, etc. - ESC ] or C1 OSC).
+// Stripped: cursor movement, screen clearing, and other control sequences.
+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;
+};
+
 // Squashing text nodes allows to combine multiple text nodes into one and write
 // to `Output` instance only once. For example, <Text>hello{' '}world</Text>
 // is actually 3 text nodes, which would result 3 writes to `Output`.
@@ -36486,7 +38116,7 @@ const squashTextNodes = (node) => {
         }
         text += nodeText;
     }
-    return text;
+    return sanitizeAnsi(text);
 };
 
 const createNode = (nodeName) => {
@@ -36529,11 +38159,12 @@ const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
         if (newChildNode.yogaNode) {
             node.yogaNode?.insertChild(newChildNode.yogaNode, index);
         }
-        return;
     }
-    node.childNodes.push(newChildNode);
-    if (newChildNode.yogaNode) {
-        node.yogaNode?.insertChild(newChildNode.yogaNode, node.yogaNode.getChildCount());
+    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);
@@ -36841,7 +38472,7 @@ const styles = (node, style = {}) => {
 // We need to conditionally perform devtools connection to avoid
 // accidentally breaking other third-party code.
 // See https://github.com/vadimdemedes/ink/issues/384
-if (process$1.env['DEV'] === 'true') {
+if (isDev()) {
     try {
         await import('./devtools-CPruVlOo.js');
     }
@@ -36894,6 +38525,14 @@ const cleanupYogaNode = (node) => {
 };
 let currentUpdatePriority = constantsExports.NoEventPriority;
 let currentRootNode;
+async function loadPackageJson() {
+    const fs = await import('node:fs');
+    const content = fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+    return JSON.parse(content);
+}
+const packageJson = isDev()
+    ? await loadPackageJson()
+    : { name: undefined, version: undefined };
 var reconciler = createReconciler({
     getRootHostContext: () => ({
         isInsideText: false,
@@ -36994,6 +38633,14 @@ var reconciler = createReconciler({
     supportsMutation: true,
     supportsPersistence: false,
     supportsHydration: false,
+    // Scheduler integration for concurrent mode
+    supportsMicrotasks: true,
+    scheduleMicrotask: queueMicrotask,
+    // @ts-expect-error @types/react-reconciler is outdated and doesn't include scheduleCallback
+    scheduleCallback: schedulerExports.unstable_scheduleCallback,
+    cancelCallback: schedulerExports.unstable_cancelCallback,
+    shouldYield: schedulerExports.unstable_shouldYield,
+    now: schedulerExports.unstable_now,
     scheduleTimeout: setTimeout,
     cancelTimeout: clearTimeout,
     noTimeout: -1,
@@ -37057,7 +38704,8 @@ var reconciler = createReconciler({
         return constantsExports.DefaultEventPriority;
     },
     maySuspendCommit() {
-        return false;
+        // Return true to enable Suspense resource preloading
+        return true;
     },
     // eslint-disable-next-line @typescript-eslint/naming-convention
     NotPendingTransition: undefined,
@@ -37083,6 +38731,8 @@ var reconciler = createReconciler({
     waitForCommitToBeReady() {
         return null;
     },
+    rendererPackageName: packageJson.name,
+    rendererVersion: packageJson.version,
 });
 
 function indentString(string, count = 1, options = {}) {
@@ -37526,10 +39176,8 @@ for (const [start, end] of ansiStyles.codes) {
     endCodesSet.add(ansiStyles.color.ansi(end));
     endCodesMap.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
 }
-const linkStartCodePrefix = "\x1B]8;;";
-const linkStartCodePrefixCharCodes = linkStartCodePrefix
-    .split("")
-    .map((char) => char.charCodeAt(0));
+const linkCodePrefix = "\x1B]8;"; // OSC 8 link prefix (params and URL follow)
+const linkCodePrefixCharCodes = linkCodePrefix.split("").map((char) => char.charCodeAt(0));
 const linkCodeSuffix = "\x07";
 const linkEndCode = `\x1B]8;;${linkCodeSuffix}`;
 function getEndCode(code) {
@@ -37539,7 +39187,7 @@ function getEndCode(code) {
         return endCodesMap.get(code);
     // We have a few special cases to handle here:
     // Links:
-    if (code.startsWith(linkStartCodePrefix))
+    if (code.startsWith(linkCodePrefix))
         return linkEndCode;
     code = code.slice(2);
     // 8-bit/24-bit colors:
@@ -37559,7 +39207,13 @@ function getEndCode(code) {
     }
 }
 function ansiCodesToString(codes) {
-    return codes.map((code) => code.code).join("");
+    // Deduplicate ANSI code strings before joining
+    const deduplicated = new Set(codes.map((code) => code.code));
+    return [...deduplicated].join("");
+}
+/** Check if a code is an intensity code (bold or dim) - these share endCode 22m but can coexist */
+function isIntensityCode(code) {
+    return code.code === ansiStyles.bold.open || code.code === ansiStyles.dim.open;
 }
 
 /** Reduces the given array of ANSI codes to the minimum necessary to render with the same style */
@@ -37582,9 +39236,8 @@ function reduceAnsiCodesIncremental(codes, newCodes) {
             // This is a start code. Remove codes it "overrides", then add it.
             // If a new code has the same endCode, it "overrides" existing ones.
             // Special case: Intensity codes (1m, 2m) can coexist (both end with 22m).
-            const isIntensityCode = code.code === ansiStyles.bold.open || code.code === ansiStyles.dim.open;
-            // Add intensity codes only if not already present
-            if (isIntensityCode) {
+            // We only add those if the exact same code is not already present.
+            if (isIntensityCode(code)) {
                 if (!ret.find((retCode) => retCode.code === code.code && retCode.endCode === code.endCode)) {
                     ret.push(code);
                 }
@@ -37614,11 +39267,19 @@ function undoAnsiCodes(codes) {
  */
 function diffAnsiCodes(from, to) {
     const endCodesInTo = new Set(to.map((code) => code.endCode));
+    const startCodesInTo = new Set(to.map((code) => code.code));
     const startCodesInFrom = new Set(from.map((code) => code.code));
     return [
         // Ignore all styles in `from` that are not overwritten or removed by `to`
         // Disable all styles in `from` that are removed in `to`
-        ...undoAnsiCodes(from.filter((code) => !endCodesInTo.has(code.endCode))),
+        ...undoAnsiCodes(from.filter((code) => {
+            // Special case: Intensity codes (1m, 2m) can coexist (both end with 22m).
+            // We have to check the start codes for those, otherwise we might miss a reset.
+            if (isIntensityCode(code)) {
+                return !startCodesInTo.has(code.code);
+            }
+            return !endCodesInTo.has(code.endCode);
+        })),
         // Add all styles in `to` that don't exist in `from`
         ...to.filter((code) => !startCodesInFrom.has(code.code)),
     ];
@@ -37659,16 +39320,32 @@ function styledCharsToString(chars) {
     return ret;
 }
 
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+function isFullwidthGrapheme(grapheme, baseCodePoint) {
+    if (isFullwidthCodePoint(baseCodePoint))
+        return true;
+    // Variation Selector 16 forces emoji presentation (2 columns wide)
+    if (grapheme.includes("\uFE0F"))
+        return true;
+    // Regional indicator pairs form flag emoji (2 columns wide)
+    if (baseCodePoint >= 0x1f1e6 && baseCodePoint <= 0x1f1ff)
+        return true;
+    return false;
+}
 // HOT PATH: Use only basic string/char code operations for maximum performance
 function parseLinkCode(string, offset) {
     string = string.slice(offset);
-    for (let index = 1; index < linkStartCodePrefixCharCodes.length; index++) {
-        if (string.charCodeAt(index) !== linkStartCodePrefixCharCodes[index]) {
+    for (let index = 1; index < linkCodePrefixCharCodes.length; index++) {
+        if (string.charCodeAt(index) !== linkCodePrefixCharCodes[index]) {
             return undefined;
         }
     }
+    // Find the semicolon that ends params
+    const paramsEndIndex = string.indexOf(";", linkCodePrefix.length);
+    if (paramsEndIndex === -1)
+        return undefined;
     // This is a link code (with or without the URL part). Find the end of it.
-    const endIndex = string.indexOf("\x07", linkStartCodePrefix.length);
+    const endIndex = string.indexOf("\x07", paramsEndIndex + 1);
     if (endIndex === -1)
         return undefined;
     return string.slice(0, endIndex + 1);
@@ -37743,10 +39420,13 @@ function splitCompoundSGRSequences(code) {
 }
 function tokenize(str, endChar = Number.POSITIVE_INFINITY) {
     const ret = [];
-    let index = 0;
     let visible = 0;
-    while (index < str.length) {
-        const codePoint = str.codePointAt(index);
+    let codeEndIndex = 0;
+    for (const { segment, index } of segmenter.segment(str)) {
+        // Skip segments consumed as part of an ANSI sequence
+        if (index < codeEndIndex)
+            continue;
+        const codePoint = segment.codePointAt(0);
         if (ESCAPES.has(codePoint)) {
             let code;
             // Peek the next code point to determine the type of ANSI sequence
@@ -37778,19 +39458,17 @@ function tokenize(str, endChar = Number.POSITIVE_INFINITY) {
                 }
             }
             if (code) {
-                index += code.length;
+                codeEndIndex = index + code.length;
                 continue;
             }
         }
-        const fullWidth = isFullwidthCodePoint(codePoint);
-        const character = String.fromCodePoint(codePoint);
+        const fullWidth = isFullwidthGrapheme(segment, codePoint);
         ret.push({
             type: "char",
-            value: character,
+            value: segment,
             fullWidth,
         });
-        index += character.length;
-        visible += fullWidth ? 2 : character.length;
+        visible += fullWidth ? 2 : 1;
         if (visible >= endChar) {
             break;
         }
@@ -37798,10 +39476,44 @@ function tokenize(str, endChar = Number.POSITIVE_INFINITY) {
     return ret;
 }
 
+class OutputCaches {
+    widths = new Map();
+    blockWidths = new Map();
+    styledChars = new Map();
+    getStyledChars(line) {
+        let cached = this.styledChars.get(line);
+        if (cached === undefined) {
+            cached = styledCharsFromTokens(tokenize(line));
+            this.styledChars.set(line, cached);
+        }
+        return cached;
+    }
+    getStringWidth(text) {
+        let cached = this.widths.get(text);
+        if (cached === undefined) {
+            cached = stringWidth(text);
+            this.widths.set(text, cached);
+        }
+        return cached;
+    }
+    getWidestLine(text) {
+        let cached = this.blockWidths.get(text);
+        if (cached === undefined) {
+            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;
+    }
+}
 class Output {
     width;
     height;
     operations = [];
+    caches = new OutputCaches();
     constructor(options) {
         const { width, height } = options;
         this.width = width;
@@ -37865,7 +39577,7 @@ class Output {
                     // If text is positioned outside of clipping area altogether,
                     // skip to the next operation to avoid unnecessary calculations
                     if (clipHorizontally) {
-                        const width = widestLine(text);
+                        const width = this.caches.getWidestLine(text);
                         if (x + width < clip.x1 || x > clip.x2) {
                             continue;
                         }
@@ -37879,7 +39591,7 @@ class Output {
                     if (clipHorizontally) {
                         lines = lines.map(line => {
                             const from = x < clip.x1 ? clip.x1 - x : 0;
-                            const width = stringWidth(line);
+                            const width = this.caches.getStringWidth(line);
                             const to = x + width > clip.x2 ? clip.x2 - x : width;
                             return sliceAnsi(line, from, to);
                         });
@@ -37907,12 +39619,12 @@ class Output {
                     for (const transformer of transformers) {
                         line = transformer(line, index);
                     }
-                    const characters = styledCharsFromTokens(tokenize(line));
+                    const characters = this.caches.getStyledChars(line);
                     let offsetX = x;
                     for (const character of characters) {
                         currentLine[offsetX] = character;
                         // Determine printed width using string-width to align with measurement
-                        const characterWidth = Math.max(1, stringWidth(character.value));
+                        const characterWidth = Math.max(1, this.caches.getStringWidth(character.value));
                         // For multi-column characters, clear following cells to avoid stray spaces/artifacts
                         if (characterWidth > 1) {
                             for (let index = 1; index < characterWidth; index++) {
@@ -38115,109 +39827,288 @@ cliCursor.toggle = (force, writableStream) => {
 	}
 };
 
+const showCursorEscape = '\u001B[?25h';
+const hideCursorEscape = '\u001B[?25l';
+/**
+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 bottom of output to the target position and show it.
+Assumes cursor is at (col 0, line visibleLineCount) — i.e. just after the last output line.
+*/
+const buildCursorSuffix = (visibleLineCount, cursorPosition) => {
+    if (!cursorPosition) {
+        return '';
+    }
+    const moveUp = visibleLineCount - cursorPosition.y;
+    return ((moveUp > 0 ? cursorUp(moveUp) : '') +
+        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 '';
+    }
+    // PreviousLineCount includes trailing newline, so visible lines = previousLineCount - 1
+    // cursor is at previousCursorPosition.y, need to go to line (previousLineCount - 1)
+    const down = previousLineCount - 1 - previousCursorPosition.y;
+    return ((down > 0 ? cursorDown(down) : '') + 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.
+*/
+const buildCursorOnlySequence = (input) => {
+    const hidePrefix = input.cursorWasShown ? hideCursorEscape : '';
+    const returnToBottom = buildReturnToBottom(input.previousLineCount, input.previousCursorPosition);
+    const cursorSuffix = buildCursorSuffix(input.visibleLineCount, input.cursorPosition);
+    return hidePrefix + returnToBottom + cursorSuffix;
+};
+/**
+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));
+};
+
+// Count visible lines in a string, ignoring the trailing empty element
+// that `split('\n')` produces when the string ends with '\n'.
+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 : undefined);
+    const hasChanges = (str, activeCursor) => {
+        const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+        return str !== previousOutput || cursorChanged;
+    };
     const render = (str) => {
         if (!showCursor && !hasHiddenCursor) {
-            cliCursor.hide();
+            cliCursor.hide(stream);
             hasHiddenCursor = true;
         }
-        const output = str + '\n';
-        if (output === previousOutput) {
-            return;
+        // Only use cursor if setCursorPosition was called since last render.
+        // This ensures stale positions don't persist after component unmount.
+        const activeCursor = getActiveCursor();
+        cursorDirty = false;
+        const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+        if (!hasChanges(str, activeCursor)) {
+            return false;
+        }
+        const lines = str.split('\n');
+        const visibleCount = visibleLineCount(lines, str);
+        const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+        if (str === previousOutput && cursorChanged) {
+            stream.write(buildCursorOnlySequence({
+                cursorWasShown,
+                previousLineCount,
+                previousCursorPosition,
+                visibleLineCount: visibleCount,
+                cursorPosition: activeCursor,
+            }));
         }
-        previousOutput = output;
-        stream.write(eraseLines(previousLineCount) + output);
-        previousLineCount = output.split('\n').length;
+        else {
+            previousOutput = str;
+            const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
+            stream.write(returnPrefix +
+                eraseLines(previousLineCount) +
+                str +
+                cursorSuffix);
+            previousLineCount = lines.length;
+        }
+        previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
+        cursorWasShown = activeCursor !== undefined;
+        return true;
     };
     render.clear = () => {
-        stream.write(eraseLines(previousLineCount));
+        const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
+        stream.write(prefix + eraseLines(previousLineCount));
         previousOutput = '';
         previousLineCount = 0;
+        previousCursorPosition = undefined;
+        cursorWasShown = false;
     };
     render.done = () => {
         previousOutput = '';
         previousLineCount = 0;
+        previousCursorPosition = undefined;
+        cursorWasShown = false;
         if (!showCursor) {
-            cliCursor.show();
+            cliCursor.show(stream);
             hasHiddenCursor = false;
         }
     };
     render.sync = (str) => {
-        const output = str + '\n';
-        previousOutput = output;
-        previousLineCount = output.split('\n').length;
+        const activeCursor = cursorDirty ? cursorPosition : undefined;
+        cursorDirty = false;
+        const lines = str.split('\n');
+        previousOutput = str;
+        previousLineCount = lines.length;
+        if (!activeCursor && cursorWasShown) {
+            stream.write(hideCursorEscape);
+        }
+        if (activeCursor) {
+            stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor));
+        }
+        previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
+        cursorWasShown = activeCursor !== undefined;
     };
+    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 : undefined);
+    const hasChanges = (str, activeCursor) => {
+        const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+        return str !== previousOutput || cursorChanged;
+    };
     const render = (str) => {
         if (!showCursor && !hasHiddenCursor) {
-            cliCursor.hide();
+            cliCursor.hide(stream);
             hasHiddenCursor = true;
         }
-        const output = str + '\n';
-        if (output === previousOutput) {
-            return;
+        // Only use cursor if setCursorPosition was called since last render.
+        // This ensures stale positions don't persist after component unmount.
+        const activeCursor = getActiveCursor();
+        cursorDirty = false;
+        const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+        if (!hasChanges(str, activeCursor)) {
+            return false;
         }
-        const previousCount = previousLines.length;
-        const nextLines = output.split('\n');
-        const nextCount = nextLines.length;
-        const visibleCount = nextCount - 1;
-        if (output === '\n' || previousOutput.length === 0) {
-            stream.write(eraseLines(previousCount) + output);
-            previousOutput = output;
+        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,
+                visibleLineCount: visibleCount,
+                cursorPosition: activeCursor,
+            }));
+            previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
+            cursorWasShown = activeCursor !== undefined;
+            return true;
+        }
+        const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+        if (str === '\n' || previousOutput.length === 0) {
+            const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+            stream.write(returnPrefix +
+                eraseLines(previousLines.length) +
+                str +
+                cursorSuffix);
+            cursorWasShown = activeCursor !== undefined;
+            previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
+            previousOutput = str;
             previousLines = nextLines;
-            return;
+            return true;
         }
+        const hasTrailingNewline = str.endsWith('\n');
         // We aggregate all chunks for incremental rendering into a buffer, and then write them to stdout at the end.
         const buffer = [];
+        buffer.push(returnPrefix);
         // Clear extra lines if the current content's line count is lower than the previous.
-        if (nextCount < previousCount) {
-            buffer.push(
-            // Erases the trailing lines and the final newline slot.
-            eraseLines(previousCount - nextCount + 1), 
-            // Positions cursor to the top of the rendered output.
-            cursorUp(visibleCount));
+        if (visibleCount < previousVisible) {
+            const previousHadTrailingNewline = previousOutput.endsWith('\n');
+            const extraSlot = previousHadTrailingNewline ? 1 : 0;
+            buffer.push(eraseLines(previousVisible - visibleCount + extraSlot), cursorUp(visibleCount));
         }
         else {
-            buffer.push(cursorUp(previousCount - 1));
+            buffer.push(cursorUp(previousVisible - 1));
         }
         for (let i = 0; i < visibleCount; i++) {
+            const isLastLine = i === visibleCount - 1;
             // We do not write lines if the contents are the same. This prevents flickering during renders.
             if (nextLines[i] === previousLines[i]) {
-                buffer.push(cursorNextLine);
+                // Don't move past the last line when there's no trailing newline,
+                // otherwise the cursor overshoots the rendered block.
+                if (!isLastLine || hasTrailingNewline) {
+                    buffer.push(cursorNextLine);
+                }
                 continue;
             }
-            buffer.push(eraseLine + nextLines[i] + '\n');
+            buffer.push(cursorTo(0) +
+                nextLines[i] +
+                eraseEndLine +
+                // Don't append newline after the last line when the input
+                // has no trailing newline (fullscreen mode).
+                (isLastLine && !hasTrailingNewline ? '' : '\n'));
         }
+        const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
+        buffer.push(cursorSuffix);
         stream.write(buffer.join(''));
-        previousOutput = output;
+        cursorWasShown = activeCursor !== undefined;
+        previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
+        previousOutput = str;
         previousLines = nextLines;
+        return true;
     };
     render.clear = () => {
-        stream.write(eraseLines(previousLines.length));
+        const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+        stream.write(prefix + eraseLines(previousLines.length));
         previousOutput = '';
         previousLines = [];
+        previousCursorPosition = undefined;
+        cursorWasShown = false;
     };
     render.done = () => {
         previousOutput = '';
         previousLines = [];
+        previousCursorPosition = undefined;
+        cursorWasShown = false;
         if (!showCursor) {
-            cliCursor.show();
+            cliCursor.show(stream);
             hasHiddenCursor = false;
         }
     };
     render.sync = (str) => {
-        const output = str + '\n';
-        previousOutput = output;
-        previousLines = output.split('\n');
+        const activeCursor = cursorDirty ? cursorPosition : undefined;
+        cursorDirty = false;
+        const lines = str.split('\n');
+        previousOutput = str;
+        previousLines = lines;
+        if (!activeCursor && cursorWasShown) {
+            stream.write(hideCursorEscape);
+        }
+        if (activeCursor) {
+            stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor));
+        }
+        previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
+        cursorWasShown = activeCursor !== undefined;
+    };
+    render.setCursorPosition = (position) => {
+        cursorPosition = position;
+        cursorDirty = true;
     };
+    render.isCursorDirty = () => cursorDirty;
+    render.willRender = (str) => hasChanges(str, getActiveCursor());
     return render;
 };
 const create = (stream, { showCursor = false, incremental = false } = {}) => {
@@ -38228,6 +40119,12 @@ const create = (stream, { showCursor = false, incremental = false } = {}) => {
 };
 const logUpdate = { create };
 
+const bsu = '\u001B[?2026h';
+const esu = '\u001B[?2026l';
+function shouldSynchronize(stream) {
+    return 'isTTY' in stream && stream.isTTY === true && !isInCi;
+}
+
 // Store all instances of Ink (instance.js) to ensure that consecutive render() calls
 // use the same instance of Ink and don't create a new one
 //
@@ -38235,6 +40132,160 @@ const logUpdate = { create };
 // but instance.js should delete itself from the map on unmount
 const instances = new WeakMap();
 
+const escape$1 = '\u001B';
+const isCsiParameterByte = (byte) => {
+    return byte >= 0x30 && byte <= 0x3f;
+};
+const isCsiIntermediateByte = (byte) => {
+    return byte >= 0x20 && byte <= 0x2f;
+};
+const isCsiFinalByte = (byte) => {
+    return byte >= 0x40 && byte <= 0x7e;
+};
+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 === undefined) {
+            return 'pending';
+        }
+        if (isCsiParameterByte(byte) || isCsiIntermediateByte(byte)) {
+            continue;
+        }
+        // Preserve legacy terminal function-key sequences like ESC[[A and ESC[[5~.
+        if (byte === 0x5b && index === csiPayloadStart) {
+            continue;
+        }
+        if (isCsiFinalByte(byte)) {
+            return {
+                sequence: input.slice(startIndex, index + 1),
+                nextIndex: index + 1,
+            };
+        }
+        return undefined;
+    }
+    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 === undefined || !isCsiFinalByte(finalByte)) {
+        return undefined;
+    }
+    return {
+        sequence: input.slice(startIndex, nextIndex),
+        nextIndex,
+    };
+};
+const parseControlSequence = (input, startIndex, prefixLength) => {
+    const sequenceType = input[startIndex + prefixLength];
+    if (sequenceType === undefined) {
+        return 'pending';
+    }
+    if (sequenceType === '[') {
+        return parseCsiSequence(input, startIndex, prefixLength);
+    }
+    if (sequenceType === 'O') {
+        return parseSs3Sequence(input, startIndex, prefixLength);
+    }
+    return undefined;
+};
+const parseEscapedCodePoint = (input, escapeIndex) => {
+    const nextCodePoint = input.codePointAt(escapeIndex + 1);
+    const nextCodePointLength = nextCodePoint !== undefined && nextCodePoint > 0xff_ff ? 2 : 1;
+    const nextIndex = escapeIndex + 1 + nextCodePointLength;
+    return {
+        sequence: input.slice(escapeIndex, nextIndex),
+        nextIndex,
+    };
+};
+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) {
+            events.push(input.slice(index));
+            return {
+                events,
+                pending: '',
+            };
+        }
+        if (escapeIndex > index) {
+            events.push(input.slice(index, escapeIndex));
+        }
+        if (escapeIndex === input.length - 1) {
+            return pendingFrom(escapeIndex);
+        }
+        const parsedSequence = parseControlSequence(input, escapeIndex, 1);
+        if (parsedSequence === 'pending') {
+            return pendingFrom(escapeIndex);
+        }
+        if (parsedSequence) {
+            events.push(parsedSequence.sequence);
+            index = parsedSequence.nextIndex;
+            continue;
+        }
+        const next = input[escapeIndex + 1];
+        if (next === escape$1) {
+            if (escapeIndex + 2 >= input.length) {
+                return pendingFrom(escapeIndex);
+            }
+            const doubleEscapeSequence = parseControlSequence(input, escapeIndex, 2);
+            if (doubleEscapeSequence === 'pending') {
+                return pendingFrom(escapeIndex);
+            }
+            if (doubleEscapeSequence) {
+                events.push(doubleEscapeSequence.sequence);
+                index = doubleEscapeSequence.nextIndex;
+                continue;
+            }
+            events.push(input.slice(escapeIndex, escapeIndex + 2));
+            index = escapeIndex + 2;
+            continue;
+        }
+        const escapedCodePoint = parseEscapedCodePoint(input, escapeIndex);
+        events.push(escapedCodePoint.sequence);
+        index = escapedCodePoint.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);
+        },
+        flushPendingEscape() {
+            if (!pending.startsWith(escape$1)) {
+                return undefined;
+            }
+            const pendingEscape = pending;
+            pending = '';
+            return pendingEscape;
+        },
+        reset() {
+            pending = '';
+        },
+    };
+};
+
 /**
 `AppContext` is a React context that exposes a method to manually exit the app (unmount).
 */
@@ -38294,6 +40345,12 @@ const FocusContext = reactExports.createContext({
 });
 FocusContext.displayName = 'InternalFocusContext';
 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const CursorContext = reactExports.createContext({
+    setCursorPosition() { },
+});
+CursorContext.displayName = 'InternalCursorContext';
+
 var escapeStringRegexp;
 var hasRequiredEscapeStringRegexp;
 
@@ -38856,102 +40913,130 @@ function ErrorOverview({ error }) {
         })))));
 }
 
-const tab = '\t';
-const shiftTab = '\u001B[Z';
-const escape = '\u001B';
-// Root component for all Ink apps
-// It renders stdin and stdout contexts, so that children can access them if needed
-// It also handles Ctrl+C exiting and cursor visibility
-class App extends reactExports.PureComponent {
-    static displayName = 'InternalApp';
+// Error boundary must be a class component since getDerivedStateFromError
+// and componentDidCatch are not available as hooks
+class ErrorBoundary extends reactExports.PureComponent {
+    static displayName = 'InternalErrorBoundary';
     static getDerivedStateFromError(error) {
         return { error };
     }
     state = {
-        isFocusEnabled: true,
-        activeFocusId: undefined,
-        focusables: [],
         error: undefined,
     };
+    componentDidCatch(error) {
+        this.props.onError(error);
+    }
+    render() {
+        if (this.state.error) {
+            return React.createElement(ErrorOverview, { error: this.state.error });
+        }
+        return this.props.children;
+    }
+}
+
+const tab = '\t';
+const shiftTab = '\u001B[Z';
+const escape = '\u001B';
+// Root component for all Ink apps
+// It renders stdin and stdout contexts, so that children can access them if needed
+// It also handles Ctrl+C exiting and cursor visibility
+function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, exitOnCtrlC, onExit, setCursorPosition, }) {
+    const [isFocusEnabled, setIsFocusEnabled] = reactExports.useState(true);
+    const [activeFocusId, setActiveFocusId] = reactExports.useState(undefined);
+    // Focusables array is managed internally via setFocusables callback pattern
+    // eslint-disable-next-line react/hook-use-state
+    const [, setFocusables] = reactExports.useState([]);
+    // Track focusables count for tab navigation check (avoids stale closure)
+    const focusablesCountRef = reactExports.useRef(0);
     // Count how many components enabled raw mode to avoid disabling
     // raw mode until all components don't need it anymore
-    rawModeEnabledCount = 0;
+    const rawModeEnabledCount = reactExports.useRef(0);
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    internal_eventEmitter = new EventEmitter();
+    const internal_eventEmitter = reactExports.useRef(new EventEmitter());
+    // Each useInput hook adds a listener, so the count can legitimately exceed the default limit of 10.
+    internal_eventEmitter.current.setMaxListeners(Infinity);
+    // Store the currently attached readable listener to avoid stale closure issues
+    const readableListenerRef = reactExports.useRef(undefined);
+    const inputParserRef = reactExports.useRef(createInputParser());
+    const pendingInputFlushRef = reactExports.useRef(undefined);
+    const clearPendingInputFlush = reactExports.useCallback(() => {
+        if (!pendingInputFlushRef.current) {
+            return;
+        }
+        clearImmediate(pendingInputFlushRef.current);
+        pendingInputFlushRef.current = undefined;
+    }, []);
     // Determines if TTY is supported on the provided stdin
-    isRawModeSupported() {
-        return this.props.stdin.isTTY;
-    }
-    render() {
-        return (React.createElement(AppContext.Provider
-        // eslint-disable-next-line react/jsx-no-constructed-context-values
-        , { 
-            // eslint-disable-next-line react/jsx-no-constructed-context-values
-            value: {
-                exit: this.handleExit,
-            } },
-            React.createElement(StdinContext.Provider
-            // eslint-disable-next-line react/jsx-no-constructed-context-values
-            , { 
-                // eslint-disable-next-line react/jsx-no-constructed-context-values
-                value: {
-                    stdin: this.props.stdin,
-                    setRawMode: this.handleSetRawMode,
-                    isRawModeSupported: this.isRawModeSupported(),
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    internal_exitOnCtrlC: this.props.exitOnCtrlC,
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    internal_eventEmitter: this.internal_eventEmitter,
-                } },
-                React.createElement(StdoutContext.Provider
-                // eslint-disable-next-line react/jsx-no-constructed-context-values
-                , { 
-                    // eslint-disable-next-line react/jsx-no-constructed-context-values
-                    value: {
-                        stdout: this.props.stdout,
-                        write: this.props.writeToStdout,
-                    } },
-                    React.createElement(StderrContext.Provider
-                    // eslint-disable-next-line react/jsx-no-constructed-context-values
-                    , { 
-                        // eslint-disable-next-line react/jsx-no-constructed-context-values
-                        value: {
-                            stderr: this.props.stderr,
-                            write: this.props.writeToStderr,
-                        } },
-                        React.createElement(FocusContext.Provider
-                        // eslint-disable-next-line react/jsx-no-constructed-context-values
-                        , { 
-                            // eslint-disable-next-line react/jsx-no-constructed-context-values
-                            value: {
-                                activeId: this.state.activeFocusId,
-                                add: this.addFocusable,
-                                remove: this.removeFocusable,
-                                activate: this.activateFocusable,
-                                deactivate: this.deactivateFocusable,
-                                enableFocus: this.enableFocus,
-                                disableFocus: this.disableFocus,
-                                focusNext: this.focusNext,
-                                focusPrevious: this.focusPrevious,
-                                focus: this.focus,
-                            } }, this.state.error ? (React.createElement(ErrorOverview, { error: this.state.error })) : (this.props.children)))))));
-    }
-    componentDidMount() {
-        cliCursor.hide(this.props.stdout);
-    }
-    componentWillUnmount() {
-        cliCursor.show(this.props.stdout);
-        // ignore calling setRawMode on an handle stdin it cannot be called
-        if (this.isRawModeSupported()) {
-            this.handleSetRawMode(false);
+    const isRawModeSupported = stdin.isTTY;
+    const detachReadableListener = reactExports.useCallback(() => {
+        if (!readableListenerRef.current) {
+            return;
         }
-    }
-    componentDidCatch(error) {
-        this.handleExit(error);
-    }
-    handleSetRawMode = (isEnabled) => {
-        const { stdin } = this.props;
-        if (!this.isRawModeSupported()) {
+        stdin.removeListener('readable', readableListenerRef.current);
+        readableListenerRef.current = undefined;
+    }, [stdin]);
+    const disableRawMode = reactExports.useCallback(() => {
+        stdin.setRawMode(false);
+        detachReadableListener();
+        stdin.unref();
+        rawModeEnabledCount.current = 0;
+        inputParserRef.current.reset();
+        clearPendingInputFlush();
+    }, [stdin, detachReadableListener, clearPendingInputFlush]);
+    const handleExit = reactExports.useCallback((errorOrResult) => {
+        if (isRawModeSupported && rawModeEnabledCount.current > 0) {
+            disableRawMode();
+        }
+        onExit(errorOrResult);
+    }, [isRawModeSupported, disableRawMode, onExit]);
+    const handleInput = reactExports.useCallback((input) => {
+        // Exit on Ctrl+C
+        // eslint-disable-next-line unicorn/no-hex-escape
+        if (input === '\x03' && exitOnCtrlC) {
+            handleExit();
+            return;
+        }
+        // Reset focus when there's an active focused component on Esc
+        if (input === escape) {
+            setActiveFocusId(currentActiveFocusId => {
+                if (currentActiveFocusId) {
+                    return undefined;
+                }
+                return currentActiveFocusId;
+            });
+        }
+    }, [exitOnCtrlC, handleExit]);
+    const emitInput = reactExports.useCallback((input) => {
+        handleInput(input);
+        internal_eventEmitter.current.emit('input', input);
+    }, [handleInput]);
+    const schedulePendingInputFlush = reactExports.useCallback(() => {
+        clearPendingInputFlush();
+        pendingInputFlushRef.current = setImmediate(() => {
+            pendingInputFlushRef.current = undefined;
+            const pendingEscape = inputParserRef.current.flushPendingEscape();
+            if (!pendingEscape) {
+                return;
+            }
+            emitInput(pendingEscape);
+        });
+    }, [clearPendingInputFlush, emitInput]);
+    const handleReadable = reactExports.useCallback(() => {
+        clearPendingInputFlush();
+        let chunk;
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        while ((chunk = stdin.read()) !== null) {
+            const inputEvents = inputParserRef.current.push(chunk);
+            for (const input of inputEvents) {
+                emitInput(input);
+            }
+        }
+        if (inputParserRef.current.hasPendingEscape()) {
+            schedulePendingInputFlush();
+        }
+    }, [stdin, emitInput, clearPendingInputFlush, schedulePendingInputFlush]);
+    const handleSetRawMode = reactExports.useCallback((isEnabled) => {
+        if (!isRawModeSupported) {
             if (stdin === process$1.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');
             }
@@ -38962,185 +41047,338 @@ class App extends reactExports.PureComponent {
         stdin.setEncoding('utf8');
         if (isEnabled) {
             // Ensure raw mode is enabled only once
-            if (this.rawModeEnabledCount === 0) {
+            if (rawModeEnabledCount.current === 0) {
                 stdin.ref();
                 stdin.setRawMode(true);
-                stdin.addListener('readable', this.handleReadable);
+                // Store the listener reference to avoid stale closure when removing
+                readableListenerRef.current = handleReadable;
+                stdin.addListener('readable', handleReadable);
             }
-            this.rawModeEnabledCount++;
+            rawModeEnabledCount.current++;
             return;
         }
         // Disable raw mode only when no components left that are using it
-        if (--this.rawModeEnabledCount === 0) {
-            stdin.setRawMode(false);
-            stdin.removeListener('readable', this.handleReadable);
-            stdin.unref();
+        if (rawModeEnabledCount.current === 0) {
+            return;
         }
-    };
-    handleReadable = () => {
-        let chunk;
-        // eslint-disable-next-line @typescript-eslint/ban-types
-        while ((chunk = this.props.stdin.read()) !== null) {
-            this.handleInput(chunk);
-            this.internal_eventEmitter.emit('input', chunk);
+        if (--rawModeEnabledCount.current === 0) {
+            disableRawMode();
         }
-    };
-    handleInput = (input) => {
-        // Exit on Ctrl+C
-        // eslint-disable-next-line unicorn/no-hex-escape
-        if (input === '\x03' && this.props.exitOnCtrlC) {
-            this.handleExit();
+    }, [isRawModeSupported, stdin, handleReadable, disableRawMode]);
+    // Focus navigation helpers
+    const findNextFocusable = reactExports.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;
+            }
         }
-        // Reset focus when there's an active focused component on Esc
-        if (input === escape && this.state.activeFocusId) {
-            this.setState({
-                activeFocusId: undefined,
-            });
+        return undefined;
+    }, []);
+    const findPreviousFocusable = reactExports.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;
+            }
         }
-        if (this.state.isFocusEnabled && this.state.focusables.length > 0) {
+        return undefined;
+    }, []);
+    const focusNext = reactExports.useCallback(() => {
+        setFocusables(currentFocusables => {
+            setActiveFocusId(currentActiveFocusId => {
+                const firstFocusableId = currentFocusables.find(focusable => focusable.isActive)?.id;
+                const nextFocusableId = findNextFocusable(currentFocusables, currentActiveFocusId);
+                return nextFocusableId ?? firstFocusableId;
+            });
+            return currentFocusables;
+        });
+    }, [findNextFocusable]);
+    const focusPrevious = reactExports.useCallback(() => {
+        setFocusables(currentFocusables => {
+            setActiveFocusId(currentActiveFocusId => {
+                const lastFocusableId = currentFocusables.findLast(focusable => focusable.isActive)?.id;
+                const previousFocusableId = findPreviousFocusable(currentFocusables, currentActiveFocusId);
+                return previousFocusableId ?? lastFocusableId;
+            });
+            return currentFocusables;
+        });
+    }, [findPreviousFocusable]);
+    // Handle tab navigation via effect that subscribes to input events
+    reactExports.useEffect(() => {
+        const handleTabNavigation = (input) => {
+            if (!isFocusEnabled || focusablesCountRef.current === 0)
+                return;
             if (input === tab) {
-                this.focusNext();
+                focusNext();
             }
             if (input === shiftTab) {
-                this.focusPrevious();
+                focusPrevious();
             }
-        }
-    };
-    handleExit = (error) => {
-        if (this.isRawModeSupported()) {
-            this.handleSetRawMode(false);
-        }
-        this.props.onExit(error);
-    };
-    enableFocus = () => {
-        this.setState({
-            isFocusEnabled: true,
+        };
+        internal_eventEmitter.current.on('input', handleTabNavigation);
+        const emitter = internal_eventEmitter.current;
+        return () => {
+            emitter.off('input', handleTabNavigation);
+        };
+    }, [isFocusEnabled, focusNext, focusPrevious]);
+    const enableFocus = reactExports.useCallback(() => {
+        setIsFocusEnabled(true);
+    }, []);
+    const disableFocus = reactExports.useCallback(() => {
+        setIsFocusEnabled(false);
+    }, []);
+    const focus = reactExports.useCallback((id) => {
+        setFocusables(currentFocusables => {
+            const hasFocusableId = currentFocusables.some(focusable => focusable?.id === id);
+            if (hasFocusableId) {
+                setActiveFocusId(id);
+            }
+            return currentFocusables;
         });
-    };
-    disableFocus = () => {
-        this.setState({
-            isFocusEnabled: false,
+    }, []);
+    const addFocusable = reactExports.useCallback((id, { autoFocus }) => {
+        setFocusables(currentFocusables => {
+            focusablesCountRef.current = currentFocusables.length + 1;
+            return [
+                ...currentFocusables,
+                {
+                    id,
+                    isActive: true,
+                },
+            ];
         });
-    };
-    focus = (id) => {
-        this.setState(previousState => {
-            const hasFocusableId = previousState.focusables.some(focusable => focusable?.id === id);
-            if (!hasFocusableId) {
-                return previousState;
+        if (autoFocus) {
+            setActiveFocusId(currentActiveFocusId => {
+                if (!currentActiveFocusId) {
+                    return id;
+                }
+                return currentActiveFocusId;
+            });
+        }
+    }, []);
+    const removeFocusable = reactExports.useCallback((id) => {
+        setActiveFocusId(currentActiveFocusId => {
+            if (currentActiveFocusId === id) {
+                return undefined;
             }
-            return { activeFocusId: id };
+            return currentActiveFocusId;
         });
-    };
-    focusNext = () => {
-        this.setState(previousState => {
-            const firstFocusableId = previousState.focusables.find(focusable => focusable.isActive)?.id;
-            const nextFocusableId = this.findNextFocusable(previousState);
-            return {
-                activeFocusId: nextFocusableId ?? firstFocusableId,
-            };
+        setFocusables(currentFocusables => {
+            const filtered = currentFocusables.filter(focusable => {
+                return focusable.id !== id;
+            });
+            focusablesCountRef.current = filtered.length;
+            return filtered;
         });
-    };
-    focusPrevious = () => {
-        this.setState(previousState => {
-            const lastFocusableId = previousState.focusables.findLast(focusable => focusable.isActive)?.id;
-            const previousFocusableId = this.findPreviousFocusable(previousState);
+    }, []);
+    const activateFocusable = reactExports.useCallback((id) => {
+        setFocusables(currentFocusables => currentFocusables.map(focusable => {
+            if (focusable.id !== id) {
+                return focusable;
+            }
             return {
-                activeFocusId: previousFocusableId ?? lastFocusableId,
+                id,
+                isActive: true,
             };
+        }));
+    }, []);
+    const deactivateFocusable = reactExports.useCallback((id) => {
+        setActiveFocusId(currentActiveFocusId => {
+            if (currentActiveFocusId === id) {
+                return undefined;
+            }
+            return currentActiveFocusId;
         });
-    };
-    addFocusable = (id, { autoFocus }) => {
-        this.setState(previousState => {
-            let nextFocusId = previousState.activeFocusId;
-            if (!nextFocusId && autoFocus) {
-                nextFocusId = id;
+        setFocusables(currentFocusables => currentFocusables.map(focusable => {
+            if (focusable.id !== id) {
+                return focusable;
             }
             return {
-                activeFocusId: nextFocusId,
-                focusables: [
-                    ...previousState.focusables,
-                    {
-                        id,
-                        isActive: true,
-                    },
-                ],
+                id,
+                isActive: false,
             };
-        });
-    };
-    removeFocusable = (id) => {
-        this.setState(previousState => ({
-            activeFocusId: previousState.activeFocusId === id
-                ? undefined
-                : previousState.activeFocusId,
-            focusables: previousState.focusables.filter(focusable => {
-                return focusable.id !== id;
-            }),
         }));
-    };
-    activateFocusable = (id) => {
-        this.setState(previousState => ({
-            focusables: previousState.focusables.map(focusable => {
-                if (focusable.id !== id) {
-                    return focusable;
-                }
-                return {
-                    id,
-                    isActive: true,
-                };
-            }),
-        }));
-    };
-    deactivateFocusable = (id) => {
-        this.setState(previousState => ({
-            activeFocusId: previousState.activeFocusId === id
-                ? undefined
-                : previousState.activeFocusId,
-            focusables: previousState.focusables.map(focusable => {
-                if (focusable.id !== id) {
-                    return focusable;
-                }
-                return {
-                    id,
-                    isActive: false,
-                };
-            }),
-        }));
-    };
-    findNextFocusable = (state) => {
-        const activeIndex = state.focusables.findIndex(focusable => {
-            return focusable.id === state.activeFocusId;
-        });
-        for (let index = activeIndex + 1; index < state.focusables.length; index++) {
-            const focusable = state.focusables[index];
-            if (focusable?.isActive) {
-                return focusable.id;
-            }
-        }
-        return undefined;
-    };
-    findPreviousFocusable = (state) => {
-        const activeIndex = state.focusables.findIndex(focusable => {
-            return focusable.id === state.activeFocusId;
-        });
-        for (let index = activeIndex - 1; index >= 0; index--) {
-            const focusable = state.focusables[index];
-            if (focusable?.isActive) {
-                return focusable.id;
+    }, []);
+    // Handle cursor visibility and raw mode cleanup on unmount
+    reactExports.useEffect(() => {
+        return () => {
+            cliCursor.show(stdout);
+            if (isRawModeSupported && rawModeEnabledCount.current > 0) {
+                disableRawMode();
             }
-        }
-        return undefined;
-    };
+        };
+    }, [stdout, isRawModeSupported, disableRawMode]);
+    // Memoize context values to prevent unnecessary re-renders
+    const appContextValue = reactExports.useMemo(() => ({
+        exit: handleExit,
+    }), [handleExit]);
+    const stdinContextValue = reactExports.useMemo(() => ({
+        stdin,
+        setRawMode: handleSetRawMode,
+        isRawModeSupported,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        internal_exitOnCtrlC: exitOnCtrlC,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        internal_eventEmitter: internal_eventEmitter.current,
+    }), [stdin, handleSetRawMode, isRawModeSupported, exitOnCtrlC]);
+    const stdoutContextValue = reactExports.useMemo(() => ({
+        stdout,
+        write: writeToStdout,
+    }), [stdout, writeToStdout]);
+    const stderrContextValue = reactExports.useMemo(() => ({
+        stderr,
+        write: writeToStderr,
+    }), [stderr, writeToStderr]);
+    const cursorContextValue = reactExports.useMemo(() => ({
+        setCursorPosition,
+    }), [setCursorPosition]);
+    const focusContextValue = reactExports.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,
+    ]);
+    return (React.createElement(AppContext.Provider, { value: appContextValue },
+        React.createElement(StdinContext.Provider, { value: stdinContextValue },
+            React.createElement(StdoutContext.Provider, { value: stdoutContextValue },
+                React.createElement(StderrContext.Provider, { value: stderrContextValue },
+                    React.createElement(FocusContext.Provider, { value: focusContextValue },
+                        React.createElement(CursorContext.Provider, { value: cursorContextValue },
+                            React.createElement(ErrorBoundary, { onError: handleExit }, children))))))));
+}
+App.displayName = 'InternalApp';
+
+// Kitty keyboard protocol flags.
+// @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+const kittyFlags = {
+    disambiguateEscapeCodes: 1,
+    reportEventTypes: 2,
+    reportAlternateKeys: 4,
+    reportAllKeysAsEscapeCodes: 8,
+    reportAssociatedText: 16,
+};
+// Converts an array of flag names to the corresponding bitmask value.
+function resolveFlags(flags) {
+    let result = 0;
+    for (const flag of flags) {
+        // eslint-disable-next-line no-bitwise
+        result |= kittyFlags[flag];
+    }
+    return result;
 }
+// Kitty keyboard modifier bits.
+// These are used in the modifier parameter of CSI u sequences.
+// Note: The actual modifier value is (modifiers - 1) as per the protocol.
+const kittyModifiers = {
+    shift: 1,
+    alt: 2,
+    ctrl: 4,
+    super: 8,
+    hyper: 16,
+    meta: 32,
+    capsLock: 64,
+    numLock: 128,
+};
 
 const noop = () => { };
+const kittyQueryEscapeByte = 0x1b;
+const kittyQueryOpenBracketByte = 0x5b;
+const kittyQueryQuestionMarkByte = 0x3f;
+const kittyQueryLetterByte = 0x75;
+const zeroByte = 0x30;
+const nineByte = 0x39;
+const isDigitByte = (byte) => byte >= zeroByte && byte <= nineByte;
+const matchKittyQueryResponse = (buffer, startIndex) => {
+    if (buffer[startIndex] !== kittyQueryEscapeByte ||
+        buffer[startIndex + 1] !== kittyQueryOpenBracketByte ||
+        buffer[startIndex + 2] !== kittyQueryQuestionMarkByte) {
+        return undefined;
+    }
+    let index = startIndex + 3;
+    const digitsStartIndex = index;
+    while (index < buffer.length && isDigitByte(buffer[index])) {
+        index++;
+    }
+    if (index === digitsStartIndex) {
+        return undefined;
+    }
+    if (index === buffer.length) {
+        return { state: 'partial' };
+    }
+    if (buffer[index] === kittyQueryLetterByte) {
+        return { state: 'complete', endIndex: index };
+    }
+    return undefined;
+};
+const hasCompleteKittyQueryResponse = (buffer) => {
+    for (let index = 0; index < buffer.length; index++) {
+        const match = matchKittyQueryResponse(buffer, index);
+        if (match?.state === 'complete') {
+            return true;
+        }
+    }
+    return false;
+};
+const stripKittyQueryResponsesAndTrailingPartial = (buffer) => {
+    const keptBytes = [];
+    let index = 0;
+    while (index < buffer.length) {
+        const match = matchKittyQueryResponse(buffer, index);
+        if (match?.state === 'complete') {
+            index = match.endIndex + 1;
+            continue;
+        }
+        if (match?.state === 'partial') {
+            break;
+        }
+        keptBytes.push(buffer[index]);
+        index++;
+    }
+    return keptBytes;
+};
+const isErrorInput = (value) => {
+    return (value instanceof Error ||
+        Object.prototype.toString.call(value) === '[object Error]');
+};
 class Ink {
+    /**
+    Whether this instance is using concurrent rendering mode.
+    */
+    isConcurrent;
     options;
     log;
+    cursorPosition;
     throttledLog;
     isScreenReaderEnabled;
     // Ignore last render after unmounting a tree to prevent empty output before exit
     isUnmounted;
+    isUnmounting;
     lastOutput;
+    lastOutputToRender;
     lastOutputHeight;
     lastTerminalWidth;
     container;
@@ -39149,8 +41387,14 @@ class Ink {
     // so that it's rerendered every time, not just new static parts, like in non-debug mode
     fullStaticOutput;
     exitPromise;
+    exitResult;
+    beforeExitHandler;
     restoreConsole;
     unsubscribeResize;
+    throttledOnRender;
+    hasPendingThrottledRender = false;
+    kittyProtocolEnabled = false;
+    cancelKittyDetection;
     constructor(options) {
         autoBind(this);
         this.options = options;
@@ -39162,43 +41406,64 @@ class Ink {
         const unthrottled = options.debug || this.isScreenReaderEnabled;
         const maxFps = options.maxFps ?? 30;
         const renderThrottleMs = maxFps > 0 ? Math.max(1, Math.ceil(1000 / maxFps)) : 0;
-        this.rootNode.onRender = unthrottled
-            ? this.onRender
-            : throttle(this.onRender, renderThrottleMs, {
+        if (unthrottled) {
+            this.rootNode.onRender = this.onRender;
+            this.throttledOnRender = undefined;
+        }
+        else {
+            const throttled = throttle(this.onRender, renderThrottleMs, {
                 leading: true,
                 trailing: true,
             });
+            this.rootNode.onRender = () => {
+                this.hasPendingThrottledRender = true;
+                throttled();
+            };
+            this.throttledOnRender = throttled;
+        }
         this.rootNode.onImmediateRender = this.onRender;
         this.log = logUpdate.create(options.stdout, {
             incremental: options.incrementalRendering,
         });
+        this.cursorPosition = undefined;
         this.throttledLog = unthrottled
             ? this.log
-            : throttle(this.log, undefined, {
+            : throttle((output) => {
+                const shouldWrite = this.log.willRender(output);
+                const sync = shouldSynchronize(this.options.stdout);
+                if (sync && shouldWrite) {
+                    this.options.stdout.write(bsu);
+                }
+                this.log(output);
+                if (sync && shouldWrite) {
+                    this.options.stdout.write(esu);
+                }
+            }, undefined, {
                 leading: true,
                 trailing: true,
             });
         // Ignore last render after unmounting a tree to prevent empty output before exit
         this.isUnmounted = false;
+        this.isUnmounting = false;
+        // Store concurrent mode setting
+        this.isConcurrent = options.concurrent ?? false;
         // Store last output to only rerender when needed
         this.lastOutput = '';
+        this.lastOutputToRender = '';
         this.lastOutputHeight = 0;
         this.lastTerminalWidth = this.getTerminalWidth();
         // This variable is used only in debug mode to store full static output
         // so that it's rerendered every time, not just new static parts, like in non-debug mode
         this.fullStaticOutput = '';
+        // Use ConcurrentRoot for concurrent mode, LegacyRoot for legacy mode
+        const rootTag = options.concurrent ? constantsExports.ConcurrentRoot : constantsExports.LegacyRoot;
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        this.container = reconciler.createContainer(this.rootNode, constantsExports.LegacyRoot, null, false, null, 'id', () => { }, () => { }, () => { }, () => { }, null);
+        this.container = reconciler.createContainer(this.rootNode, rootTag, null, false, null, 'id', () => { }, () => { }, () => { }, () => { });
         // Unmount when process exits
         this.unsubscribeExit = signalExit(this.unmount, { alwaysLast: false });
-        if (process$1.env['DEV'] === 'true') {
-            reconciler.injectIntoDevTools({
-                bundleType: 0,
-                // Reporting React DOM's version, not Ink's
-                // See https://github.com/facebook/react/issues/16666#issuecomment-532639905
-                version: '16.13.1',
-                rendererPackageName: 'ink',
-            });
+        if (isDev()) {
+            // @ts-expect-error outdated types
+            reconciler.injectIntoDevTools();
         }
         if (options.patchConsole) {
             this.patchConsole();
@@ -39209,11 +41474,16 @@ class Ink {
                 options.stdout.off('resize', this.resized);
             };
         }
+        this.initKittyKeyboard();
     }
     getTerminalWidth = () => {
         // The 'columns' property can be undefined or 0 when not using a TTY.
-        // In that case we fall back to 80.
-        return this.options.stdout.columns || 80;
+        // Use terminal-size as a fallback for piped processes, then default to 80.
+        if (this.options.stdout.columns) {
+            return this.options.stdout.columns;
+        }
+        const size = terminalSize();
+        return size?.columns ?? 80;
     };
     resized = () => {
         const currentWidth = this.getTerminalWidth();
@@ -39221,6 +41491,7 @@ class Ink {
             // We clear the screen when decreasing terminal width to prevent duplicate overlapping re-renders.
             this.log.clear();
             this.lastOutput = '';
+            this.lastOutputToRender = '';
         }
         this.calculateLayout();
         this.onRender();
@@ -39229,12 +41500,34 @@ class Ink {
     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 = () => {
+        // Clear() resets log-update's cursor state, so replay the latest cursor intent
+        // before restoring output after external stdout/stderr writes.
+        this.log.setCursorPosition(this.cursorPosition);
+        this.log(this.lastOutputToRender || this.lastOutput + '\n');
+    };
     calculateLayout = () => {
         const terminalWidth = this.getTerminalWidth();
         this.rootNode.yogaNode.setWidth(terminalWidth);
         this.rootNode.yogaNode.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
     };
     onRender = () => {
+        this.hasPendingThrottledRender = false;
         if (this.isUnmounted) {
             return;
         }
@@ -39255,10 +41548,15 @@ class Ink {
                 this.options.stdout.write(staticOutput);
             }
             this.lastOutput = output;
+            this.lastOutputToRender = output + '\n';
             this.lastOutputHeight = outputHeight;
             return;
         }
         if (this.isScreenReaderEnabled) {
+            const sync = shouldSynchronize(this.options.stdout);
+            if (sync) {
+                this.options.stdout.write(bsu);
+            }
             if (hasStaticOutput) {
                 // We need to erase the main output before writing new static output
                 const erase = this.lastOutputHeight > 0
@@ -39269,9 +41567,12 @@ class Ink {
                 this.lastOutputHeight = 0;
             }
             if (output === this.lastOutput && !hasStaticOutput) {
+                if (sync) {
+                    this.options.stdout.write(esu);
+                }
                 return;
             }
-            const terminalWidth = this.options.stdout.columns || 80;
+            const terminalWidth = this.getTerminalWidth();
             const wrappedOutput = wrapAnsi(output, terminalWidth, {
                 trim: false,
                 hard: true,
@@ -39287,41 +41588,69 @@ class Ink {
                 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;
         }
+        // Detect fullscreen: output fills or exceeds terminal height.
+        // Only apply when writing to a real TTY — piped output always gets trailing newlines.
+        const isFullscreen = this.options.stdout.isTTY && outputHeight >= this.options.stdout.rows;
+        const outputToRender = isFullscreen ? output : output + '\n';
         if (this.lastOutputHeight >= this.options.stdout.rows) {
+            const sync = shouldSynchronize(this.options.stdout);
+            if (sync) {
+                this.options.stdout.write(bsu);
+            }
             this.options.stdout.write(clearTerminal + this.fullStaticOutput + output);
             this.lastOutput = output;
+            this.lastOutputToRender = outputToRender;
             this.lastOutputHeight = outputHeight;
-            this.log.sync(output);
+            this.log.sync(outputToRender);
+            if (sync) {
+                this.options.stdout.write(esu);
+            }
             return;
         }
         // To ensure static output is cleanly rendered before main output, clear main output first
         if (hasStaticOutput) {
+            const sync = shouldSynchronize(this.options.stdout);
+            if (sync) {
+                this.options.stdout.write(bsu);
+            }
             this.log.clear();
             this.options.stdout.write(staticOutput);
-            this.log(output);
+            this.log(outputToRender);
+            if (sync) {
+                this.options.stdout.write(esu);
+            }
         }
-        if (!hasStaticOutput && output !== this.lastOutput) {
-            this.throttledLog(output);
+        else if (output !== this.lastOutput || this.log.isCursorDirty()) {
+            // ThrottledLog manages its own bsu/esu at actual write time
+            this.throttledLog(outputToRender);
         }
         this.lastOutput = output;
+        this.lastOutputToRender = outputToRender;
         this.lastOutputHeight = outputHeight;
     };
     render(node) {
         const tree = (React.createElement(accessibilityContext.Provider, { value: { isScreenReaderEnabled: this.isScreenReaderEnabled } },
-            React.createElement(App, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, writeToStdout: this.writeToStdout, writeToStderr: this.writeToStderr, exitOnCtrlC: this.options.exitOnCtrlC, onExit: this.unmount }, node)));
-        // @ts-expect-error the types for `react-reconciler` are not up to date with the library.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        reconciler.updateContainerSync(tree, this.container, null, noop);
-        // @ts-expect-error the types for `react-reconciler` are not up to date with the library.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        reconciler.flushSyncWork();
+            React.createElement(App, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, exitOnCtrlC: this.options.exitOnCtrlC, writeToStdout: this.writeToStdout, writeToStderr: this.writeToStderr, setCursorPosition: this.setCursorPosition, onExit: this.handleAppExit }, node)));
+        if (this.options.concurrent) {
+            // Concurrent mode: use updateContainer (async scheduling)
+            reconciler.updateContainer(tree, this.container, null, noop);
+        }
+        else {
+            // Legacy mode: use updateContainerSync + flushSyncWork (sync)
+            reconciler.updateContainerSync(tree, this.container, null, noop);
+            reconciler.flushSyncWork();
+        }
     }
     writeToStdout(data) {
         if (this.isUnmounted) {
@@ -39335,9 +41664,16 @@ class Ink {
             this.options.stdout.write(data);
             return;
         }
+        const sync = shouldSynchronize(this.options.stdout);
+        if (sync) {
+            this.options.stdout.write(bsu);
+        }
         this.log.clear();
         this.options.stdout.write(data);
-        this.log(this.lastOutput);
+        this.restoreLastOutput();
+        if (sync) {
+            this.options.stdout.write(esu);
+        }
     }
     writeToStderr(data) {
         if (this.isUnmounted) {
@@ -39352,17 +41688,57 @@ class Ink {
             this.options.stderr.write(data);
             return;
         }
+        const sync = shouldSynchronize(this.options.stdout);
+        if (sync) {
+            this.options.stdout.write(bsu);
+        }
         this.log.clear();
         this.options.stderr.write(data);
-        this.log(this.lastOutput);
+        this.restoreLastOutput();
+        if (sync) {
+            this.options.stdout.write(esu);
+        }
     }
     // eslint-disable-next-line @typescript-eslint/ban-types
     unmount(error) {
-        if (this.isUnmounted) {
+        if (this.isUnmounted || this.isUnmounting) {
             return;
         }
-        this.calculateLayout();
-        this.onRender();
+        this.isUnmounting = true;
+        if (this.beforeExitHandler) {
+            process$1.off('beforeExit', this.beforeExitHandler);
+            this.beforeExitHandler = undefined;
+        }
+        const stdout = this.options.stdout;
+        const canWriteToStdout = !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true);
+        const settleThrottle = (throttled) => {
+            if (typeof throttled.flush !== 'function') {
+                return;
+            }
+            if (canWriteToStdout) {
+                throttled.flush();
+            }
+            else if (typeof throttled.cancel === 'function') {
+                throttled.cancel();
+            }
+        };
+        // Clear any pending throttled render timer on unmount. When stdout is writable,
+        // flush so the final frame is emitted; otherwise cancel to avoid delayed callbacks.
+        settleThrottle(this.throttledOnRender ?? {});
+        if (canWriteToStdout) {
+            // If throttling is enabled and there is already a pending render, flushing above
+            // is sufficient. Also avoid calling onRender() again when static output already
+            // exists, as that can duplicate <Static> children output on exit (see issue #397).
+            const shouldRenderFinalFrame = !this.throttledOnRender ||
+                (!this.hasPendingThrottledRender && this.fullStaticOutput === '');
+            if (shouldRenderFinalFrame) {
+                this.calculateLayout();
+                this.onRender();
+            }
+        }
+        // Mark as unmounted after the final render but before stdout writes
+        // that could re-enter exit() via synchronous write callbacks.
+        this.isUnmounted = true;
         this.unsubscribeExit();
         if (typeof this.restoreConsole === 'function') {
             this.restoreConsole();
@@ -39370,27 +41746,71 @@ class Ink {
         if (typeof this.unsubscribeResize === 'function') {
             this.unsubscribeResize();
         }
-        // CIs don't handle erasing ansi escapes well, so it's better to
-        // only render last frame of non-static output
-        if (isInCi) {
-            this.options.stdout.write(this.lastOutput + '\n');
+        // Cancel any in-progress auto-detection before checking protocol state
+        if (this.cancelKittyDetection) {
+            this.cancelKittyDetection();
+        }
+        // Flush any pending throttled log writes if possible, otherwise cancel to
+        // prevent delayed callbacks from writing to a closed stream.
+        const throttledLog = this.throttledLog;
+        settleThrottle(throttledLog);
+        if (canWriteToStdout) {
+            if (this.kittyProtocolEnabled) {
+                try {
+                    this.options.stdout.write('\u001B[<u');
+                }
+                catch {
+                    // Best-effort: stdout may already be destroyed during shutdown
+                }
+            }
+            // CIs don't handle erasing ansi escapes well, so it's better to
+            // only render last frame of non-static output
+            if (isInCi) {
+                this.options.stdout.write(this.lastOutput + '\n');
+            }
+            else if (!this.options.debug) {
+                this.log.done();
+            }
         }
-        else if (!this.options.debug) {
-            this.log.done();
+        this.kittyProtocolEnabled = false;
+        if (this.options.concurrent) {
+            // Concurrent mode: use updateContainer (async scheduling)
+            reconciler.updateContainer(null, this.container, null, noop);
+        }
+        else {
+            // Legacy mode: use updateContainerSync + flushSyncWork (sync)
+            reconciler.updateContainerSync(null, this.container, null, noop);
+            reconciler.flushSyncWork();
         }
-        this.isUnmounted = true;
-        // @ts-expect-error the types for `react-reconciler` are not up to date with the library.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        reconciler.updateContainerSync(null, this.container, null, noop);
-        // @ts-expect-error the types for `react-reconciler` are not up to date with the library.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        reconciler.flushSyncWork();
         instances.delete(this.options.stdout);
-        if (error instanceof Error) {
-            this.rejectExitPromise(error);
+        // Ensure all queued writes have been processed before resolving the
+        // exit promise. For real writable streams, queue an empty write as a
+        // barrier — its callback fires only after all prior writes complete.
+        // For non-stream objects (e.g. test spies), resolve on next tick.
+        //
+        // When called from signal-exit during process shutdown (error is a
+        // number or null rather than undefined/Error), resolve synchronously
+        // because the event loop is draining and async callbacks won't fire.
+        const { exitResult } = this;
+        const resolveOrReject = () => {
+            if (isErrorInput(error)) {
+                this.rejectExitPromise(error);
+            }
+            else {
+                this.resolveExitPromise(exitResult);
+            }
+        };
+        const isProcessExiting = error !== undefined && !isErrorInput(error);
+        const hasWritableState = stdout._writableState !== undefined ||
+            stdout.writableLength !== undefined;
+        if (isProcessExiting) {
+            resolveOrReject();
+        }
+        else if (canWriteToStdout && hasWritableState) {
+            this.options.stdout.write('', resolveOrReject);
         }
         else {
-            this.resolveExitPromise();
+            setImmediate(resolveOrReject);
         }
     }
     async waitUntilExit() {
@@ -39398,11 +41818,20 @@ class Ink {
             this.resolveExitPromise = resolve;
             this.rejectExitPromise = reject;
         });
+        if (!this.beforeExitHandler) {
+            this.beforeExitHandler = () => {
+                this.unmount();
+            };
+            process$1.once('beforeExit', this.beforeExitHandler);
+        }
         return this.exitPromise;
     }
     clear() {
         if (!isInCi && !this.options.debug) {
             this.log.clear();
+            // Sync lastOutput so that unmount's final onRender
+            // sees it as unchanged and log-update skips it
+            this.log.sync(this.lastOutputToRender || this.lastOutput + '\n');
         }
     }
     patchConsole() {
@@ -39421,6 +41850,73 @@ class Ink {
             }
         });
     }
+    initKittyKeyboard() {
+        // Protocol is opt-in: if kittyKeyboard is not specified, do nothing
+        if (!this.options.kittyKeyboard) {
+            return;
+        }
+        const opts = this.options.kittyKeyboard;
+        const mode = opts.mode ?? 'auto';
+        if (mode === 'disabled' ||
+            !this.options.stdin.isTTY ||
+            !this.options.stdout.isTTY) {
+            return;
+        }
+        const flags = opts.flags ?? ['disambiguateEscapeCodes'];
+        if (mode === 'enabled') {
+            this.enableKittyProtocol(flags);
+            return;
+        }
+        // Auto mode: use heuristic precheck, then confirm with protocol query
+        const term = process$1.env['TERM'] ?? '';
+        const termProgram = process$1.env['TERM_PROGRAM'] ?? '';
+        const isKnownSupportingTerminal = 'KITTY_WINDOW_ID' in process$1.env ||
+            term === 'xterm-kitty' ||
+            termProgram === 'WezTerm' ||
+            termProgram === 'ghostty';
+        if (!isInCi && isKnownSupportingTerminal) {
+            this.confirmKittySupport(flags);
+        }
+    }
+    confirmKittySupport(flags) {
+        const { stdin, stdout } = this.options;
+        let responseBuffer = [];
+        const cleanup = () => {
+            this.cancelKittyDetection = undefined;
+            clearTimeout(timer);
+            stdin.removeListener('data', onData);
+            // Re-emit any buffered data that wasn't the protocol response,
+            // so it isn't lost from Ink's normal input pipeline.
+            // Clear responseBuffer afterwards to make cleanup idempotent.
+            const remaining = stripKittyQueryResponsesAndTrailingPartial(responseBuffer);
+            responseBuffer = [];
+            if (remaining.length > 0) {
+                stdin.unshift(Buffer.from(remaining));
+            }
+        };
+        const onData = (data) => {
+            const chunk = typeof data === 'string' ? Buffer.from(data) : data;
+            for (const byte of chunk) {
+                responseBuffer.push(byte);
+            }
+            if (hasCompleteKittyQueryResponse(responseBuffer)) {
+                cleanup();
+                if (!this.isUnmounted) {
+                    this.enableKittyProtocol(flags);
+                }
+            }
+        };
+        // Attach listener before writing the query so that synchronous
+        // or immediate responses are not missed.
+        stdin.on('data', onData);
+        const timer = setTimeout(cleanup, 200);
+        this.cancelKittyDetection = cleanup;
+        stdout.write('\u001B[?u');
+    }
+    enableKittyProtocol(flags) {
+        this.options.stdout.write(`\u001B[>${resolveFlags(flags)}u`);
+        this.kittyProtocolEnabled = true;
+    }
 }
 
 /**
@@ -39436,9 +41932,10 @@ const render = (node, options) => {
         patchConsole: true,
         maxFps: 30,
         incrementalRendering: false,
+        concurrent: false,
         ...getOptions(options),
     };
-    const instance = getInstance(inkOptions.stdout, () => new Ink(inkOptions));
+    const instance = getInstance(inkOptions.stdout, () => new Ink(inkOptions), inkOptions.concurrent ?? false);
     instance.render(node);
     return {
         rerender: instance.render,
@@ -39459,12 +41956,16 @@ const getOptions = (stdout = {}) => {
     }
     return stdout;
 };
-const getInstance = (stdout, createInstance) => {
+const getInstance = (stdout, createInstance, concurrent) => {
     let instance = instances.get(stdout);
     if (!instance) {
         instance = createInstance();
         instances.set(stdout, instance);
     }
+    else if (instance.isConcurrent !== concurrent) {
+        console.warn(`Warning: render() was called with concurrent: ${concurrent}, but the existing instance for this stdout uses concurrent: ${instance.isConcurrent}. ` +
+            `The concurrent option only takes effect on the first render. Call unmount() first if you need to change the rendering mode.`);
+    }
     return instance;
 };
 
@@ -39584,6 +42085,249 @@ const isCtrlKey = (code) => {
         '[8^',
     ].includes(code);
 };
+// Kitty keyboard protocol: CSI codepoint ; modifiers [: eventType] [; text-as-codepoints] u
+const kittyKeyRe = /^\x1b\[(\d+)(?:;(\d+)(?::(\d+))?(?:;([\d:]+))?)?u$/;
+// Kitty-enhanced special keys: CSI number ; modifiers : eventType {letter|~}
+// These are legacy CSI sequences enhanced with the :eventType field.
+// Examples: \x1b[1;1:1A (up arrow press), \x1b[3;1:3~ (delete release)
+const kittySpecialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Za-z~])$/;
+// Letter-terminated special key names (CSI 1 ; mods letter)
+const kittySpecialLetterKeys = {
+    A: 'up',
+    B: 'down',
+    C: 'right',
+    D: 'left',
+    E: 'clear',
+    F: 'end',
+    H: 'home',
+    P: 'f1',
+    Q: 'f2',
+    R: 'f3',
+    S: 'f4',
+};
+// Number-terminated special key names (CSI number ; mods ~)
+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',
+};
+// Map of special codepoints to key names in kitty protocol
+const kittyCodepointNames = {
+    27: 'escape',
+    // 13 (return) and 32 (space) are handled before this lookup
+    // in parseKittyKeypress so they can be marked as printable.
+    9: 'tab',
+    127: 'delete',
+    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',
+};
+// Valid Unicode codepoint range, excluding surrogates
+const isValidCodepoint = (cp) => cp >= 0 && cp <= 0x10_ffff && !(cp >= 0xd8_00 && cp <= 0xdf_ff);
+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),
+        option: !!(modifiers & 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];
+    // Bail on invalid primary codepoint
+    if (!isValidCodepoint(codepoint)) {
+        return null;
+    }
+    // Parse text-as-codepoints field (colon-separated Unicode codepoints)
+    let text;
+    if (textField) {
+        text = textField
+            .split(':')
+            .map(cp => safeFromCodePoint(parseInt(cp, 10)))
+            .join('');
+    }
+    // Determine key name from codepoint
+    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) {
+        // Ctrl+letter comes as codepoint 1-26
+        name = String.fromCodePoint(codepoint + 96); // 'a' is 97
+        isPrintable = false;
+    }
+    else {
+        name = safeFromCodePoint(codepoint).toLowerCase();
+        isPrintable = true;
+    }
+    // Default text to the character from the codepoint when not explicitly
+    // provided by the protocol, so keys like space and return produce their
+    // expected text input (' ' and '\r' respectively).
+    if (isPrintable && !text) {
+        text = safeFromCodePoint(codepoint);
+    }
+    return {
+        name,
+        ...parseKittyModifiers(modifiers),
+        eventType: resolveEventType(eventType),
+        sequence: s,
+        raw: s,
+        isKittyProtocol: true,
+        isPrintable,
+        text,
+    };
+};
+// Parse kitty-enhanced special key sequences (arrow keys, function keys, etc.)
+// These use the legacy CSI format but with an added :eventType field.
+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 (Buffer$1.isBuffer(s)) {
@@ -39601,6 +42345,29 @@ const parseKeypress = (s = '') => {
     else if (!s) {
         s = '';
     }
+    // Try kitty keyboard protocol parsers first
+    const kittyResult = parseKittyKeypress(s);
+    if (kittyResult)
+        return kittyResult;
+    const kittySpecialResult = parseKittySpecialKey(s);
+    if (kittySpecialResult)
+        return kittySpecialResult;
+    // If the input matched the kitty CSI-u pattern but was rejected (e.g.,
+    // invalid codepoint), return a safe empty keypress instead of falling
+    // through to legacy parsing which can produce unsafe states (undefined name)
+    if (kittyKeyRe.test(s)) {
+        return {
+            name: '',
+            ctrl: false,
+            meta: false,
+            shift: false,
+            option: false,
+            sequence: s,
+            raw: s,
+            isKittyProtocol: true,
+            isPrintable: false,
+        };
+    }
     const key = {
         name: '',
         ctrl: false,
@@ -39611,10 +42378,11 @@ const parseKeypress = (s = '') => {
         raw: s,
     };
     key.sequence = key.sequence || s || key.name;
-    if (s === '\r') {
-        // carriage return
+    if (s === '\r' || s === '\x1b\r') {
+        // carriage return (or option+return on macOS)
         key.raw = undefined;
         key.name = 'return';
+        key.option = s.length === 2;
     }
     else if (s === '\n') {
         // enter, should have been called linefeed
@@ -39742,6 +42510,8 @@ const useInput = (inputHandler, options = {}) => {
                 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,
@@ -39754,9 +42524,38 @@ const useInput = (inputHandler, options = {}) => {
                 // to avoid breaking changes in Ink.
                 // TODO(vadimdemedes): consider removing this in the next major version.
                 meta: keypress.meta || keypress.name === 'escape' || keypress.option,
+                // Kitty keyboard protocol modifiers
+                super: keypress.super ?? false,
+                hyper: keypress.hyper ?? false,
+                capsLock: keypress.capsLock ?? false,
+                numLock: keypress.numLock ?? false,
+                eventType: keypress.eventType,
             };
-            let input = keypress.ctrl ? keypress.name : keypress.sequence;
-            if (nonAlphanumericKeys.includes(keypress.name)) {
+            let input;
+            if (keypress.isKittyProtocol) {
+                // Use text-as-codepoints field for printable keys (needed when
+                // reportAllKeysAsEscapeCodes flag is enabled), suppress non-printable
+                if (keypress.isPrintable) {
+                    input = keypress.text ?? keypress.name;
+                }
+                else if (keypress.ctrl && keypress.name.length === 1) {
+                    // Ctrl+letter via codepoint 1-26 form: not printable text, but
+                    // the letter name must flow through so handlers (e.g. exitOnCtrlC
+                    // checking `input === 'c' && key.ctrl`) still work.
+                    input = keypress.name;
+                }
+                else {
+                    input = '';
+                }
+            }
+            else if (keypress.ctrl) {
+                input = keypress.name;
+            }
+            else {
+                input = keypress.sequence;
+            }
+            if (!keypress.isKittyProtocol &&
+                nonAlphanumericKeys.includes(keypress.name)) {
                 input = '';
             }
             // Strip meta if it's still remaining after `parseKeypress`
@@ -40253,4 +43052,4 @@ const layout = {
 };
 
 export { AppContext as A, Box as B, React as R, Text as T, useStdout as a, render as b, colors as c, jsxRuntimeExports as j, layout as l, reactExports as r, symbols as s, useInput as u };
-//# sourceMappingURL=theme-CzLXk_6s.js.map
+//# sourceMappingURL=theme-BmodcXss.js.map