saturon 0.2.2 → 0.3.0

package/dist/engine.js

@@ -0,0 +1,1900 @@
+import { Color } from "./Color.js";
+import { config, systemColors } from "./config.js";
+import { colorModels, colorSpaces, namedColors } from "./converters.js";
+import { fitMethods } from "./math.js";
+import { cache, fit, normalize, plugins, spaceConverterToModelConverter } from "./utils.js";
+export const grammar = `
+/* ==========================================================================
+   Core Color Types
+   ========================================================================== */
+<color> = <color-base> | currentColor | <system-color> | <contrast-color()> | <device-cmyk()> | <light-dark-color>
+
+<color-base> = <hex-color> | <color-function> | <named-color> | <color-mix()> | transparent
+
+<color-function> = <rgb()> | <rgba()> | <hsl()> | <hsla()> | <hwb()> | <lab()> | <lch()> | <oklab()> | <oklch()> | <alpha()> | <color()> | <custom-color-function>
+
+/* ==========================================================================
+   RGB & RGBA Syntax
+   ========================================================================== */
+<rgb()> = [ <legacy-rgb-syntax> | <modern-rgb-syntax> | <relative-rgb-syntax> ]
+<rgba()> = [ <legacy-rgba-syntax> | <modern-rgba-syntax> | <relative-rgba-syntax> ]
+
+<legacy-rgb-syntax> = rgb( <percentage>#{3} [ , <alpha-value> ]? ) | rgb( <number>#{3} [ , <alpha-value> ]? )      
+<legacy-rgba-syntax> = rgba( <percentage>#{3} [ , <alpha-value> ]? ) | rgba( <number>#{3} [ , <alpha-value> ]? )      
+
+<modern-rgb-syntax> = rgb( <rgb-absolute-component>{3} [ / <alpha-absolute-value> ]? )
+<modern-rgba-syntax> = rgba( <rgb-absolute-component>{3} [ / <alpha-absolute-value> ]? )
+<rgb-absolute-component> = <number> | <percentage> | none
+<alpha-absolute-value> = <alpha-value> | none
+
+<relative-rgb-syntax> = rgb( from <color> <rgb-relative-component>{3} [ / <rgb-relative-alpha> ]? )
+<relative-rgba-syntax> = rgba( from <color> <rgb-relative-component>{3} [ / <rgb-relative-alpha> ]? )
+
+/* ==========================================================================
+   HSL & HSLA Syntax
+   ========================================================================== */
+<hsl()> = [ <legacy-hsl-syntax> | <modern-hsl-syntax> | <relative-hsl-syntax> ]
+<hsla()> = [ <legacy-hsla-syntax> | <modern-hsla-syntax> | <relative-hsla-syntax> ]
+
+<legacy-hsl-syntax> = hsl( <hue> , <percentage> , <percentage> [ , <alpha-value> ]? )  
+<legacy-hsla-syntax> = hsla( <hue> , <percentage> , <percentage> [ , <alpha-value> ]? )  
+
+<modern-hsl-syntax> = hsl( [ <hue> | none ] [ <percentage> | <number> | none ]{2} [ / <alpha-absolute-value> ]? )
+<modern-hsla-syntax> = hsla( [ <hue> | none ] [ <percentage> | <number> | none ]{2} [ / <alpha-absolute-value> ]? )
+
+<relative-hsl-syntax> = hsl( from <color> <hsl-relative-hue> <hsl-relative-component>{2} [ / <hsl-relative-alpha> ]? )
+<relative-hsla-syntax> = hsla( from <color> <hsl-relative-hue> <hsl-relative-component>{2} [ / <hsl-relative-alpha> ]? )
+<hsl-relative-hue> = <hue> | none | h | s | l | alpha
+<hsl-relative-component> = <percentage> | <number> | none | h | s | l | alpha
+<hsl-relative-alpha> = <alpha-value> | none | h | s | l | alpha
+
+/* ==========================================================================
+   HWB Syntax
+   ========================================================================== */
+<hwb()> = [ <absolute-hwb-syntax> | <relative-hwb-syntax> ]
+<absolute-hwb-syntax> = hwb( [ <hue> | none ] [ <percentage> | <number> | none ]{2} [ / <alpha-absolute-value> ]? )
+<relative-hwb-syntax> = hwb( from <color> <hwb-relative-hue> <hwb-relative-component>{2} [ / <hwb-relative-alpha> ]? )
+<hwb-relative-hue> = <hue> | none | h | w | b | alpha
+<hwb-relative-component> = <percentage> | <number> | none | h | w | b | alpha
+<hwb-relative-alpha> = <alpha-value> | none | h | w | b | alpha
+
+/* ==========================================================================
+   LAB & LCH Syntax
+   ========================================================================== */
+<lab()> = [ <absolute-lab-syntax> | <relative-lab-syntax> ]
+<absolute-lab-syntax> = lab( [ <percentage> | <number> | none ]{3} [ / <alpha-absolute-value> ]? )
+<relative-lab-syntax> = lab( from <color> <lab-relative-component>{3} [ / <lab-relative-alpha> ]? )
+<lab-relative-component> = <percentage> | <number> | none | l | a | b | alpha
+<lab-relative-alpha> = <alpha-value> | none | l | a | b | alpha
+
+<lch()> = [ <absolute-lch-syntax> | <relative-lch-syntax> ]
+<absolute-lch-syntax> = lch( [ <percentage> | <number> | none ]{2} [ <hue> | none ] [ / <alpha-absolute-value> ]? )
+<relative-lch-syntax> = lch( from <color> <lch-relative-component>{2} <lch-relative-hue> [ / <lch-relative-alpha> ]? )
+<lch-relative-component> = <percentage> | <number> | none | l | c | h | alpha
+<lch-relative-hue> = <hue> | none | l | c | h | alpha
+<lch-relative-alpha> = <alpha-value> | none | l | c | h | alpha
+
+/* ==========================================================================
+   OKLAB & OKLCH Syntax
+   ========================================================================== */
+<oklab()> = [ <absolute-oklab-syntax> | <relative-oklab-syntax> ]
+<absolute-oklab-syntax> = oklab( [ <percentage> | <number> | none ]{3} [ / <alpha-absolute-value> ]? )
+<relative-oklab-syntax> = oklab( from <color> <oklab-relative-component>{3} [ / <oklab-relative-alpha> ]? )
+<oklab-relative-component> = <percentage> | <number> | none | l | a | b | alpha
+<oklab-relative-alpha> = <alpha-value> | none | l | a | b | alpha
+
+<oklch()> = [ <absolute-oklch-syntax> | <relative-oklch-syntax> ]
+<absolute-oklch-syntax> = oklch( [ <percentage> | <number> | none ]{2} [ <hue> | none ] [ / <alpha-absolute-value> ]? )
+<relative-oklch-syntax> = oklch( from <color> <oklch-relative-component>{2} <oklch-relative-hue> [ / <oklch-relative-alpha> ]? )
+<oklch-relative-component> = <percentage> | <number> | none | l | c | h | alpha
+<oklch-relative-hue> = <hue> | none | l | c | h | alpha
+<oklch-relative-alpha> = <alpha-value> | none | l | c | h | alpha
+
+/* ==========================================================================
+   ALPHA Syntax
+   ========================================================================== */
+<alpha()> = alpha( from <color> [ / [ <alpha-value> | none | alpha ] ]? )
+
+/* ==========================================================================
+   COLOR Space Function Syntax
+   ========================================================================== */
+<color()> = [ <absolute-color-syntax> | <relative-color-syntax> ]
+<absolute-color-syntax> = color( [ <predefined-rgb> | <xyz-space> | <custom-color-space> ] [ <number> | <percentage> | none ]{3} [ / [ <alpha-value> | none ] ]? )
+<relative-color-syntax> = [ <relative-rgb-color-syntax> | <relative-xyz-color-syntax> | <relative-custom-color-syntax> ]
+
+<relative-rgb-color-syntax> = color( from <color> <predefined-rgb> <rgb-relative-component>{3} [ / <rgb-relative-alpha> ]? )
+
+<relative-xyz-color-syntax> = color( from <color> <xyz-space> <xyz-relative-component>{3} [ / <xyz-relative-alpha> ]? )
+<xyz-relative-component> = <number> | <percentage> | none | x | y | z | alpha
+<xyz-relative-alpha> = <alpha-value> | none | x | y | z | alpha
+
+<predefined-rgb> = srgb | srgb-linear | display-p3 | a98-rgb | prophoto-rgb | rec2020
+<xyz-space> = xyz | xyz-d50 | xyz-d65
+
+<relative-custom-color-syntax> = %unregistered-sentinal-value%
+
+/* ==========================================================================
+   Functional Utilities (Light/Dark, Contrast, CMYK, Mix)
+   ========================================================================== */
+<light-dark-color> = light-dark( <color> , <color> )
+
+<contrast-color()> = contrast-color( <color> )
+
+<device-cmyk()> = <legacy-device-cmyk-syntax> | <modern-device-cmyk-syntax>
+<legacy-device-cmyk-syntax> = device-cmyk( <number>#{4} )
+<modern-device-cmyk-syntax> = device-cmyk( <cmyk-component>{4} [ / [ <alpha-value> | none ] ]? )
+<cmyk-component> = <number> | <percentage> | none
+
+<color-mix()> = color-mix( [ <color-interpolation-method> , ]? [ <color> && <percentage [0,100]>? ]# )
+<color-interpolation-method> = in [ <rectangular-color-space> | <polar-color-space> <hue-interpolation-method>? ]
+<color-space> = <rectangular-color-space> | <polar-color-space>
+<rectangular-color-space> = srgb | srgb-linear | display-p3 | display-p3-linear | a98-rgb | prophoto-rgb | rec2020 | lab | oklab | <xyz-space> | <custom-color-space> | <custom-rectangular-space>
+<polar-color-space> = hsl | hwb | lch | oklch | <custom-polar-space>
+<hue-interpolation-method> = [ shorter | longer | increasing | decreasing ] hue
+
+<custom-color-function> = %unregistered-sentinel-value%
+<custom-rectangular-space> = %unregistered-sentinel-value%
+<custom-polar-space> = %unregistered-sentinel-value%
+
+/* ==========================================================================
+   Shared Value Components
+   ========================================================================== */
+<alpha-value> = <number> | <percentage>
+<hue> = <number> | <angle>
+<rgb-relative-component> = <number> | <percentage> | none | r | g | b | alpha
+<rgb-relative-alpha> = <alpha-value> | none | r | g | b | alpha
+<custom-color-space> = %unregistered-sentinel-value%
+`;
+const RULE_START_RE = /^<[^>]+>\s*=/;
+const HASH_REPEAT_RE = /^(.*)#\{(\d+)\}$/;
+const REPEAT_RE = /^(.*)\{(\d+)\}$/;
+const REF_RE = /^<([^>\s]+)(?:\s+([^>]+))?>$/;
+const ARG_RE = /\[[^\]]+\]|[^\s]+/g;
+export const grammarMap = parseGrammar(grammar);
+function concatNodes(a, b) {
+    const lenA = a.length;
+    const lenB = b.length;
+    const result = new Array(lenA + lenB);
+    for (let i = 0; i < lenA; i++)
+        result[i] = a[i];
+    for (let i = 0; i < lenB; i++)
+        result[lenA + i] = b[i];
+    return result;
+}
+function parseCmykComponent(n) {
+    if (!n?.value)
+        return 0;
+    const raw = Array.isArray(n.value) ? n.value[0]?.value : n.value;
+    return parseFloat(raw.trim());
+}
+function getLiteralValue(n) {
+    if (!n)
+        return "";
+    if (n.type === "literal")
+        return n.value;
+    if (Array.isArray(n.value))
+        return getLiteralValue(n.value[0]);
+    return "";
+}
+export function validateTokens(tokens, rootRule) {
+    const memo = new Map();
+    const rulesToTest = rootRule ? [rootRule] : Object.keys(grammarMap);
+    for (let i = 0; i < rulesToTest.length; i++) {
+        const ruleName = rulesToTest[i];
+        const results = matchRule(ruleName, tokens, 0, grammarMap, memo, null);
+        for (let j = 0; j < results.length; j++) {
+            const result = results[j];
+            if (result.success && result.nextIndex === tokens.length) {
+                return result.nodes[0];
+            }
+        }
+    }
+    throw new Error("Invalid syntax");
+}
+export function matchRule(ruleName, tokens, index, grammar, memo, currentFunction, args) {
+    const key = `${ruleName}:${index}:${currentFunction || ""}:${args ? args.join(",") : ""}`;
+    const cached = memo.get(key);
+    if (cached)
+        return cached;
+    const token = tokens[index];
+    const validator = validators[ruleName];
+    if (validator) {
+        if (!token)
+            return [];
+        if (validator(token, args)) {
+            const result = [
+                {
+                    success: true,
+                    nextIndex: index + 1,
+                    nodes: [{ type: ruleName, value: token }],
+                },
+            ];
+            memo.set(key, result);
+            return result;
+        }
+        memo.set(key, []);
+        return [];
+    }
+    const rule = grammar[ruleName];
+    if (!rule) {
+        memo.set(key, []);
+        return [];
+    }
+    const results = matchNode(rule, tokens, index, grammar, memo, currentFunction);
+    const wrapped = new Array(results.length);
+    for (let i = 0; i < results.length; i++) {
+        wrapped[i] = {
+            success: true,
+            nextIndex: results[i].nextIndex,
+            nodes: [{ type: ruleName, value: results[i].nodes }],
+        };
+    }
+    memo.set(key, wrapped);
+    return wrapped;
+}
+export function matchNode(node, tokens, index, grammar, memo, currentFunction) {
+    switch (node.kind) {
+        case "literal": {
+            const token = tokens[index];
+            if (!token || token !== node.value.toLowerCase())
+                return [];
+            return [
+                {
+                    success: true,
+                    nextIndex: index + 1,
+                    nodes: [
+                        {
+                            type: token === "(" || token === ")" || token === "," || token === "/" ? "symbol" : "literal",
+                            value: token,
+                        },
+                    ],
+                },
+            ];
+        }
+        case "ref": {
+            const token = tokens[index];
+            if (!token)
+                return [];
+            if (currentFunction && colorModels[currentFunction]) {
+                const component = colorModels[currentFunction].components[token];
+                if (component && component.value === node.name) {
+                    return [
+                        {
+                            success: true,
+                            nextIndex: index + 1,
+                            nodes: [{ type: node.name, value: token }],
+                        },
+                    ];
+                }
+            }
+            return matchRule(node.name, tokens, index, grammar, memo, currentFunction, node.args);
+        }
+        case "choice": {
+            const results = [];
+            for (let i = 0; i < node.nodes.length; i++) {
+                const childMatches = matchNode(node.nodes[i], tokens, index, grammar, memo, currentFunction);
+                for (let j = 0; j < childMatches.length; j++) {
+                    results.push(childMatches[j]);
+                }
+            }
+            return results;
+        }
+        case "sequence": {
+            let states = [{ success: true, nextIndex: index, nodes: [] }];
+            for (let i = 0; i < node.nodes.length; i++) {
+                const child = node.nodes[i];
+                const nextStates = [];
+                for (let j = 0; j < states.length; j++) {
+                    const state = states[j];
+                    const matches = matchNode(child, tokens, state.nextIndex, grammar, memo, currentFunction);
+                    for (let k = 0; k < matches.length; k++) {
+                        nextStates.push({
+                            success: true,
+                            nextIndex: matches[k].nextIndex,
+                            nodes: concatNodes(state.nodes, matches[k].nodes),
+                        });
+                    }
+                }
+                states = nextStates;
+                if (states.length === 0)
+                    return [];
+            }
+            return states;
+        }
+        case "optional": {
+            const matches = matchNode(node.node, tokens, index, grammar, memo, currentFunction);
+            const results = new Array(matches.length + 1);
+            results[0] = { success: true, nextIndex: index, nodes: [] };
+            for (let i = 0; i < matches.length; i++) {
+                results[i + 1] = matches[i];
+            }
+            return results;
+        }
+        case "repeat": {
+            let states = [{ success: true, nextIndex: index, nodes: [] }];
+            for (let i = 0; i < node.min; i++) {
+                const nextStates = [];
+                for (let j = 0; j < states.length; j++) {
+                    const state = states[j];
+                    const matches = matchNode(node.node, tokens, state.nextIndex, grammar, memo, currentFunction);
+                    for (let k = 0; k < matches.length; k++) {
+                        nextStates.push({
+                            success: true,
+                            nextIndex: matches[k].nextIndex,
+                            nodes: concatNodes(state.nodes, matches[k].nodes),
+                        });
+                    }
+                }
+                states = nextStates;
+                if (states.length === 0)
+                    return [];
+            }
+            return states;
+        }
+        case "permutation": {
+            const numNodes = node.nodes.length;
+            const fullMask = (1 << numNodes) - 1;
+            let states = [{ nextIndex: index, nodes: [], remainingMask: fullMask }];
+            const finalResults = [];
+            while (states.length > 0) {
+                const nextStates = [];
+                for (let i = 0; i < states.length; i++) {
+                    const state = states[i];
+                    let allRemainingOptional = true;
+                    for (let bit = 0; bit < numNodes; bit++) {
+                        if ((state.remainingMask & (1 << bit)) !== 0) {
+                            if (node.nodes[bit].kind !== "optional") {
+                                allRemainingOptional = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (allRemainingOptional) {
+                        finalResults.push({
+                            success: true,
+                            nextIndex: state.nextIndex,
+                            nodes: state.nodes,
+                        });
+                    }
+                    for (let bit = 0; bit < numNodes; bit++) {
+                        if ((state.remainingMask & (1 << bit)) !== 0) {
+                            const child = node.nodes[bit];
+                            const nodeToMatch = child.kind === "optional" ? child.node : child;
+                            const matches = matchNode(nodeToMatch, tokens, state.nextIndex, grammar, memo, currentFunction);
+                            const nextMask = state.remainingMask & ~(1 << bit);
+                            for (let m = 0; m < matches.length; m++) {
+                                nextStates.push({
+                                    nextIndex: matches[m].nextIndex,
+                                    nodes: concatNodes(state.nodes, matches[m].nodes),
+                                    remainingMask: nextMask,
+                                });
+                            }
+                        }
+                    }
+                }
+                states = nextStates;
+            }
+            return finalResults;
+        }
+        case "hashList": {
+            let currentStates = matchNode(node.node, tokens, index, grammar, memo, currentFunction);
+            const allSuccessfulStates = [];
+            while (currentStates.length > 0) {
+                const nextStates = [];
+                for (let i = 0; i < currentStates.length; i++) {
+                    const state = currentStates[i];
+                    allSuccessfulStates.push(state);
+                    const commaIdx = state.nextIndex;
+                    if (commaIdx < tokens.length && tokens[commaIdx] === ",") {
+                        const commaNode = { type: "symbol", value: "," };
+                        const matches = matchNode(node.node, tokens, commaIdx + 1, grammar, memo, currentFunction);
+                        for (let m = 0; m < matches.length; m++) {
+                            const match = matches[m];
+                            if (match.nextIndex > commaIdx) {
+                                const newNodes = new Array(state.nodes.length + 1 + match.nodes.length);
+                                let idx = 0;
+                                for (let n = 0; n < state.nodes.length; n++)
+                                    newNodes[idx++] = state.nodes[n];
+                                newNodes[idx++] = commaNode;
+                                for (let n = 0; n < match.nodes.length; n++)
+                                    newNodes[idx++] = match.nodes[n];
+                                nextStates.push({
+                                    success: true,
+                                    nextIndex: match.nextIndex,
+                                    nodes: newNodes,
+                                });
+                            }
+                        }
+                    }
+                }
+                currentStates = nextStates;
+            }
+            return allSuccessfulStates;
+        }
+    }
+}
+export function tokenize(input) {
+    const lower = input.toLowerCase();
+    const tokens = [];
+    let i = 0;
+    while (i < lower.length) {
+        if (lower.slice(i, i + 2) === "/*") {
+            const endIndex = lower.indexOf("*/", i + 2);
+            if (endIndex !== -1) {
+                i = endIndex + 2;
+            }
+            else {
+                i = lower.length;
+            }
+            continue;
+        }
+        const ch = lower[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (lower.slice(i, i + 5) === "calc(") {
+            const start = i;
+            let parenCount = 0;
+            while (i < lower.length) {
+                if (lower[i] === "(")
+                    parenCount++;
+                else if (lower[i] === ")") {
+                    parenCount--;
+                    if (parenCount === 0) {
+                        i++;
+                        break;
+                    }
+                }
+                i++;
+            }
+            tokens.push(lower.slice(start, i));
+            continue;
+        }
+        if ("(),/".includes(ch)) {
+            tokens.push(ch);
+            i++;
+            continue;
+        }
+        const start = i;
+        while (i < lower.length && !/\s/.test(lower[i]) && !"(),/".includes(lower[i])) {
+            i++;
+        }
+        tokens.push(lower.slice(start, i));
+    }
+    return tokens;
+}
+export function parseGrammar(grammar) {
+    const rules = {};
+    const lines = grammar.replace(/\/\*[\s\S]*?\*\//g, "").split("\n");
+    let currentRuleName = "";
+    let currentDef = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        if (RULE_START_RE.test(line)) {
+            if (currentRuleName)
+                rules[currentRuleName] = parseExpression(currentDef);
+            const eqIndex = line.indexOf("=");
+            currentRuleName = line.slice(0, eqIndex).trim();
+            currentDef = line.slice(eqIndex + 1).trim();
+        }
+        else if (currentRuleName) {
+            currentDef += " " + line;
+        }
+    }
+    if (currentRuleName)
+        rules[currentRuleName] = parseExpression(currentDef);
+    return rules;
+}
+export function parseExpression(expr) {
+    const parts = splitTopLevel(expr, "|");
+    if (parts.length > 1)
+        return { kind: "choice", nodes: parts.map(parsePermutation) };
+    return parsePermutation(expr);
+}
+function splitTopLevel(str, separator) {
+    const result = [];
+    let depth = 0;
+    let start = 0;
+    const sepLen = separator.length;
+    const len = str.length;
+    for (let i = 0; i < len; i++) {
+        const ch = str.charCodeAt(i);
+        if (ch === 91 || ch === 40) {
+            // '[' or '('
+            depth++;
+        }
+        else if (ch === 93 || ch === 41) {
+            // ']' or ')'
+            depth--;
+        }
+        else if (depth === 0 && str.startsWith(separator, i)) {
+            const part = str.slice(start, i).trim();
+            if (part)
+                result.push(part);
+            i += sepLen - 1;
+            start = i + 1;
+        }
+    }
+    const last = str.slice(start).trim();
+    if (last)
+        result.push(last);
+    return result;
+}
+function splitSequence(str) {
+    const result = [];
+    let i = 0;
+    const len = str.length;
+    while (i < len) {
+        const ch = str.charCodeAt(i);
+        // space (32), tab (9), newline (10), carriage return (13)
+        if (ch === 32 || ch === 9 || ch === 10 || ch === 13) {
+            i++;
+            continue;
+        }
+        // '(', ')', ',', '/', '|' -> 40, 41, 44, 47, 124
+        if (ch === 40 || ch === 41 || ch === 44 || ch === 47 || ch === 124) {
+            result.push(str[i]);
+            i++;
+            continue;
+        }
+        const start = i;
+        if (ch === 60) {
+            // '<'
+            while (i < len && str.charCodeAt(i) !== 62)
+                i++; // '>'
+            i++;
+            while (i < len) {
+                const c = str.charCodeAt(i);
+                if (c === 32 ||
+                    c === 9 ||
+                    c === 10 ||
+                    c === 13 ||
+                    c === 40 ||
+                    c === 41 ||
+                    c === 44 ||
+                    c === 47 ||
+                    c === 124)
+                    break;
+                i++;
+            }
+            result.push(str.slice(start, i));
+            continue;
+        }
+        if (ch === 91) {
+            // '['
+            let depth = 1;
+            i++;
+            while (i < len && depth > 0) {
+                const c = str.charCodeAt(i);
+                if (c === 91)
+                    depth++; // '['
+                else if (c === 93)
+                    depth--; // ']'
+                i++;
+            }
+            while (i < len) {
+                const c = str.charCodeAt(i);
+                if (c === 32 ||
+                    c === 9 ||
+                    c === 10 ||
+                    c === 13 ||
+                    c === 40 ||
+                    c === 41 ||
+                    c === 44 ||
+                    c === 47 ||
+                    c === 124)
+                    break;
+                i++;
+            }
+            result.push(str.slice(start, i));
+            continue;
+        }
+        while (i < len) {
+            const c = str.charCodeAt(i);
+            if (c === 32 ||
+                c === 9 ||
+                c === 10 ||
+                c === 13 ||
+                c === 40 ||
+                c === 41 ||
+                c === 44 ||
+                c === 47 ||
+                c === 124)
+                break;
+            i++;
+        }
+        result.push(str.slice(start, i));
+    }
+    return result;
+}
+function parsePermutation(targetExpr) {
+    const parts = splitTopLevel(targetExpr, "&&");
+    if (parts.length > 1)
+        return { kind: "permutation", nodes: parts.map(parseSequence) };
+    return parseSequence(targetExpr);
+}
+function parseSequence(targetExpr) {
+    const tokens = splitSequence(targetExpr);
+    return { kind: "sequence", nodes: tokens.map(parseTerm) };
+}
+function parseTerm(term) {
+    term = term.trim();
+    const len = term.length;
+    if (len === 1) {
+        const c = term.charCodeAt(0);
+        if (c === 40 || c === 41 || c === 44 || c === 47) {
+            return { kind: "literal", value: term };
+        }
+    }
+    const lastChar = term.charCodeAt(len - 1);
+    if (lastChar === 35 && term.indexOf("{") === -1) {
+        // '#'
+        return { kind: "hashList", node: parseTerm(term.slice(0, -1)) };
+    }
+    if (lastChar === 63) {
+        // '?'
+        return { kind: "optional", node: parseTerm(term.slice(0, -1)) };
+    }
+    const hashRepeatMatch = HASH_REPEAT_RE.exec(term);
+    if (hashRepeatMatch) {
+        const innerNode = parseTerm(hashRepeatMatch[1]);
+        const count = Number(hashRepeatMatch[2]);
+        const commaNode = { kind: "literal", value: "," };
+        const nodes = [];
+        for (let i = 0; i < count; i++) {
+            nodes.push(innerNode);
+            if (i < count - 1)
+                nodes.push(commaNode);
+        }
+        return { kind: "sequence", nodes };
+    }
+    const repeatMatch = REPEAT_RE.exec(term);
+    if (repeatMatch) {
+        const num = Number(repeatMatch[2]);
+        return {
+            kind: "repeat",
+            node: parseTerm(repeatMatch[1]),
+            min: num,
+            max: num,
+        };
+    }
+    const firstChar = term.charCodeAt(0);
+    if (firstChar === 91 && lastChar === 93) {
+        // '[' and ']'
+        return parseExpression(term.slice(1, -1));
+    }
+    if (firstChar === 60 && lastChar === 62) {
+        // '<' and '>'
+        const match = REF_RE.exec(term);
+        if (match) {
+            let argsArray = undefined;
+            if (match[2]) {
+                const argMatches = match[2].match(ARG_RE);
+                if (argMatches) {
+                    argsArray = argMatches.map((arg) => arg.trim());
+                }
+            }
+            return { kind: "ref", name: `<${match[1]}>`, args: argsArray };
+        }
+        return { kind: "ref", name: term };
+    }
+    return { kind: "literal", value: term };
+}
+const { PI: pi, E: e, pow, sqrt, sin, cos, tan, asin, acos, atan, atan2, exp, log, log10, log2, abs, min, max, hypot, round, ceil, floor, sign, trunc, random, } = Math;
+const BASE_MATH_ENV = {
+    pi,
+    e,
+    tau: pi * 2,
+    pow,
+    sqrt,
+    sin,
+    cos,
+    tan,
+    asin,
+    acos,
+    atan,
+    atan2,
+    exp,
+    log,
+    log10,
+    log2,
+    abs,
+    min,
+    max,
+    hypot,
+    round,
+    ceil,
+    floor,
+    sign,
+    trunc,
+    random,
+};
+function extractToken(n) {
+    if (typeof n === "string")
+        return n;
+    if (n.type === "<percentage>")
+        return String(n.value || "");
+    if (Array.isArray(n.value))
+        return extractToken(n.value[0]);
+    return String(n.value || "");
+}
+function parsePercent(str, type, min, max) {
+    const percent = parseFloat(str);
+    if (isNaN(percent))
+        throw new Error(`Invalid percentage: '${str}'.`);
+    if (type === "percentage")
+        return percent;
+    if (min < 0 && max > 0)
+        return ((percent / 100) * (max - min)) / 2;
+    return (percent / 100) * (max - min) + min;
+}
+function parseHue(str) {
+    const val = parseFloat(str);
+    if (isNaN(val))
+        throw new Error(`Invalid hue: '${str}'.`);
+    if (str[str.length - 1] === "deg")
+        return val;
+    if (str[str.length - 1] === "rad")
+        return val * (180 / pi);
+    if (str[str.length - 1] === "grad")
+        return val * 0.9;
+    if (str[str.length - 1] === "turn")
+        return val * 360;
+    return val;
+}
+function parseCalcExpression(expr, type, base, min, max) {
+    if (expr === "infinity")
+        return Infinity;
+    if (expr === "-infinity")
+        return -Infinity;
+    if (expr === "nan")
+        return NaN;
+    const UNIT_NUM = 1; // 001
+    const UNIT_PCT = 2; // 010
+    const UNIT_ANG = 4; // 100
+    const getUnitName = (u) => (u === UNIT_ANG ? "angle" : u === UNIT_PCT ? "percent" : "number");
+    const tokenize = (s) => {
+        const out = [];
+        for (let i = 0; i < s.length;) {
+            const c = s[i];
+            if (/\s/.test(c)) {
+                i++;
+                continue;
+            }
+            if (s.slice(i, i + 2) === "**") {
+                out.push({ type: "operator", value: "**" });
+                i += 2;
+                continue;
+            }
+            if (/[0-9]/.test(c) || (c === "." && /[0-9]/.test(s[i + 1] || ""))) {
+                let numStr = "";
+                while (i < s.length && /[0-9.]/.test(s[i]))
+                    numStr += s[i++];
+                if (i < s.length && /[eE]/.test(s[i])) {
+                    numStr += s[i++];
+                    if (/[+-]/.test(s[i]))
+                        numStr += s[i++];
+                    while (i < s.length && /[0-9]/.test(s[i]))
+                        numStr += s[i++];
+                }
+                let unitType = UNIT_NUM;
+                let rawUnit = "";
+                if (s[i] === "%") {
+                    unitType = UNIT_PCT;
+                    rawUnit = "%";
+                    i++;
+                }
+                else if (s.slice(i, i + 3) === "deg") {
+                    unitType = UNIT_ANG;
+                    rawUnit = "deg";
+                    i += 3;
+                }
+                else if (s.slice(i, i + 3) === "rad") {
+                    unitType = UNIT_ANG;
+                    rawUnit = "rad";
+                    i += 3;
+                }
+                else if (s.slice(i, i + 4) === "grad") {
+                    unitType = UNIT_ANG;
+                    rawUnit = "grad";
+                    i += 4;
+                }
+                else if (s.slice(i, i + 4) === "turn") {
+                    unitType = UNIT_ANG;
+                    rawUnit = "turn";
+                    i += 4;
+                }
+                let val = parseFloat(numStr);
+                if (unitType === UNIT_PCT) {
+                    val = parsePercent(numStr + rawUnit, type, min, max);
+                }
+                else if (unitType === UNIT_ANG) {
+                    val = parseHue(numStr + rawUnit);
+                }
+                out.push({ type: "number", value: val, unit: unitType });
+                continue;
+            }
+            if (/[a-zA-Z_]/.test(c)) {
+                let id = "";
+                while (i < s.length && /[a-zA-Z0-9_]/.test(s[i]))
+                    id += s[i++];
+                out.push({ type: "identifier", value: id });
+                continue;
+            }
+            if ("+-*/%(),".includes(c)) {
+                out.push({ type: "operator", value: c });
+                i++;
+                continue;
+            }
+            throw new Error(`Unexpected character: ${c}`);
+        }
+        return out;
+    };
+    const parse = (tokens) => {
+        let pos = 0;
+        const cur = () => (pos < tokens.length ? tokens[pos] : null);
+        const nxt = () => {
+            if (pos >= tokens.length)
+                throw new Error("Unexpected end of input");
+            return tokens[pos++];
+        };
+        const expect = (v) => {
+            const t = cur();
+            if (!t || t.value !== v) {
+                throw new Error(`Expected "${v}" but got "${t ? t.value : "end of input"}"`);
+            }
+            nxt();
+        };
+        const parsePrimary = () => {
+            const t = cur();
+            if (!t)
+                throw new Error("Unexpected end of input");
+            if (t.type === "number") {
+                nxt();
+                return { type: "number", value: t.value, unit: t.unit };
+            }
+            if (t.type === "identifier") {
+                nxt();
+                if (cur() && cur().value === "(") {
+                    nxt();
+                    const args = [];
+                    if (cur() && cur().value !== ")") {
+                        args.push(parseAdd());
+                        while (cur() && cur().value === ",") {
+                            nxt();
+                            args.push(parseAdd());
+                        }
+                    }
+                    expect(")");
+                    return { type: "call", func: t.value, args };
+                }
+                return { type: "var", name: t.value };
+            }
+            if (t.value === "(") {
+                nxt();
+                const e = parseAdd();
+                expect(")");
+                return e;
+            }
+            throw new Error(`Unexpected token: ${t.value}`);
+        };
+        const parseUnary = () => {
+            if (cur() && (cur().value === "+" || cur().value === "-")) {
+                const op = nxt().value;
+                return { type: "unary", op, arg: parseUnary() };
+            }
+            return parsePrimary();
+        };
+        const parsePower = () => {
+            let left = parseUnary();
+            while (cur() && cur().value === "**") {
+                const op = nxt().value;
+                left = { type: "binary", op, left, right: parseUnary() };
+            }
+            return left;
+        };
+        const parseMul = () => {
+            let left = parsePower();
+            while (cur() && ["*", "/", "%"].includes(String(cur().value))) {
+                const op = nxt().value;
+                left = { type: "binary", op, left, right: parsePower() };
+            }
+            return left;
+        };
+        const parseAdd = () => {
+            let left = parseMul();
+            while (cur() && (cur().value === "+" || cur().value === "-")) {
+                const op = nxt().value;
+                left = { type: "binary", op, left, right: parseMul() };
+            }
+            return left;
+        };
+        const ast = parseAdd();
+        if (pos < tokens.length) {
+            throw new Error(`Extra tokens after expression: ${tokens
+                .slice(pos)
+                .map((t) => t.value)
+                .join(" ")}`);
+        }
+        return ast;
+    };
+    // eslint-disable-next-line no-unused-vars
+    const evaluate = (ast, env) => {
+        switch (ast.type) {
+            case "number":
+                return { value: ast.value, unit: ast.unit };
+            case "var": {
+                const v = env[ast.name];
+                if (v === undefined)
+                    throw new Error(`Unknown variable: ${ast.name}`);
+                if (typeof v === "function") {
+                    throw new Error(`Expected variable but found function: ${ast.name}`);
+                }
+                return { value: v, unit: UNIT_NUM };
+            }
+            case "binary": {
+                const L = evaluate(ast.left, env);
+                const R = evaluate(ast.right, env);
+                switch (ast.op) {
+                    case "+":
+                    case "-": {
+                        const val = ast.op === "+" ? L.value + R.value : L.value - R.value;
+                        const unitMask = L.unit | R.unit;
+                        if (L.unit === R.unit)
+                            return { value: val, unit: L.unit };
+                        if (unitMask === 5)
+                            return { value: val, unit: UNIT_ANG };
+                        throw new Error(`Cannot ${ast.op} mismatched units: ${getUnitName(L.unit)} and ${getUnitName(R.unit)}`);
+                    }
+                    case "*": {
+                        const val = L.value * R.value;
+                        if (L.unit === UNIT_NUM)
+                            return { value: val, unit: R.unit };
+                        if (R.unit === UNIT_NUM)
+                            return { value: val, unit: L.unit };
+                        throw new Error(`Cannot multiply units: ${getUnitName(L.unit)} and ${getUnitName(R.unit)}`);
+                    }
+                    case "/": {
+                        if (R.unit === UNIT_NUM)
+                            return { value: L.value / R.value, unit: L.unit };
+                        if (L.unit === R.unit)
+                            return { value: L.value / R.value, unit: UNIT_NUM };
+                        throw new Error(`Cannot divide units: ${getUnitName(L.unit)} by ${getUnitName(R.unit)}`);
+                    }
+                    case "%": {
+                        if (R.unit === UNIT_NUM)
+                            return { value: L.value % R.value, unit: L.unit };
+                        if (L.unit === R.unit)
+                            return { value: L.value % R.value, unit: L.unit };
+                        throw new Error(`Cannot modulo units: ${getUnitName(L.unit)} by ${getUnitName(R.unit)}`);
+                    }
+                    case "**": {
+                        if (R.unit !== UNIT_NUM)
+                            throw new Error(`Exponent must be a number, got ${getUnitName(R.unit)}`);
+                        return { value: L.value ** R.value, unit: L.unit };
+                    }
+                    default:
+                        throw new Error(`Unknown binary operator: ${ast.op}`);
+                }
+            }
+            case "unary": {
+                const res = evaluate(ast.arg, env);
+                switch (ast.op) {
+                    case "+":
+                        return { value: +res.value, unit: res.unit };
+                    case "-":
+                        return { value: -res.value, unit: res.unit };
+                    default:
+                        throw new Error(`Unknown unary operator: ${ast.op}`);
+                }
+            }
+            case "call": {
+                const fn = env[ast.func];
+                if (typeof fn !== "function")
+                    throw new Error(`Unknown function: ${ast.func}`);
+                const evaluatedArgs = ast.args.map((a) => evaluate(a, env));
+                const numArgs = evaluatedArgs.map((a) => a.value);
+                const val = fn(...numArgs); // eslint-disable-line no-unused-vars
+                const preserveUnitFuncs = ["min", "max", "round", "ceil", "floor", "abs", "sign", "trunc"];
+                if (preserveUnitFuncs.includes(ast.func)) {
+                    let combinedMask = 0;
+                    for (let i = 0; i < evaluatedArgs.length; i++) {
+                        combinedMask |= evaluatedArgs[i].unit;
+                    }
+                    if ((combinedMask & 6) === 6)
+                        throw new Error(`Function ${ast.func} cannot mix angle and percent`);
+                    if ((combinedMask & 3) === 3)
+                        throw new Error(`Function ${ast.func} cannot mix number and percent`);
+                    const finalUnit = combinedMask & UNIT_ANG ? UNIT_ANG : combinedMask & UNIT_PCT ? UNIT_PCT : UNIT_NUM;
+                    return { value: val, unit: finalUnit };
+                }
+                return { value: val, unit: UNIT_NUM };
+            }
+            default: {
+                throw new Error(`Unknown AST node type: ${ast.type}`); // eslint-disable-line @typescript-eslint/no-explicit-any
+            }
+        }
+    };
+    const calcEnv = Object.assign({}, BASE_MATH_ENV, base);
+    return evaluate(parse(tokenize(expr)), calcEnv).value;
+}
+export function evaluateComponent(node, expectedType, base = {}) {
+    if (!node)
+        return NaN;
+    const token = extractToken(node);
+    return evaluateCSSValue(token, expectedType, base);
+}
+export function evaluateCSSValue(tokenString, expectedType, base = {}) {
+    const token = tokenString.trim();
+    if (token === "none")
+        return NaN;
+    if (token in base)
+        return base[token];
+    const [tMin, tMax] = Array.isArray(expectedType) ? expectedType : expectedType === "percentage" ? [0, 100] : [0, 1];
+    if (/^-?(?:\d+|\d*\.\d+)$/.test(token)) {
+        return parseFloat(token);
+    }
+    if (token[token.length - 1] === "%" && /^-?(?:\d+|\d*\.\d+)%$/.test(token)) {
+        return parsePercent(token, expectedType, tMin, tMax);
+    }
+    if (/^-?(?:\d+|\d*\.\d+)(deg|rad|grad|turn)$/.test(token)) {
+        return parseHue(token);
+    }
+    if (token.slice(0, 5) === "calc(" && token[token.length - 1] === ")") {
+        return parseCalcExpression(token.slice(5, -1).trim(), expectedType, base, tMin, tMax);
+    }
+    throw new Error(`Unable to parse component token: ${token}`);
+}
+function createLegacyColorParser(model, componentKeys) {
+    return (node) => {
+        const t = node.value;
+        const config = colorModels[model].components;
+        const c1 = evaluateComponent(t[2], config[componentKeys[0]].value);
+        const c2 = evaluateComponent(t[4], config[componentKeys[1]].value);
+        const c3 = evaluateComponent(t[6], config[componentKeys[2]].value);
+        let alpha = 1;
+        if (t[7]?.type === "symbol" && t[7]?.value === ",")
+            alpha = evaluateComponent(t[8], [0, 1]);
+        return { model, coords: [c1, c2, c3, alpha] };
+    };
+}
+function createModernColorParser(model, componentKeys) {
+    return (node) => {
+        const t = node.value;
+        const config = colorModels[model].components;
+        const c1 = evaluateComponent(t[2], config[componentKeys[0]].value);
+        const c2 = evaluateComponent(t[3], config[componentKeys[1]].value);
+        const c3 = evaluateComponent(t[4], config[componentKeys[2]].value);
+        let alpha = 1;
+        if (t[5]?.type === "symbol" && t[5]?.value === "/")
+            alpha = evaluateComponent(t[6], [0, 1]);
+        return { model, coords: [c1, c2, c3, alpha] };
+    };
+}
+function createRelativeColorParser(model, componentKeys) {
+    return (node) => {
+        const t = node.value;
+        const config = colorModels[model].components;
+        const originColorNode = t[3];
+        const originParsed = parseNode(originColorNode);
+        const originInstance = new Color(originParsed.model, originParsed.coords).in(model);
+        const baseEnv = originInstance.toObject({ fit: "none", precision: null });
+        const c1 = evaluateComponent(t[4], config[componentKeys[0]].value, baseEnv);
+        const c2 = evaluateComponent(t[5], config[componentKeys[1]].value, baseEnv);
+        const c3 = evaluateComponent(t[6], config[componentKeys[2]].value, baseEnv);
+        let alpha = 1;
+        if (t[7]?.type === "symbol" && t[7]?.value === "/") {
+            alpha = evaluateComponent(t[8], [0, 1], baseEnv);
+        }
+        return {
+            model,
+            coords: [c1, c2, c3, alpha],
+        };
+    };
+}
+function createRelativeColorFunctionParser(node) {
+    const t = node.value;
+    const { model, coords } = parseNode(t[3]);
+    const spaceNode = t[4];
+    const targetModel = (Array.isArray(spaceNode.value) ? spaceNode.value[0]?.value : spaceNode.value);
+    const originInstance = new Color(model, coords).in(targetModel);
+    const baseEnv = originInstance.toObject({ fit: "none", precision: null });
+    const c1 = evaluateComponent(t[5], [0, 1], baseEnv);
+    const c2 = evaluateComponent(t[6], [0, 1], baseEnv);
+    const c3 = evaluateComponent(t[7], [0, 1], baseEnv);
+    let alpha = 1;
+    if (t[8]?.type === "symbol" && t[8]?.value === "/") {
+        alpha = evaluateComponent(t[9], [0, 1], baseEnv);
+    }
+    return {
+        model: targetModel,
+        coords: [c1, c2, c3, alpha],
+    };
+}
+export const validators = (() => {
+    const NUMBER_REGEX = /^-?(?:\d+(?:\.\d+)?|\.\d+)$/;
+    const PERCENT_REGEX = /^-?(?:\d+(?:\.\d+)?|\.\d+)%$/;
+    const ANGLE_REGEX = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:deg|rad|turn|grad)$/;
+    const RANGE_REGEX = /^\[([^,]+),([^\]]+)\]$/;
+    const systemColorsSet = new Set(Object.keys(systemColors).map((key) => key.toLowerCase()));
+    const rangeCache = new Map();
+    const getRange = (args) => {
+        if (!args)
+            return undefined;
+        for (let i = 0; i < args.length; i++) {
+            if (RANGE_REGEX.test(args[i]))
+                return args[i];
+        }
+        return undefined;
+    };
+    const checkRange = (val, rangeStr) => {
+        let bounds = rangeCache.get(rangeStr);
+        if (!bounds) {
+            const match = rangeStr.match(RANGE_REGEX);
+            bounds = {
+                min: match[1].trim() === "-INF" ? -Infinity : parseFloat(match[1]),
+                max: match[2].trim() === "INF" || match[2].trim() === "+INF" ? Infinity : parseFloat(match[2]),
+            };
+            rangeCache.set(rangeStr, bounds);
+        }
+        if (bounds.min !== -Infinity && val < bounds.min)
+            return false;
+        if (bounds.max !== Infinity && val > bounds.max)
+            return false;
+        return true;
+    };
+    return {
+        "<named-color>": (str) => Object.hasOwn(namedColors, str),
+        "<system-color>": (str) => systemColorsSet.has(str),
+        "<hex-color>": (str) => {
+            return (str[0] === "#" &&
+                (str.length === 4 || str.length === 5 || str.length === 7 || str.length === 9) &&
+                /^[0-9a-fA-F]+$/.test(str.slice(1)));
+        },
+        "<number>": (str, args) => {
+            if (str.startsWith("calc(") && str.endsWith(")"))
+                return true;
+            if (!NUMBER_REGEX.test(str))
+                return false;
+            if (args !== undefined) {
+                const rangeArg = getRange(args);
+                if (rangeArg)
+                    return checkRange(parseFloat(str), rangeArg);
+            }
+            return true;
+        },
+        "<percentage>": (str, args) => {
+            if (str.startsWith("calc(") && str.endsWith(")"))
+                return true;
+            if (!PERCENT_REGEX.test(str))
+                return false;
+            if (args !== undefined) {
+                const rangeArg = getRange(args);
+                if (rangeArg)
+                    return checkRange(parseFloat(str), rangeArg);
+            }
+            return true;
+        },
+        "<angle>": (str, args) => {
+            if (str.startsWith("calc(") && str.endsWith(")"))
+                return true;
+            if (!ANGLE_REGEX.test(str))
+                return false;
+            if (args !== undefined) {
+                const rangeArg = getRange(args);
+                if (rangeArg)
+                    return checkRange(parseFloat(str), rangeArg);
+            }
+            return true;
+        },
+    }; // eslint-disable-line no-unused-vars
+})();
+export const parsers = {
+    "<color>": (node) => {
+        const child = node.value[0];
+        const { type, value } = child;
+        if (type === "literal") {
+            if (value === "currentcolor")
+                return { model: "rgb", coords: [0, 0, 0, 1] };
+            else
+                throw new Error(`Unknown <color>: ${value}`);
+        }
+        return parseNode(child);
+    },
+    "<color-base>": (node) => {
+        const child = node.value[0];
+        const { type, value } = child;
+        if (type === "literal") {
+            if (value === "transparent")
+                return { model: "rgb", coords: [0, 0, 0, 0] };
+            else
+                throw new Error(`Unknown <color-base>: ${value}`);
+        }
+        return parseNode(child);
+    },
+    "<named-color>": (node) => {
+        const { value: name } = node;
+        const rgb = namedColors[name];
+        if (!rgb)
+            throw new Error(`Unknown <named-color>: ${name}`);
+        return { model: "rgb", coords: [...rgb, 1] };
+    },
+    "<system-color>": (node) => {
+        const { value: name } = node;
+        const index = config.theme === "light" ? 0 : 1;
+        const key = Object.keys(systemColors).find((k) => k.toLowerCase() === name);
+        const rgb = systemColors[key][index];
+        if (!rgb)
+            throw new Error(`Unknown <system-color>: ${name}`);
+        return { model: "rgb", coords: [...rgb, 1] };
+    },
+    "<contrast-color()>": (node) => {
+        // contrast-color ( <color> )
+        const colorNode = node.value[2];
+        const { model, coords } = parseNode(colorNode);
+        const [, luminance] = new Color(model, coords).in("xyz-d65").coords;
+        return { model: "rgb", coords: luminance > 0.5 ? [0, 0, 0, 1] : [255, 255, 255, 1] };
+    },
+    "<light-dark-color>": (node) => {
+        const children = node.value;
+        // light-dark ( <color> , <color> )
+        const lightNode = children[2];
+        const darkNode = children[4];
+        const { model, coords } = parseNode(config?.theme === "light" ? lightNode : darkNode);
+        const { coords: rgbCoords } = new Color(model, coords).in("rgb");
+        return { model: "rgb", coords: rgbCoords };
+    },
+    "<hex-color>": (node) => {
+        const hex = node.value;
+        const len = hex.length;
+        let r = 0, g = 0, b = 0, a = 1;
+        if (len === 4 || len === 5) {
+            const rCh = hex.charCodeAt(1);
+            const gCh = hex.charCodeAt(2);
+            const bCh = hex.charCodeAt(3);
+            const rVal = rCh > 64 ? (rCh & 7) + 9 : rCh & 15;
+            const gVal = gCh > 64 ? (gCh & 7) + 9 : gCh & 15;
+            const bVal = bCh > 64 ? (bCh & 7) + 9 : bCh & 15;
+            r = (rVal << 4) | rVal;
+            g = (gVal << 4) | gVal;
+            b = (bVal << 4) | bVal;
+            if (len === 5) {
+                const aCh = hex.charCodeAt(4);
+                const aVal = aCh > 64 ? (aCh & 7) + 9 : aCh & 15;
+                a = ((aVal << 4) | aVal) / 255;
+            }
+        }
+        else {
+            const num = parseInt(hex.slice(1), 16);
+            if (len === 7) {
+                r = (num >> 16) & 255;
+                g = (num >> 8) & 255;
+                b = num & 255;
+            }
+            else if (len === 9) {
+                r = (num >> 24) & 255;
+                g = (num >> 16) & 255;
+                b = (num >> 8) & 255;
+                a = (num & 255) / 255;
+            }
+        }
+        return {
+            model: "rgb",
+            coords: [r, g, b, a],
+        };
+    },
+    "<device-cmyk()>": (node) => parseNode(node.value[0]),
+    "<legacy-device-cmyk-syntax>": (node) => {
+        // device-cmyk( <number>#{4} )
+        const t = node.value;
+        const [c, m, y, k] = [t[2], t[4], t[6], t[8]].map(parseCmykComponent);
+        return {
+            model: "rgb",
+            coords: [(1 - (c * (1 - k) + k)) * 255, (1 - (m * (1 - k) + k)) * 255, (1 - (y * (1 - k) + k)) * 255, 1],
+        };
+    },
+    "<modern-device-cmyk-syntax>": (node) => {
+        // device-cmyk( <cmyk-component>{4} [ / [ <alpha-value> | none ] ]? )
+        const t = node.value;
+        const c = evaluateComponent(t[2], [0, 1]);
+        const m = evaluateComponent(t[3], [0, 1]);
+        const y = evaluateComponent(t[4], [0, 1]);
+        const k = evaluateComponent(t[5], [0, 1]);
+        const alphaNode = t.find((c, idx) => idx === 7 && (c.type === "<alpha-value>" || (c.type === "literal" && c.value === "none")));
+        const alpha = alphaNode ? evaluateComponent(alphaNode, [0, 1]) : 1;
+        const cMath = normalize(c, [0, 1]);
+        const mMath = normalize(m, [0, 1]);
+        const yMath = normalize(y, [0, 1]);
+        const kMath = normalize(k, [0, 1]);
+        const alphaMath = isNaN(alpha) ? alpha : Math.max(0, Math.min(1, alpha));
+        return {
+            model: "rgb",
+            coords: [
+                (1 - (cMath * (1 - kMath) + kMath)) * 255,
+                (1 - (mMath * (1 - kMath) + kMath)) * 255,
+                (1 - (yMath * (1 - kMath) + kMath)) * 255,
+                alphaMath,
+            ],
+        };
+    },
+    "<color-mix()>": (node) => {
+        let model = "oklab";
+        let hue = "shorter";
+        const children = node.value;
+        let i = 2;
+        if (children[i]?.type === "<color-interpolation-method>") {
+            const methodParts = children[i].value;
+            i++;
+            if (methodParts[1]) {
+                model = getLiteralValue(methodParts[1]);
+            }
+            if (methodParts[2] && methodParts[2].type !== "symbol") {
+                hue = getLiteralValue(methodParts[2]);
+            }
+        }
+        const items = [];
+        while (i < children.length) {
+            const current = children[i];
+            if (current.type === "symbol" && (current.value === "," || current.value === ")")) {
+                i++;
+                continue;
+            }
+            let percentage = undefined;
+            let colorNode;
+            if (current.type === "<percentage>") {
+                const tokenStr = String(current.value || "");
+                percentage = evaluateCSSValue(tokenStr, "percentage");
+                i++;
+                colorNode = children[i];
+            }
+            else {
+                colorNode = current;
+                const nextNode = children[i + 1];
+                if (nextNode?.type === "<percentage>") {
+                    const tokenStr = String(nextNode.value || "");
+                    percentage = evaluateCSSValue(tokenStr, "percentage");
+                    i++;
+                }
+            }
+            const colorData = colorNode ? parseNode(colorNode) : null;
+            if (colorData && colorData.coords) {
+                i++;
+                items.push({
+                    color: new Color(colorData.model, colorData.coords),
+                    percentage: percentage,
+                });
+                continue;
+            }
+            i++;
+        }
+        if (items.length === 0) {
+            throw new Error("color-mix() must contain at least one color component.");
+        }
+        const mixedResult = Color.mix(items, { in: model, hue });
+        return {
+            model: mixedResult.model,
+            coords: mixedResult.coords,
+        };
+    },
+    "<color-function>": (node) => parseNode(node.value[0]),
+    "<custom-color-function>": (node) => parseNode(node.value[0]),
+    "<rgb()>": (node) => parseNode(node.value[0]),
+    "<rgba()>": (node) => parseNode(node.value[0]),
+    "<hsl()>": (node) => parseNode(node.value[0]),
+    "<hsla()>": (node) => parseNode(node.value[0]),
+    "<hwb()>": (node) => parseNode(node.value[0]),
+    "<lab()>": (node) => parseNode(node.value[0]),
+    "<lch()>": (node) => parseNode(node.value[0]),
+    "<oklab()>": (node) => parseNode(node.value[0]),
+    "<oklch()>": (node) => parseNode(node.value[0]),
+    "<legacy-rgb-syntax>": createLegacyColorParser("rgb", ["r", "g", "b"]),
+    "<legacy-rgba-syntax>": createLegacyColorParser("rgb", ["r", "g", "b"]),
+    "<legacy-hsl-syntax>": createLegacyColorParser("hsl", ["h", "s", "l"]),
+    "<legacy-hsla-syntax>": createLegacyColorParser("hsl", ["h", "s", "l"]),
+    "<modern-rgb-syntax>": createModernColorParser("rgb", ["r", "g", "b"]),
+    "<modern-rgba-syntax>": createModernColorParser("rgb", ["r", "g", "b"]),
+    "<modern-hsl-syntax>": createModernColorParser("hsl", ["h", "s", "l"]),
+    "<modern-hsla-syntax>": createModernColorParser("hsl", ["h", "s", "l"]),
+    "<absolute-hwb-syntax>": createModernColorParser("hwb", ["h", "w", "b"]),
+    "<absolute-lab-syntax>": createModernColorParser("lab", ["l", "a", "b"]),
+    "<absolute-lch-syntax>": createModernColorParser("lch", ["l", "c", "h"]),
+    "<absolute-oklab-syntax>": createModernColorParser("oklab", ["l", "a", "b"]),
+    "<absolute-oklch-syntax>": createModernColorParser("oklch", ["l", "c", "h"]),
+    "<relative-rgb-syntax>": createRelativeColorParser("rgb", ["r", "g", "b"]),
+    "<relative-rgba-syntax>": createRelativeColorParser("rgb", ["r", "g", "b"]),
+    "<relative-hsl-syntax>": createRelativeColorParser("hsl", ["h", "s", "l"]),
+    "<relative-hsla-syntax>": createRelativeColorParser("hsl", ["h", "s", "l"]),
+    "<relative-hwb-syntax>": createRelativeColorParser("hwb", ["h", "w", "b"]),
+    "<relative-lab-syntax>": createRelativeColorParser("lab", ["l", "a", "b"]),
+    "<relative-lch-syntax>": createRelativeColorParser("lch", ["l", "c", "h"]),
+    "<relative-oklab-syntax>": createRelativeColorParser("oklab", ["l", "a", "b"]),
+    "<relative-oklch-syntax>": createRelativeColorParser("oklch", ["l", "c", "h"]),
+    "<alpha()>": (node) => {
+        const children = node.value;
+        // alpha(from <color> / [ <alpha-value> | none ])
+        const colorNode = children[3];
+        const originColor = parseNode(colorNode);
+        if (!originColor)
+            throw new Error("Missing or invalid origin color in alpha() function");
+        const originInstance = new Color(originColor.model, originColor.coords);
+        const baseEnv = originInstance.toObject({ fit: "none", precision: null });
+        const alphaNode = children.find((c, idx) => c.type === "<alpha-value>" || (idx === 5 && c.type === "literal" && c.value === "none"));
+        const targetAlpha = alphaNode ? evaluateComponent(alphaNode, [0, 1], baseEnv) : originColor.coords[3];
+        return {
+            model: originColor.model,
+            coords: [...originColor.coords.slice(0, 3), targetAlpha],
+        };
+    },
+    "<color()>": (node) => parseNode(node.value[0]),
+    "<relative-color-syntax>": (node) => parseNode(node.value[0]),
+    "<absolute-color-syntax>": (node) => {
+        const t = node.value;
+        const spaceNode = t[2];
+        const model = (Array.isArray(spaceNode.value) ? spaceNode.value[0]?.value : spaceNode.value);
+        const c1 = evaluateComponent(t[3], [0, 1]);
+        const c2 = evaluateComponent(t[4], [0, 1]);
+        const c3 = evaluateComponent(t[5], [0, 1]);
+        const alphaNode = t.find((c, idx) => idx > 5 && (c.type === "<alpha-value>" || (c.type === "literal" && c.value === "none")));
+        const alpha = alphaNode ? evaluateComponent(alphaNode, [0, 1]) : 1;
+        return {
+            model,
+            coords: [c1, c2, c3, alpha],
+        };
+    },
+    "<relative-rgb-color-syntax>": createRelativeColorFunctionParser,
+    "<relative-xyz-color-syntax>": createRelativeColorFunctionParser,
+    "<relative-custom-color-syntax>": (node) => parseNode(node.value[0]),
+}; // eslint-disable-line no-unused-vars
+export const formatters = (() => {
+    const colorFunctionFormatters = (() => {
+        const out = {};
+        for (const model of Object.keys(colorModels)) {
+            const { bridge, fromBridge, supportsLegacy, components, alphaVariant } = colorModels[model];
+            out[model] = {
+                bridge,
+                fromBridge: (coords) => [...fromBridge(coords), coords[3] ?? 1],
+                format: ([c1, c2, c3, a = 1], options = {}) => {
+                    const { legacy = false, fit: fitMethod = config.defaults.fit, precision, units = false } = options;
+                    const fitted = fit([c1, c2, c3], model, { method: fitMethod, precision });
+                    const formatted = [...fitted, a].map((c, index) => {
+                        const norm = normalize(c, Object.values(components)[index].value);
+                        if ((units || legacy) && components) {
+                            const def = Object.values(components).find((comp) => comp.index === index);
+                            if (def?.value === "percentage")
+                                return `${norm}%`;
+                            if (def?.value === "hue" && units)
+                                return `${norm}deg`;
+                        }
+                        return norm.toString();
+                    });
+                    const f = formatted.slice(0, 3);
+                    const alpha = formatted[3];
+                    if (model in colorSpaces)
+                        return `color(${model} ${f.join(" ")}${a !== 1 ? ` / ${alpha}` : ""})`;
+                    if (legacy && supportsLegacy) {
+                        return a === 1
+                            ? `${model}(${f.join(", ")})`
+                            : `${alphaVariant || model}(${f.join(", ")}, ${alpha})`;
+                    }
+                    return `${model}(${f.join(" ")}${a !== 1 ? ` / ${alpha}` : ""})`;
+                },
+            };
+        }
+        return out;
+    })();
+    return {
+        ...colorFunctionFormatters,
+        "hex-color": {
+            bridge: "rgb",
+            fromBridge: (coords) => coords,
+            format: ([r, g, b, a = 1]) => {
+                const toHex = (v) => v.toString(16).padStart(2, "0");
+                const hex = [r, g, b].map((v) => toHex(Math.round(Math.max(0, Math.min(255, v))))).join("");
+                return `#${hex}${a < 1 ? toHex(Math.round(a * 255)) : ""}`;
+            },
+        },
+        "named-color": {
+            bridge: "rgb",
+            fromBridge: (coords) => coords,
+            format: (rgb) => {
+                const [r, g, b] = rgb.map((v, i) => (i < 3 ? Math.round(Math.min(255, Math.max(0, v))) : v));
+                for (const [name, [nr, ng, nb]] of Object.entries(namedColors)) {
+                    if (r === nr && g === ng && b === nb)
+                        return name;
+                }
+            },
+        },
+        "device-cmyk": {
+            bridge: "rgb",
+            fromBridge: (coords) => coords,
+            format: ([red, green, blue, alpha = 1], options = {}) => {
+                const { legacy = false, precision = 3, fit: fitMethod = config.defaults.fit } = options;
+                const [fr, fg, fb] = fit([red, green, blue], "rgb", { method: fitMethod });
+                const r = fr / 255;
+                const g = fg / 255;
+                const b = fb / 255;
+                const k = 1 - Math.max(r, g, b);
+                const formatComponent = (value) => {
+                    return Number(precision === null ? value : value.toFixed(precision)).toString();
+                };
+                const c = formatComponent(k === 1 ? 0 : (1 - r - k) / (1 - k));
+                const m = formatComponent(k === 1 ? 0 : (1 - g - k) / (1 - k));
+                const y = formatComponent(k === 1 ? 0 : (1 - b - k) / (1 - k));
+                const kFormatted = formatComponent(k);
+                const alphaFormatted = Number(alpha.toFixed(3)).toString();
+                if (legacy) {
+                    return `device-cmyk(${c}, ${m}, ${y}, ${kFormatted}${alpha < 1 ? `, ${alphaFormatted}` : ""})`;
+                }
+                const rgbPart = colorFunctionFormatters.rgb.format?.([fr, fg, fb, alpha], options);
+                return `device-cmyk(${c} ${m} ${y} ${kFormatted}${alpha < 1 ? ` / ${alphaFormatted}` : ""}, ${rgbPart})`;
+            },
+        },
+    };
+})();
+export function parseNode(node) {
+    const parser = parsers[node.type];
+    if (!parser)
+        throw new Error(`No parser for rule: ${node.type}`);
+    return parser(node);
+}
+export function isValid(input, rule) {
+    const cleaned = input.replace(/[A-Z]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 32));
+    const tokens = tokenize(cleaned);
+    const memo = new Map();
+    if (rule) {
+        if (grammarMap[rule]) {
+            const results = matchRule(rule, tokens, 0, grammarMap, memo, null);
+            return results.some((result) => result.success && result.nextIndex === tokens.length);
+        }
+        if (validators[rule]) {
+            const results = matchRule(rule, tokens, 0, grammarMap, memo, null);
+            return results.some((result) => result.success && result.nextIndex === tokens.length);
+        }
+        try {
+            const inlineNode = parseExpression(rule);
+            const results = matchNode(inlineNode, tokens, 0, grammarMap, memo, null);
+            return results.some((result) => result.success && result.nextIndex === tokens.length);
+        }
+        catch (error) {
+            throw new Error(`Failed to resolve rule or parse inline expression: "${rule}"`, { cause: error });
+        }
+    }
+    const allRules = new Set([...Object.keys(grammarMap), ...Object.keys(validators)]);
+    for (const ruleName of allRules) {
+        const results = matchRule(ruleName, tokens, 0, grammarMap, memo, null);
+        const isMatch = results.some((result) => result.success && result.nextIndex === tokens.length);
+        if (isMatch)
+            return true;
+    }
+    return false;
+}
+const getters = {
+    "color-models": () => Object.keys(colorModels),
+    "color-spaces": () => Object.keys(colorSpaces),
+    "named-colors": () => Object.keys(namedColors),
+    "system-colors": () => Object.keys(systemColors),
+    "output-types": () => {
+        return Object.keys(formatters).filter((key) => {
+            const type = formatters[key];
+            return typeof type["fromBridge"] === "function" && typeof type["format"] === "function";
+        });
+    },
+    plugins: () => Object.keys(plugins),
+    "fit-methods": () => ["none", "clip", ...Object.keys(fitMethods)],
+};
+/**
+ * Retrieve a list of registered items of a specified type.
+ *
+ * @param type - The getter type, e.g. "color-types".
+ * @returns The array returned by the getter.
+ */
+export function get(type) {
+    const fn = getters[type];
+    return fn();
+}
+const registry = {
+    customSpaces: new Set(),
+    rectangularFunctions: new Set(),
+    polarFunctions: new Set(),
+    functionRules: new Set(),
+    grammarExtensions: new Map(),
+};
+const registerers = {
+    "named-color": (name, rgb) => {
+        if (!Array.isArray(rgb) || rgb.length !== 3) {
+            throw new Error(`RGB value must be an array of three numbers, received length ${rgb.length}.`);
+        }
+        const n = name.replace(/[^a-zA-Z]/g, "").toLowerCase();
+        const names = namedColors;
+        if (names[n])
+            throw new Error(`<named-color> '${n}' is already registered.`);
+        const duplicate = Object.entries(names).find(([, value]) => value.every((channel, i) => channel === rgb[i]));
+        if (duplicate)
+            throw new Error(`RGB value [${rgb.join(", ")}] is already registered as '${duplicate[0]}'.`);
+        names[n] = rgb;
+    },
+    "color-function": (name, converter) => {
+        const n = name.replace(/(?:\s+)/g, "").toLowerCase();
+        const models = colorModels;
+        if (typeof converter.components === "object" &&
+            converter.components !== null &&
+            !Array.isArray(converter.components)) {
+            const normalized = {};
+            for (const key of Object.keys(converter.components)) {
+                normalized[key.toLowerCase()] = converter.components[key];
+            }
+            converter.components = normalized;
+        }
+        else {
+            throw new TypeError("Converter.components must be a non-null object.");
+        }
+        if (typeof converter !== "object" || converter === null) {
+            throw new TypeError("Converter must be a non-null object.");
+        }
+        const requiredFns = [
+            ["bridge", "string"],
+            ["toBridge", "function"],
+            ["fromBridge", "function"],
+        ];
+        for (const [key, type] of requiredFns) {
+            if (typeof converter[key] !== type) {
+                throw new TypeError(`Converter.${String(key)} must be a ${type}.`);
+            }
+        }
+        if (converter.bridge in colorModels === false) {
+            throw new Error(`Converter.bridge '${converter.bridge}' does not correspond to any registered color model.`);
+        }
+        if ("targetGamut" in converter && converter.targetGamut !== null && typeof converter.targetGamut !== "string") {
+            throw new TypeError(`Converter.targetGamut must be a string or null.`);
+        }
+        if ("supportsLegacy" in converter && typeof converter.supportsLegacy !== "boolean") {
+            throw new TypeError(`Converter.supportsLegacy must be a boolean.`);
+        }
+        if ("alphaVariant" in converter && typeof converter.alphaVariant !== "string") {
+            throw new TypeError(`Converter.alphaVariant must be a string.`);
+        }
+        const componentNames = Object.keys(converter.components);
+        if (new Set(componentNames).size !== componentNames.length) {
+            throw new Error("Converter.components must have unique component names.");
+        }
+        if (componentNames.includes("none")) {
+            throw new Error('Converter.components cannot have a component named "none".');
+        }
+        models[n] = converter;
+        if (converter.alphaVariant) {
+            const av = converter.alphaVariant.replace(/(?:\s+)/g, "").toLowerCase();
+            models[av] = converter;
+        }
+        cache.clear();
+        const compKeys = Object.keys(converter.components);
+        const isPolar = compKeys.some((k) => k === "hue" || k === "h");
+        if (isPolar) {
+            registry.polarFunctions.add(n);
+        }
+        else {
+            registry.rectangularFunctions.add(n);
+        }
+        const compList = compKeys.join(" | ");
+        const modernComponentsExpr = compKeys
+            .map((key) => (key === "hue" || key === "h" ? "[ <hue> | none ]" : "[ <number> | <percentage> | none ]"))
+            .join(" ");
+        const legacyComponentsExpr = compKeys
+            .map((key) => (key === "hue" || key === "h" ? "<hue>" : "[ <number> | <percentage> ]"))
+            .join(" , ");
+        const registerSyntaxForName = (fName) => {
+            const baseRuleName = `<${fName}()>`;
+            const modernRuleName = `<modern-${fName}-syntax>`;
+            const legacyRuleName = `<legacy-${fName}-syntax>`;
+            const relativeRuleName = `<relative-${fName}-syntax>`;
+            const compRuleName = `<${fName}-relative-component>`;
+            const alphaRuleName = `<${fName}-relative-alpha>`;
+            const modernExpr = `${fName}( ${modernComponentsExpr} [ / [ <alpha-value> | none ] ]? )`;
+            const legacyExpr = `${fName}( ${legacyComponentsExpr} [ , <alpha-value> ]? )`;
+            const compExpr = `<number> | <percentage> | none | ${compList} | alpha`;
+            const alphaExpr = `<alpha-value> | none | ${compList} | alpha`;
+            const relativeExpr = `${fName}( from <color> ${compRuleName}{3} [ / ${alphaRuleName} ]? )`;
+            const functionSubOptions = [modernRuleName, relativeRuleName];
+            if (converter.supportsLegacy) {
+                functionSubOptions.unshift(legacyRuleName);
+            }
+            const baseExpr = `[ ${functionSubOptions.join(" | ")} ]`;
+            grammarMap[compRuleName] = parseExpression(compExpr);
+            grammarMap[alphaRuleName] = parseExpression(alphaExpr);
+            grammarMap[modernRuleName] = parseExpression(modernExpr);
+            grammarMap[relativeRuleName] = parseExpression(relativeExpr);
+            if (converter.supportsLegacy) {
+                grammarMap[legacyRuleName] = parseExpression(legacyExpr);
+                parsers[legacyRuleName] = createLegacyColorParser(n, compKeys);
+            }
+            grammarMap[baseRuleName] = parseExpression(baseExpr);
+            registry.functionRules.add(baseRuleName);
+            parsers[baseRuleName] = (node) => parseNode(node.value[0]);
+            parsers[modernRuleName] = createModernColorParser(n, compKeys);
+            parsers[relativeRuleName] = createRelativeColorParser(n, compKeys);
+        };
+        try {
+            registerSyntaxForName(n);
+            if (converter.alphaVariant) {
+                const av = converter.alphaVariant.replace(/(?:\s+)/g, "").toLowerCase();
+                registerSyntaxForName(av);
+            }
+            const masterFunctionChoiceExpr = Array.from(registry.functionRules).join(" | ");
+            grammarMap["<custom-color-function>"] = parseExpression(masterFunctionChoiceExpr);
+            if (registry.rectangularFunctions.size > 0) {
+                const rectChoiceExpr = Array.from(registry.rectangularFunctions).join(" | ");
+                grammarMap["<custom-rectangular-space>"] = parseExpression(rectChoiceExpr);
+            }
+            if (registry.polarFunctions.size > 0) {
+                const polarChoiceExpr = Array.from(registry.polarFunctions).join(" | ");
+                grammarMap["<custom-polar-space>"] = parseExpression(polarChoiceExpr);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to dynamically bind custom color definition execution parameters for "${n}".`, {
+                cause: error,
+            });
+        }
+    },
+    "color-space": (name, converter) => {
+        const n = name.replace(/(?:\s+)/g, "-").toLowerCase();
+        const spaces = colorSpaces;
+        const models = colorModels;
+        if (typeof converter !== "object" || converter === null) {
+            throw new TypeError("Converter must be a non-null object.");
+        }
+        if (!Array.isArray(converter.components) || converter.components.some((c) => typeof c !== "string")) {
+            throw new TypeError("Converter.components must be an array of strings.");
+        }
+        if (typeof converter.bridge !== "string") {
+            throw new TypeError("Converter.bridge must be a string.");
+        }
+        const matrixChecks = [
+            ["toBridgeMatrix", "toBridgeMatrix"],
+            ["fromBridgeMatrix", "fromBridgeMatrix"],
+        ];
+        for (const [key, label] of matrixChecks) {
+            const matrix = converter[key];
+            if (!Array.isArray(matrix) ||
+                matrix.some((row) => !Array.isArray(row) || row.some((val) => typeof val !== "number"))) {
+                throw new TypeError(`Converter.${label} must be a 2D array of numbers.`);
+            }
+        }
+        if (converter.bridge in colorModels === false) {
+            throw new Error(`Converter.bridge '${converter.bridge}' does not correspond to any registered color model.`);
+        }
+        if ("targetGamut" in converter && converter.targetGamut !== null) {
+            throw new TypeError("Converter.targetGamut must be null if provided.");
+        }
+        if ("toLinear" in converter && typeof converter.toLinear !== "function") {
+            throw new TypeError("Converter.toLinear must be a function if provided.");
+        }
+        if ("fromLinear" in converter && typeof converter.fromLinear !== "function") {
+            throw new TypeError("Converter.fromLinear must be a function if provided.");
+        }
+        const modelConv = spaceConverterToModelConverter(n, converter);
+        spaces[n] = modelConv;
+        models[n] = modelConv;
+        cache.clear();
+        registry.customSpaces.add(n);
+        const dynamicChoiceExpression = Array.from(registry.customSpaces).join(" | ");
+        const compList = converter.components.join(" | ");
+        const compRuleName = `<${n}-relative-component>`;
+        const alphaRuleName = `<${n}-relative-alpha>`;
+        const syntaxRuleName = `<relative-${n}-color-syntax>`;
+        const compExpr = `<number> | <percentage> | none | ${compList} | alpha`;
+        const alphaExpr = `<alpha-value> | none | ${compList} | alpha`;
+        const syntaxExpr = `color( from <color> ${n} ${compRuleName}{3} [ / ${alphaRuleName} ]? )`;
+        const relativeChoiceExpr = Array.from(registry.customSpaces)
+            .map((space) => `<relative-${space}-color-syntax>`)
+            .join(" | ");
+        try {
+            grammarMap["<custom-color-space>"] = parseExpression(dynamicChoiceExpression);
+            grammarMap[compRuleName] = parseExpression(compExpr);
+            grammarMap[alphaRuleName] = parseExpression(alphaExpr);
+            grammarMap[syntaxRuleName] = parseExpression(syntaxExpr);
+            grammarMap["<relative-custom-color-syntax>"] = parseExpression(relativeChoiceExpr);
+            parsers[syntaxRuleName] = createRelativeColorFunctionParser;
+        }
+        catch (error) {
+            throw new Error(`Failed to dynamically bind color space "${n}" to grammarMap.`, { cause: error });
+        }
+    },
+    parser: (name, spec) => {
+        const n = name.trim().toLowerCase();
+        if (!/^<.+>$/.test(n)) {
+            throw new Error(`Grammar rule name must start with '<' and end with '>', received '${n}'.`);
+        }
+        if (typeof spec !== "object" || spec === null) {
+            throw new TypeError("Grammar rule specification must be a non-null object.");
+        }
+        if (typeof spec.rule !== "string") {
+            throw new TypeError("Grammar rule specification must include a 'rule' string.");
+        }
+        if (spec.parse !== undefined && typeof spec.parse !== "function") {
+            throw new TypeError("Grammar rule specification 'parse' must be a function if provided.");
+        }
+        if (spec.appendTo !== undefined && typeof spec.appendTo !== "string" && !Array.isArray(spec.appendTo)) {
+            throw new TypeError("Grammar rule 'appendTo' must be a string or an array of strings.");
+        }
+        try {
+            grammarMap[n] = parseExpression(spec.rule);
+            if (spec.parse) {
+                parsers[n] = spec.parse;
+            }
+            if (spec.appendTo) {
+                const targets = Array.isArray(spec.appendTo) ? spec.appendTo : [spec.appendTo];
+                for (let target of targets) {
+                    target = target.trim().toLowerCase();
+                    if (!/^<.+>$/.test(target)) {
+                        throw new Error(`Target appendTo rule must be formatted as '<rule-name>', received '${target}'.`);
+                    }
+                    if (!registry.grammarExtensions.has(target)) {
+                        registry.grammarExtensions.set(target, new Set());
+                    }
+                    registry.grammarExtensions.get(target).add(n);
+                    const baseTargetName = `<${target.slice(1, -1)}-core-base>`;
+                    if (!grammarMap[baseTargetName]) {
+                        if (!grammarMap[target]) {
+                            throw new Error(`Target rule '${target}' does not exist in the grammar map to append to.`);
+                        }
+                        grammarMap[baseTargetName] = grammarMap[target];
+                    }
+                    const extensions = Array.from(registry.grammarExtensions.get(target));
+                    const appendedChoiceExpr = `[ ${baseTargetName} | ${extensions.join(" | ")} ]`;
+                    grammarMap[target] = parseExpression(appendedChoiceExpr);
+                    parsers[target] = (node) => parseNode(node.value[0]);
+                    parsers[baseTargetName] = (node) => parseNode(node.value[0]);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to register custom grammar rule for "${n}".`, { cause: error });
+        }
+    },
+    formatter: (name, converter) => {
+        const n = name.trim().toLowerCase();
+        if (typeof converter !== "object" || converter === null) {
+            throw new TypeError("Formatter must be a non-null object.");
+        }
+        if (typeof converter.bridge !== "string") {
+            throw new TypeError("Formatter.bridge must be a string.");
+        }
+        if (typeof converter.fromBridge !== "function") {
+            throw new TypeError("Formatter.fromBridge must be a function.");
+        }
+        if (typeof converter.format !== "function") {
+            throw new TypeError("Formatter.format must be a function.");
+        }
+        if (converter.bridge in colorModels === false) {
+            throw new Error(`Formatter.bridge '${converter.bridge}' does not correspond to any registered color model.`);
+        }
+        const registeredFormatters = formatters;
+        if (n in registeredFormatters) {
+            throw new Error(`Formatter '${n}' is already registered.`);
+        }
+        registeredFormatters[n] = converter;
+    },
+    "fit-method": (name, method) => {
+        const n = name.trim().replace(/\s+/g, "-").toLowerCase();
+        const methods = fitMethods;
+        if (n in methods)
+            throw new Error(`Fit method '${n}' already exists.`);
+        if (typeof method !== "function")
+            throw new TypeError("Fit method must be a function.");
+        methods[n] = method;
+    },
+};
+/**
+ * Bulk register multiple converters of a specified type.
+ *
+ * @param type - The converter type, e.g. "color-function".
+ * @param entries - Array of { name, value } objects.
+ */
+export function register(type, entries) {
+    const fn = registerers[type];
+    for (const entry of entries)
+        fn(entry.name, entry.value); // eslint-disable-line @typescript-eslint/no-explicit-any
+}