@visual-z/xeno 0.1.3 → 0.2.0

package/src/vendor/pi-tui/native/win32/src/win32-platform.c

@@ -0,0 +1,241 @@
+#define PI_CLIPBOARD_WRITE
+#include "../../clipboard.h"
+
+#ifndef BI_ALPHABITFIELDS
+#define BI_ALPHABITFIELDS 6
+#endif
+
+#define KEY_PRESSED_MASK 0x8000
+#define OPEN_CLIPBOARD_ATTEMPTS 10
+#define OPEN_CLIPBOARD_RETRY_MS 5
+#define BITMAP_FILE_HEADER_SIZE 14
+
+static int string_equals(const char* left, const char* right) {
+    while (*left && *right && *left == *right) {
+        left++;
+        right++;
+    }
+    return *left == 0 && *right == 0;
+}
+
+static int is_key_pressed(int virtual_key) {
+    return ((unsigned short)GetAsyncKeyState(virtual_key) & KEY_PRESSED_MASK) != 0;
+}
+
+static int is_modifier_name_pressed(const char* name) {
+    if (string_equals(name, "shift")) return is_key_pressed(VK_SHIFT) || is_key_pressed(VK_LSHIFT) || is_key_pressed(VK_RSHIFT);
+    if (string_equals(name, "control")) return is_key_pressed(VK_CONTROL) || is_key_pressed(VK_LCONTROL) || is_key_pressed(VK_RCONTROL);
+    if (string_equals(name, "option") || string_equals(name, "alt")) return is_key_pressed(VK_MENU) || is_key_pressed(VK_LMENU) || is_key_pressed(VK_RMENU);
+    if (string_equals(name, "command") || string_equals(name, "super") || string_equals(name, "win")) return is_key_pressed(VK_LWIN) || is_key_pressed(VK_RWIN);
+    return 0;
+}
+
+static napi_value __cdecl enable_virtual_terminal_input(napi_env env, napi_callback_info info) {
+    (void)info;
+
+    HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
+    DWORD mode = 0;
+    bool enabled = handle != INVALID_HANDLE_VALUE &&
+        GetConsoleMode(handle, &mode) &&
+        SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_INPUT);
+
+    napi_get_boolean_fn napi_get_boolean = (napi_get_boolean_fn)node_symbol("napi_get_boolean");
+    napi_value result = 0;
+    if (!napi_get_boolean || napi_get_boolean(env, enabled, &result) != 0) {
+        return fail(env, "Could not configure console input");
+    }
+    return result;
+}
+
+static napi_value __cdecl is_modifier_pressed(napi_env env, napi_callback_info info) {
+    napi_get_cb_info_fn napi_get_cb_info = (napi_get_cb_info_fn)node_symbol("napi_get_cb_info");
+    napi_get_value_string_utf8_fn napi_get_value_string_utf8 =
+        (napi_get_value_string_utf8_fn)node_symbol("napi_get_value_string_utf8");
+    napi_get_boolean_fn napi_get_boolean = (napi_get_boolean_fn)node_symbol("napi_get_boolean");
+
+    bool pressed = false;
+    if (napi_get_cb_info && napi_get_value_string_utf8) {
+        size_t argc = 1;
+        napi_value args[1] = {0};
+        if (napi_get_cb_info(env, info, &argc, args, 0, 0) == 0 && argc >= 1 && args[0]) {
+            char name[16] = {0};
+            size_t copied = 0;
+            if (napi_get_value_string_utf8(env, args[0], name, sizeof(name), &copied) == 0) {
+                pressed = is_modifier_name_pressed(name);
+            }
+        }
+    }
+
+    napi_value result = 0;
+    if (!napi_get_boolean || napi_get_boolean(env, pressed, &result) != 0) {
+        return fail(env, "Could not inspect modifier state");
+    }
+    return result;
+}
+
+static bool open_clipboard(HWND owner) {
+    for (int attempt = 0; attempt < OPEN_CLIPBOARD_ATTEMPTS; attempt++) {
+        if (OpenClipboard(owner)) return true;
+        Sleep(OPEN_CLIPBOARD_RETRY_MS);
+    }
+    return false;
+}
+
+static uint16_t read_u16(const uint8_t* data) {
+    return (uint16_t)data[0] | ((uint16_t)data[1] << 8);
+}
+
+static uint32_t read_u32(const uint8_t* data) {
+    return (uint32_t)data[0] |
+        ((uint32_t)data[1] << 8) |
+        ((uint32_t)data[2] << 16) |
+        ((uint32_t)data[3] << 24);
+}
+
+static void write_u32(uint8_t* data, uint32_t value) {
+    data[0] = (uint8_t)value;
+    data[1] = (uint8_t)(value >> 8);
+    data[2] = (uint8_t)(value >> 16);
+    data[3] = (uint8_t)(value >> 24);
+}
+
+static void copy_bytes(uint8_t* destination, const uint8_t* source, size_t length) {
+    volatile uint8_t* target = destination;
+    const volatile uint8_t* input = source;
+    for (size_t index = 0; index < length; index++) target[index] = input[index];
+}
+
+static size_t dib_pixel_offset(const uint8_t* dib, size_t size) {
+    if (size < 12) return 0;
+    uint32_t header_size = read_u32(dib);
+
+    if (header_size == 12) {
+        uint16_t bits_per_pixel = read_u16(dib + 10);
+        uint32_t color_count = bits_per_pixel <= 8 ? 1u << bits_per_pixel : 0;
+        size_t offset = header_size + (size_t)color_count * 3;
+        return offset <= size ? offset : 0;
+    }
+
+    if (header_size < 40 || header_size > size) return 0;
+    uint16_t bits_per_pixel = read_u16(dib + 14);
+    uint32_t compression = read_u32(dib + 16);
+    uint32_t color_count = read_u32(dib + 32);
+    if (!color_count && bits_per_pixel <= 8) color_count = 1u << bits_per_pixel;
+
+    size_t offset = header_size + (size_t)color_count * 4;
+    if (header_size == 40 && compression == BI_BITFIELDS) offset += 3 * sizeof(uint32_t);
+    if (header_size == 40 && compression == BI_ALPHABITFIELDS) offset += 4 * sizeof(uint32_t);
+    return offset <= size ? offset : 0;
+}
+
+static void read_clipboard_image(clipboard_job* job) {
+    UINT png_format = RegisterClipboardFormatW(L"PNG");
+    if (!(png_format && IsClipboardFormatAvailable(png_format)) &&
+        !IsClipboardFormatAvailable(CF_DIBV5) && !IsClipboardFormatAvailable(CF_DIB)) {
+        job->format = CLIPBOARD_EMPTY;
+        return;
+    }
+    HGLOBAL handle = png_format && IsClipboardFormatAvailable(png_format)
+        ? (HGLOBAL)GetClipboardData(png_format) : 0;
+    bool is_png = handle != 0;
+    if (!handle && IsClipboardFormatAvailable(CF_DIBV5)) handle = (HGLOBAL)GetClipboardData(CF_DIBV5);
+    if (!handle && IsClipboardFormatAvailable(CF_DIB)) handle = (HGLOBAL)GetClipboardData(CF_DIB);
+
+    const uint8_t* source = handle ? (const uint8_t*)GlobalLock(handle) : 0;
+    size_t size = handle ? GlobalSize(handle) : 0;
+    if (!source || !size) {
+        if (source) GlobalUnlock(handle);
+        job->error = "Clipboard does not contain an image";
+        return;
+    }
+    if (is_png) {
+        clipboard_copy(job, source, size, CLIPBOARD_BUFFER);
+    } else {
+        size_t offset = dib_pixel_offset(source, size);
+        uint8_t* bitmap = offset && size <= UINT32_MAX - BITMAP_FILE_HEADER_SIZE
+            ? clipboard_alloc(size + BITMAP_FILE_HEADER_SIZE) : 0;
+        if (bitmap) {
+            bitmap[0] = 'B';
+            bitmap[1] = 'M';
+            write_u32(bitmap + 2, (uint32_t)(size + BITMAP_FILE_HEADER_SIZE));
+            write_u32(bitmap + 10, (uint32_t)(BITMAP_FILE_HEADER_SIZE + offset));
+            copy_bytes(bitmap + BITMAP_FILE_HEADER_SIZE, source, size);
+            job->data = bitmap;
+            job->length = size + BITMAP_FILE_HEADER_SIZE;
+            job->format = CLIPBOARD_BUFFER;
+        } else {
+            job->error = "Could not create clipboard image buffer";
+        }
+    }
+    GlobalUnlock(handle);
+}
+
+static void clipboard_execute(clipboard_job* job) {
+    // A real clipboard owner is required for text writes, including under Node
+    // without a console. Create and destroy it on the same worker thread.
+    HWND owner = 0;
+    if (job->operation == CLIPBOARD_WRITE) {
+        owner = CreateWindowExW(0, L"STATIC", 0, 0, 0, 0, 0, 0,
+            HWND_MESSAGE, 0, GetModuleHandleA(0), 0);
+        if (!owner) {
+            job->error = "Could not create clipboard owner window";
+            return;
+        }
+    }
+    if (!open_clipboard(owner)) {
+        if (owner) DestroyWindow(owner);
+        job->error = "Could not open clipboard";
+        return;
+    }
+    if (job->operation == CLIPBOARD_WRITE) {
+        size_t size = (job->length + 1) * sizeof(uint16_t);
+        HGLOBAL handle = GlobalAlloc(GMEM_MOVEABLE, size);
+        void* text = handle ? GlobalLock(handle) : 0;
+        bool success = false;
+        if (text) {
+            copy_bytes(text, job->data, size);
+            GlobalUnlock(handle);
+            success = EmptyClipboard() && SetClipboardData(CF_UNICODETEXT, handle) != 0;
+        }
+        if (!success) {
+            if (handle) GlobalFree(handle);
+            job->error = "Could not set clipboard text";
+        }
+    } else if (job->operation == CLIPBOARD_TEXT) {
+        if (!IsClipboardFormatAvailable(CF_UNICODETEXT)) {
+            job->format = CLIPBOARD_EMPTY;
+        } else {
+            HGLOBAL handle = (HGLOBAL)GetClipboardData(CF_UNICODETEXT);
+            const uint16_t* text = handle ? GlobalLock(handle) : 0;
+            if (text) {
+                size_t capacity = GlobalSize(handle) / sizeof(uint16_t);
+                size_t length = 0;
+                while (length < capacity && text[length]) length++;
+                clipboard_copy(job, text, length * sizeof(uint16_t), CLIPBOARD_UTF16);
+                GlobalUnlock(handle);
+            } else {
+                job->error = "Clipboard does not contain text";
+            }
+        }
+    } else {
+        read_clipboard_image(job);
+    }
+    CloseClipboard();
+    if (owner) DestroyWindow(owner);
+}
+
+BOOL WINAPI _DllMainCRTStartup(HINSTANCE instance, DWORD reason, LPVOID reserved) {
+    (void)instance;
+    (void)reason;
+    (void)reserved;
+    return TRUE;
+}
+
+PI_NAPI_EXPORT napi_value PI_NAPI_CALL napi_register_module_v1(napi_env env, napi_value exports) {
+    set_function_export(env, exports, "enableVirtualTerminalInput", enable_virtual_terminal_input);
+    set_function_export(env, exports, "isModifierPressed", is_modifier_pressed);
+    set_function_export(env, exports, "getText", get_clipboard_text);
+    set_function_export(env, exports, "setText", set_clipboard_text);
+    set_function_export(env, exports, "getImage", get_clipboard_image);
+    return exports;
+}

package/src/vendor/pi-tui/native-platform.ts

@@ -11,6 +11,8 @@ export interface NativeClipboard {
 	getText(): Promise<string | null | undefined>;
 	/** Undefined means unavailable, null means no image; transfer failures reject. */
 	getImage(): Promise<Uint8Array | null | undefined>;
+	/** POSIX paths of file URLs on the clipboard. Undefined means unsupported, null means no files. */
+	getFilePaths?(): Promise<string[] | null | undefined>;
 	/** Linux uses command-line tools to retain clipboard ownership instead. */
 	setText?(text: string): Promise<void>;
 }

package/src/vendor/pi-tui/oklab.ts

@@ -0,0 +1,233 @@
+/**
+ * Oklab and OKHSL <-> sRGB conversion. `colors.ts` builds its OKLCH, OKHSL, and color mixing on it.
+ *
+ * Oklab and OKHSL are Björn Ottosson's color spaces; OKHSL's saturation is relative to the sRGB gamut at
+ * each hue and lightness. This is a port of his reference implementation (https://bottosson.github.io/posts/colorpicker/),
+ * Copyright (c) 2021 Björn Ottosson, used under the MIT license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions: The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+ * KIND, EXPRESS OR IMPLIED.
+ */
+
+import type { RgbColor } from "./terminal-colors.ts";
+
+type Vector = [number, number, number];
+type Matrix = [Vector, Vector, Vector];
+
+const multiply = (m: Matrix, [x, y, z]: Vector): Vector =>
+	m.map((row) => row[0] * x + row[1] * y + row[2] * z) as Vector;
+
+// ============================================================================
+// OKHSL <-> sRGB
+// ============================================================================
+
+const LINEAR_SRGB_TO_LMS: Matrix = [
+	[0.4122214694707629, 0.5363325372617349, 0.0514459932675022],
+	[0.2119034958178251, 0.6806995506452344, 0.1073969535369405],
+	[0.0883024591900564, 0.2817188391361215, 0.6299787016738222],
+];
+const LMS_TO_LAB: Matrix = [
+	[0.210454268309314, 0.793617774702305, -0.0040720430116193],
+	[1.9779985324311684, -2.42859224204858, 0.450593709617411],
+	[0.0259040424655478, 0.7827717124575296, -0.8086757549230774],
+];
+const LAB_TO_LMS: Matrix = [
+	[1, 0.3963377773761749, 0.2158037573099136],
+	[1, -0.1055613458156586, -0.0638541728258133],
+	[1, -0.0894841775298119, -1.2914855480194092],
+];
+const LMS_TO_LINEAR_SRGB: Matrix = [
+	[4.0767416360759583, -3.3077115392580629, 0.2309699031821043],
+	[-1.2684379732850315, 2.6097573492876882, -0.341319376002657],
+	[-0.0041960761386756, -0.7034186179359362, 1.7076146940746117],
+];
+/**
+ * Per sRGB channel (red, green, blue): the (a, b) half-plane where that channel clips
+ * first, and the polynomial approximating the maximum saturation there.
+ */
+const SATURATION_FIT: [[number, number], number[]][] = [
+	[
+		[-1.8817031, -0.80936501],
+		[1.19086277, 1.76576728, 0.59662641, 0.75515197, 0.56771245],
+	],
+	[
+		[1.8144408, -1.19445267],
+		[0.73956515, -0.45954404, 0.08285427, 0.12541073, -0.14503204],
+	],
+	[
+		[0.13110758, 1.81333971],
+		[1.35733652, -0.00915799, -1.1513021, -0.50559606, 0.00692167],
+	],
+];
+const K1 = 0.206;
+const K2 = 0.03;
+const K3 = (1 + K1) / (1 + K2);
+
+/** Oklab lightness to OKHSL lightness. */
+export const oklabToOkhslLightness = (x: number): number =>
+	0.5 * (K3 * x - K1 + Math.sqrt((K3 * x - K1) ** 2 + 4 * K2 * K3 * x));
+/** OKHSL lightness to Oklab lightness. */
+const okhslToOklabLightness = (x: number): number => (x * x + K1 * x) / (K3 * (x + K2));
+
+/** sRGB transfer function: linear to encoded channel, both 0-1. */
+const linearToSrgb = (value: number): number =>
+	value > 0.0031308 ? 1.055 * value ** (1 / 2.4) - 0.055 : 12.92 * value;
+/** Inverse sRGB transfer function: encoded to linear channel, both 0-1. */
+const srgbToLinear = (value: number): number => (value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4);
+
+/** Oklab [L, a, b] to linear sRGB [r, g, b] (0-1, may leave the gamut). */
+export function oklabToLinearSrgb(lab: Vector): Vector {
+	return multiply(LMS_TO_LINEAR_SRGB, multiply(LAB_TO_LMS, lab).map((value) => value ** 3) as Vector);
+}
+
+/** Linear sRGB [r, g, b] (0-1) to Oklab [L, a, b]. */
+function linearSrgbToOklab(rgb: Vector): Vector {
+	return multiply(LMS_TO_LAB, multiply(LINEAR_SRGB_TO_LMS, rgb).map(Math.cbrt) as Vector);
+}
+
+/** sRGB channels (0-255) to Oklab [L, a, b]. */
+export function rgbToOklab({ r, g, b }: RgbColor): Vector {
+	return linearSrgbToOklab([r / 255, g / 255, b / 255].map(srgbToLinear) as Vector);
+}
+
+/** Linear sRGB [r, g, b] to sRGB channels (0-255, rounded), clipping out-of-gamut channels. */
+export function linearSrgbToRgb(linear: Vector): RgbColor {
+	const [r, g, b] = linear.map((value) => Math.round(Math.min(1, Math.max(0, linearToSrgb(value))) * 255));
+	return { r, g, b };
+}
+
+/** Rate of change of each cube-root LMS component along a chroma direction (a, b). */
+function lmsSlopes(a: number, b: number): Vector {
+	return [LAB_TO_LMS[0], LAB_TO_LMS[1], LAB_TO_LMS[2]].map((row) => row[1] * a + row[2] * b) as Vector;
+}
+
+/** Largest saturation (C/L) inside sRGB for hue (a, b): polynomial fit plus one Halley step. */
+function maxSaturation(a: number, b: number): number {
+	const channel = SATURATION_FIT.findIndex(([[x, y]], index) => index === 2 || x * a + y * b > 1);
+	const [k0, k1, k2, k3, k4] = SATURATION_FIT[channel][1];
+	const weights = LMS_TO_LINEAR_SRGB[channel];
+	const saturation = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b;
+
+	const slopes = lmsSlopes(a, b);
+	const base = slopes.map((k) => 1 + saturation * k);
+	const dot = (values: number[]) => values.reduce((sum, value, index) => sum + weights[index] * value, 0);
+	const f = dot(base.map((value) => value ** 3));
+	const f1 = dot(base.map((value, index) => 3 * slopes[index] * value ** 2));
+	const f2 = dot(base.map((value, index) => 6 * slopes[index] ** 2 * value));
+	return saturation - (f * f1) / (f1 * f1 - 0.5 * f * f2);
+}
+
+/** Oklab lightness and chroma of the most saturated sRGB color of hue (a, b). */
+function cusp(a: number, b: number): [number, number] {
+	const saturation = maxSaturation(a, b);
+	const lightness = Math.cbrt(1 / Math.max(...oklabToLinearSrgb([1, saturation * a, saturation * b])));
+	return [lightness, lightness * saturation];
+}
+
+/** Chroma where the constant-lightness line at `lightness` leaves the sRGB gamut. */
+function maxChroma(a: number, b: number, lightness: number, [cuspL, cuspC]: [number, number]): number {
+	if (lightness <= cuspL) return (cuspC * lightness) / cuspL;
+	// Upper half: triangle edge, then one Halley step against each channel reaching 1.
+	const t = (cuspC * (lightness - 1)) / (cuspL - 1);
+	const slopes = lmsSlopes(a, b);
+	const lms = slopes.map((k) => lightness + t * k);
+	const cubes = lms.map((value) => value ** 3);
+	const first = lms.map((value, index) => 3 * slopes[index] * value ** 2);
+	const second = lms.map((value, index) => 6 * slopes[index] ** 2 * value);
+	const dot = (row: Vector, values: number[]) => row[0] * values[0] + row[1] * values[1] + row[2] * values[2];
+	const steps = LMS_TO_LINEAR_SRGB.map((row) => {
+		const f = dot(row, cubes) - 1;
+		const f1 = dot(row, first);
+		const f2 = dot(row, second);
+		const u = f1 / (f1 * f1 - 0.5 * f * f2);
+		return u >= 0 ? -f * u : Number.MAX_VALUE;
+	});
+	return t + Math.min(...steps);
+}
+
+/** OKHSL's chroma reference points at lightness L and hue (a, b): [c0, cMid, cMax]. */
+function chromaStops(L: number, a: number, b: number): [number, number, number] {
+	const peak = cusp(a, b);
+	const cMax = maxChroma(a, b, L, peak);
+	const k = cMax / Math.min(L * (peak[1] / peak[0]), (1 - L) * (peak[1] / (1 - peak[0])));
+	const midS =
+		0.11516993 +
+		1 /
+			(7.4477897 +
+				4.1590124 * b +
+				a *
+					(-2.19557347 +
+						1.75198401 * b +
+						a * (-2.13704948 - 10.02301043 * b + a * (-4.24894561 + 5.38770819 * b + 4.69891013 * a))));
+	const midT =
+		0.11239642 +
+		1 /
+			(1.6132032 -
+				0.68124379 * b +
+				a *
+					(0.40370612 +
+						0.90148123 * b +
+						a * (-0.27087943 + 0.6122399 * b + a * (0.00299215 - 0.45399568 * b - 0.14661872 * a))));
+	const cMid = 0.9 * k * Math.sqrt(Math.sqrt(1 / (1 / (L * midS) ** 4 + 1 / ((1 - L) * midT) ** 4)));
+	const c0 = Math.sqrt(1 / (1 / (L * 0.4) ** 2 + 1 / ((1 - L) * 0.8) ** 2));
+	return [c0, cMid, cMax];
+}
+
+/**
+ * Convert OKHSL to sRGB channels (0-255, rounded), clipping out-of-gamut channels.
+ * @param hue Hue in degrees.
+ * @param saturation Saturation, 0-1.
+ * @param lightness Lightness, 0-1.
+ */
+export function okhslToRgb(hue: number, saturation: number, lightness: number): RgbColor {
+	const L = okhslToOklabLightness(lightness);
+	let lab: Vector = [L, 0, 0];
+	if (L > 0 && L < 1 && saturation > 0) {
+		const angle = (2 * Math.PI * (((hue % 360) + 360) % 360)) / 360;
+		const a = Math.cos(angle);
+		const b = Math.sin(angle);
+		const [c0, cMid, cMax] = chromaStops(L, a, b);
+		// Chroma rises from 0 through cMid at s = 0.8 to cMax at s = 1.
+		let chroma: number;
+		if (saturation < 0.8) {
+			const t = 1.25 * saturation;
+			const k1 = 0.8 * c0;
+			chroma = (t * k1) / (1 - (1 - k1 / cMid) * t);
+		} else {
+			const t = 5 * (saturation - 0.8);
+			const k1 = (0.2 * cMid ** 2 * 1.25 ** 2) / c0;
+			chroma = cMid + (t * k1) / (1 - (1 - k1 / (cMax - cMid)) * t);
+		}
+		lab = [L, chroma * a, chroma * b];
+	}
+	return linearSrgbToRgb(oklabToLinearSrgb(lab));
+}
+
+/**
+ * Convert sRGB channels (0-255) to OKHSL.
+ * @returns Hue `h` in degrees (0 for grays), saturation `s` and lightness `l` 0-1.
+ */
+export function rgbToOkhsl(rgb: RgbColor): { h: number; s: number; l: number } {
+	const [L, labA, labB] = rgbToOklab(rgb);
+	const chroma = Math.hypot(labA, labB);
+	const lightness = oklabToOkhslLightness(L);
+	if (chroma < 1e-9 || lightness <= 0 || lightness >= 1) return { h: 0, s: 0, l: lightness };
+
+	const hue = ((Math.atan2(labB, labA) * 180) / Math.PI + 360) % 360;
+	const [c0, cMid, cMax] = chromaStops(L, labA / chroma, labB / chroma);
+	let saturation: number;
+	if (chroma < cMid) {
+		const k1 = 0.8 * c0;
+		saturation = 0.8 * (chroma / (k1 + (1 - k1 / cMid) * chroma));
+	} else {
+		const k1 = (0.2 * cMid ** 2 * 1.25 ** 2) / c0;
+		const offset = chroma - cMid;
+		saturation = 0.8 + 0.2 * (offset / (k1 + (1 - k1 / (cMax - cMid)) * offset));
+	}
+	return { h: hue, s: Math.min(1, Math.max(0, saturation)), l: lightness };
+}

package/src/vendor/pi-tui/terminal-colors.ts

@@ -6,6 +6,16 @@ export interface RgbColor {
 
 export type TerminalColorScheme = "dark" | "light";
 
+/** Colors the terminal reports for its current theme. */
+export interface TerminalColors {
+	/** Default foreground (OSC 10). */
+	foreground?: RgbColor;
+	/** Default background (OSC 11). */
+	background?: RgbColor;
+	/** ANSI colors 0-15 (OSC 4). Only set when the terminal reported all 16. */
+	palette?: RgbColor[];
+}
+
 function hexToRgb(hex: string): RgbColor {
 	const normalized = hex.startsWith("#") ? hex.slice(1) : hex;
 	const r = parseInt(normalized.slice(0, 2), 16);
@@ -25,20 +35,28 @@ function parseOscHexChannel(channel: string): number | undefined {
 	return Math.round((parseInt(channel, 16) / max) * 255);
 }
 
-const OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN = /^\x1b\]11;([^\x07\x1b]*)(?:\x07|\x1b\\)$/i;
-const COLOR_SCHEME_REPORT_PATTERN = /^(?:\x1b\[\?997;(1|2)n)+$/;
+/** What an OSC color reply reports: the default foreground (OSC 10), background (OSC 11), or a palette index (OSC 4). */
+export type OscColorTarget = "foreground" | "background" | number;
 
-export function isOsc11BackgroundColorResponse(data: string): boolean {
-	return OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN.test(data);
-}
+const OSC_COLOR_RESPONSE_PATTERN = /^\x1b\](?:(1[01])|4;(\d{1,3}));([^\x07\x1b]*)(?:\x07|\x1b\\)$/i;
+const COLOR_SCHEME_REPORT_PATTERN = /^(?:\x1b\[\?997;(1|2)n)+$/;
 
-export function parseOsc11BackgroundColor(data: string): RgbColor | undefined {
-	const match = data.match(OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN);
+/**
+ * Parse an OSC 10, 11, or 4 color reply. Returns undefined when `data` is not such a reply;
+ * `rgb` is undefined when it is a reply with an unparseable color.
+ */
+export function parseOscColorResponse(data: string): { target: OscColorTarget; rgb: RgbColor | undefined } | undefined {
+	const match = data.match(OSC_COLOR_RESPONSE_PATTERN);
 	if (!match) {
 		return undefined;
 	}
+	const target: OscColorTarget =
+		match[1] === "10" ? "foreground" : match[1] === "11" ? "background" : Number.parseInt(match[2], 10);
+	return { target, rgb: parseOscColorValue(match[3]) };
+}
 
-	const value = match[1].trim();
+function parseOscColorValue(rawValue: string): RgbColor | undefined {
+	const value = rawValue.trim();
 	if (value.startsWith("#")) {
 		const hex = value.slice(1);
 		if (/^[0-9a-f]{6}$/i.test(hex)) {

package/src/vendor/pi-tui/terminal-image.ts

@@ -2,6 +2,7 @@ import { execSync } from "node:child_process";
 import { homedir } from "node:os";
 import { isAbsolute } from "node:path";
 import { pathToFileURL } from "node:url";
+import type { TerminalColorMode } from "./colors.ts";
 
 export type ImageProtocol = "kitty" | "iterm2" | null;
 
@@ -71,7 +72,7 @@ function detectCapabilitiesFromEnvironment(tmuxForwardsHyperlink: () => boolean)
 	const terminalEmulator = process.env.TERMINAL_EMULATOR?.toLowerCase() || "";
 	const term = process.env.TERM?.toLowerCase() || "";
 	const colorTerm = process.env.COLORTERM?.toLowerCase() || "";
-	const hasTrueColorHint = colorTerm === "truecolor" || colorTerm === "24bit";
+	const hasTrueColorHint = colorTerm === "truecolor" || colorTerm === "24bit" || term.endsWith("-direct");
 	const isWindowsConsole = process.platform === "win32";
 
 	// Emit OSC 8 hyperlinks only when tmux confirms it forwards.
@@ -168,6 +169,10 @@ export function getCapabilities(): TerminalCapabilities {
 	return cachedCapabilities;
 }
 
+export function getTerminalColorMode(capabilities: TerminalCapabilities = getCapabilities()): TerminalColorMode {
+	return capabilities.trueColor ? "truecolor" : "256color";
+}
+
 export function resetCapabilitiesCache(): void {
 	cachedCapabilities = null;
 }
@@ -432,11 +437,21 @@ export function cropKittyImageLine(line: string, hiddenRows: number, visibleRows
 	return `${line.slice(0, match.index)}\x1b_G${controls.join(",")};${line.slice(match.index + match[0].length)}`;
 }
 
+function chooseLessDistortedCellCount(upperCount: number, idealCount: number): number {
+	if (upperCount <= 1) return upperCount;
+
+	const lowerCount = upperCount - 1;
+	const upperDistortion = Math.max(upperCount / idealCount, idealCount / upperCount);
+	const lowerDistortion = Math.max(lowerCount / idealCount, idealCount / lowerCount);
+	return lowerDistortion < upperDistortion ? lowerCount : upperCount;
+}
+
 export function calculateImageCellSize(
 	imageDimensions: ImageDimensions,
 	maxWidthCells: number,
 	maxHeightCells?: number,
 	cellDimensions: CellDimensions = { widthPx: 9, heightPx: 18 },
+	optimizeAspectRatio = false,
 ): ImageCellSize {
 	const maxWidth = Math.max(1, Math.floor(maxWidthCells));
 	const maxHeight = maxHeightCells === undefined ? undefined : Math.max(1, Math.floor(maxHeightCells));
@@ -449,13 +464,26 @@ export function calculateImageCellSize(
 
 	const scaledWidthPx = imageWidth * scale;
 	const scaledHeightPx = imageHeight * scale;
-	const columns = Math.ceil(scaledWidthPx / cellDimensions.widthPx);
-	const rows = Math.ceil(scaledHeightPx / cellDimensions.heightPx);
+	let columns = Math.max(1, Math.min(maxWidth, Math.ceil(scaledWidthPx / cellDimensions.widthPx)));
+	const heightRows = scaledHeightPx / cellDimensions.heightPx;
+	let rows = Math.max(1, Math.ceil(heightRows));
+	if (maxHeight !== undefined) {
+		rows = Math.min(maxHeight, rows);
+	}
 
-	return {
-		columns: Math.max(1, Math.min(maxWidth, columns)),
-		rows: Math.max(1, maxHeight === undefined ? rows : Math.min(maxHeight, rows)),
-	};
+	if (!optimizeAspectRatio) {
+		return { columns, rows };
+	}
+
+	if (widthScale <= heightScale) {
+		const idealRows = (columns * cellDimensions.widthPx * imageHeight) / (imageWidth * cellDimensions.heightPx);
+		rows = chooseLessDistortedCellCount(rows, idealRows);
+	} else {
+		const idealColumns = (rows * cellDimensions.heightPx * imageWidth) / (imageHeight * cellDimensions.widthPx);
+		columns = chooseLessDistortedCellCount(columns, idealColumns);
+	}
+
+	return { columns, rows };
 }
 
 export function calculateImageRows(
@@ -619,7 +647,14 @@ export function renderImage(
 	}
 
 	const maxWidth = options.maxWidthCells ?? 80;
-	const size = calculateImageCellSize(imageDimensions, maxWidth, options.maxHeightCells, getCellDimensions());
+	// Reduce Kitty's cell-aligned distortion without shrinking iTerm2 reservations.
+	const size = calculateImageCellSize(
+		imageDimensions,
+		maxWidth,
+		options.maxHeightCells,
+		getCellDimensions(),
+		caps.images === "kitty",
+	);
 
 	if (caps.images === "kitty") {
 		if (options.imageId !== undefined) {