@mkbabb/value.js 0.1.0 → 0.2.0

package/dist/value.d.ts

@@ -0,0 +1,1753 @@
+import { Parser } from '@mkbabb/parse-that';
+
+export declare const ABSOLUTE_LENGTH_UNITS: readonly ["px", "cm", "mm", "Q", "in", "pc", "pt"];
+
+export declare function adobeRgb2xyz({ r, g, b, alpha }: AdobeRGBColor): XYZColor;
+
+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);
+}
+
+export declare function adobeRgbToLinear(c: number): number;
+
+export declare const ALPHA_DENORM_UNIT = "%";
+
+export declare const ALPHA_RANGE: {
+    readonly "%": {
+        readonly min: 0;
+        readonly max: 100;
+    };
+    readonly number: {
+        readonly min: 0;
+        readonly max: 1;
+    };
+};
+
+export declare const ANGLE_UNITS: readonly ["deg", "rad", "grad", "turn"];
+
+export declare const arrayEquals: (a: any[], b: any[]) => boolean;
+
+export declare const BLACKLISTED_COALESCE_UNITS: readonly ["string", "var", "calc"];
+
+export declare function camelCaseToHyphen(str: string): string;
+
+declare function cancelAnimationFrame_2(handle: number | undefined | null | any): void;
+export { cancelAnimationFrame_2 as cancelAnimationFrame }
+
+export declare function clamp(value: number, min: number, max: number): number;
+
+export declare function clone(obj: any): any;
+
+export declare abstract class Color<T = number> {
+    readonly colorSpace: ColorSpace;
+    alpha: T;
+    [key: string]: any;
+    protected components: Map<string, T>;
+    constructor(colorSpace: ColorSpace, alpha?: T);
+    toString(): string;
+    toFormattedString(digits?: number): string;
+    valueOf(): T[];
+    toJSON(): Record<string, T>;
+    clone(): this;
+    keys(): string[];
+    values(): T[];
+    entries(): [string, T][];
+    protected getComponent(key: string): T | undefined;
+    protected setComponent(key: string, value: T): void;
+}
+
+export declare function color2<T, C extends ColorSpace>(color: Color<T>, to: C): Color<T>;
+
+export declare const COLOR_NAMES: {
+    readonly aliceblue: "#f0f8ff";
+    readonly antiquewhite: "#faebd7";
+    readonly aqua: "#00ffff";
+    readonly aquamarine: "#7fffd4";
+    readonly azure: "#f0ffff";
+    readonly beige: "#f5f5dc";
+    readonly bisque: "#ffe4c4";
+    readonly black: "#000000";
+    readonly blanchedalmond: "#ffebcd";
+    readonly blue: "#0000ff";
+    readonly blueviolet: "#8a2be2";
+    readonly brown: "#a52a2a";
+    readonly burlywood: "#deb887";
+    readonly cadetblue: "#5f9ea0";
+    readonly chartreuse: "#7fff00";
+    readonly chocolate: "#d2691e";
+    readonly coral: "#ff7f50";
+    readonly cornflowerblue: "#6495ed";
+    readonly cornsilk: "#fff8dc";
+    readonly crimson: "#dc143c";
+    readonly cyan: "#00ffff";
+    readonly darkblue: "#00008b";
+    readonly darkcyan: "#008b8b";
+    readonly darkgoldenrod: "#b8860b";
+    readonly darkgray: "#a9a9a9";
+    readonly darkgreen: "#006400";
+    readonly darkgrey: "#a9a9a9";
+    readonly darkkhaki: "#bdb76b";
+    readonly darkmagenta: "#8b008b";
+    readonly darkolivegreen: "#556b2f";
+    readonly darkorange: "#ff8c00";
+    readonly darkorchid: "#9932cc";
+    readonly darkred: "#8b0000";
+    readonly darksalmon: "#e9967a";
+    readonly darkseagreen: "#8fbc8f";
+    readonly darkslateblue: "#483d8b";
+    readonly darkslategray: "#2f4f4f";
+    readonly darkslategrey: "#2f4f4f";
+    readonly darkturquoise: "#00ced1";
+    readonly darkviolet: "#9400d3";
+    readonly deeppink: "#ff1493";
+    readonly deepskyblue: "#00bfff";
+    readonly dimgray: "#696969";
+    readonly dimgrey: "#696969";
+    readonly dodgerblue: "#1e90ff";
+    readonly firebrick: "#b22222";
+    readonly floralwhite: "#fffaf0";
+    readonly forestgreen: "#228b22";
+    readonly fuchsia: "#ff00ff";
+    readonly gainsboro: "#dcdcdc";
+    readonly ghostwhite: "#f8f8ff";
+    readonly gold: "#ffd700";
+    readonly goldenrod: "#daa520";
+    readonly gray: "#808080";
+    readonly green: "#008000";
+    readonly greenyellow: "#adff2f";
+    readonly grey: "#808080";
+    readonly honeydew: "#f0fff0";
+    readonly hotpink: "#ff69b4";
+    readonly indianred: "#cd5c5c";
+    readonly indigo: "#4b0082";
+    readonly ivory: "#fffff0";
+    readonly khaki: "#f0e68c";
+    readonly lavender: "#e6e6fa";
+    readonly lavenderblush: "#fff0f5";
+    readonly lawngreen: "#7cfc00";
+    readonly lemonchiffon: "#fffacd";
+    readonly lightblue: "#add8e6";
+    readonly lightcoral: "#f08080";
+    readonly lightcyan: "#e0ffff";
+    readonly lightgoldenrodyellow: "#fafad2";
+    readonly lightgray: "#d3d3d3";
+    readonly lightgreen: "#90ee90";
+    readonly lightgrey: "#d3d3d3";
+    readonly lightpink: "#ffb6c1";
+    readonly lightsalmon: "#ffa07a";
+    readonly lightseagreen: "#20b2aa";
+    readonly lightskyblue: "#87cefa";
+    readonly lightslategray: "#778899";
+    readonly lightslategrey: "#778899";
+    readonly lightsteelblue: "#b0c4de";
+    readonly lightyellow: "#ffffe0";
+    readonly lime: "#00ff00";
+    readonly limegreen: "#32cd32";
+    readonly linen: "#faf0e6";
+    readonly magenta: "#ff00ff";
+    readonly maroon: "#800000";
+    readonly mediumaquamarine: "#66cdaa";
+    readonly mediumblue: "#0000cd";
+    readonly mediumorchid: "#ba55d3";
+    readonly mediumpurple: "#9370db";
+    readonly mediumseagreen: "#3cb371";
+    readonly mediumslateblue: "#7b68ee";
+    readonly mediumspringgreen: "#00fa9a";
+    readonly mediumturquoise: "#48d1cc";
+    readonly mediumvioletred: "#c71585";
+    readonly midnightblue: "#191970";
+    readonly mintcream: "#f5fffa";
+    readonly mistyrose: "#ffe4e1";
+    readonly moccasin: "#ffe4b5";
+    readonly navajowhite: "#ffdead";
+    readonly navy: "#000080";
+    readonly oldlace: "#fdf5e6";
+    readonly olive: "#808000";
+    readonly olivedrab: "#6b8e23";
+    readonly orange: "#ffa500";
+    readonly orangered: "#ff4500";
+    readonly orchid: "#da70d6";
+    readonly palegoldenrod: "#eee8aa";
+    readonly palegreen: "#98fb98";
+    readonly paleturquoise: "#afeeee";
+    readonly palevioletred: "#db7093";
+    readonly papayawhip: "#ffefd5";
+    readonly peachpuff: "#ffdab9";
+    readonly peru: "#cd853f";
+    readonly pink: "#ffc0cb";
+    readonly plum: "#dda0dd";
+    readonly powderblue: "#b0e0e6";
+    readonly purple: "#800080";
+    readonly rebeccapurple: "#663399";
+    readonly red: "#ff0000";
+    readonly rosybrown: "#bc8f8f";
+    readonly royalblue: "#4169e1";
+    readonly saddlebrown: "#8b4513";
+    readonly salmon: "#fa8072";
+    readonly sandybrown: "#f4a460";
+    readonly seagreen: "#2e8b57";
+    readonly seashell: "#fff5ee";
+    readonly sienna: "#a0522d";
+    readonly silver: "#c0c0c0";
+    readonly skyblue: "#87ceeb";
+    readonly slateblue: "#6a5acd";
+    readonly slategray: "#708090";
+    readonly slategrey: "#708090";
+    readonly snow: "#fffafa";
+    readonly springgreen: "#00ff7f";
+    readonly steelblue: "#4682b4";
+    readonly tan: "#d2b48c";
+    readonly teal: "#008080";
+    readonly thistle: "#d8bfd8";
+    readonly tomato: "#ff6347";
+    readonly turquoise: "#40e0d0";
+    readonly violet: "#ee82ee";
+    readonly wheat: "#f5deb3";
+    readonly white: "#ffffff";
+    readonly whitesmoke: "#f5f5f5";
+    readonly yellow: "#ffff00";
+    readonly yellowgreen: "#9acd32";
+    readonly padaleckipink: "oklch(100% 0.42 360deg / 71.70%)";
+    readonly "lodge-blu-color": "rgb(53\t101\t144)";
+    readonly lavendi: "oklch(79.90% 0.11 318.24deg / 100%)";
+    readonly shadyshroom: "oklch(53% 0.07 21.60deg / 100%)";
+    readonly patriarchalplum: "oklch(31.20% 0.11 19.80deg / 100%)";
+};
+
+export declare const COLOR_SPACE_DENORM_UNITS: {
+    readonly rgb: {
+        readonly r: "";
+        readonly g: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+    readonly hsl: {
+        readonly h: "deg";
+        readonly s: "%";
+        readonly l: "%";
+        readonly alpha: "%";
+    };
+    readonly hsv: {
+        readonly h: "deg";
+        readonly s: "%";
+        readonly v: "%";
+        readonly alpha: "%";
+    };
+    readonly hwb: {
+        readonly h: "deg";
+        readonly w: "%";
+        readonly b: "%";
+        readonly alpha: "%";
+    };
+    readonly lab: {
+        readonly l: "%";
+        readonly a: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+    readonly lch: {
+        readonly l: "%";
+        readonly c: "";
+        readonly h: "deg";
+        readonly alpha: "%";
+    };
+    readonly oklab: {
+        readonly l: "%";
+        readonly a: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+    readonly oklch: {
+        readonly l: "%";
+        readonly c: "";
+        readonly h: "deg";
+        readonly alpha: "%";
+    };
+    readonly xyz: {
+        readonly x: "%";
+        readonly y: "%";
+        readonly z: "%";
+        readonly alpha: "%";
+    };
+    readonly kelvin: {
+        readonly kelvin: "K";
+        readonly alpha: "%";
+    };
+    readonly "srgb-linear": {
+        readonly r: "";
+        readonly g: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+    readonly "display-p3": {
+        readonly r: "";
+        readonly g: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+    readonly "a98-rgb": {
+        readonly r: "";
+        readonly g: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+    readonly "prophoto-rgb": {
+        readonly r: "";
+        readonly g: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+    readonly rec2020: {
+        readonly r: "";
+        readonly g: "";
+        readonly b: "";
+        readonly alpha: "%";
+    };
+};
+
+export declare const COLOR_SPACE_NAMES: {
+    readonly rgb: "RGB";
+    readonly hsl: "HSL";
+    readonly hsv: "HSV";
+    readonly hwb: "HWB";
+    readonly lab: "Lab";
+    readonly lch: "LCh";
+    readonly oklab: "OKLab";
+    readonly oklch: "OKLCh";
+    readonly xyz: "XYZ";
+    readonly kelvin: "Kelvin";
+    readonly "srgb-linear": "sRGB Linear";
+    readonly "display-p3": "Display P3";
+    readonly "a98-rgb": "Adobe RGB";
+    readonly "prophoto-rgb": "ProPhoto RGB";
+    readonly rec2020: "Rec. 2020";
+};
+
+export declare const COLOR_SPACE_RANGES: {
+    readonly rgb: {
+        readonly r: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 255;
+            };
+        };
+        readonly g: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 255;
+            };
+        };
+        readonly b: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 255;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly hsl: {
+        readonly h: {
+            readonly deg: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly s: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly l: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly hsv: {
+        readonly h: {
+            readonly deg: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly s: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly v: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly hwb: {
+        readonly h: {
+            readonly deg: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly w: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly b: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly lab: {
+        readonly l: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly a: {
+            readonly number: {
+                readonly min: -125;
+                readonly max: 125;
+            };
+            readonly "%": {
+                readonly min: -100;
+                readonly max: 100;
+            };
+        };
+        readonly b: {
+            readonly number: {
+                readonly min: -125;
+                readonly max: 125;
+            };
+            readonly "%": {
+                readonly min: -100;
+                readonly max: 100;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly lch: {
+        readonly l: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly c: {
+            readonly number: {
+                readonly min: 0;
+                readonly max: 150;
+            };
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly h: {
+            readonly deg: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly oklab: {
+        readonly l: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly a: {
+            readonly number: {
+                readonly min: -0.4;
+                readonly max: 0.4;
+            };
+            readonly "%": {
+                readonly min: -100;
+                readonly max: 100;
+            };
+        };
+        readonly b: {
+            readonly number: {
+                readonly min: -0.4;
+                readonly max: 0.4;
+            };
+            readonly "%": {
+                readonly min: -100;
+                readonly max: 100;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly oklch: {
+        readonly l: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly c: {
+            readonly number: {
+                readonly min: 0;
+                readonly max: 0.5;
+            };
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly h: {
+            readonly deg: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 360;
+            };
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly xyz: {
+        readonly x: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly y: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly z: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly kelvin: {
+        readonly kelvin: {
+            readonly number: {
+                readonly min: 1000;
+                readonly max: 40000;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly "srgb-linear": {
+        readonly r: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly g: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly b: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly "display-p3": {
+        readonly r: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly g: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly b: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly "a98-rgb": {
+        readonly r: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly g: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly b: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly "prophoto-rgb": {
+        readonly r: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly g: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly b: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+    readonly rec2020: {
+        readonly r: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly g: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly b: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+        readonly alpha: {
+            readonly "%": {
+                readonly min: 0;
+                readonly max: 100;
+            };
+            readonly number: {
+                readonly min: 0;
+                readonly max: 1;
+            };
+        };
+    };
+};
+
+export declare const COLOR_UNITS: readonly ["color"];
+
+export declare type ColorSpace = keyof typeof COLOR_SPACE_RANGES;
+
+export declare type ColorSpaceMap<T> = {
+    rgb: RGBColor<T>;
+    hsl: HSLColor<T>;
+    hsv: HSVColor<T>;
+    hwb: HWBColor<T>;
+    lab: LABColor<T>;
+    lch: LCHColor<T>;
+    oklab: OKLABColor<T>;
+    oklch: OKLCHColor<T>;
+    kelvin: KelvinColor<T>;
+    xyz: XYZColor<T>;
+    "srgb-linear": LinearSRGBColor<T>;
+    "display-p3": DisplayP3Color<T>;
+    "a98-rgb": AdobeRGBColor<T>;
+    "prophoto-rgb": ProPhotoRGBColor<T>;
+    rec2020: Rec2020Color<T>;
+};
+
+export declare const colorUnit2: <C extends ColorSpace>(color: ValueUnit<Color<ValueUnit<number>>, "color">, to?: C | null, normalized?: boolean, inverse?: boolean, inplace?: boolean) => ValueUnit<ColorSpaceMap<ValueUnit<number>>[C], "color">;
+
+declare type ComponentExpr = {
+    type: "ref";
+    name: string;
+} | {
+    type: "calc";
+    expr: string;
+} | {
+    type: "literal";
+    value: number;
+} | {
+    type: "none";
+};
+
+export declare const COMPUTED_UNITS: readonly ["var", "calc"];
+
+/**
+ * Compute the maximum saturation S = C/L for a given hue direction (a_, b_)
+ * where a_² + b_² ≈ 1. Uses a polynomial initial guess refined by one
+ * Halley's method step for cubic convergence.
+ */
+export declare function computeMaxSaturation(a_: number, b_: number): number;
+
+export declare function convert2(value: number, from: (typeof UNITS)[number], to: (typeof UNITS)[number], target?: HTMLElement): number;
+
+export declare function convertAbsoluteUnitToPixels(value: number, unit: string): number;
+
+export declare function convertToDegrees(value: number, unit: (typeof ANGLE_UNITS)[number]): number;
+
+export declare function convertToDPI(value: number, unit: (typeof RESOLUTION_UNITS)[number]): number;
+
+export declare function convertToMs(value: number, unit: (typeof TIME_UNITS)[number]): number;
+
+export declare function convertToPixels(value: number, unit: (typeof ABSOLUTE_LENGTH_UNITS)[number] | (typeof RELATIVE_LENGTH_UNITS)[number] | (typeof PERCENTAGE_UNITS)[number], element?: HTMLElement, property?: string): number;
+
+export declare function createHash(algorithm: string, data: string): Promise<string>;
+
+export declare const CSSColor: {
+    Value: Parser<ValueUnit<any, string | undefined>>;
+    colorValue: Parser<ValueUnit<any, string | undefined>>;
+    componentExpr: Parser<ComponentExpr>;
+    sep: Parser<string>;
+    alphaSep: Parser<string>;
+    div: Parser<string>;
+};
+
+export declare const CSSFunction: {
+    Function: Parser<any>;
+    Value: Parser<any>;
+    FunctionArgs: Parser<ValueArray<any>>;
+};
+
+export declare const CSSJSON: Parser<ValueUnit<any, string>>;
+
+export declare const CSSString: Parser<ValueUnit<string, string | undefined>>;
+
+export declare const CSSValues: {
+    Value: Parser<any>;
+    Values: Parser<any[]>;
+};
+
+export declare const CSSValueUnit: {
+    Length: Parser<ValueUnit<number, string>>;
+    Angle: Parser<ValueUnit<number, string>>;
+    Time: Parser<ValueUnit<number, string>>;
+    TimePercentage: Parser<ValueUnit<any, string | undefined>>;
+    Resolution: Parser<ValueUnit<number, string>>;
+    Percentage: Parser<ValueUnit<any, string | undefined>>;
+    Color: Parser<ValueUnit<any, string | undefined>>;
+    Slash: Parser<ValueUnit<string, string>>;
+    Value: Parser<ValueUnit<any, string | undefined>>;
+    sep: Parser<string>;
+};
+
+export declare function cubicBezier(t: number, x1: number, y1: number, x2: number, y2: number): number[];
+
+export declare function cubicBezierToString(x1: number, y1: number, x2: number, y2: number): string;
+
+export declare function cubicBezierToSVG(x1: number, y1: number, x2: number, y2: number): string;
+
+export declare const CYLINDRICAL_HUE_COMPONENT: Partial<Record<ColorSpace, string>>;
+
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, immediate?: boolean): ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+};
+
+export declare function deCasteljau(t: number, points: number[]): number;
+
+/**
+ * Analytical sRGB gamut mapping based on Bjorn Ottosson's ok_color.h
+ * https://bottosson.github.io/posts/gamutclipping/
+ *
+ * Strategy: adaptive L0 (alpha=0.05) — deterministic, zero-iteration,
+ * perceptually correct in OKLab with exact hue preservation.
+ *
+ * MIT License — Copyright (c) 2021 Bjorn Ottosson
+ */
+export declare const DELTA_E_OK_JND = 0.02;
+
+export declare function deltaEOK(L1: number, a1: number, b1: number, L2: number, a2: number, b2: number): number;
+
+export declare function displayP32xyz({ r, g, b, alpha }: DisplayP3Color): XYZColor;
+
+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);
+}
+
+/** Parser that always fails with the given message. */
+export declare function fail(message: string): Parser<never>;
+
+/**
+ * Find the cusp (L_cusp, C_cusp) — the point of maximum chroma on the
+ * gamut boundary for a given hue direction.
+ */
+export declare function findCusp(a_: number, b_: number): {
+    L: number;
+    C: number;
+};
+
+/**
+ * Find the parameter t where the ray from (L0, 0) through (L1, C1)
+ * intersects the sRGB gamut boundary. Returns t ∈ [0,1].
+ *
+ * Lower half uses closed-form; upper half uses one Halley's method step.
+ */
+export declare function findGamutIntersection(a_: number, b_: number, L1: number, C1: number, L0: number, cusp: {
+    L: number;
+    C: number;
+}): number;
+
+export declare const flattenObject: (obj: any) => Record<string, any>;
+
+export declare const FRAME_RATE: number;
+
+export declare class FunctionValue<T = any, N extends string = string> {
+    name: N;
+    values: Array<ValueUnit<T> | FunctionValue<T>>;
+    constructor(name: N, values: Array<ValueUnit<T> | FunctionValue<T>>);
+    setSubProperty(subProperty: any): void;
+    setProperty(property: any): void;
+    setTargets(targets: HTMLElement[]): void;
+    setValue(value: T, index?: number): void;
+    valueOf(): any[];
+    toString(): string;
+    toJSON(): Record<string, any[]>;
+    clone(): FunctionValue<T>;
+}
+
+export declare const GAMUT_SECTOR_COEFFICIENTS: readonly [{
+    readonly test: (a: number, b: number) => boolean;
+    readonly k0: 1.19086277;
+    readonly k1: 1.76576728;
+    readonly k2: 0.59662641;
+    readonly k3: 0.75515197;
+    readonly k4: 0.56771245;
+    readonly wl: 4.0767416621;
+    readonly wm: -3.3077115913;
+    readonly ws: 0.2309699292;
+}, {
+    readonly test: (a: number, b: number) => boolean;
+    readonly k0: 0.73956515;
+    readonly k1: -0.45954404;
+    readonly k2: 0.08285427;
+    readonly k3: 0.1254107;
+    readonly k4: 0.14503204;
+    readonly wl: -1.2684380046;
+    readonly wm: 2.6097574011;
+    readonly ws: -0.3413193965;
+}, {
+    readonly test: () => boolean;
+    readonly k0: 1.35733652;
+    readonly k1: -0.00915799;
+    readonly k2: -1.1513021;
+    readonly k3: -0.50559606;
+    readonly k4: 0.00692167;
+    readonly wl: -0.0041960863;
+    readonly wm: -0.7034186147;
+    readonly ws: 1.707614701;
+}];
+
+export declare function gamutMap<C extends Color>(color: C): C;
+
+/**
+ * Core gamut mapping in raw OKLab space.
+ * Adaptive L0 strategy (alpha=0.05) — preserves hue exactly.
+ *
+ * Input/output: raw OKLab (L ∈ [0,1], a,b ∈ [-0.4,0.4]).
+ * Returns the mapped (L, a, b) tuple.
+ */
+export declare function gamutMapOKLab(L: number, a: number, b: number): [number, number, number];
+
+/**
+ * Map an sRGB color (components may be outside [0,1]) to in-gamut sRGB.
+ * Returns clamped sRGB [0,1]³.
+ */
+export declare function gamutMapSRGB(r: number, g: number, b: number): [number, number, number];
+
+export declare const getComputedValue: ((value: ValueUnit, target: HTMLElement) => ValueUnit<any, any>) & {
+    cache: Map<string, {
+        value: ValueUnit<any, any>;
+        timestamp: number;
+    }>;
+};
+
+export declare const getFormattedColorSpaceRange: <T extends ColorSpace>(colorSpace: T) => ColorSpaceMap<{
+    min: string;
+    max: string;
+}>[T];
+
+export declare const hex2rgb: (hex: string) => RGBColor;
+
+export declare const hsl2hsv: ({ h, s, l, alpha }: HSLColor) => HSVColor;
+
+export declare const hsl2hwb: ({ h, s, l, alpha }: HSLColor) => HWBColor;
+
+export declare function hsl2rgb({ h, s, l, alpha }: HSLColor): RGBColor;
+
+export declare function hsl2xyz(hsl: HSLColor): XYZColor<number>;
+
+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);
+}
+
+export declare const hsv2hsl: ({ h, s, v, alpha }: HSVColor) => HSLColor;
+
+export declare function hsv2xyz(hsv: HSVColor): XYZColor;
+
+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);
+}
+
+export declare const HUE_RANGE: {
+    readonly deg: {
+        readonly min: 0;
+        readonly max: 360;
+    };
+    readonly number: {
+        readonly min: 0;
+        readonly max: 360;
+    };
+    readonly "%": {
+        readonly min: 0;
+        readonly max: 100;
+    };
+};
+
+export declare type HueInterpolationMethod = "shorter" | "longer" | "increasing" | "decreasing";
+
+export declare const hwb2hsl: ({ h, w, b, alpha }: HWBColor) => HSLColor;
+
+export declare function hwb2xyz(hwb: HWBColor): XYZColor;
+
+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 const hyphenToCamelCase: (str: string) => string;
+
+export declare const identifier: Parser<string>;
+
+export declare const integer: Parser<number>;
+
+export declare function interpBezier(t: number, points: number[][]): number[];
+
+export declare type InterpolatedVar<T> = {
+    start: ValueUnit<T>;
+    stop: ValueUnit<T>;
+    value: ValueUnit<T>;
+    computed: boolean;
+};
+
+/**
+ * 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;
+
+/** Invert a 3×3 matrix via cofactor expansion. Returns the inverse. */
+export declare function invertMat3(m: Mat3): Mat3;
+
+export declare function isColorUnit(value: ValueUnit<Color<ValueUnit>>): value is ValueUnit<Color<ValueUnit>>;
+
+export declare function isCSSStyleName(value: any): value is (typeof STYLE_NAMES)[number];
+
+/** Check if linear sRGB values are within the [0,1]³ gamut. */
+export declare function isInSRGBGamut(r: number, g: number, b: number): boolean;
+
+export declare const isObject: (value: any) => boolean;
+
+/** Case-insensitive string match. Returns the matched portion of the input. */
+export declare const istring: (str: string) => Parser<string>;
+
+export declare const kelvin2rgb: ({ kelvin, alpha }: KelvinColor) => RGBColor;
+
+export declare function kelvin2xyz(kelvin: KelvinColor): XYZColor;
+
+export declare class KelvinColor<T = number> extends Color<T> {
+    constructor(kelvin: T, alpha?: T);
+    get kelvin(): T;
+    set kelvin(value: T);
+}
+
+export declare function lab2lch({ l, a, b, alpha }: LABColor): LCHColor;
+
+export declare function lab2oklab(lab: LABColor): OKLABColor;
+
+export declare function lab2oklch(lab: LABColor): OKLCHColor;
+
+export declare function lab2xyz(lab: LABColor): XYZColor;
+
+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);
+}
+
+export declare function lch2lab({ l, c, h, alpha }: LCHColor): LABColor;
+
+export declare function lch2xyz(lch: LCHColor): XYZColor;
+
+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 const LENGTH_UNITS: readonly ["px", "cm", "mm", "Q", "in", "pc", "pt", "em", "ex", "ch", "rem", "lh", "rlh", "vw", "vh", "vmin", "vmax", "vb", "vi", "svw", "svh", "lvw", "lvh", "dvw", "dvh"];
+
+export declare function lerp(t: number, start: number, end: number): number;
+
+export declare const LINEAR_SRGB_TO_LMS: Mat3;
+
+export declare function linearSrgb2xyz({ r, g, b, alpha }: LinearSRGBColor): XYZColor;
+
+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);
+}
+
+export declare function linearToAdobeRgb(c: number): number;
+
+export declare function linearToProPhoto(c: number): number;
+
+export declare function linearToRec2020(c: number): number;
+
+export declare function linearToSrgb(channel: number): number;
+
+export declare const LMS_TO_LINEAR_SRGB: Mat3;
+
+export declare const LMS_TO_OKLAB_MATRIX: Mat3;
+
+export declare const LMS_TO_XYZ_MATRIX: Mat3;
+
+export declare function logerp(t: number, start: number, end: number): number;
+
+export declare type Mat3 = [
+number,
+number,
+number,
+number,
+number,
+number,
+number,
+number,
+number
+];
+
+export declare interface MatrixValues {
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    skewX: number;
+    skewY: number;
+    skewZ: number;
+    translateX: number;
+    translateY: number;
+    translateZ: number;
+    rotateX: number;
+    rotateY: number;
+    rotateZ: number;
+    perspectiveX: number;
+    perspectiveY: number;
+    perspectiveZ: number;
+    perspectiveW: number;
+}
+
+export declare function memoize<T extends (...args: any[]) => any>(func: T, options?: MemoizeOptions): T & {
+    cache: Map<string, {
+        value: ReturnType<T>;
+        timestamp: number;
+    }>;
+};
+
+export declare interface MemoizeOptions {
+    maxCacheSize?: number;
+    ttl?: number;
+    keyFn?: (...args: any[]) => string;
+}
+
+/**
+ * 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;
+
+/** Multiply two Mat3 matrices (row-major): result = A × B */
+export declare function multiplyMat3(a: Mat3, b: Mat3): Mat3;
+
+export declare const none: Parser<string>;
+
+export declare const normalizeColor: (color: Color<ValueUnit<number> | number>, inverse?: boolean) => Color<ValueUnit<number>>;
+
+export declare const normalizeColorUnit: (color: ValueUnit<Color<ValueUnit<number>>, "color">, inverse?: boolean, inplace?: boolean) => ValueUnit<Color<ValueUnit<number>>, "color">;
+
+export declare const normalizeColorUnitComponent: (v: number, unit: string, colorSpace: ColorSpace, component: string, inverse?: boolean) => ValueUnit<number, string>;
+
+export declare const normalizeColorUnits: (a: ValueUnit<Color<ValueUnit<number>>, "color">, b: ValueUnit<Color<ValueUnit<number>>, "color">, to?: ColorSpace, normalized?: boolean, inverse?: boolean, inplace?: boolean) => readonly [ValueUnit<RGBColor<ValueUnit<number, string | undefined>> | HSLColor<ValueUnit<number, string | undefined>> | HSVColor<ValueUnit<number, string | undefined>> | HWBColor<ValueUnit<number, string | undefined>> | LABColor<ValueUnit<number, string | undefined>> | LCHColor<ValueUnit<number, string | undefined>> | OKLABColor<ValueUnit<number, string | undefined>> | OKLCHColor<ValueUnit<number, string | undefined>> | XYZColor<ValueUnit<number, string | undefined>> | KelvinColor<ValueUnit<number, string | undefined>> | LinearSRGBColor<ValueUnit<number, string | undefined>> | DisplayP3Color<ValueUnit<number, string | undefined>> | AdobeRGBColor<ValueUnit<number, string | undefined>> | ProPhotoRGBColor<ValueUnit<number, string | undefined>> | Rec2020Color<ValueUnit<number, string | undefined>>, "color">, ValueUnit<RGBColor<ValueUnit<number, string | undefined>> | HSLColor<ValueUnit<number, string | undefined>> | HSVColor<ValueUnit<number, string | undefined>> | HWBColor<ValueUnit<number, string | undefined>> | LABColor<ValueUnit<number, string | undefined>> | LCHColor<ValueUnit<number, string | undefined>> | OKLABColor<ValueUnit<number, string | undefined>> | OKLCHColor<ValueUnit<number, string | undefined>> | XYZColor<ValueUnit<number, string | undefined>> | KelvinColor<ValueUnit<number, string | undefined>> | LinearSRGBColor<ValueUnit<number, string | undefined>> | DisplayP3Color<ValueUnit<number, string | undefined>> | AdobeRGBColor<ValueUnit<number, string | undefined>> | ProPhotoRGBColor<ValueUnit<number, string | undefined>> | Rec2020Color<ValueUnit<number, string | undefined>>, "color">];
+
+export declare const normalizeNumericUnits: (a: ValueUnit, b: ValueUnit, inplace?: boolean) => [ValueUnit, ValueUnit];
+
+export declare function normalizeValueUnits(left: ValueUnit, right: ValueUnit): InterpolatedVar<any>;
+
+export declare const number: Parser<number>;
+
+export declare function oklab2lab(oklab: OKLABColor): LABColor;
+
+export declare function oklab2oklch({ l, a, b, alpha }: OKLABColor): OKLCHColor;
+
+export declare function oklab2xyz({ l, a, b, alpha }: OKLABColor): XYZColor;
+
+export declare const OKLAB_TO_LMS_COEFF: {
+    readonly l: Vec3;
+    readonly m: Vec3;
+    readonly s: Vec3;
+};
+
+export declare const OKLAB_TO_LMS_MATRIX: Mat3;
+
+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);
+}
+
+/**
+ * Direct OKLab→linear sRGB conversion (no XYZ intermediate).
+ * L ∈ [0,1], a,b ∈ [-0.4,0.4] (raw OKLab, NOT normalized).
+ */
+export declare function oklabToLinearSRGB(L: number, a: number, b: number): [number, number, number];
+
+export declare function oklch2lab(oklch: OKLCHColor): LABColor;
+
+export declare function oklch2oklab({ l, c, h, alpha }: OKLCHColor): OKLABColor;
+
+export declare function oklch2xyz(oklch: OKLCHColor): XYZColor;
+
+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 function parseCSSColor(input: string): ValueUnit;
+
+export declare const parseCSSPercent: ((input: string | number) => number) & {
+    cache: Map<string, {
+        value: number;
+        timestamp: number;
+    }>;
+};
+
+export declare const parseCSSTime: ((input: string) => number) & {
+    cache: Map<string, {
+        value: number;
+        timestamp: number;
+    }>;
+};
+
+export declare const parseCSSValue: ((input: string) => ValueUnit | FunctionValue) & {
+    cache: Map<string, {
+        value: ValueUnit<any, string | undefined> | FunctionValue<any, string>;
+        timestamp: number;
+    }>;
+};
+
+export declare function parseCSSValueUnit(input: string): ValueUnit;
+
+/**
+ * Parse and return a result object with `.status` and `.value`.
+ * Equivalent to Parsimmon's `.parse()` return shape.
+ */
+export declare function parseResult<T>(parser: Parser<T>, input: string): {
+    status: boolean;
+    value: T;
+};
+
+export declare const PERCENTAGE_UNITS: readonly ["%"];
+
+export declare function proPhoto2xyz({ r, g, b, alpha }: ProPhotoRGBColor): XYZColor;
+
+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);
+}
+
+export declare function proPhotoToLinear(c: number): number;
+
+export declare function rec20202xyz({ r, g, b, alpha }: Rec2020Color): XYZColor;
+
+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);
+}
+
+export declare function rec2020ToLinear(c: number): number;
+
+export declare const RELATIVE_LENGTH_UNITS: readonly ["em", "ex", "ch", "rem", "lh", "rlh", "vw", "vh", "vmin", "vmax", "vb", "vi", "svw", "svh", "lvw", "lvh", "dvw", "dvh"];
+
+declare function requestAnimationFrame_2(callback: FrameRequestCallback): number | NodeJS.Timeout;
+export { requestAnimationFrame_2 as requestAnimationFrame }
+
+export declare const RESOLUTION_UNITS: readonly ["dpi", "dpcm", "dppx", "cqw"];
+
+export declare const rgb2hex: ({ r, g, b, alpha }: RGBColor) => string;
+
+export declare const rgb2hsl: ({ r, g, b, alpha }: RGBColor) => HSLColor;
+
+export declare const rgb2kelvin: ({ r, g, b, alpha }: RGBColor) => KelvinColor;
+
+export declare function rgb2xyz({ r, g, b, alpha }: RGBColor): XYZColor;
+
+export declare const RGB_RANGE: {
+    readonly "%": {
+        readonly min: 0;
+        readonly max: 100;
+    };
+    readonly number: {
+        readonly min: 0;
+        readonly max: 255;
+    };
+};
+
+export declare const RGBA_MAX = 255;
+
+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);
+}
+
+export declare function scale(value: number, fromMin: number, fromMax: number, toMin?: number, toMax?: number): number;
+
+export declare function seekPreviousValue<T>(ix: number, values: T[], pred: (f: T) => boolean): number | undefined;
+
+export declare function sleep(ms: number): Promise<unknown>;
+
+export declare function srgbToLinear(channel: number): number;
+
+/**
+ * Convert sRGB (possibly out-of-gamut) to raw OKLab.
+ * Uses the direct linear sRGB → LMS path.
+ */
+export declare function srgbToOKLab(r: number, g: number, b: number): [number, number, number];
+
+export declare const STRING_UNITS: readonly ["string"];
+
+export declare const STYLE_NAMES: readonly ["accentColor", "additiveSymbols", "alignContent", "alignItems", "alignSelf", "alignmentBaseline", "all", "anchorName", "animation", "animationComposition", "animationDelay", "animationDirection", "animationDuration", "animationFillMode", "animationIterationCount", "animationName", "animationPlayState", "animationRange", "animationRangeEnd", "animationRangeStart", "animationTimeline", "animationTimingFunction", "appRegion", "appearance", "ascentOverride", "aspectRatio", "backdropFilter", "backfaceVisibility", "background", "backgroundAttachment", "backgroundBlendMode", "backgroundClip", "backgroundColor", "backgroundImage", "backgroundOrigin", "backgroundPosition", "backgroundPositionX", "backgroundPositionY", "backgroundRepeat", "backgroundSize", "basePalette", "baselineShift", "baselineSource", "blockSize", "border", "borderBlock", "borderBlockColor", "borderBlockEnd", "borderBlockEndColor", "borderBlockEndStyle", "borderBlockEndWidth", "borderBlockStart", "borderBlockStartColor", "borderBlockStartStyle", "borderBlockStartWidth", "borderBlockStyle", "borderBlockWidth", "borderBottom", "borderBottomColor", "borderBottomLeftRadius", "borderBottomRightRadius", "borderBottomStyle", "borderBottomWidth", "borderCollapse", "borderColor", "borderEndEndRadius", "borderEndStartRadius", "borderImage", "borderImageOutset", "borderImageRepeat", "borderImageSlice", "borderImageSource", "borderImageWidth", "borderInline", "borderInlineColor", "borderInlineEnd", "borderInlineEndColor", "borderInlineEndStyle", "borderInlineEndWidth", "borderInlineStart", "borderInlineStartColor", "borderInlineStartStyle", "borderInlineStartWidth", "borderInlineStyle", "borderInlineWidth", "borderLeft", "borderLeftColor", "borderLeftStyle", "borderLeftWidth", "borderRadius", "borderRight", "borderRightColor", "borderRightStyle", "borderRightWidth", "borderSpacing", "borderStartEndRadius", "borderStartStartRadius", "borderStyle", "borderTop", "borderTopColor", "borderTopLeftRadius", "borderTopRightRadius", "borderTopStyle", "borderTopWidth", "borderWidth", "bottom", "boxShadow", "boxSizing", "breakAfter", "breakBefore", "breakInside", "bufferedRendering", "captionSide", "caretColor", "clear", "clip", "clipPath", "clipRule", "color", "colorInterpolation", "colorInterpolationFilters", "colorRendering", "colorScheme", "columnCount", "columnFill", "columnGap", "columnRule", "columnRuleColor", "columnRuleStyle", "columnRuleWidth", "columnSpan", "columnWidth", "columns", "contain", "containIntrinsicBlockSize", "containIntrinsicHeight", "containIntrinsicInlineSize", "containIntrinsicSize", "containIntrinsicWidth", "container", "containerName", "containerType", "content", "contentVisibility", "counterIncrement", "counterReset", "counterSet", "cursor", "cx", "cy", "d", "descentOverride", "direction", "display", "dominantBaseline", "emptyCells", "fallback", "fieldSizing", "fill", "fillOpacity", "fillRule", "filter", "flex", "flexBasis", "flexDirection", "flexFlow", "flexGrow", "flexShrink", "flexWrap", "float", "floodColor", "floodOpacity", "font", "fontDisplay", "fontFamily", "fontFeatureSettings", "fontKerning", "fontOpticalSizing", "fontPalette", "fontSize", "fontStretch", "fontStyle", "fontSynthesis", "fontSynthesisSmallCaps", "fontSynthesisStyle", "fontSynthesisWeight", "fontVariant", "fontVariantAlternates", "fontVariantCaps", "fontVariantEastAsian", "fontVariantLigatures", "fontVariantNumeric", "fontVariantPosition", "fontVariationSettings", "fontWeight", "forcedColorAdjust", "gap", "grid", "gridArea", "gridAutoColumns", "gridAutoFlow", "gridAutoRows", "gridColumn", "gridColumnEnd", "gridColumnGap", "gridColumnStart", "gridGap", "gridRow", "gridRowEnd", "gridRowGap", "gridRowStart", "gridTemplate", "gridTemplateAreas", "gridTemplateColumns", "gridTemplateRows", "height", "hyphenateCharacter", "hyphenateLimitChars", "hyphens", "imageOrientation", "imageRendering", "inherits", "initialLetter", "initialValue", "inlineSize", "inset", "insetArea", "insetBlock", "insetBlockEnd", "insetBlockStart", "insetInline", "insetInlineEnd", "insetInlineStart", "isolation", "justifyContent", "justifyItems", "justifySelf", "left", "letterSpacing", "lightingColor", "lineBreak", "lineGapOverride", "lineHeight", "listStyle", "listStyleImage", "listStylePosition", "listStyleType", "margin", "marginBlock", "marginBlockEnd", "marginBlockStart", "marginBottom", "marginInline", "marginInlineEnd", "marginInlineStart", "marginLeft", "marginRight", "marginTop", "marker", "markerEnd", "markerMid", "markerStart", "mask", "maskClip", "maskComposite", "maskImage", "maskMode", "maskOrigin", "maskPosition", "maskRepeat", "maskSize", "maskType", "mathDepth", "mathShift", "mathStyle", "maxBlockSize", "maxHeight", "maxInlineSize", "maxWidth", "minBlockSize", "minHeight", "minInlineSize", "minWidth", "mixBlendMode", "navigation", "negative", "objectFit", "objectPosition", "objectViewBox", "offset", "offsetAnchor", "offsetDistance", "offsetPath", "offsetPosition", "offsetRotate", "opacity", "order", "orphans", "outline", "outlineColor", "outlineOffset", "outlineStyle", "outlineWidth", "overflow", "overflowAnchor", "overflowClipMargin", "overflowWrap", "overflowX", "overflowY", "overlay", "overrideColors", "overscrollBehavior", "overscrollBehaviorBlock", "overscrollBehaviorInline", "overscrollBehaviorX", "overscrollBehaviorY", "pad", "padding", "paddingBlock", "paddingBlockEnd", "paddingBlockStart", "paddingBottom", "paddingInline", "paddingInlineEnd", "paddingInlineStart", "paddingLeft", "paddingRight", "paddingTop", "page", "pageBreakAfter", "pageBreakBefore", "pageBreakInside", "pageOrientation", "paintOrder", "perspective", "perspectiveOrigin", "placeContent", "placeItems", "placeSelf", "pointerEvents", "position", "positionAnchor", "positionTry", "positionTryOptions", "positionTryOrder", "positionVisibility", "prefix", "quotes", "r", "range", "resize", "right", "rotate", "rowGap", "rubyPosition", "rx", "ry", "scale", "scrollBehavior", "scrollMargin", "scrollMarginBlock", "scrollMarginBlockEnd", "scrollMarginBlockStart", "scrollMarginBottom", "scrollMarginInline", "scrollMarginInlineEnd", "scrollMarginInlineStart", "scrollMarginLeft", "scrollMarginRight", "scrollMarginTop", "scrollPadding", "scrollPaddingBlock", "scrollPaddingBlockEnd", "scrollPaddingBlockStart", "scrollPaddingBottom", "scrollPaddingInline", "scrollPaddingInlineEnd", "scrollPaddingInlineStart", "scrollPaddingLeft", "scrollPaddingRight", "scrollPaddingTop", "scrollSnapAlign", "scrollSnapStop", "scrollSnapType", "scrollTimeline", "scrollTimelineAxis", "scrollTimelineName", "scrollbarColor", "scrollbarGutter", "scrollbarWidth", "shapeImageThreshold", "shapeMargin", "shapeOutside", "shapeRendering", "size", "sizeAdjust", "speak", "speakAs", "src", "stopColor", "stopOpacity", "stroke", "strokeDasharray", "strokeDashoffset", "strokeLinecap", "strokeLinejoin", "strokeMiterlimit", "strokeOpacity", "strokeWidth", "suffix", "symbols", "syntax", "system", "tabSize", "tableLayout", "textAlign", "textAlignLast", "textAnchor", "textCombineUpright", "textDecoration", "textDecorationColor", "textDecorationLine", "textDecorationSkipInk", "textDecorationStyle", "textDecorationThickness", "textEmphasis", "textEmphasisColor", "textEmphasisPosition", "textEmphasisStyle", "textIndent", "textOrientation", "textOverflow", "textRendering", "textShadow", "textSizeAdjust", "textSpacingTrim", "textTransform", "textUnderlineOffset", "textUnderlinePosition", "textWrap", "timelineScope", "top", "touchAction", "transform", "transformBox", "transformOrigin", "transformStyle", "transition", "transitionBehavior", "transitionDelay", "transitionDuration", "transitionProperty", "transitionTimingFunction", "translate", "types", "unicodeBidi", "unicodeRange", "userSelect", "vectorEffect", "verticalAlign", "viewTimeline", "viewTimelineAxis", "viewTimelineInset", "viewTimelineName", "viewTransitionClass", "viewTransitionName", "visibility", "webkitAlignContent", "webkitAlignItems", "webkitAlignSelf", "webkitAnimation", "webkitAnimationDelay", "webkitAnimationDirection", "webkitAnimationDuration", "webkitAnimationFillMode", "webkitAnimationIterationCount", "webkitAnimationName", "webkitAnimationPlayState", "webkitAnimationTimingFunction", "webkitAppRegion", "webkitAppearance", "webkitBackfaceVisibility", "webkitBackgroundClip", "webkitBackgroundOrigin", "webkitBackgroundSize", "webkitBorderAfter", "webkitBorderAfterColor", "webkitBorderAfterStyle", "webkitBorderAfterWidth", "webkitBorderBefore", "webkitBorderBeforeColor", "webkitBorderBeforeStyle", "webkitBorderBeforeWidth", "webkitBorderBottomLeftRadius", "webkitBorderBottomRightRadius", "webkitBorderEnd", "webkitBorderEndColor", "webkitBorderEndStyle", "webkitBorderEndWidth", "webkitBorderHorizontalSpacing", "webkitBorderImage", "webkitBorderRadius", "webkitBorderStart", "webkitBorderStartColor", "webkitBorderStartStyle", "webkitBorderStartWidth", "webkitBorderTopLeftRadius", "webkitBorderTopRightRadius", "webkitBorderVerticalSpacing", "webkitBoxAlign", "webkitBoxDecorationBreak", "webkitBoxDirection", "webkitBoxFlex", "webkitBoxOrdinalGroup", "webkitBoxOrient", "webkitBoxPack", "webkitBoxReflect", "webkitBoxShadow", "webkitBoxSizing", "webkitClipPath", "webkitColumnBreakAfter", "webkitColumnBreakBefore", "webkitColumnBreakInside", "webkitColumnCount", "webkitColumnGap", "webkitColumnRule", "webkitColumnRuleColor", "webkitColumnRuleStyle", "webkitColumnRuleWidth", "webkitColumnSpan", "webkitColumnWidth", "webkitColumns", "webkitFilter", "webkitFlex", "webkitFlexBasis", "webkitFlexDirection", "webkitFlexFlow", "webkitFlexGrow", "webkitFlexShrink", "webkitFlexWrap", "webkitFontFeatureSettings", "webkitFontSmoothing", "webkitHyphenateCharacter", "webkitJustifyContent", "webkitLineBreak", "webkitLineClamp", "webkitLocale", "webkitLogicalHeight", "webkitLogicalWidth", "webkitMarginAfter", "webkitMarginBefore", "webkitMarginEnd", "webkitMarginStart", "webkitMask", "webkitMaskBoxImage", "webkitMaskBoxImageOutset", "webkitMaskBoxImageRepeat", "webkitMaskBoxImageSlice", "webkitMaskBoxImageSource", "webkitMaskBoxImageWidth", "webkitMaskClip", "webkitMaskComposite", "webkitMaskImage", "webkitMaskOrigin", "webkitMaskPosition", "webkitMaskPositionX", "webkitMaskPositionY", "webkitMaskRepeat", "webkitMaskSize", "webkitMaxLogicalHeight", "webkitMaxLogicalWidth", "webkitMinLogicalHeight", "webkitMinLogicalWidth", "webkitOpacity", "webkitOrder", "webkitPaddingAfter", "webkitPaddingBefore", "webkitPaddingEnd", "webkitPaddingStart", "webkitPerspective", "webkitPerspectiveOrigin", "webkitPerspectiveOriginX", "webkitPerspectiveOriginY", "webkitPrintColorAdjust", "webkitRtlOrdering", "webkitRubyPosition", "webkitShapeImageThreshold", "webkitShapeMargin", "webkitShapeOutside", "webkitTapHighlightColor", "webkitTextCombine", "webkitTextDecorationsInEffect", "webkitTextEmphasis", "webkitTextEmphasisColor", "webkitTextEmphasisPosition", "webkitTextEmphasisStyle", "webkitTextFillColor", "webkitTextOrientation", "webkitTextSecurity", "webkitTextSizeAdjust", "webkitTextStroke", "webkitTextStrokeColor", "webkitTextStrokeWidth", "webkitTransform", "webkitTransformOrigin", "webkitTransformOriginX", "webkitTransformOriginY", "webkitTransformOriginZ", "webkitTransformStyle", "webkitTransition", "webkitTransitionDelay", "webkitTransitionDuration", "webkitTransitionProperty", "webkitTransitionTimingFunction", "webkitUserDrag", "webkitUserModify", "webkitUserSelect", "webkitWritingMode", "whiteSpace", "whiteSpaceCollapse", "widows", "width", "willChange", "wordBreak", "wordSpacing", "wordWrap", "writingMode", "x", "y", "zIndex", "zoom"];
+
+/** Parser that always succeeds with the given value without consuming input. */
+export declare function succeed<T>(value: T): Parser<T>;
+
+export declare const TIME_UNITS: readonly ["s", "ms"];
+
+/** Multiply a Mat3 (row-major) by a Vec3: result = M * v */
+export declare function transformMat3(v: Vec3, m: Mat3): Vec3;
+
+/** Transpose a Mat3 (row-major → row-major transpose) */
+export declare function transposeMat3(m: Mat3): Mat3;
+
+/**
+ * Try to parse; return the result or throw on failure.
+ * Equivalent to Parsimmon's `.tryParse()`.
+ */
+export declare function tryParse<T>(parser: Parser<T>, input: string): T;
+
+export declare const unflattenObject: (flatObj: Record<string, any[]>) => any;
+
+export declare const unflattenObjectToString: (flatObj: Record<string, any[]>) => Record<string, string>;
+
+export declare const UNIT_RANGE: {
+    readonly "%": {
+        readonly min: 0;
+        readonly max: 100;
+    };
+    readonly number: {
+        readonly min: 0;
+        readonly max: 1;
+    };
+};
+
+export declare const UNITS: readonly ["px", "cm", "mm", "Q", "in", "pc", "pt", "em", "ex", "ch", "rem", "lh", "rlh", "vw", "vh", "vmin", "vmax", "vb", "vi", "svw", "svh", "lvw", "lvh", "dvw", "dvh", "s", "ms", "deg", "rad", "grad", "turn", "%", "dpi", "dpcm", "dppx", "cqw", "var", "calc", "string", "color", "", undefined];
+
+export declare const unpackMatrixValues: (value: FunctionValue) => MatrixValues;
+
+export declare class ValueArray<T = any> extends Array<ValueUnit<T> | FunctionValue<T>> {
+    constructor(...args: Array<ValueUnit<T> | FunctionValue<T>>);
+    setSubProperty(subProperty: any): void;
+    setProperty(property: any): void;
+    setTargets(targets: HTMLElement[]): void;
+    setValue(value: T, index?: number): void;
+    valueOf(): (any[] | T)[];
+    toString(): string;
+    toJSON(): (Record<string, any[]> | T)[];
+    clone(): ValueArray<T>;
+}
+
+export declare class ValueUnit<T = any, U = (typeof UNITS)[number] | string> {
+    value: T;
+    unit?: U | undefined;
+    superType?: string[] | undefined;
+    subProperty?: string | undefined;
+    property?: string | undefined;
+    targets?: HTMLElement[] | undefined;
+    constructor(value: T, unit?: U | undefined, superType?: string[] | undefined, subProperty?: string | undefined, property?: string | undefined, targets?: HTMLElement[] | undefined);
+    setSubProperty(subProperty: any): void;
+    setProperty(property: any): void;
+    setTargets(targets: HTMLElement[]): void;
+    valueOf(): T;
+    setValue(value: T): void;
+    toString(): string;
+    toJSON(): T;
+    toFixed(fractionDigits?: number): string;
+    clone(): ValueUnit<T, U>;
+    coalesce(right?: ValueUnit, inplace?: boolean): ValueUnit<any, any>;
+}
+
+/**
+ * Minimal 3×3 matrix and 3-element vector math.
+ * Replaces gl-matrix dependency — uses native number[] for full f64 precision
+ * (gl-matrix uses Float32Array).
+ *
+ * Mat3 is stored in row-major order:
+ *   [m00, m01, m02, m10, m11, m12, m20, m21, m22]
+ */
+export declare type Vec3 = [number, number, number];
+
+export declare function waitUntil(condition: () => boolean, delay?: number): Promise<void>;
+
+export declare const WHITE_POINT_D50: Vec3;
+
+export declare const WHITE_POINT_D50_D65: Mat3;
+
+export declare const WHITE_POINT_D65: Vec3;
+
+export declare const WHITE_POINT_D65_D50: Mat3;
+
+export declare const WHITE_POINTS: {
+    D65: Vec3;
+    D50: Vec3;
+};
+
+export declare type WhitePoint = keyof typeof WHITE_POINTS;
+
+declare class WhitePointColor<T = number> extends Color<T> {
+    whitePoint: WhitePoint;
+    constructor(colorSpace: ColorSpace, alpha: T, whitePoint: WhitePoint);
+}
+
+export declare function xyz2adobeRgb({ x, y, z, alpha }: XYZColor): AdobeRGBColor;
+
+export declare function xyz2displayP3({ x, y, z, alpha }: XYZColor): DisplayP3Color;
+
+export declare function xyz2hsl(xyz: XYZColor): HSLColor<number>;
+
+export declare function xyz2hsv(xyz: XYZColor): HSVColor;
+
+export declare function xyz2hwb(xyz: XYZColor): HWBColor;
+
+export declare function xyz2kelvin(xyz: XYZColor): KelvinColor;
+
+export declare function xyz2lab(xyz: XYZColor, toWhitePoint?: WhitePoint): LABColor;
+
+export declare function xyz2lch(xyz: XYZColor): LCHColor;
+
+export declare function xyz2linearSrgb({ x, y, z, alpha }: XYZColor): LinearSRGBColor;
+
+export declare function xyz2oklab(xyz: XYZColor): OKLABColor;
+
+export declare function xyz2oklch(xyz: XYZColor): OKLCHColor;
+
+export declare function xyz2proPhoto({ x, y, z, alpha }: XYZColor): ProPhotoRGBColor;
+
+export declare function xyz2rec2020({ x, y, z, alpha }: XYZColor): Rec2020Color;
+
+export declare const xyz2rgb: ({ x, y, z, alpha }: XYZColor, correctGamut?: boolean) => RGBColor;
+
+export declare const XYZ_TO_LMS_MATRIX: Mat3;
+
+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);
+}
+
+export { }