@visual-z/xeno 0.2.1 → 0.4.0

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

@@ -1,241 +0,0 @@
-#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-modifiers.ts

@@ -1,13 +0,0 @@
-import { getNativePlatformHelper, type ModifierKey } from "./native-platform.ts";
-
-export type { ModifierKey } from "./native-platform.ts";
-
-export function isNativeModifierPressed(key: ModifierKey): boolean {
-	const helper = getNativePlatformHelper();
-	if (!helper?.isModifierPressed) return false;
-	try {
-		return helper.isModifierPressed(key) === true;
-	} catch {
-		return false;
-	}
-}

package/src/vendor/pi-tui/native-module-path.ts

@@ -1,31 +0,0 @@
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const moduleRequire = createRequire(import.meta.url);
-const TUI_PACKAGE_NAME = "@earendil-works/pi-tui";
-
-export interface NativeModuleCandidateOptions {
-	moduleUrl?: string;
-	execPath?: string;
-	resolvePackage?: (specifier: string) => string;
-}
-
-export function getNativeModuleCandidates(nativePath: string, options: NativeModuleCandidateOptions = {}): string[] {
-	const moduleDir = dirname(fileURLToPath(options.moduleUrl ?? import.meta.url));
-	const candidates: string[] = [];
-
-	try {
-		const packageEntry = (options.resolvePackage ?? moduleRequire.resolve)(TUI_PACKAGE_NAME);
-		candidates.push(join(dirname(packageEntry), "..", nativePath));
-	} catch {
-		// Standalone binaries do not have an installed TUI package.
-	}
-
-	candidates.push(
-		join(moduleDir, "..", nativePath),
-		join(moduleDir, nativePath),
-		join(dirname(options.execPath ?? process.execPath), nativePath),
-	);
-	return Array.from(new Set(candidates));
-}

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

@@ -1,65 +0,0 @@
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { getNativeModuleCandidates } from "./native-module-path.ts";
-
-const cjsRequire = createRequire(import.meta.url);
-
-export type ModifierKey = "shift" | "command" | "control" | "option";
-
-export interface NativeClipboard {
-	/** Undefined means unavailable, null means no text; transfer failures reject. */
-	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>;
-}
-
-type NativePlatformHelper = NativeClipboard & {
-	enableVirtualTerminalInput?: () => boolean;
-	isModifierPressed?: (name: ModifierKey) => boolean;
-};
-
-// Cache module loading, not display availability: a disconnected display can recover.
-const helpers = new Map<string, NativePlatformHelper | undefined>();
-
-function loadNativePlatformHelper(platform: string, suffix = ""): NativePlatformHelper | undefined {
-	const arch = process.arch;
-	if (arch !== "x64" && arch !== "arm64") return undefined;
-	const nativePath = path.join(
-		"native",
-		platform,
-		"prebuilds",
-		`${platform}-${arch}`,
-		`${platform}-platform${suffix}.node`,
-	);
-	if (helpers.has(nativePath)) return helpers.get(nativePath);
-
-	for (const modulePath of getNativeModuleCandidates(nativePath)) {
-		try {
-			const helper = cjsRequire(modulePath) as Partial<NativePlatformHelper> | null;
-			if (typeof helper?.getText === "function" && typeof helper.getImage === "function") {
-				helpers.set(nativePath, helper as NativePlatformHelper);
-				return helper as NativePlatformHelper;
-			}
-		} catch {
-			// Try the next possible packaging location.
-		}
-	}
-	helpers.set(nativePath, undefined);
-	return undefined;
-}
-
-export function getNativePlatformHelper(): NativePlatformHelper | undefined {
-	if (process.platform !== "darwin" && process.platform !== "win32") return undefined;
-	return loadNativePlatformHelper(process.platform);
-}
-
-/** Load a clipboard helper without opening the display until a read is requested. */
-export function getNativeClipboard(): NativeClipboard | undefined {
-	if (process.platform !== "linux") return getNativePlatformHelper();
-	if (!process.env.DISPLAY) return undefined;
-	return loadNativePlatformHelper("linux", "-x11");
-}

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

@@ -1,233 +0,0 @@
-/**
- * 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 };
-}