@mkbabb/value.js 0.5.0 → 0.10.0

package/dist/units/color/constants.d.ts

@@ -764,6 +764,27 @@ export declare const COLOR_SPACE_DENORM_UNITS: {
     };
 };
 export type ColorSpace = keyof typeof COLOR_SPACE_RANGES;
+export type ColorSpaceRanges = typeof COLOR_SPACE_RANGES;
+export type ColorSpaceDenormUnits = typeof COLOR_SPACE_DENORM_UNITS;
+/** Components of a color space (the keys of its range record). */
+export type ColorComponent<C extends ColorSpace> = keyof ColorSpaceRanges[C];
+/** A `{ min, max }` bound — the value type of every per-unit range entry. */
+export interface ColorSpaceBound {
+    readonly min: number;
+    readonly max: number;
+}
+/**
+ * Typed bound lookup for `(space, component)` at a given unit, with the CSS
+ * `number` fallback. Replaces the former untyped `COLOR_SPACE_RANGES` index
+ * + `ranges[unit] ?? ranges.number` idiom — returns a precise `ColorSpaceBound`
+ * so the `{ min, max }` destructure at every call site is fully typed.
+ */
+export declare const getColorSpaceBound: (colorSpace: ColorSpace, component: string, unit: string) => ColorSpaceBound;
+/**
+ * Typed denorm-unit lookup for `(space, component)`. Replaces the former
+ * untyped `COLOR_SPACE_DENORM_UNITS` index — returns a precise `string`.
+ */
+export declare const getColorSpaceDenormUnit: (colorSpace: ColorSpace, component: string) => string;
 export declare const COLOR_SPACE_NAMES: {
     readonly rgb: "RGB";
     readonly hsl: "HSL";

package/dist/units/color/contrast.d.ts

@@ -0,0 +1,35 @@
+import { OKLCHColor, Color } from '.';
+/**
+ * Compute a contrast-safe OKLCH tuple by shifting lightness away from
+ * the background when the original color is too close.
+ *
+ * Preserves hue; reduces chroma at extreme lightness to stay in gamut.
+ *
+ * @param L  OKLab/OKLCH lightness [0, 1]
+ * @param C  OKLCH chroma (normalized [0, 1], physical max ~0.5)
+ * @param H  OKLCH hue in degrees [0, 360]
+ * @param bgLightness  background surface lightness in OKLab [0, 1]
+ * @param minContrast  minimum lightness distance (default 0.35)
+ * @returns adjusted { L, C, H } tuple
+ */
+export declare function computeSafeAccent(L: number, C: number, H: number, bgLightness: number, minContrast?: number): {
+    L: number;
+    C: number;
+    H: number;
+};
+/**
+ * Extract OKLCH lightness from any Color by converting through OKLab.
+ */
+export declare function getOklchLightness(color: Color): number;
+/**
+ * Check if a color needs contrast adjustment against a background.
+ */
+export declare function needsContrastAdjustment(color: Color, bgLightness: number, minContrast?: number): boolean;
+/**
+ * Convert any Color to a contrast-safe OKLCHColor for use as foreground
+ * text/icons against a background of the given lightness.
+ *
+ * If the color already has sufficient contrast, returns an OKLCH clone
+ * of the original (no adjustment).
+ */
+export declare function safeAccentColor(color: Color, bgLightness: number, minContrast?: number): OKLCHColor;

package/dist/units/color/conversions/cylindrical.d.ts

@@ -0,0 +1,13 @@
+import { HSLColor, HSVColor, HWBColor, RGBColor, XYZColor } from '..';
+export declare const hsv2hsl: ({ h, s, v, alpha }: HSVColor) => HSLColor;
+export declare const hsl2hsv: ({ h, s, l, alpha }: HSLColor) => HSVColor;
+export declare const hwb2hsl: ({ h, w, b, alpha }: HWBColor) => HSLColor;
+export declare const hsl2hwb: ({ h, s, l, alpha }: HSLColor) => HWBColor;
+export declare const rgb2hsl: ({ r, g, b, alpha }: RGBColor) => HSLColor;
+export declare function hsl2rgb({ h, s, l, alpha }: HSLColor): RGBColor;
+export declare function hsl2xyz(hsl: HSLColor): XYZColor<number>;
+export declare function xyz2hsl(xyz: XYZColor): HSLColor<number>;
+export declare function hsv2xyz(hsv: HSVColor): XYZColor;
+export declare function xyz2hsv(xyz: XYZColor): HSVColor;
+export declare function hwb2xyz(hwb: HWBColor): XYZColor;
+export declare function xyz2hwb(xyz: XYZColor): HWBColor;

package/dist/units/color/conversions/direct.d.ts

@@ -0,0 +1,41 @@
+import { OKLABColor, OKLCHColor, RGBColor, Color, ColorSpaceMap, HSLColor } from '..';
+import { ColorSpace } from '../constants';
+/** Direct OKLab → RGB. Skips XYZColor allocation + one matrix multiply. */
+export declare function directOklabToRgb(oklab: OKLABColor): RGBColor;
+/** Direct RGB → OKLab. Skips XYZColor allocation + one matrix multiply. */
+export declare function directRgbToOklab(rgb: RGBColor): OKLABColor;
+/** Direct OKLCH → RGB. Polar → Cartesian → direct OKLab→RGB. */
+export declare function directOklchToRgb(oklch: OKLCHColor): RGBColor;
+/** Direct RGB → OKLCH. Direct RGB→OKLab Cartesian → polar (skip OKLABColor wrap). */
+export declare function directRgbToOklch(rgb: RGBColor): OKLCHColor;
+/** Direct HSL → RGB. Already a closed-form cylindrical conversion (no XYZ). */
+export declare function directHslToRgb(hsl: HSLColor): RGBColor;
+/** Direct RGB → HSL. Already a closed-form cylindrical conversion (no XYZ). */
+export declare function directRgbToHsl(rgb: RGBColor): HSLColor;
+/**
+ * A `From → To` direct conversion. The direct-path functions operate on
+ * numeric channels and build same-arity `number`-component colors, so the
+ * component type is concrete `number`.
+ */
+type DirectPath<From extends ColorSpace, To extends ColorSpace> = (color: ColorSpaceMap<number>[From]) => ColorSpaceMap<number>[To];
+/**
+ * Distributes over every `${From}->${To}` color-space pair; each entry is the
+ * exact `From → To` conversion signature (or absent).
+ */
+export type DirectPathsTable = {
+    [K in `${ColorSpace}->${ColorSpace}`]?: K extends `${infer From extends ColorSpace}->${infer To extends ColorSpace}` ? DirectPath<From, To> : never;
+};
+export declare const DIRECT_PATHS: DirectPathsTable;
+/**
+ * Typed `DIRECT_PATHS` lookup. Returns the wired direct conversion for
+ * `from → to` (or `undefined` when the pair routes through the XYZ hub). The
+ * return type is narrowed to the target space `C` so `color2` consumes it
+ * cast-free.
+ *
+ * The `directKey` is composed from runtime values, so TS cannot pick a single
+ * `DirectPathsTable` entry statically — the lone `as` re-asserts the table
+ * value as the `C`-targeted signature. This is a narrowing assertion, not a
+ * type-erasing double cast.
+ */
+export declare const getDirectPath: <C extends ColorSpace>(from: ColorSpace, to: C) => ((color: Color<number>) => ColorSpaceMap<number>[C]) | undefined;
+export {};

package/dist/units/color/conversions/hex.d.ts

@@ -0,0 +1,3 @@
+import { RGBColor } from '..';
+export declare const hex2rgb: (hex: string) => RGBColor;
+export declare const rgb2hex: ({ r, g, b, alpha }: RGBColor) => string;

package/dist/units/color/conversions/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Conversion-module aggregate barrel.
+ *
+ * Re-exports every `{from}2{to}` conversion function from the 6 focused
+ * conversion modules. Consumers that need a single conversion import the
+ * specific module directly; this barrel exists for namespace-style access
+ * (`import * as Conversions`) where the `{from}2{to}` name is computed.
+ *
+ * G.W1 Lane B — created with the `src/units/color/utils.ts` G3 decomposition.
+ */
+export { hex2rgb, rgb2hex } from './hex';
+export { kelvin2rgb, rgb2kelvin, kelvin2xyz, xyz2kelvin } from './kelvin';
+export { hsv2hsl, hsl2hsv, hwb2hsl, hsl2hwb, rgb2hsl, hsl2rgb, hsl2xyz, xyz2hsl, hsv2xyz, xyz2hsv, hwb2xyz, xyz2hwb, } from './cylindrical';
+export { xyz2lab, lab2xyz, lch2lab, lab2lch, lch2xyz, xyz2lch, } from './lab';
+export { oklab2xyz, xyz2oklab, oklab2lab, lab2oklab, oklab2oklch, oklch2oklab, oklch2lab, lab2oklch, oklch2xyz, xyz2oklch, } from './oklab';
+export { srgbToLinear, linearToSrgb, adobeRgbToLinear, linearToAdobeRgb, proPhotoToLinear, linearToProPhoto, rec2020ToLinear, linearToRec2020, } from './transfer';
+export { rgb2xyz, xyz2rgb, linearSrgb2xyz, xyz2linearSrgb, displayP32xyz, xyz2displayP3, adobeRgb2xyz, xyz2adobeRgb, proPhoto2xyz, xyz2proPhoto, rec20202xyz, xyz2rec2020, } from './xyz-extended';

package/dist/units/color/conversions/kelvin.d.ts

@@ -0,0 +1,5 @@
+import { KelvinColor, RGBColor, XYZColor } from '..';
+export declare const kelvin2rgb: ({ kelvin, alpha }: KelvinColor) => RGBColor;
+export declare const rgb2kelvin: ({ r, g, b, alpha }: RGBColor) => KelvinColor;
+export declare function kelvin2xyz(kelvin: KelvinColor): XYZColor;
+export declare function xyz2kelvin(xyz: XYZColor): KelvinColor;

package/dist/units/color/conversions/lab.d.ts

@@ -0,0 +1,8 @@
+import { LABColor, LCHColor, XYZColor } from '..';
+import { WhitePoint } from '../constants';
+export declare function xyz2lab(xyz: XYZColor, toWhitePoint?: WhitePoint): LABColor;
+export declare function lab2xyz(lab: LABColor): XYZColor;
+export declare function lch2lab({ l, c, h, alpha }: LCHColor): LABColor;
+export declare function lab2lch({ l, a, b, alpha }: LABColor): LCHColor;
+export declare function lch2xyz(lch: LCHColor): XYZColor;
+export declare function xyz2lch(xyz: XYZColor): LCHColor;

package/dist/units/color/conversions/oklab.d.ts

@@ -0,0 +1,11 @@
+import { LABColor, OKLABColor, OKLCHColor, XYZColor } from '..';
+export declare function oklab2xyz({ l, a, b, alpha }: OKLABColor): XYZColor;
+export declare function xyz2oklab(xyz: XYZColor): OKLABColor;
+export declare function oklab2lab(oklab: OKLABColor): LABColor;
+export declare function lab2oklab(lab: LABColor): OKLABColor;
+export declare function oklab2oklch({ l, a, b, alpha }: OKLABColor): OKLCHColor;
+export declare function oklch2oklab({ l, c, h, alpha }: OKLCHColor): OKLABColor;
+export declare function oklch2lab(oklch: OKLCHColor): LABColor;
+export declare function lab2oklch(lab: LABColor): OKLCHColor;
+export declare function oklch2xyz(oklch: OKLCHColor): XYZColor;
+export declare function xyz2oklch(xyz: XYZColor): OKLCHColor;

package/dist/units/color/conversions/transfer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Transfer functions — gamma encode/decode for the RGB-family color spaces.
+ *
+ * Each wide-gamut RGB space carries its own opto-electronic transfer function
+ * (OETF) and its inverse. These are pure scalar functions — no color-class
+ * dependency — consumed by `xyz-extended.ts` (the matrix-multiply converters)
+ * and by the OKLab/RGB direct paths in `dispatch.ts`.
+ *
+ * G.W1 Lane B — extracted from `src/units/color/utils.ts` (G3 decomposition).
+ */
+/** Convert an sRGB channel to linear-light sRGB. */
+export declare function srgbToLinear(channel: number): number;
+/** Convert a linear-light sRGB channel back to gamma-encoded sRGB. */
+export declare function linearToSrgb(channel: number): number;
+/** Identity transfer (linear-light spaces — no gamma curve). */
+export declare const linearTransfer: (c: number) => number;
+export declare function adobeRgbToLinear(c: number): number;
+export declare function linearToAdobeRgb(c: number): number;
+export declare function proPhotoToLinear(c: number): number;
+export declare function linearToProPhoto(c: number): number;
+export declare function rec2020ToLinear(c: number): number;
+export declare function linearToRec2020(c: number): number;

package/dist/units/color/conversions/xyz-extended.d.ts

@@ -0,0 +1,13 @@
+import { AdobeRGBColor, DisplayP3Color, LinearSRGBColor, ProPhotoRGBColor, Rec2020Color, RGBColor, XYZColor } from '..';
+export declare function rgb2xyz({ r, g, b, alpha }: RGBColor): XYZColor;
+export declare const xyz2rgb: ({ x, y, z, alpha }: XYZColor, correctGamut?: boolean) => RGBColor;
+export declare function linearSrgb2xyz(color: LinearSRGBColor): XYZColor;
+export declare function xyz2linearSrgb(xyz: XYZColor): LinearSRGBColor;
+export declare function displayP32xyz(color: DisplayP3Color): XYZColor;
+export declare function xyz2displayP3(xyz: XYZColor): DisplayP3Color;
+export declare function adobeRgb2xyz(color: AdobeRGBColor): XYZColor;
+export declare function xyz2adobeRgb(xyz: XYZColor): AdobeRGBColor;
+export declare function proPhoto2xyz({ r, g, b, alpha }: ProPhotoRGBColor): XYZColor;
+export declare function xyz2proPhoto({ x, y, z, alpha }: XYZColor): ProPhotoRGBColor;
+export declare function rec20202xyz(color: Rec2020Color): XYZColor;
+export declare function xyz2rec2020(xyz: XYZColor): Rec2020Color;

package/dist/units/color/dispatch.d.ts

@@ -0,0 +1,26 @@
+import { Color, ColorSpaceMap } from '.';
+import { ColorSpace } from './constants';
+import { hex2rgb, rgb2hex } from './conversions/hex';
+export { hex2rgb, rgb2hex };
+export { deltaEOK, isInSRGBGamut, DELTA_E_OK_JND } from './gamut';
+export { computeSafeAccent, safeAccentColor, needsContrastAdjustment, getOklchLightness, } from './contrast';
+export declare const getFormattedColorSpaceRange: <T extends ColorSpace>(colorSpace: T) => ColorSpaceMap<{
+    min: string;
+    max: string;
+}>[T];
+export declare function color2<T, C extends ColorSpace>(color: Color<T>, to: C): Color<T>;
+export declare function gamutMap<C extends Color>(color: C): C;
+export type HueInterpolationMethod = "shorter" | "longer" | "increasing" | "decreasing";
+export declare const CYLINDRICAL_HUE_COMPONENT: Partial<Record<ColorSpace, string>>;
+/**
+ * Interpolate between two hue values using the given method.
+ * Hues are in [0, 1] (normalized). Returns an interpolated hue in [0, 1].
+ * Handles NaN (CSS `none`): if one hue is NaN, the other's value is used.
+ */
+export declare function interpolateHue(h1: number, h2: number, t: number, method?: HueInterpolationMethod): number;
+/**
+ * Mix two colors per CSS color-mix() specification.
+ * Both colors should be normalized (components in [0, 1]).
+ * Percentages p1, p2 are in [0, 1] (e.g. 0.5 = 50%).
+ */
+export declare function mixColors(col1: Color, col2: Color, p1: number, p2: number, space?: ColorSpace, hueMethod?: HueInterpolationMethod): Color;

package/dist/units/color/gamut.d.ts

@@ -58,3 +58,9 @@ export declare function srgbToOKLab(r: number, g: number, b: number): [number, n
  * Returns clamped sRGB [0,1]³.
  */
 export declare function gamutMapSRGB(r: number, g: number, b: number): [number, number, number];
+/** OKLab (L,a,b) → OKLCH (L,C,H) with H in degrees [0,360). */
+export declare function rawOklabToOklch(L: number, a: number, b: number): [number, number, number];
+/** OKLCH (L,C,H) → OKLab (L,a,b). H in degrees. */
+export declare function rawOklchToOklab(L: number, C: number, H: number): [number, number, number];
+/** OKLab → clamped sRGB [0,255]. */
+export declare function oklabToRgb255(L: number, a: number, b: number): [number, number, number];

package/dist/units/color/index.d.ts

@@ -1,155 +1,258 @@
 import { ColorSpace, WhitePoint } from './constants';
+declare const __ColorChannel: unique symbol;
+export type ColorChannel<T = number> = T & {
+    readonly [__ColorChannel]: true;
+};
+/**
+ * Brand-erasing identity helper. Casts a plain `T` value to `ColorChannel<T>`
+ * at write sites that compute channels from arithmetic / interpolation. The
+ * `ColorChannel<T>` brand on declared fields requires an explicit cast on
+ * assignment — this helper makes the intent clear and keeps the line short.
+ *
+ * Zero runtime cost (identity function; inlined by V8).
+ *
+ * E.W1 Lane E — lifted from per-file duplicates in `utils.ts` + `contrast.ts`
+ * to live alongside the `ColorChannel<T>` brand declaration. Internal-only:
+ * NOT re-exported from `src/index.ts`.
+ */
+export declare const ch: <T>(v: T) => ColorChannel<T>;
+/**
+ * Typed channel read. `key` is any channel name from `color.channels` /
+ * `color.keys()`; the result is the branded `ColorChannel<T>` slot value.
+ *
+ * The lone assertion re-narrows the index-signature read to `ColorChannel<T>` —
+ * a documented index-narrowing at the one dynamic-access boundary, not a
+ * type-erasing double cast.
+ */
+export declare const channelOf: <T>(color: Color<T>, key: string) => ColorChannel<T>;
+/**
+ * Typed channel write. Accepts a `ColorChannel<T>` (use `ch()` to brand a raw
+ * computed value) and assigns it to the named slot.
+ */
+export declare const setChannel: <T>(color: Color<T>, key: string, value: ColorChannel<T>) => void;
+/**
+ * Abstract base class for all CSS color spaces.
+ *
+ * Generic over component type `T` — `number` for math operations,
+ * `ValueUnit` for CSS parsing/serialization.
+ *
+ * **L8 storage**: components live as own properties on the instance (e.g.
+ * `instance.r`, `instance.l`) — V8 hidden-class monomorphic. Subclasses declare
+ * their fields via `declare r: ColorChannel<T>` and override `get channels()`.
+ *
+ * All 15 color spaces extend this class. Conversion between spaces routes
+ * through XYZ D65 as the hub (see `utils.ts`). Components are normalized to
+ * [0,1] internally; physical ranges (e.g. [0,255] for RGB, [0,360] for hue)
+ * are applied on output.
+ */
 export declare abstract class Color<T = number> {
     readonly colorSpace: ColorSpace;
     alpha: T;
+    /**
+     * Dynamic channel index signature.
+     *
+     * **G.W2 Lane C (G-OPP-4) — BREAKING-decision verdict: KEEP (documented).**
+     *
+     * `Color<T>` is publicly barrel-exported (`src/index.ts`) and the demo
+     * dynamically indexes instances by a runtime `component: string`
+     * (`useColorModel.ts:197,206`, `ComponentSliders.vue:56,178`,
+     * `useSliderGradients.ts:36`). The signature is therefore part of the
+     * observable public surface — dropping it is a BREAKING change.
+     *
+     * It also *cannot* be tightened to a typed `[channel: string]:
+     * ColorChannel<T> | T` form: a TypeScript string index signature requires
+     * **every** declared member to be assignable to it, and `Color<T>` carries
+     * non-channel members (`whitePoint: WhitePoint`, `colorSpace: ColorSpace`,
+     * and the `toString`/`values`/`entries`/… methods) whose types are not
+     * assignable to a channel-value union. `any` is the only index type the
+     * heterogeneous class shape admits.
+     *
+     * The internal pipeline no longer *relies* on this `any` leak, though — the
+     * typed `ch<T>` channel accessors below (`channelOf` / `setChannel`) give
+     * `clone()`/`values()`/`entries()` + `interpolate.ts` + `normalize.ts`
+     * cast-free `ColorChannel<T>`-typed reads/writes. The index signature
+     * survives purely as the public dynamic-access affordance.
+     */
     [key: string]: any;
-    protected components: Map<string, T>;
+    /**
+     * Reference white point for this color instance.
+     *
+     * E.W1 Lane B (WhitePointColor lift): hoisted from the deleted
+     * `WhitePointColor<T>` intermediate class to the base. Optional with a
+     * D65 default — the historically D50 spaces (`LABColor`, `OKLABColor`)
+     * set `"D50"` explicitly in their constructors; `XYZColor` keeps the
+     * D65 default to mirror its prior `super(…, "D65")` call.
+     *
+     * Subclasses that don't carry a meaningful white point (HSL/HSV/HWB
+     * cylindrical, KelvinColor) leave it as the inherited default; reads
+     * are harmless and the field is monomorphic across all 14 subclasses
+     * (V8 hidden-class stable — verified by `bench/color-channel-access.mjs`).
+     */
+    whitePoint: WhitePoint;
     constructor(colorSpace: ColorSpace, alpha?: T);
+    /**
+     * The static channel-name list for this color space (e.g. `["r","g","b"]`
+     * for RGBColor). Subclasses override.
+     */
+    abstract get channels(): readonly string[];
+    static _assertChannel(value: unknown): void;
+    private static _cloneDepth;
+    private static readonly CLONE_DEPTH_LIMIT;
     toString(): string;
     toFormattedString(digits?: number): string;
     valueOf(): T[];
     toJSON(): Record<string, T>;
     clone(): this;
-    keys(): string[];
+    /**
+     * Return the ordered list of channel keys followed by `"alpha"`.
+     *
+     * E.W1 Lane C — cached as a static-per-subclass `readonly` tuple
+     * (`channelKeysWithAlpha`). Pre-Lane-C this allocated a new array on every
+     * call via `[...this.channels, "alpha"]`; the demo gradient interpolation
+     * + `lerpColorValue` + `mixColors` + `normalizeColor` all hit this path
+     * per frame, so the per-call array churn was measurable.
+     *
+     * Subclasses define their own `static readonly channelKeysWithAlpha`
+     * (frozen tuple); the base falls back to a synthesized array for the
+     * abstract case (never reached in normal flow — there is no abstract
+     * `Color` instance — but kept for type safety).
+     */
+    keys(): readonly string[];
     values(): T[];
     entries(): [string, T][];
-    protected getComponent(key: string): T | undefined;
-    protected setComponent(key: string, value: T): void;
-}
-declare class WhitePointColor<T = number> extends Color<T> {
-    whitePoint: WhitePoint;
-    constructor(colorSpace: ColorSpace, alpha: T, whitePoint: WhitePoint);
 }
+/** sRGB color space — the web's default. Components: r, g, b in [0,255] denormalized. D65 white point, ~2.2 gamma. */
 export declare class RGBColor<T = number> extends Color<T> {
-    constructor(r: T, g: T, b: T, alpha?: T);
-    get r(): T;
-    set r(value: T);
-    get g(): T;
-    set g(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["r", "g", "b", "alpha"];
+    r: ColorChannel<T>;
+    g: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(r?: T, g?: T, b?: T, alpha?: T);
 }
+/** HSL cylindrical space — hue [0,360], saturation [0,1], lightness [0,1]. D65 white point. */
 export declare class HSLColor<T = number> extends Color<T> {
-    constructor(h: T, s: T, l: T, alpha?: T);
-    get h(): T;
-    set h(value: T);
-    get s(): T;
-    set s(value: T);
-    get l(): T;
-    set l(value: T);
+    static readonly channelKeysWithAlpha: readonly ["h", "s", "l", "alpha"];
+    h: ColorChannel<T>;
+    s: ColorChannel<T>;
+    l: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(h?: T, s?: T, l?: T, alpha?: T);
 }
+/** HSV cylindrical space — hue [0,360], saturation [0,1], value [0,1]. D65 white point. */
 export declare class HSVColor<T = number> extends Color<T> {
-    constructor(h: T, s: T, v: T, alpha?: T);
-    get h(): T;
-    set h(value: T);
-    get s(): T;
-    set s(value: T);
-    get v(): T;
-    set v(value: T);
+    static readonly channelKeysWithAlpha: readonly ["h", "s", "v", "alpha"];
+    h: ColorChannel<T>;
+    s: ColorChannel<T>;
+    v: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(h?: T, s?: T, v?: T, alpha?: T);
 }
+/** HWB space — hue [0,360], whiteness [0,1], blackness [0,1]. D65 white point. */
 export declare class HWBColor<T = number> extends Color<T> {
-    constructor(h: T, w: T, b: T, alpha?: T);
-    get h(): T;
-    set h(value: T);
-    get w(): T;
-    set w(value: T);
-    get b(): T;
-    set b(value: T);
-}
-export declare class LABColor<T = number> extends WhitePointColor<T> {
-    constructor(l: T, a: T, b: T, alpha?: T);
-    get l(): T;
-    set l(value: T);
-    get a(): T;
-    set a(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["h", "w", "b", "alpha"];
+    h: ColorChannel<T>;
+    w: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(h?: T, w?: T, b?: T, alpha?: T);
 }
+/** CIE Lab (D50) — perceptual lightness L [0,100], a/b axes [-125,125]. */
+export declare class LABColor<T = number> extends Color<T> {
+    static readonly channelKeysWithAlpha: readonly ["l", "a", "b", "alpha"];
+    l: ColorChannel<T>;
+    a: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(l?: T, a?: T, b?: T, alpha?: T);
+}
+/** CIE LCH (D50) — cylindrical form of Lab. L [0,100], C [0,150], H [0,360]. */
 export declare class LCHColor<T = number> extends Color<T> {
-    constructor(l: T, c: T, h: T, alpha?: T);
-    get l(): T;
-    set l(value: T);
-    get c(): T;
-    set c(value: T);
-    get h(): T;
-    set h(value: T);
-}
-export declare class OKLABColor<T = number> extends WhitePointColor<T> {
-    constructor(l: T, a: T, b: T, alpha?: T);
-    get l(): T;
-    set l(value: T);
-    get a(): T;
-    set a(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["l", "c", "h", "alpha"];
+    l: ColorChannel<T>;
+    c: ColorChannel<T>;
+    h: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(l?: T, c?: T, h?: T, alpha?: T);
+}
+/** OKLab (D50) — perceptually uniform. L [0,1], a/b [-0.4,0.4]. Björn Ottosson's improvement over CIE Lab. */
+export declare class OKLABColor<T = number> extends Color<T> {
+    static readonly channelKeysWithAlpha: readonly ["l", "a", "b", "alpha"];
+    l: ColorChannel<T>;
+    a: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(l?: T, a?: T, b?: T, alpha?: T);
 }
+/** OKLCH — cylindrical form of OKLab. L [0,1], C [0,0.4], H [0,360]. CSS Color Level 4 recommended space. */
 export declare class OKLCHColor<T = number> extends Color<T> {
-    constructor(l: T, c: T, h: T, alpha?: T);
-    get l(): T;
-    set l(value: T);
-    get c(): T;
-    set c(value: T);
-    get h(): T;
-    set h(value: T);
-}
-export declare class XYZColor<T = number> extends WhitePointColor<T> {
-    constructor(x: T, y: T, z: T, alpha?: T);
-    get x(): T;
-    set x(value: T);
-    get y(): T;
-    set y(value: T);
-    get z(): T;
-    set z(value: T);
+    static readonly channelKeysWithAlpha: readonly ["l", "c", "h", "alpha"];
+    l: ColorChannel<T>;
+    c: ColorChannel<T>;
+    h: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(l?: T, c?: T, h?: T, alpha?: T);
+}
+/** CIE XYZ (D65) — the connection space hub for all conversions. Unbounded components. */
+export declare class XYZColor<T = number> extends Color<T> {
+    static readonly channelKeysWithAlpha: readonly ["x", "y", "z", "alpha"];
+    x: ColorChannel<T>;
+    y: ColorChannel<T>;
+    z: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(x?: T, y?: T, z?: T, alpha?: T);
 }
+/** Color temperature — single kelvin component [1000,40000]. Converts through blackbody radiation to sRGB. */
 export declare class KelvinColor<T = number> extends Color<T> {
-    constructor(kelvin: T, alpha?: T);
-    get kelvin(): T;
-    set kelvin(value: T);
+    static readonly channelKeysWithAlpha: readonly ["kelvin", "alpha"];
+    kelvin: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(kelvin?: T, alpha?: T);
 }
+/** Linear-light sRGB — no gamma curve. Components r, g, b in [0,1]. D65 white point. */
 export declare class LinearSRGBColor<T = number> extends Color<T> {
-    constructor(r: T, g: T, b: T, alpha?: T);
-    get r(): T;
-    set r(value: T);
-    get g(): T;
-    set g(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["r", "g", "b", "alpha"];
+    r: ColorChannel<T>;
+    g: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(r?: T, g?: T, b?: T, alpha?: T);
 }
+/** Display P3 — wide-gamut space used by Apple displays. Components r, g, b in [0,1]. D65, sRGB transfer. */
 export declare class DisplayP3Color<T = number> extends Color<T> {
-    constructor(r: T, g: T, b: T, alpha?: T);
-    get r(): T;
-    set r(value: T);
-    get g(): T;
-    set g(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["r", "g", "b", "alpha"];
+    r: ColorChannel<T>;
+    g: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(r?: T, g?: T, b?: T, alpha?: T);
 }
+/** Adobe RGB (1998) — wide-gamut space for print/photography. Components r, g, b in [0,1]. D65, gamma 2.2. */
 export declare class AdobeRGBColor<T = number> extends Color<T> {
-    constructor(r: T, g: T, b: T, alpha?: T);
-    get r(): T;
-    set r(value: T);
-    get g(): T;
-    set g(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["r", "g", "b", "alpha"];
+    r: ColorChannel<T>;
+    g: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(r?: T, g?: T, b?: T, alpha?: T);
 }
+/** ProPhoto RGB (ROMM) — ultra-wide gamut for photography. Components r, g, b in [0,1]. D50, gamma 1.8. */
 export declare class ProPhotoRGBColor<T = number> extends Color<T> {
-    constructor(r: T, g: T, b: T, alpha?: T);
-    get r(): T;
-    set r(value: T);
-    get g(): T;
-    set g(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["r", "g", "b", "alpha"];
+    r: ColorChannel<T>;
+    g: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(r?: T, g?: T, b?: T, alpha?: T);
 }
+/** ITU-R BT.2020 — HDR/UHD broadcast gamut. Components r, g, b in [0,1]. D65, PQ transfer. */
 export declare class Rec2020Color<T = number> extends Color<T> {
-    constructor(r: T, g: T, b: T, alpha?: T);
-    get r(): T;
-    set r(value: T);
-    get g(): T;
-    set g(value: T);
-    get b(): T;
-    set b(value: T);
+    static readonly channelKeysWithAlpha: readonly ["r", "g", "b", "alpha"];
+    r: ColorChannel<T>;
+    g: ColorChannel<T>;
+    b: ColorChannel<T>;
+    get channels(): readonly string[];
+    constructor(r?: T, g?: T, b?: T, alpha?: T);
 }
 export type ColorSpaceMap<T> = {
     rgb: RGBColor<T>;
@@ -168,4 +271,5 @@ export type ColorSpaceMap<T> = {
     "prophoto-rgb": ProPhotoRGBColor<T>;
     rec2020: Rec2020Color<T>;
 };
-export {};
+export { getFormattedColorSpaceRange, color2, gamutMap, interpolateHue, mixColors, CYLINDRICAL_HUE_COMPONENT, computeSafeAccent, safeAccentColor, needsContrastAdjustment, getOklchLightness, hex2rgb, rgb2hex, } from './dispatch';
+export type { HueInterpolationMethod } from './dispatch';