silvery 0.17.0 → 0.17.2

package/dist/src-9B5k0JmY.mjs

@@ -0,0 +1,1629 @@
+import { i as __require, n as __esmMin } from "./chunk-BSw8zbkd.mjs";
+import "string-width";
+//#region packages/ansi/src/detection.ts
+/**
+* Detect if terminal supports cursor control (repositioning).
+* Returns false for dumb terminals and piped output.
+*/
+function detectCursor(stdout) {
+	if (!stdout.isTTY) return false;
+	if (process.env.TERM === "dumb") return false;
+	return true;
+}
+/**
+* Detect if terminal can read raw keystrokes.
+* Requires stdin to be a TTY with raw mode support.
+*/
+function detectInput(stdin) {
+	if (!stdin.isTTY) return false;
+	return typeof stdin.setRawMode === "function";
+}
+/**
+* Detect color level supported by terminal.
+* Returns null if no color support.
+*
+* Checks (in order):
+* 1. NO_COLOR env var - forces no color
+* 2. FORCE_COLOR env var - forces color level
+* 3. COLORTERM=truecolor - truecolor support
+* 4. TERM patterns - detect from terminal type
+* 5. CI detection - basic colors in CI
+*/
+function detectColor(stdout) {
+	if (process.env.NO_COLOR !== void 0) return null;
+	const forceColor = process.env.FORCE_COLOR;
+	if (forceColor !== void 0) {
+		if (forceColor === "0" || forceColor === "false") return null;
+		if (forceColor === "1") return "basic";
+		if (forceColor === "2") return "256";
+		if (forceColor === "3") return "truecolor";
+		return "basic";
+	}
+	if (!stdout.isTTY) return null;
+	if (process.env.TERM === "dumb") return null;
+	const colorTerm = process.env.COLORTERM;
+	if (colorTerm === "truecolor" || colorTerm === "24bit") return "truecolor";
+	const term = process.env.TERM ?? "";
+	if (term.includes("truecolor") || term.includes("24bit") || term.includes("xterm-ghostty") || term.includes("xterm-kitty") || term.includes("wezterm")) return "truecolor";
+	if (term.includes("256color") || term.includes("256")) return "256";
+	const termProgram = process.env.TERM_PROGRAM;
+	if (termProgram === "iTerm.app" || termProgram === "Apple_Terminal") return termProgram === "iTerm.app" ? "truecolor" : "256";
+	if (termProgram === "Ghostty" || termProgram === "WezTerm") return "truecolor";
+	if (process.env.KITTY_WINDOW_ID) return "truecolor";
+	if (term.includes("xterm") || term.includes("color") || term.includes("ansi")) return "basic";
+	if (CI_ENVS.some((env) => process.env[env] !== void 0)) return "basic";
+	if (process.env.WT_SESSION) return "truecolor";
+	return "basic";
+}
+/**
+* Detect if terminal can render unicode symbols.
+* Based on TERM, locale, and known terminal apps.
+*/
+function detectUnicode() {
+	if (process.env.CI) {
+		if (process.env.GITHUB_ACTIONS) return true;
+	}
+	const lang = process.env.LANG ?? process.env.LC_ALL ?? process.env.LC_CTYPE ?? "";
+	if (lang.toLowerCase().includes("utf-8") || lang.toLowerCase().includes("utf8")) return true;
+	if (process.env.WT_SESSION) return true;
+	const termProgram = process.env.TERM_PROGRAM ?? "";
+	if ([
+		"iTerm.app",
+		"Ghostty",
+		"WezTerm",
+		"Apple_Terminal"
+	].includes(termProgram)) return true;
+	if (process.env.KITTY_WINDOW_ID) return true;
+	const term = process.env.TERM ?? "";
+	if (term.includes("xterm") || term.includes("rxvt") || term.includes("screen") || term.includes("tmux")) return true;
+	return false;
+}
+/**
+* Default capabilities (assumes modern terminal with full support).
+*/
+function defaultCaps() {
+	return {
+		program: "",
+		term: "",
+		colorLevel: "truecolor",
+		kittyKeyboard: false,
+		kittyGraphics: false,
+		sixel: false,
+		osc52: false,
+		hyperlinks: false,
+		notifications: false,
+		bracketedPaste: true,
+		mouse: true,
+		syncOutput: false,
+		unicode: true,
+		underlineStyles: true,
+		underlineColor: true,
+		textEmojiWide: true,
+		textSizingSupported: false,
+		darkBackground: true,
+		nerdfont: false
+	};
+}
+/**
+* Check if macOS is in dark mode by reading the system appearance preference.
+* Uses `defaults read -g AppleInterfaceStyle` — returns "Dark" when dark mode
+* is active, exits non-zero when light mode. ~2ms via spawnSync.
+*
+* Result is cached after first call to avoid repeated process spawns.
+*/
+function detectMacOSDarkMode() {
+	if (cachedMacOSDarkMode !== void 0) return cachedMacOSDarkMode;
+	try {
+		const { spawnSync } = __require("child_process");
+		cachedMacOSDarkMode = spawnSync("defaults", [
+			"read",
+			"-g",
+			"AppleInterfaceStyle"
+		], {
+			encoding: "utf-8",
+			timeout: 500
+		}).stdout?.trim() === "Dark";
+	} catch {
+		cachedMacOSDarkMode = false;
+	}
+	return cachedMacOSDarkMode;
+}
+/** Detect terminal capabilities from environment variables.
+* Synchronous. Minimal I/O: may run `defaults` on macOS for Apple_Terminal.
+*/
+function detectTerminalCaps() {
+	const program = process.env.TERM_PROGRAM ?? "";
+	const term = process.env.TERM ?? "";
+	const colorTerm = process.env.COLORTERM ?? "";
+	const noColor = process.env.NO_COLOR !== void 0;
+	const isAppleTerminal = program === "Apple_Terminal";
+	let colorLevel = "none";
+	if (!noColor) {
+		if (isAppleTerminal) colorLevel = "256";
+		else if (colorTerm === "truecolor" || colorTerm === "24bit") colorLevel = "truecolor";
+		else if (term.includes("256color")) colorLevel = "256";
+		else if (process.stdout?.isTTY) colorLevel = "basic";
+	}
+	const isKitty = term === "xterm-kitty";
+	const isITerm = program === "iTerm.app";
+	const isGhostty = program === "ghostty";
+	const isWezTerm = program === "WezTerm";
+	const isAlacritty = program === "Alacritty";
+	const isFoot = term === "foot" || term === "foot-extra";
+	const isModern = isKitty || isITerm || isGhostty || isWezTerm || isFoot;
+	let isKittyWithTextSizing = false;
+	if (isKitty) {
+		const parts = (process.env.TERM_PROGRAM_VERSION ?? "").split(".");
+		const major = Number(parts[0]) || 0;
+		const minor = Number(parts[1]) || 0;
+		isKittyWithTextSizing = major > 0 || major === 0 && minor >= 40;
+	}
+	let darkBackground = !isAppleTerminal;
+	const colorFgBg = process.env.COLORFGBG;
+	if (colorFgBg) {
+		const parts = colorFgBg.split(";");
+		const bg = parseInt(parts[parts.length - 1] ?? "", 10);
+		if (!isNaN(bg)) darkBackground = bg < 7;
+	} else if (isAppleTerminal) darkBackground = detectMacOSDarkMode();
+	let nerdfont = isModern || isAlacritty;
+	const nfEnv = process.env.NERDFONT;
+	if (nfEnv === "0" || nfEnv === "false") nerdfont = false;
+	else if (nfEnv === "1" || nfEnv === "true") nerdfont = true;
+	const underlineExtensions = isModern || isAlacritty;
+	return {
+		program,
+		term,
+		colorLevel,
+		kittyKeyboard: isKitty || isGhostty || isWezTerm || isFoot,
+		kittyGraphics: isKitty || isGhostty,
+		sixel: isFoot || isWezTerm,
+		osc52: isModern || isAlacritty,
+		hyperlinks: isModern || isAlacritty,
+		notifications: isITerm || isKitty,
+		bracketedPaste: true,
+		mouse: true,
+		syncOutput: isModern || isAlacritty,
+		unicode: true,
+		underlineStyles: underlineExtensions,
+		underlineColor: underlineExtensions,
+		textEmojiWide: !isAppleTerminal,
+		textSizingSupported: isKittyWithTextSizing,
+		darkBackground,
+		nerdfont
+	};
+}
+var CI_ENVS, cachedMacOSDarkMode;
+var init_detection = __esmMin((() => {
+	CI_ENVS = [
+		"CI",
+		"GITHUB_ACTIONS",
+		"GITLAB_CI",
+		"JENKINS_URL",
+		"BUILDKITE",
+		"CIRCLECI",
+		"TRAVIS"
+	];
+}));
+//#endregion
+//#region packages/ansi/src/sgr-codes.ts
+/**
+* SGR (Select Graphic Rendition) color code helpers.
+*
+* Shared by buffer.ts (styleToAnsiCodes) and output-phase.ts (styleTransition).
+* Emits the shortest possible SGR code string for a given color.
+*/
+/**
+* Emit the shortest SGR code string for a foreground color.
+* - Basic 0-7: 4-bit code (30+N)
+* - Extended 8-255: 256-color (38;5;N)
+* - RGB: true color (38;2;R;G;B)
+*/
+function fgColorCode(color) {
+	if (typeof color === "number") {
+		if (color >= 0 && color <= 7) return `${30 + color}`;
+		return `38;5;${color}`;
+	}
+	return `38;2;${color.r};${color.g};${color.b}`;
+}
+/**
+* Emit the shortest SGR code string for a background color.
+* - Basic 0-7: 4-bit code (40+N)
+* - Extended 8-255: 256-color (48;5;N)
+* - RGB: true color (48;2;R;G;B)
+*/
+function bgColorCode(color) {
+	if (typeof color === "number") {
+		if (color >= 0 && color <= 7) return `${40 + color}`;
+		return `48;5;${color}`;
+	}
+	return `48;2;${color.r};${color.g};${color.b}`;
+}
+var init_sgr_codes = __esmMin((() => {}));
+//#endregion
+//#region packages/ansi/src/utils.ts
+var init_utils = __esmMin((() => {}));
+//#endregion
+//#region packages/ansi/src/color-maps.ts
+/** Find nearest ANSI 16 color index for an RGB value. */
+function nearestAnsi16(r, g, b) {
+	let bestIdx = 0;
+	let bestDist = Infinity;
+	for (let i = 0; i < 16; i++) {
+		const [cr, cg, cb] = ANSI_16_COLORS[i];
+		const dist = (r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2;
+		if (dist < bestDist) {
+			bestDist = dist;
+			bestIdx = i;
+		}
+	}
+	return bestIdx;
+}
+/** Convert RGB to 256-color index (using the 6x6x6 color cube). */
+function rgbToAnsi256(r, g, b) {
+	if (r === g && g === b) {
+		if (r < 8) return 16;
+		if (r > 248) return 231;
+		return Math.round((r - 8) / 247 * 24) + 232;
+	}
+	const ri = Math.round(r / 255 * 5);
+	const gi = Math.round(g / 255 * 5);
+	const bi = Math.round(b / 255 * 5);
+	return 16 + 36 * ri + 6 * gi + bi;
+}
+/**
+* Generate SGR foreground code for an RGB color at the given color level.
+* Returns the SGR parameter string (e.g., "31" or "38;5;196" or "38;2;255;0;0").
+*/
+function fgFromRgb(r, g, b, level) {
+	if (level === "truecolor") return `38;2;${r};${g};${b}`;
+	if (level === "256") return `38;5;${rgbToAnsi256(r, g, b)}`;
+	const idx = nearestAnsi16(r, g, b);
+	return idx < 8 ? `${30 + idx}` : `${82 + idx}`;
+}
+/**
+* Generate SGR background code for an RGB color at the given color level.
+*/
+function bgFromRgb(r, g, b, level) {
+	if (level === "truecolor") return `48;2;${r};${g};${b}`;
+	if (level === "256") return `48;5;${rgbToAnsi256(r, g, b)}`;
+	const idx = nearestAnsi16(r, g, b);
+	return idx < 8 ? `${40 + idx}` : `${92 + idx}`;
+}
+var MODIFIERS, FG_COLORS, BG_COLORS, ANSI_16_COLORS;
+var init_color_maps = __esmMin((() => {
+	MODIFIERS = {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29],
+		overline: [53, 55]
+	};
+	FG_COLORS = {
+		black: 30,
+		red: 31,
+		green: 32,
+		yellow: 33,
+		blue: 34,
+		magenta: 35,
+		cyan: 36,
+		white: 37,
+		blackBright: 90,
+		gray: 90,
+		grey: 90,
+		redBright: 91,
+		greenBright: 92,
+		yellowBright: 93,
+		blueBright: 94,
+		magentaBright: 95,
+		cyanBright: 96,
+		whiteBright: 97
+	};
+	BG_COLORS = {
+		bgBlack: 40,
+		bgRed: 41,
+		bgGreen: 42,
+		bgYellow: 43,
+		bgBlue: 44,
+		bgMagenta: 45,
+		bgCyan: 46,
+		bgWhite: 47,
+		bgBlackBright: 100,
+		bgGray: 100,
+		bgGrey: 100,
+		bgRedBright: 101,
+		bgGreenBright: 102,
+		bgYellowBright: 103,
+		bgBlueBright: 104,
+		bgMagentaBright: 105,
+		bgCyanBright: 106,
+		bgWhiteBright: 107
+	};
+	ANSI_16_COLORS = [
+		[
+			0,
+			0,
+			0
+		],
+		[
+			128,
+			0,
+			0
+		],
+		[
+			0,
+			128,
+			0
+		],
+		[
+			128,
+			128,
+			0
+		],
+		[
+			0,
+			0,
+			128
+		],
+		[
+			128,
+			0,
+			128
+		],
+		[
+			0,
+			128,
+			128
+		],
+		[
+			192,
+			192,
+			192
+		],
+		[
+			128,
+			128,
+			128
+		],
+		[
+			255,
+			0,
+			0
+		],
+		[
+			0,
+			255,
+			0
+		],
+		[
+			255,
+			255,
+			0
+		],
+		[
+			0,
+			0,
+			255
+		],
+		[
+			255,
+			0,
+			255
+		],
+		[
+			0,
+			255,
+			255
+		],
+		[
+			255,
+			255,
+			255
+		]
+	];
+}));
+//#endregion
+//#region packages/ansi/src/terminal-control.ts
+/**
+* Enable mouse tracking with full hover support.
+*
+* Uses two modes:
+* - **1003** (any-event tracking): Reports ALL mouse motion — clicks, drags, AND hover.
+*   This is what makes onMouseEnter/onMouseLeave work. Without it, only clicks are reported.
+* - **1006** (SGR encoding): Decimal coordinates with no 223-column limit.
+*
+* WARNING: Do NOT replace 1003 with 1000+1002. The xterm mouse modes form a hierarchy:
+*   1000 = clicks only
+*   1002 = clicks + drag (motion while button held)
+*   1003 = clicks + drag + hover (ALL motion, even without button)
+* Mode 1003 supersedes 1000 and 1002. Using 1000+1002 instead of 1003 silently
+* disables hover — onMouseEnter/onMouseLeave stop firing with no error.
+*/
+function enableMouse() {
+	return `${CSI$1}?1003h${CSI$1}?1006h`;
+}
+/**
+* Disable mouse tracking. Disables in reverse order of enabling.
+*/
+function disableMouse() {
+	return `${CSI$1}?1006l${CSI$1}?1003l`;
+}
+/**
+* Enable the Kitty keyboard protocol (push mode).
+*
+* Sends CSI > flags u to opt into the specified modes.
+* Supported by: Ghostty, Kitty, WezTerm, foot. Ignored by unsupported terminals.
+*
+* Flags are a bitfield:
+*
+* | Flag | Bit | Description                               |
+* | ---- | --- | ----------------------------------------- |
+* | 1    | 0   | Disambiguate escape codes                 |
+* | 2    | 1   | Report event types (press/repeat/release)  |
+* | 4    | 2   | Report alternate keys                     |
+* | 8    | 3   | Report all keys as escape codes           |
+* | 16   | 4   | Report associated text                    |
+*
+* @param flags Bitfield of Kitty keyboard flags
+*/
+function enableKittyKeyboard(flags = 1) {
+	return `${CSI$1}>${flags}u`;
+}
+/**
+* Disable the Kitty keyboard protocol (pop mode stack).
+* Sends CSI < u to restore the previous keyboard mode.
+*/
+function disableKittyKeyboard() {
+	return `${CSI$1}<u`;
+}
+var ESC$3, CSI$1;
+var init_terminal_control = __esmMin((() => {
+	ESC$3 = "\x1B";
+	CSI$1 = `${ESC$3}[`;
+	`${ESC$3}`;
+}));
+//#endregion
+//#region packages/color/src/color.ts
+/** Parse #rrggbb or #rgb to [r, g, b]. Returns null for invalid input. */
+function hexToRgb(hex) {
+	if (hex[0] !== "#") return null;
+	const h = hex.slice(1);
+	if (h.length === 3) return [
+		parseInt(h[0] + h[0], 16),
+		parseInt(h[1] + h[1], 16),
+		parseInt(h[2] + h[2], 16)
+	];
+	if (h.length === 6) return [
+		parseInt(h.slice(0, 2), 16),
+		parseInt(h.slice(2, 4), 16),
+		parseInt(h.slice(4, 6), 16)
+	];
+	return null;
+}
+/** Convert [r, g, b] (0-255) to hex string. */
+function rgbToHex(r, g, b) {
+	const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
+	return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`.toUpperCase();
+}
+/**
+* Blend two hex colors. t=0 returns a, t=1 returns b.
+* For non-hex inputs (ANSI names), returns `a` unchanged.
+*/
+function blend(a, b, t) {
+	const rgbA = hexToRgb(a);
+	const rgbB = hexToRgb(b);
+	if (!rgbA || !rgbB) return a;
+	return rgbToHex(rgbA[0] + (rgbB[0] - rgbA[0]) * t, rgbA[1] + (rgbB[1] - rgbA[1]) * t, rgbA[2] + (rgbB[2] - rgbA[2]) * t);
+}
+/**
+* Brighten a hex color. amount=0.1 adds 10% lightness toward white.
+* For non-hex inputs (ANSI names), returns the color unchanged.
+*/
+function brighten(color, amount) {
+	return blend(color, "#FFFFFF", amount);
+}
+/**
+* Darken a hex color. amount=0.1 adds 10% darkness toward black.
+* For non-hex inputs (ANSI names), returns the color unchanged.
+*/
+function darken(color, amount) {
+	return blend(color, "#000000", amount);
+}
+/**
+* Linearize an sRGB channel value (0-255) for luminance calculation.
+* Per WCAG 2.1: values below the threshold use a linear scale,
+* above use the gamma-corrected formula.
+*/
+function channelLuminance(c) {
+	const s = c / 255;
+	return s <= .03928 ? s / 12.92 : Math.pow((s + .055) / 1.055, 2.4);
+}
+/**
+* Compute relative luminance of a hex color per WCAG 2.1.
+* Returns a value between 0 (darkest) and 1 (lightest), or null for invalid input.
+*/
+function relativeLuminance(hex) {
+	const rgb = hexToRgb(hex);
+	if (!rgb) return null;
+	return .2126 * channelLuminance(rgb[0]) + .7152 * channelLuminance(rgb[1]) + .0722 * channelLuminance(rgb[2]);
+}
+/**
+* Pick black or white text for readability on the given background.
+* Uses relative luminance (WCAG formula).
+*/
+function contrastFg(bg) {
+	const luminance = relativeLuminance(bg);
+	if (luminance === null) return "#FFFFFF";
+	return luminance > .179 ? "#000000" : "#FFFFFF";
+}
+function rgbToHsl(r, g, b) {
+	r /= 255;
+	g /= 255;
+	b /= 255;
+	const max = Math.max(r, g, b), min = Math.min(r, g, b);
+	const l = (max + min) / 2;
+	if (max === min) return [
+		0,
+		0,
+		l
+	];
+	const d = max - min;
+	const s = l > .5 ? d / (2 - max - min) : d / (max + min);
+	let h = 0;
+	if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+	else if (max === g) h = ((b - r) / d + 2) / 6;
+	else h = ((r - g) / d + 4) / 6;
+	return [
+		h * 360,
+		s,
+		l
+	];
+}
+function hslToHex(h, s, l) {
+	h = (h % 360 + 360) % 360;
+	const a = s * Math.min(l, 1 - l);
+	const f = (n) => {
+		const k = (n + h / 30) % 12;
+		return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+	};
+	return rgbToHex(f(0) * 255, f(8) * 255, f(4) * 255);
+}
+function hexToHsl(hex) {
+	const rgb = hexToRgb(hex);
+	if (!rgb) return null;
+	return rgbToHsl(rgb[0], rgb[1], rgb[2]);
+}
+/**
+* Desaturate a hex color by reducing saturation.
+* amount=0.4 reduces saturation by 40%.
+* For non-hex inputs, returns the color unchanged.
+*/
+function desaturate(color, amount) {
+	const hsl = hexToHsl(color);
+	if (!hsl) return color;
+	const [h, s, l] = hsl;
+	return hslToHex(h, s * (1 - amount), l);
+}
+/**
+* Get the complementary color (180° hue rotation).
+* For non-hex inputs, returns the color unchanged.
+*/
+function complement(color) {
+	const hsl = hexToHsl(color);
+	if (!hsl) return color;
+	const [h, s, l] = hsl;
+	return hslToHex(h + 180, s, l);
+}
+var init_color = __esmMin((() => {}));
+//#endregion
+//#region packages/color/src/contrast.ts
+/**
+* Check contrast ratio between foreground and background colors.
+*
+* Uses the WCAG 2.1 relative luminance formula to compute the contrast
+* ratio and check AA (>= 4.5:1) and AAA (>= 7:1) compliance for normal text.
+*
+* @param fg - Foreground hex color (e.g. "#FFFFFF")
+* @param bg - Background hex color (e.g. "#000000")
+* @returns Contrast ratio and AA/AAA pass/fail, or null if colors are not valid hex
+*
+* @example
+* ```typescript
+* const result = checkContrast("#FFFFFF", "#000000")
+* // { ratio: 21, aa: true, aaa: true }
+*
+* const poor = checkContrast("#777777", "#888888")
+* // { ratio: ~1.3, aa: false, aaa: false }
+* ```
+*/
+function checkContrast(fg, bg) {
+	const fgLum = relativeLuminance(fg);
+	const bgLum = relativeLuminance(bg);
+	if (fgLum === null || bgLum === null) return null;
+	const lighter = Math.max(fgLum, bgLum);
+	const darker = Math.min(fgLum, bgLum);
+	const ratio = (lighter + .05) / (darker + .05);
+	return {
+		ratio,
+		aa: ratio >= 4.5,
+		aaa: ratio >= 7
+	};
+}
+/**
+* Adjust a color's lightness until it meets a minimum contrast ratio
+* against a reference color. Preserves hue and saturation — only
+* lightness is shifted, and only as much as needed.
+*
+* Returns the original color unchanged if it already meets the target.
+*
+* @param color - The color to adjust (hex)
+* @param against - The reference background color (hex)
+* @param minRatio - Minimum contrast ratio to achieve (e.g. 4.5 for AA)
+* @returns Adjusted hex color meeting the target, or original if already OK
+*
+* For impossible targets (e.g. 21:1 against mid-gray), returns the
+* best achievable color (near-black or near-white in the same hue).
+*
+* @example
+* ```typescript
+* // Yellow on white — too low contrast, gets darkened
+* ensureContrast("#FFAB91", "#FFFFFF", 4.5)  // → "#B35600" (darker orange)
+*
+* // Blue on dark bg — already fine, returned unchanged
+* ensureContrast("#5C9FFF", "#1A1A2E", 4.5)  // → "#5C9FFF"
+* ```
+*/
+function ensureContrast(color, against, minRatio) {
+	const current = checkContrast(color, against);
+	if (!current) return color;
+	if (current.ratio >= minRatio) return color;
+	const hsl = hexToHsl(color);
+	if (!hsl) return color;
+	const [h, s] = hsl;
+	const lightBg = contrastFg(against) === "#000000";
+	let lo, hi;
+	if (lightBg) {
+		lo = 0;
+		hi = hsl[2];
+	} else {
+		lo = hsl[2];
+		hi = 1;
+	}
+	for (let i = 0; i < 20; i++) {
+		const mid = (lo + hi) / 2;
+		const r = checkContrast(hslToHex(h, s, mid), against);
+		if (!r) break;
+		if (lightBg) if (r.ratio >= minRatio) lo = mid;
+		else hi = mid;
+		else if (r.ratio >= minRatio) hi = mid;
+		else lo = mid;
+	}
+	return hslToHex(h, s, lightBg ? lo : hi);
+}
+var init_contrast = __esmMin((() => {
+	init_color();
+}));
+//#endregion
+//#region packages/color/src/index.ts
+var init_src$1 = __esmMin((() => {
+	init_color();
+	init_contrast();
+}));
+//#endregion
+//#region packages/ansi/src/style/colors.ts
+var THEME_TOKEN_DEFAULTS;
+var init_colors = __esmMin((() => {
+	init_src$1();
+	init_color_maps();
+	THEME_TOKEN_DEFAULTS = {
+		primary: 33,
+		secondary: 36,
+		accent: 35,
+		error: 31,
+		warning: 33,
+		success: 32,
+		info: 36,
+		muted: 2,
+		link: 34,
+		border: 90,
+		surface: 37
+	};
+}));
+//#endregion
+//#region packages/ansi/src/style/style.ts
+/**
+* Resolve a color value against a theme — the canonical token resolver.
+*
+* If the color starts with `$`, looks up the token in the theme.
+* Supports `$primary`, `$surface-bg` (hyphens stripped), `$color0`–`$color15` (palette).
+* Non-`$` strings pass through unchanged. Returns undefined if no theme or unknown token.
+*
+* Compatible with @silvery/theme's Theme type (or any object with string properties).
+*/
+function resolveThemeColor(name, theme) {
+	if (!name) return void 0;
+	if (!name.startsWith("$")) return name;
+	if (!theme) return void 0;
+	return resolveToken(name, theme);
+}
+/** Internal: resolve a token name (with or without $ prefix) against a theme. */
+function resolveToken(name, theme) {
+	if (!theme) return void 0;
+	const token = name.startsWith("$") ? name.slice(1) : name;
+	if (token.startsWith("color")) {
+		const idx = parseInt(token.slice(5), 10);
+		if (idx >= 0 && idx < 16 && theme.palette && idx < theme.palette.length) return theme.palette[idx];
+	}
+	const val = theme[token.replace(/-/g, "")];
+	return typeof val === "string" ? val : void 0;
+}
+/** Convert chalk numeric level (0-3) to ColorLevel. */
+function fromChalkLevel(n) {
+	if (n <= 0) return null;
+	if (n === 1) return "basic";
+	if (n === 2) return "256";
+	return "truecolor";
+}
+/** Convert ColorLevel to chalk numeric level (0-3). */
+function toChalkLevel(cl) {
+	if (cl === null) return 0;
+	if (cl === "basic") return 1;
+	if (cl === "256") return 2;
+	return 3;
+}
+/**
+* Create a style object for terminal output.
+*
+* @param options - Color level and optional theme
+* @returns A chainable style object (chalk-compatible API)
+*
+* @example
+* ```ts
+* import { createStyle } from "@silvery/ansi"
+*
+* const s = createStyle()
+* console.log(s.bold.red("Error!"))
+* console.log(s.hex("#818cf8")("Indigo"))
+*
+* // With theme
+* const s = createStyle({ theme })
+* console.log(s.primary("Deploy"))
+* console.log(s.success("Done"))
+* ```
+*/
+function createStyle(options) {
+	const ref = {
+		level: null,
+		theme: options?.theme
+	};
+	if (options?.level !== void 0) ref.level = options.level;
+	else try {
+		ref.level = detectColor(process.stdout);
+	} catch {
+		ref.level = null;
+	}
+	return createChainWithRef({
+		opens: [],
+		closes: []
+	}, ref);
+}
+/**
+* Create a chain that reads level from a mutable ref.
+* This allows `style.level = 3` to affect all subsequent calls.
+*/
+function createChainWithRef(state, ref) {
+	const proxyRef = { proxy: null };
+	const handler = {
+		apply(_target, _thisArg, args) {
+			const level = ref.level;
+			if (state.visible && level === null) return "";
+			let text;
+			if (args.length === 0) text = "";
+			else if (Array.isArray(args[0]) && "raw" in args[0]) text = String.raw(args[0], ...args.slice(1));
+			else if (args.length > 1) text = args.map((a) => String(a ?? "")).join(" ");
+			else text = String(args[0] ?? "");
+			if (text === "") return "";
+			if (level === null || state.opens.length === 0) return text;
+			const open = `${ESC$2}${state.opens.join(";")}m`;
+			const close = `${ESC$2}${state.closes.join(";")}m`;
+			for (const closeCode of state.closes) {
+				const closeSeq = `${ESC$2}${closeCode}m`;
+				const parts = text.split(closeSeq);
+				if (parts.length > 1) text = parts.join(`${closeSeq}${open}`);
+			}
+			if (text.includes("\n")) text = text.replace(/\r?\n/g, `${close}$&${open}`);
+			return `${open}${text}${close}`;
+		},
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			if (prop === "level") return toChalkLevel(ref.level);
+			if (prop === "resolve") return (token) => resolveToken(token, ref.theme);
+			if (prop === "visible") return createChainWithRef({
+				...state,
+				visible: true
+			}, ref);
+			if (prop === "call" || prop === "apply" || prop === "bind") return Function.prototype[prop].bind(proxyRef.proxy);
+			const level = ref.level;
+			if (prop === "hex" || prop === "bgHex") return (color) => {
+				if (level === null) return createChainWithRef(state, ref);
+				const rgb = hexToRgb(color);
+				if (!rgb) return createChainWithRef(state, ref);
+				const code = prop === "hex" ? fgFromRgb(rgb[0], rgb[1], rgb[2], level) : bgFromRgb(rgb[0], rgb[1], rgb[2], level);
+				const close = prop === "hex" ? "39" : "49";
+				return createChainWithRef({
+					opens: [...state.opens, code],
+					closes: [...state.closes, close]
+				}, ref);
+			};
+			if (prop === "rgb" || prop === "bgRgb") return (r, g, b) => {
+				if (level === null) return createChainWithRef(state, ref);
+				const code = prop === "rgb" ? fgFromRgb(r, g, b, level) : bgFromRgb(r, g, b, level);
+				const close = prop === "rgb" ? "39" : "49";
+				return createChainWithRef({
+					opens: [...state.opens, code],
+					closes: [...state.closes, close]
+				}, ref);
+			};
+			if (prop === "ansi256") return (code) => {
+				if (level === null) return createChainWithRef(state, ref);
+				return createChainWithRef({
+					opens: [...state.opens, `38;5;${code}`],
+					closes: [...state.closes, "39"]
+				}, ref);
+			};
+			if (prop === "bgAnsi256") return (code) => {
+				if (level === null) return createChainWithRef(state, ref);
+				return createChainWithRef({
+					opens: [...state.opens, `48;5;${code}`],
+					closes: [...state.closes, "49"]
+				}, ref);
+			};
+			if (prop in MODIFIERS) {
+				if (level === null) return createChainWithRef(state, ref);
+				const [open, close] = MODIFIERS[prop];
+				return createChainWithRef({
+					opens: [...state.opens, String(open)],
+					closes: [...state.closes, String(close)]
+				}, ref);
+			}
+			if (prop in FG_COLORS) {
+				if (level === null) return createChainWithRef(state, ref);
+				return createChainWithRef({
+					opens: [...state.opens, String(FG_COLORS[prop])],
+					closes: [...state.closes, "39"]
+				}, ref);
+			}
+			if (prop in BG_COLORS) {
+				if (level === null) return createChainWithRef(state, ref);
+				return createChainWithRef({
+					opens: [...state.opens, String(BG_COLORS[prop])],
+					closes: [...state.closes, "49"]
+				}, ref);
+			}
+			if (THEME_TOKENS.has(prop)) {
+				if (level === null) return createChainWithRef(state, ref);
+				const hex = resolveToken(prop, ref.theme);
+				if (hex) {
+					const rgb = hexToRgb(hex);
+					if (rgb) {
+						const code = fgFromRgb(rgb[0], rgb[1], rgb[2], level);
+						if (prop === "link") return createChainWithRef({
+							opens: [
+								...state.opens,
+								code,
+								"4"
+							],
+							closes: [
+								...state.closes,
+								"39",
+								"24"
+							]
+						}, ref);
+						return createChainWithRef({
+							opens: [...state.opens, code],
+							closes: [...state.closes, "39"]
+						}, ref);
+					}
+				}
+				const fallback = THEME_TOKEN_DEFAULTS[prop];
+				if (fallback !== void 0) {
+					if (prop === "muted") return createChainWithRef({
+						opens: [...state.opens, String(fallback)],
+						closes: [...state.closes, "22"]
+					}, ref);
+					if (prop === "link") return createChainWithRef({
+						opens: [
+							...state.opens,
+							String(fallback),
+							"4"
+						],
+						closes: [
+							...state.closes,
+							"39",
+							"24"
+						]
+					}, ref);
+					return createChainWithRef({
+						opens: [...state.opens, String(fallback)],
+						closes: [...state.closes, "39"]
+					}, ref);
+				}
+			}
+		},
+		set(_target, prop, value) {
+			if (prop === "level") {
+				ref.level = fromChalkLevel(value);
+				return true;
+			}
+			return false;
+		},
+		has(_target, prop) {
+			if (prop === "level") return true;
+			if (typeof prop === "symbol") return false;
+			return prop in MODIFIERS || prop in FG_COLORS || prop in BG_COLORS || THEME_TOKENS.has(prop) || KNOWN_METHODS.has(prop);
+		}
+	};
+	const target = function() {};
+	const proxy = new Proxy(target, handler);
+	proxyRef.proxy = proxy;
+	return proxy;
+}
+var ESC$2, KNOWN_METHODS, THEME_TOKENS;
+var init_style = __esmMin((() => {
+	init_detection();
+	init_colors();
+	ESC$2 = "\x1B[";
+	KNOWN_METHODS = new Set([
+		"hex",
+		"rgb",
+		"bgHex",
+		"bgRgb",
+		"ansi256",
+		"bgAnsi256",
+		"resolve"
+	]);
+	THEME_TOKENS = new Set([
+		"primary",
+		"secondary",
+		"accent",
+		"error",
+		"warning",
+		"success",
+		"info",
+		"muted",
+		"link",
+		"border",
+		"surface"
+	]);
+	createStyle();
+}));
+//#endregion
+//#region packages/ansi/src/style/mixed-proxy.ts
+/**
+* Create a proxy that wraps a style instance with additional properties.
+*
+* The proxy makes the result:
+* - Callable: result('text') applies current styles
+* - Chainable: result.bold.red('text') chains styles
+* - Extended: result.anyExtraProp accesses extra properties
+*
+* Extra properties take priority over style properties on name collision.
+*/
+function createMixedStyle(style, extra) {
+	return createChainProxy(style, extra);
+}
+/**
+* Internal recursive proxy builder for style chain + extra properties.
+*/
+function createChainProxy(currentStyle, extra) {
+	const handler = {
+		apply(_target, _thisArg, args) {
+			return currentStyle(...args);
+		},
+		get(_target, prop) {
+			if (prop in extra) {
+				const value = extra[prop];
+				if (typeof value === "function") return value;
+				return value;
+			}
+			if (typeof prop === "symbol") {
+				if (prop === Symbol.dispose) return extra[Symbol.dispose];
+				return;
+			}
+			if (STYLE_METHODS.has(prop)) {
+				const method = currentStyle[prop];
+				if (typeof method === "function") return (...args) => {
+					return createChainProxy(method.apply(currentStyle, args), extra);
+				};
+			}
+			const styleProp = currentStyle[prop];
+			if (styleProp !== void 0) {
+				if (typeof styleProp === "function" || typeof styleProp === "object") return createChainProxy(styleProp, extra);
+				return styleProp;
+			}
+		},
+		set(_target, prop, value) {
+			extra[prop] = value;
+			return true;
+		},
+		defineProperty(_target, prop, descriptor) {
+			Object.defineProperty(extra, prop, descriptor);
+			return true;
+		},
+		has(_target, prop) {
+			if (prop in extra) return true;
+			if (typeof prop === "string" && prop in currentStyle) return true;
+			return false;
+		}
+	};
+	const proxyTarget = function() {};
+	return new Proxy(proxyTarget, handler);
+}
+var STYLE_METHODS;
+var init_mixed_proxy = __esmMin((() => {
+	STYLE_METHODS = new Set([
+		"hex",
+		"bgHex",
+		"rgb",
+		"bgRgb",
+		"ansi256",
+		"bgAnsi256"
+	]);
+}));
+//#endregion
+//#region packages/ansi/src/theme/derive.ts
+function deriveTheme(palette, mode = "truecolor", adjustments) {
+	if (mode === "ansi16") return deriveAnsi16Theme(palette);
+	return deriveTruecolorTheme(palette, adjustments);
+}
+function deriveTruecolorTheme(p, adjustments) {
+	const dark = p.dark ?? true;
+	const bg = p.background;
+	function ensure(token, color, against, target) {
+		const result = ensureContrast(color, against, target);
+		if (adjustments && result !== color) {
+			const before = checkContrast(color, against);
+			const after = checkContrast(result, against);
+			adjustments.push({
+				token,
+				from: color,
+				to: result,
+				against,
+				target,
+				ratioBefore: before?.ratio ?? 0,
+				ratioAfter: after?.ratio ?? 0
+			});
+		}
+		return result;
+	}
+	const surfacebg = blend(bg, p.foreground, .05);
+	const popoverbg = blend(bg, p.foreground, .08);
+	const fg = ensure("fg", p.foreground, popoverbg, AA);
+	const primary = ensure("primary", p.primary ?? (dark ? p.yellow : p.blue), bg, AA);
+	const accent = ensure("accent", complement(primary), bg, AA);
+	const secondary = ensure("secondary", blend(primary, accent, .35), bg, AA);
+	const error = ensure("error", p.red, bg, AA);
+	const warning = ensure("warning", p.yellow, bg, AA);
+	const success = ensure("success", p.green, bg, AA);
+	const info = ensure("info", blend(fg, accent, .5), bg, AA);
+	const link = ensure("link", dark ? p.brightBlue : p.blue, bg, AA);
+	const mutedbg = blend(bg, p.foreground, .04);
+	const muted = ensure("muted", blend(fg, bg, .4), mutedbg, AA);
+	const disabledfg = ensure("disabledfg", blend(fg, bg, .5), bg, DIM);
+	const border = ensure("border", blend(bg, p.foreground, .15), bg, FAINT);
+	const inputborder = ensure("inputborder", blend(bg, p.foreground, .25), bg, CONTROL);
+	const selection = ensure("selection", p.selectionForeground, p.selectionBackground, AA);
+	const cursor = ensure("cursor", p.cursorText, p.cursorColor, AA);
+	return {
+		name: p.name ?? (dark ? "derived-dark" : "derived-light"),
+		bg,
+		fg,
+		muted,
+		mutedbg,
+		surface: fg,
+		surfacebg,
+		popover: fg,
+		popoverbg,
+		inverse: contrastFg(blend(fg, bg, .1)),
+		inversebg: blend(fg, bg, .1),
+		cursor,
+		cursorbg: p.cursorColor,
+		selection,
+		selectionbg: p.selectionBackground,
+		primary,
+		primaryfg: contrastFg(primary),
+		secondary,
+		secondaryfg: contrastFg(secondary),
+		accent,
+		accentfg: contrastFg(accent),
+		error,
+		errorfg: contrastFg(error),
+		warning,
+		warningfg: contrastFg(warning),
+		success,
+		successfg: contrastFg(success),
+		info,
+		infofg: contrastFg(info),
+		border,
+		inputborder,
+		focusborder: link,
+		link,
+		disabledfg,
+		palette: [
+			p.black,
+			p.red,
+			p.green,
+			p.yellow,
+			p.blue,
+			p.magenta,
+			p.cyan,
+			p.white,
+			p.brightBlack,
+			p.brightRed,
+			p.brightGreen,
+			p.brightYellow,
+			p.brightBlue,
+			p.brightMagenta,
+			p.brightCyan,
+			p.brightWhite
+		]
+	};
+}
+function deriveAnsi16Theme(p) {
+	const dark = p.dark ?? true;
+	const primaryColor = dark ? p.yellow : p.blue;
+	return {
+		name: p.name ?? (dark ? "derived-ansi16-dark" : "derived-ansi16-light"),
+		bg: p.background,
+		fg: p.foreground,
+		muted: p.white,
+		mutedbg: p.black,
+		surface: p.foreground,
+		surfacebg: p.black,
+		popover: p.foreground,
+		popoverbg: p.black,
+		inverse: p.black,
+		inversebg: p.brightWhite,
+		cursor: p.cursorText,
+		cursorbg: p.cursorColor,
+		selection: p.selectionForeground,
+		selectionbg: p.selectionBackground,
+		primary: primaryColor,
+		primaryfg: p.black,
+		secondary: p.magenta,
+		secondaryfg: p.black,
+		accent: p.cyan,
+		accentfg: p.black,
+		error: dark ? p.brightRed : p.red,
+		errorfg: p.black,
+		warning: p.yellow,
+		warningfg: p.black,
+		success: dark ? p.brightGreen : p.green,
+		successfg: p.black,
+		info: p.cyan,
+		infofg: p.black,
+		border: p.brightBlack,
+		inputborder: p.brightBlack,
+		focusborder: dark ? p.brightBlue : p.blue,
+		link: dark ? p.brightBlue : p.blue,
+		disabledfg: p.brightBlack,
+		palette: [
+			p.black,
+			p.red,
+			p.green,
+			p.yellow,
+			p.blue,
+			p.magenta,
+			p.cyan,
+			p.white,
+			p.brightBlack,
+			p.brightRed,
+			p.brightGreen,
+			p.brightYellow,
+			p.brightBlue,
+			p.brightMagenta,
+			p.brightCyan,
+			p.brightWhite
+		]
+	};
+}
+var AA, DIM, FAINT, CONTROL;
+var init_derive = __esmMin((() => {
+	init_src$1();
+	AA = 4.5;
+	DIM = 3;
+	FAINT = 1.5;
+	CONTROL = 3;
+}));
+//#endregion
+//#region packages/ansi/src/theme/default-palettes.ts
+var ansi16DarkTheme, ansi16LightTheme;
+var init_default_palettes = __esmMin((() => {
+	ansi16DarkTheme = {
+		name: "dark-ansi16",
+		bg: "",
+		fg: "whiteBright",
+		muted: "white",
+		mutedbg: "black",
+		surface: "whiteBright",
+		surfacebg: "black",
+		popover: "whiteBright",
+		popoverbg: "black",
+		inverse: "black",
+		inversebg: "whiteBright",
+		cursor: "black",
+		cursorbg: "yellow",
+		selection: "black",
+		selectionbg: "yellow",
+		primary: "yellow",
+		primaryfg: "black",
+		secondary: "white",
+		secondaryfg: "black",
+		accent: "blueBright",
+		accentfg: "black",
+		error: "redBright",
+		errorfg: "black",
+		warning: "yellow",
+		warningfg: "black",
+		success: "greenBright",
+		successfg: "black",
+		info: "cyan",
+		infofg: "black",
+		border: "gray",
+		inputborder: "gray",
+		focusborder: "blueBright",
+		link: "blueBright",
+		disabledfg: "gray",
+		palette: [
+			"black",
+			"red",
+			"green",
+			"yellow",
+			"blue",
+			"magenta",
+			"cyan",
+			"white",
+			"blackBright",
+			"redBright",
+			"greenBright",
+			"yellowBright",
+			"blueBright",
+			"magentaBright",
+			"cyanBright",
+			"whiteBright"
+		]
+	};
+	ansi16LightTheme = {
+		name: "light-ansi16",
+		bg: "",
+		fg: "black",
+		muted: "blackBright",
+		mutedbg: "white",
+		surface: "black",
+		surfacebg: "white",
+		popover: "black",
+		popoverbg: "white",
+		inverse: "whiteBright",
+		inversebg: "black",
+		cursor: "black",
+		cursorbg: "blue",
+		selection: "black",
+		selectionbg: "cyan",
+		primary: "blue",
+		primaryfg: "black",
+		secondary: "blue",
+		secondaryfg: "black",
+		accent: "cyan",
+		accentfg: "black",
+		error: "red",
+		errorfg: "black",
+		warning: "yellow",
+		warningfg: "black",
+		success: "green",
+		successfg: "black",
+		info: "cyan",
+		infofg: "black",
+		border: "gray",
+		inputborder: "gray",
+		focusborder: "blue",
+		link: "blueBright",
+		disabledfg: "gray",
+		palette: [
+			"black",
+			"red",
+			"green",
+			"yellow",
+			"blue",
+			"magenta",
+			"cyan",
+			"white",
+			"blackBright",
+			"redBright",
+			"greenBright",
+			"yellowBright",
+			"blueBright",
+			"magentaBright",
+			"cyanBright",
+			"whiteBright"
+		]
+	};
+}));
+//#endregion
+//#region packages/ansi/src/theme/types.ts
+var COLOR_PALETTE_FIELDS;
+var init_types = __esmMin((() => {
+	COLOR_PALETTE_FIELDS = [
+		"black",
+		"red",
+		"green",
+		"yellow",
+		"blue",
+		"magenta",
+		"cyan",
+		"white",
+		"brightBlack",
+		"brightRed",
+		"brightGreen",
+		"brightYellow",
+		"brightBlue",
+		"brightMagenta",
+		"brightCyan",
+		"brightWhite",
+		"foreground",
+		"background",
+		"cursorColor",
+		"cursorText",
+		"selectionBackground",
+		"selectionForeground"
+	];
+}));
+//#endregion
+//#region packages/ansi/src/osc-palette.ts
+function queryPaletteColor(index, write) {
+	if (index < 0 || index > 255) throw new RangeError(`Palette index must be 0-255, got ${index}`);
+	write(`${ESC$1}]4;${index};?${BEL$1}`);
+}
+function queryMultiplePaletteColors(indices, write) {
+	for (const index of indices) queryPaletteColor(index, write);
+}
+function setPaletteColor(index, color, write) {
+	if (index < 0 || index > 255) throw new RangeError(`Palette index must be 0-255, got ${index}`);
+	write(`${ESC$1}]4;${index};${color}${BEL$1}`);
+}
+function parsePaletteResponse(input) {
+	const prefixIdx = input.indexOf(OSC4_PREFIX);
+	if (prefixIdx === -1) return null;
+	const bodyStart = prefixIdx + OSC4_PREFIX.length;
+	let bodyEnd = input.indexOf(BEL$1, bodyStart);
+	if (bodyEnd === -1) bodyEnd = input.indexOf(`${ESC$1}\\`, bodyStart);
+	if (bodyEnd === -1) return null;
+	const body = input.slice(bodyStart, bodyEnd);
+	const match = OSC4_BODY_RE.exec(body);
+	if (!match) return null;
+	const index = Number.parseInt(match[1], 10);
+	if (index < 0 || index > 255) return null;
+	return {
+		index,
+		color: `#${normalizeHexChannel$1(match[2])}${normalizeHexChannel$1(match[3])}${normalizeHexChannel$1(match[4])}`
+	};
+}
+function normalizeHexChannel$1(hex) {
+	switch (hex.length) {
+		case 1: return hex + hex;
+		case 2: return hex;
+		default: return hex.slice(0, 2);
+	}
+}
+var ESC$1, BEL$1, OSC4_PREFIX, OSC4_BODY_RE;
+var init_osc_palette = __esmMin((() => {
+	ESC$1 = "\x1B";
+	BEL$1 = "\x07";
+	OSC4_PREFIX = `${ESC$1}]4;`;
+	OSC4_BODY_RE = /^(\d+);rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})$/;
+}));
+//#endregion
+//#region packages/ansi/src/osc-colors.ts
+function normalizeHexChannel(hex) {
+	switch (hex.length) {
+		case 1: return hex + hex;
+		case 2: return hex;
+		default: return hex.slice(0, 2);
+	}
+}
+function parseOscColorResponse(input, oscCode) {
+	const prefix = `${ESC}]${oscCode};`;
+	const prefixIdx = input.indexOf(prefix);
+	if (prefixIdx === -1) return null;
+	const bodyStart = prefixIdx + prefix.length;
+	let bodyEnd = input.indexOf(BEL, bodyStart);
+	if (bodyEnd === -1) bodyEnd = input.indexOf(`${ESC}\\`, bodyStart);
+	if (bodyEnd === -1) return null;
+	const body = input.slice(bodyStart, bodyEnd);
+	const match = RGB_BODY_RE.exec(body);
+	if (!match) return null;
+	return `#${normalizeHexChannel(match[1])}${normalizeHexChannel(match[2])}${normalizeHexChannel(match[3])}`;
+}
+async function queryOscColor(write, read, oscCode, timeoutMs) {
+	write(`${ESC}]${oscCode};?${BEL}`);
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	return parseOscColorResponse(data, oscCode);
+}
+async function queryForegroundColor(write, read, timeoutMs = 200) {
+	return queryOscColor(write, read, 10, timeoutMs);
+}
+async function queryBackgroundColor(write, read, timeoutMs = 200) {
+	return queryOscColor(write, read, 11, timeoutMs);
+}
+async function queryCursorColor(write, read, timeoutMs = 200) {
+	return queryOscColor(write, read, 12, timeoutMs);
+}
+function setForegroundColor(write, color) {
+	write(`${ESC}]10;${color}${BEL}`);
+}
+function setBackgroundColor(write, color) {
+	write(`${ESC}]11;${color}${BEL}`);
+}
+function setCursorColor(write, color) {
+	write(`${ESC}]12;${color}${BEL}`);
+}
+function resetForegroundColor(write) {
+	write(`${ESC}]110${BEL}`);
+}
+function resetBackgroundColor(write) {
+	write(`${ESC}]111${BEL}`);
+}
+function resetCursorColor(write) {
+	write(`${ESC}]112${BEL}`);
+}
+async function detectColorScheme(write, read, timeoutMs = 200) {
+	const bg = await queryBackgroundColor(write, read, timeoutMs);
+	if (bg == null) return null;
+	const r = parseInt(bg.slice(1, 3), 16) / 255;
+	const g = parseInt(bg.slice(3, 5), 16) / 255;
+	const b = parseInt(bg.slice(5, 7), 16) / 255;
+	return .2126 * r + .7152 * g + .0722 * b > .5 ? "light" : "dark";
+}
+var ESC, BEL, RGB_BODY_RE;
+var init_osc_colors = __esmMin((() => {
+	ESC = "\x1B";
+	BEL = "\x07";
+	RGB_BODY_RE = /rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})/;
+}));
+//#endregion
+//#region packages/ansi/src/theme/detect.ts
+async function detectTerminalPalette(timeoutMs = 150) {
+	const stdin = process.stdin;
+	const stdout = process.stdout;
+	if (!stdin.isTTY || !stdout.isTTY) return null;
+	const wasRaw = stdin.isRaw;
+	if (!wasRaw) stdin.setRawMode(true);
+	let buffer = "";
+	const onData = (chunk) => {
+		buffer += chunk.toString();
+	};
+	stdin.on("data", onData);
+	try {
+		const write = (s) => {
+			stdout.write(s);
+		};
+		const read = (ms) => new Promise((resolve) => {
+			if (buffer.length > 0) {
+				const result = buffer;
+				buffer = "";
+				resolve(result);
+				return;
+			}
+			const timer = setTimeout(() => {
+				resolve(buffer.length > 0 ? buffer : null);
+				buffer = "";
+			}, ms);
+			const check = (_chunk) => {
+				clearTimeout(timer);
+				stdin.removeListener("data", check);
+				const result = buffer;
+				buffer = "";
+				resolve(result);
+			};
+			stdin.on("data", check);
+		});
+		const bg = await queryBackgroundColor(write, read, timeoutMs);
+		const fg = await queryForegroundColor(write, read, timeoutMs);
+		const ansi = new Array(16).fill(null);
+		queryMultiplePaletteColors(Array.from({ length: 16 }, (_, i) => i), write);
+		await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+		const remaining = buffer;
+		buffer = "";
+		if (remaining) {
+			const oscPrefix = "\x1B]4;";
+			let pos = 0;
+			while (pos < remaining.length) {
+				const nextOsc = remaining.indexOf(oscPrefix, pos);
+				if (nextOsc === -1) break;
+				let end = remaining.indexOf("\x07", nextOsc);
+				if (end === -1) end = remaining.indexOf("\x1B\\", nextOsc);
+				if (end === -1) break;
+				const parsed = parsePaletteResponse(remaining.slice(nextOsc, end + 1));
+				if (parsed && parsed.index >= 0 && parsed.index < 16) ansi[parsed.index] = parsed.color;
+				pos = end + 1;
+			}
+		}
+		const dark = bg ? isDarkColor(bg) : true;
+		const palette = { dark };
+		if (bg) palette.background = bg;
+		if (fg) palette.foreground = fg;
+		const ansiFields = [
+			"black",
+			"red",
+			"green",
+			"yellow",
+			"blue",
+			"magenta",
+			"cyan",
+			"white",
+			"brightBlack",
+			"brightRed",
+			"brightGreen",
+			"brightYellow",
+			"brightBlue",
+			"brightMagenta",
+			"brightCyan",
+			"brightWhite"
+		];
+		for (let i = 0; i < 16; i++) if (ansi[i]) palette[ansiFields[i]] = ansi[i];
+		if (fg) {
+			palette.cursorColor = fg;
+			palette.selectionForeground = fg;
+		}
+		if (bg) palette.cursorText = bg;
+		if (ansi[4]) palette.selectionBackground = ansi[4];
+		return {
+			fg,
+			bg,
+			ansi,
+			dark,
+			palette
+		};
+	} finally {
+		stdin.removeListener("data", onData);
+		if (!wasRaw) stdin.setRawMode(false);
+	}
+}
+function isDarkColor(hex) {
+	const r = parseInt(hex.slice(1, 3), 16) / 255;
+	const g = parseInt(hex.slice(3, 5), 16) / 255;
+	const b = parseInt(hex.slice(5, 7), 16) / 255;
+	return .2126 * r + .7152 * g + .0722 * b <= .5;
+}
+var init_detect = __esmMin((() => {
+	init_osc_palette();
+	init_osc_colors();
+})), CSI;
+var init_color_scheme = __esmMin((() => {
+	CSI = `[`;
+	`${CSI}`;
+	`${CSI}`;
+}));
+//#endregion
+//#region packages/ansi/src/index.ts
+var init_src = __esmMin((() => {
+	init_detection();
+	init_sgr_codes();
+	init_utils();
+	init_terminal_control();
+	init_style();
+	init_mixed_proxy();
+	init_derive();
+	init_default_palettes();
+	init_types();
+	init_detect();
+	init_osc_palette();
+	init_color_scheme();
+}));
+//#endregion
+export { contrastFg as A, enableKittyKeyboard as B, resolveThemeColor as C, blend as D, ensureContrast as E, hslToHex as F, detectColor as G, bgColorCode as H, rgbToHex as I, detectTerminalCaps as J, detectCursor as K, rgbToHsl as L, desaturate as M, hexToHsl as N, brighten as O, hexToRgb as P, disableKittyKeyboard as R, createStyle as S, checkContrast as T, fgColorCode as U, enableMouse as V, defaultCaps as W, detectUnicode as Y, COLOR_PALETTE_FIELDS as _, queryCursorColor as a, deriveTheme as b, resetCursorColor as c, setCursorColor as d, setForegroundColor as f, setPaletteColor as g, queryPaletteColor as h, queryBackgroundColor as i, darken as j, complement as k, resetForegroundColor as l, queryMultiplePaletteColors as m, detectTerminalPalette as n, queryForegroundColor as o, parsePaletteResponse as p, detectInput as q, detectColorScheme as r, resetBackgroundColor as s, init_src as t, setBackgroundColor as u, ansi16DarkTheme as v, init_src$1 as w, createMixedStyle as x, ansi16LightTheme as y, disableMouse as z };
+
+//# sourceMappingURL=src-9B5k0JmY.mjs.map