@navecss/tokens 0.1.0

package/dist/lib/theming/on-star.d.ts

@@ -0,0 +1,11 @@
+import { type Adjacency } from './adjacency-source.ts';
+import { type SlotMapping } from './semantics.ts';
+export declare function deriveOnStarAnchors(adjacency: readonly Adjacency[]): Record<string, string>;
+export declare const ON_STAR_ANCHORS: Record<string, string>;
+export interface OnStarSource {
+    mapping: Record<string, SlotMapping>;
+    branchMapping: Record<string, SlotMapping>;
+    anchors: Record<string, string>;
+    adjacency?: readonly Adjacency[];
+}
+export declare function assertOnStarShape(source?: OnStarSource): void;

package/dist/lib/theming/on-star.js

@@ -0,0 +1,87 @@
+import { ADJACENCY } from "./adjacency-source.js";
+import { ACHROMATIC_MAPPING, CHROMATIC_MAPPING } from "./semantics.js";
+const STATE_OR_FOREGROUND_SUFFIX_RE = /\.(hover|active|foreground)$/;
+function familyAnchorFor(subject) {
+    return subject.slice('on-'.length);
+}
+export function deriveOnStarAnchors(adjacency) {
+    const anchors = {};
+    for (const { subject, against } of adjacency) {
+        if (!subject.startsWith('on-'))
+            continue;
+        if (STATE_OR_FOREGROUND_SUFFIX_RE.test(against))
+            continue;
+        if (against !== familyAnchorFor(subject))
+            continue;
+        anchors[subject] = against;
+    }
+    return anchors;
+}
+export const ON_STAR_ANCHORS = deriveOnStarAnchors(ADJACENCY);
+const SHIPPED_ON_STAR_SOURCE = () => ({
+    mapping: CHROMATIC_MAPPING,
+    branchMapping: ACHROMATIC_MAPPING,
+    anchors: ON_STAR_ANCHORS,
+    adjacency: ADJACENCY,
+});
+function restingPartnersBySubject(adjacency) {
+    const resting = new Map();
+    for (const { subject, against } of adjacency) {
+        if (!subject.startsWith('on-'))
+            continue;
+        if (STATE_OR_FOREGROUND_SUFFIX_RE.test(against))
+            continue;
+        const candidates = resting.get(subject) ?? [];
+        if (!candidates.includes(against))
+            candidates.push(against);
+        resting.set(subject, candidates);
+    }
+    return resting;
+}
+function assertOnStarAnchorsResolve(adjacency, anchors) {
+    for (const [subject, candidates] of restingPartnersBySubject(adjacency)) {
+        if (Object.hasOwn(anchors, subject))
+            continue;
+        const listed = candidates.map((name) => `"${name}"`).join(' and ');
+        throw new Error(`on-* anchor check: "${subject}" declares the resting partner(s) ${listed}, none of ` +
+            `which is "${familyAnchorFor(subject)}" — its own family's solid-background role, the ` +
+            'only anchor an on-* foreground can take. Declare that pair, or rename the ' +
+            'subject to the family it is the foreground of.');
+    }
+}
+function assertOnStarSlot(slot, source) {
+    const anchor = source.anchors[slot];
+    if (anchor === undefined) {
+        throw new Error(`on-* anchor check: ${slot} names no anchor in ON_STAR_ANCHORS.`);
+    }
+    if (STATE_OR_FOREGROUND_SUFFIX_RE.test(anchor)) {
+        throw new Error(`on-* anchor check: ${slot}'s anchor "${anchor}" is a state or a foreground role, ` +
+            'not the resting solid-background it must be.');
+    }
+    if (!Object.hasOwn(source.mapping, anchor)) {
+        throw new Error(`on-* anchor check: ${slot}'s anchor "${anchor}" is not a name the build emits.`);
+    }
+    for (const mapping of [source.mapping[slot], source.branchMapping[slot]]) {
+        if (mapping && ('alias' in mapping.light || 'alias' in mapping.dark)) {
+            throw new Error(`on-* anchor check: ${slot}'s value is composed or aliased, not a whole declaration.`);
+        }
+    }
+}
+function assertNoAliasingOfOnStarSlots(mapping) {
+    for (const [name, slotMapping] of Object.entries(mapping)) {
+        for (const branch of ['light', 'dark']) {
+            const ref = slotMapping[branch];
+            if ('alias' in ref && ref.alias.startsWith('on-')) {
+                throw new Error(`on-* anchor check: ${name} aliases the on-* slot "${ref.alias}".`);
+            }
+        }
+    }
+}
+export function assertOnStarShape(source = SHIPPED_ON_STAR_SOURCE()) {
+    if (source.adjacency)
+        assertOnStarAnchorsResolve(source.adjacency, source.anchors);
+    const onStarSlots = Object.keys(source.mapping).filter((name) => name.startsWith('on-'));
+    for (const slot of onStarSlots)
+        assertOnStarSlot(slot, source);
+    assertNoAliasingOfOnStarSlots(source.mapping);
+}

package/dist/lib/theming/palette-record.d.ts

@@ -0,0 +1,2 @@
+import type { PipelineResult } from './pipeline.ts';
+export declare function composePaletteRecord(result: PipelineResult): Record<string, unknown>;

package/dist/lib/theming/palette-record.js

@@ -0,0 +1,15 @@
+import { SLOT_DESCRIPTIONS } from "./descriptions.js";
+const PALETTE_RECORD_NOTE = 'This file is a resolved palette record: what this build produced for every semantic colour slot, in both schemes. It is not a DTCG 2025.10 document, and it is not meant to be read by a DTCG 2025.10 tool, because its keys are flat dotted names and most of its values are relative-colour-syntax strings, neither of which that format expresses. The token document is tokens.json, shipped beside it.';
+const PALETTE_RECORD_NOTE_KEY = 'aboutThisFile';
+export function composePaletteRecord(result) {
+    const record = { [PALETTE_RECORD_NOTE_KEY]: PALETTE_RECORD_NOTE };
+    for (const slot of result.slots) {
+        const description = SLOT_DESCRIPTIONS.get(slot.slot);
+        record[`color.${slot.slot}.${slot.branch}`] = {
+            $type: 'color',
+            $value: slot.css,
+            ...(description !== undefined && { $description: description }),
+        };
+    }
+    return record;
+}

package/dist/lib/theming/pipeline.d.ts

@@ -0,0 +1,43 @@
+import type { Oklch } from './color-math.ts';
+import { type NeutralStep } from './neutral.ts';
+import { type Ramp, type SeedRecord } from './ramp.ts';
+export interface Seeds {
+    primary: Oklch;
+    danger: Oklch;
+    declaredTintHue: number;
+}
+export declare const OVERRIDE_SCALE_NAMES: readonly ["danger", "neutral", "primary"];
+export type PerStepOverrides = Partial<Record<(typeof OVERRIDE_SCALE_NAMES)[number], Record<number, number>>>;
+interface PipelineRecords {
+    primary: SeedRecord;
+    danger: SeedRecord;
+    achromaticBranch: boolean;
+    tintHue: number;
+}
+export interface ResolvedSlot {
+    slot: string;
+    branch: 'dark' | 'light';
+    resolved: {
+        scale: 'danger' | 'neutral' | 'primary';
+        step: number;
+    };
+    literal: Oklch;
+    css: string;
+}
+export interface PipelineResult {
+    records: PipelineRecords;
+    primaryRamp: Ramp;
+    dangerRamp: Ramp;
+    neutralLiterals: readonly NeutralStep[];
+    slots: readonly ResolvedSlot[];
+    actionSecondaryForeground: {
+        dark: ResolvedSlot;
+        light: ResolvedSlot;
+    };
+    actionSecondaryBorder: {
+        dark: ResolvedSlot;
+        light: ResolvedSlot;
+    };
+}
+export declare function runPipeline(seeds: Seeds, overrides?: PerStepOverrides, env?: ReadonlyMap<number, number>): PipelineResult;
+export {};

package/dist/lib/theming/pipeline.js

@@ -0,0 +1,104 @@
+import { formatOklch } from "./color-math.js";
+import { computeNeutralChromaCeiling, generateNeutralRampLiterals, neutralRcsFormula, resolveNeutralStep, } from "./neutral.js";
+import { DEFAULT_ENV, generateRamp, rampStep } from "./ramp.js";
+import { ACTION_SECONDARY_BORDER, ACTION_SECONDARY_FOREGROUND, resolveSlotMapping, SEMANTIC_SLOTS, } from "./semantics.js";
+export const OVERRIDE_SCALE_NAMES = ['danger', 'neutral', 'primary'];
+function resolveStepRef(ref, branch, isAchromaticBranch) {
+    let current = ref;
+    for (let depth = 0; depth < 10; depth++) {
+        if (!('alias' in current))
+            return current;
+        const target = resolveSlotMapping(current.alias, isAchromaticBranch);
+        current = target[branch];
+    }
+    throw new Error('Alias chain too deep — likely a cycle in the semantic mapping.');
+}
+function cssForResolved(resolved, ctx) {
+    if (resolved.scale === 'neutral') {
+        const colour = resolveNeutralStep(resolved.step, ctx.tintHue, ctx.neutralLiterals);
+        return { css: neutralRcsFormula(resolved.step, ctx.neutralLiterals), literal: colour };
+    }
+    const ramp = resolved.scale === 'primary' ? ctx.primaryRamp : ctx.dangerRamp;
+    const colour = rampStep(ramp, resolved.step);
+    return { css: formatOklch(colour), literal: colour };
+}
+function resolveOne(slot, ref, branch, ctx) {
+    const resolved = resolveStepRef(ref, branch, ctx.isAchromaticBranch);
+    const { css, literal } = cssForResolved(resolved, ctx);
+    return { slot, branch, resolved, css, literal };
+}
+function applyOverrides(steps, overrides) {
+    if (!overrides)
+        return steps;
+    return steps.map((s) => {
+        const override = overrides[s.step];
+        return override === undefined ? s : { ...s, c: override };
+    });
+}
+function generateRamps(seeds, overrides, env) {
+    const primaryGenerated = generateRamp(seeds.primary, env);
+    const dangerGenerated = generateRamp(seeds.danger, env);
+    const finalPrimaryRamp = {
+        ...primaryGenerated,
+        steps: applyOverrides(primaryGenerated.steps, overrides.primary),
+    };
+    const finalDangerRamp = {
+        ...dangerGenerated,
+        steps: applyOverrides(dangerGenerated.steps, overrides.danger),
+    };
+    const neutralLiterals = applyOverrides(generateNeutralRampLiterals(computeNeutralChromaCeiling()), overrides.neutral);
+    const isAchromaticBranch = finalPrimaryRamp.seedRecord.achromatic;
+    const tintHue = isAchromaticBranch
+        ? seeds.declaredTintHue
+        : finalPrimaryRamp.seedRecord.usedSeed.h;
+    return {
+        primaryRamp: finalPrimaryRamp,
+        dangerRamp: finalDangerRamp,
+        neutralLiterals,
+        tintHue,
+        isAchromaticBranch,
+    };
+}
+function resolveAllSlots(ctx) {
+    const slots = [];
+    for (const slotName of SEMANTIC_SLOTS) {
+        const mapping = resolveSlotMapping(slotName, ctx.isAchromaticBranch);
+        for (const branch of ['light', 'dark']) {
+            slots.push(resolveOne(slotName, mapping[branch], branch, ctx));
+        }
+    }
+    return slots;
+}
+function resolveActionSecondaryCompanions(ctx) {
+    const fgRef = { alias: ACTION_SECONDARY_FOREGROUND };
+    const borderRef = { alias: ACTION_SECONDARY_BORDER };
+    return {
+        actionSecondaryForeground: {
+            light: resolveOne('action.secondary.foreground', fgRef, 'light', ctx),
+            dark: resolveOne('action.secondary.foreground', fgRef, 'dark', ctx),
+        },
+        actionSecondaryBorder: {
+            light: resolveOne('action.secondary.border', borderRef, 'light', ctx),
+            dark: resolveOne('action.secondary.border', borderRef, 'dark', ctx),
+        },
+    };
+}
+export function runPipeline(seeds, overrides = {}, env = DEFAULT_ENV) {
+    const ctx = generateRamps(seeds, overrides, env);
+    const records = {
+        primary: ctx.primaryRamp.seedRecord,
+        danger: ctx.dangerRamp.seedRecord,
+        achromaticBranch: ctx.isAchromaticBranch,
+        tintHue: ctx.tintHue,
+    };
+    const slots = resolveAllSlots(ctx);
+    const companions = resolveActionSecondaryCompanions(ctx);
+    return {
+        records,
+        primaryRamp: ctx.primaryRamp,
+        dangerRamp: ctx.dangerRamp,
+        neutralLiterals: ctx.neutralLiterals,
+        slots,
+        ...companions,
+    };
+}

package/dist/lib/theming/ramp.d.ts

@@ -0,0 +1,34 @@
+import { type Oklch, type SeedNormalization } from './color-math.ts';
+export declare const DEFAULT_ENV: ReadonlyMap<number, number>;
+export declare const ENV_CEILING = 0.95;
+export declare const ADVERSARIAL_SEEDS: readonly {
+    name: string;
+    seed: Oklch;
+}[];
+export declare const S_BAND: {
+    readonly lo: 0.2;
+    readonly hi: 0.9;
+};
+export interface SeedRecord {
+    normalized: boolean;
+    normalization: SeedNormalization;
+    bandClamped: boolean;
+    usedSeed: Oklch;
+    sLightness: number;
+    s: number;
+    achromatic: boolean;
+}
+export declare function decomposeSeed(seed: Oklch): SeedRecord;
+interface RampStep {
+    step: number;
+    l: number;
+    c: number;
+    h: number;
+}
+export interface Ramp {
+    seedRecord: SeedRecord;
+    steps: readonly RampStep[];
+}
+export declare function generateRamp(seed: Oklch, env?: ReadonlyMap<number, number>): Ramp;
+export declare function rampStep(ramp: Ramp, step: number): Oklch;
+export {};

package/dist/lib/theming/ramp.js

@@ -0,0 +1,92 @@
+import { isOklchInGamut, maxChroma, normalizeSeed, } from "./color-math.js";
+import { STEP_TABLE, stepLightness } from "./step-table.js";
+export const DEFAULT_ENV = new Map([
+    [0, 0],
+    [50, 0.35],
+    [100, 0.55],
+    [150, 0.68],
+    [200, 0.78],
+    [300, 0.88],
+    [400, 0.93],
+    [500, 0.95],
+    [600, 0.95],
+    [700, 0.95],
+    [800, 0.88],
+    [850, 0.78],
+    [900, 0.62],
+    [950, 0.4],
+    [1000, 0],
+]);
+export const ENV_CEILING = 0.95;
+export const ADVERSARIAL_SEEDS = [
+    { name: 'red', seed: { l: 0.6, c: 0.15, h: 25 } },
+    { name: 'blue', seed: { l: 0.55, c: 0.15, h: 260 } },
+    { name: 'violet', seed: { l: 0.55, c: 0.15, h: 300 } },
+    { name: 'yellow-green', seed: { l: 0.7, c: 0.15, h: 110 } },
+];
+export const S_BAND = { lo: 0.2, hi: 0.9 };
+export function decomposeSeed(seed) {
+    const { seed: used, normalization, normalized } = normalizeSeed(seed);
+    const isAchromatic = used.c === 0;
+    if (isAchromatic) {
+        return {
+            normalized,
+            normalization,
+            bandClamped: false,
+            usedSeed: used,
+            sLightness: used.l,
+            s: 0,
+            achromatic: true,
+        };
+    }
+    const isBandClamped = used.l < S_BAND.lo || used.l > S_BAND.hi;
+    const sLightness = isBandClamped ? Math.min(Math.max(used.l, S_BAND.lo), S_BAND.hi) : used.l;
+    const denom = maxChroma(sLightness, used.h);
+    const s = denom === 0 ? 0 : Math.min(Math.max(used.c / denom, 0), 1);
+    return {
+        normalized,
+        normalization,
+        bandClamped: isBandClamped,
+        usedSeed: used,
+        sLightness,
+        s,
+        achromatic: false,
+    };
+}
+export function generateRamp(seed, env = DEFAULT_ENV) {
+    const seedRecord = decomposeSeed(seed);
+    const hue = seedRecord.achromatic ? 0 : seedRecord.usedSeed.h;
+    const steps = STEP_TABLE.map(({ step, l }) => {
+        const envValue = env.get(step);
+        if (envValue === undefined) {
+            throw new Error(`The environment curve has no value for step ${step}. Open an issue.`);
+        }
+        if (envValue > ENV_CEILING) {
+            throw new Error(`env(${step}) = ${envValue} exceeds the hard invariant ceiling of ${ENV_CEILING}. ` +
+                'Raising the 0.95 ceiling is a gamut change, not a curve edit: open an issue.');
+        }
+        if (seedRecord.achromatic) {
+            return { step, l, c: 0, h: 0 };
+        }
+        const cap = maxChroma(l, hue);
+        const c = seedRecord.s * envValue * cap;
+        const permitted = ENV_CEILING * cap;
+        if (c > permitted + 1e-9) {
+            throw new Error(`The scale at hue ${hue} step ${step} requested chroma ${c}, which exceeds the ` +
+                `permitted ceiling ${permitted} (0.95 * maxChroma(${l}, ${hue})). Open an issue ` +
+                'rather than raising the ceiling here.');
+        }
+        if (!isOklchInGamut({ l, c, h: hue })) {
+            throw new Error(`Step ${step} of the scale at hue ${hue} is out of sRGB gamut. Open an issue.`);
+        }
+        return { step, l, c, h: hue };
+    });
+    return { seedRecord, steps };
+}
+export function rampStep(ramp, step) {
+    stepLightness(step);
+    const found = ramp.steps.find((s) => s.step === step);
+    if (!found)
+        throw new Error(`Step ${step} missing from generated ramp.`);
+    return { l: found.l, c: found.c, h: found.h };
+}

package/dist/lib/theming/seed-channel-split.d.ts

@@ -0,0 +1,8 @@
+export declare function readNumericToken(text: string): number;
+export declare function isNoneKeyword(text: string): boolean;
+export declare function splitChannelArgs(args: string): {
+    alpha: number | undefined;
+    isLegacySyntax: boolean;
+    parts: string[];
+};
+export declare function parseHueDeg(token: string): number;

package/dist/lib/theming/seed-channel-split.js

@@ -0,0 +1,99 @@
+import { clamp01 } from "./seed-refusal.js";
+const CSS_WHITESPACE_EDGES = /^[ \t\n\r\f]+|[ \t\n\r\f]+$/g;
+function cssTrim(text) {
+    return text.replaceAll(CSS_WHITESPACE_EDGES, '');
+}
+const CSS_NUMBER = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+export function readNumericToken(text) {
+    if (text.trim() === '')
+        return NaN;
+    if (/\s/u.test(text))
+        return NaN;
+    if (!CSS_NUMBER.test(text))
+        return NaN;
+    return Number(text);
+}
+export function isNoneKeyword(text) {
+    return /^none$/i.test(text);
+}
+function parseAlphaToken(token) {
+    const t = cssTrim(token);
+    if (t.endsWith('%'))
+        return clamp01(readNumericToken(t.slice(0, -1)) / 100);
+    return clamp01(readNumericToken(t));
+}
+const CSS_WHITESPACE_CHARS = ' \t\n\r\f';
+function splitTopLevel(text, isSeparator) {
+    const tokens = [];
+    let current = '';
+    let depth = 0;
+    for (const ch of text) {
+        if (ch === '(')
+            depth += 1;
+        else if (ch === ')')
+            depth = Math.max(0, depth - 1);
+        if (depth === 0 && isSeparator(ch)) {
+            if (current !== '')
+                tokens.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current !== '')
+        tokens.push(current);
+    return tokens;
+}
+function lastTopLevelSlashIndex(text) {
+    let depth = 0;
+    let lastIndex = -1;
+    for (const [i, ch] of text.split('').entries()) {
+        if (ch === '(')
+            depth += 1;
+        else if (ch === ')')
+            depth = Math.max(0, depth - 1);
+        else if (ch === '/' && depth === 0)
+            lastIndex = i;
+    }
+    return lastIndex;
+}
+export function splitChannelArgs(args) {
+    const trimmed = cssTrim(args);
+    const slashIdx = lastTopLevelSlashIndex(trimmed);
+    let main = trimmed;
+    let alpha;
+    if (slashIdx !== -1) {
+        main = cssTrim(trimmed.slice(0, slashIdx));
+        alpha = parseAlphaToken(trimmed.slice(slashIdx + 1));
+    }
+    const commaParts = splitTopLevel(main, (ch) => ch === ',');
+    const isLegacySyntax = commaParts.length > 1;
+    let parts;
+    if (isLegacySyntax) {
+        parts = commaParts.map((p) => cssTrim(p)).filter(Boolean);
+        if (alpha === undefined && parts.length === 4) {
+            alpha = parseAlphaToken(parts.pop());
+        }
+    }
+    else {
+        parts = splitTopLevel(main, (ch) => CSS_WHITESPACE_CHARS.includes(ch));
+    }
+    return { alpha, isLegacySyntax, parts };
+}
+const ANGLE_UNITS = [
+    { toDeg: 0.9, unit: 'grad' },
+    { toDeg: 360, unit: 'turn' },
+    { toDeg: 180 / Math.PI, unit: 'rad' },
+    { toDeg: 1, unit: 'deg' },
+];
+export function parseHueDeg(token) {
+    if (isNoneKeyword(token))
+        return 0;
+    const lower = token.toLowerCase();
+    for (const { toDeg, unit } of ANGLE_UNITS) {
+        if (lower.endsWith(unit)) {
+            return readNumericToken(token.slice(0, token.length - unit.length)) * toDeg;
+        }
+    }
+    return readNumericToken(token);
+}

package/dist/lib/theming/seed-form-parsers-css-color-4.d.ts

@@ -0,0 +1,8 @@
+import type { Oklch } from './color-math.ts';
+import type { ColorFunctionSpace } from './seed-input.ts';
+export declare function ingestLab(input: string, args: string): Oklch;
+export declare function ingestLch(input: string, args: string): Oklch;
+export declare function ingestColor(input: string, args: string): {
+    space: ColorFunctionSpace;
+    value: Oklch;
+};

package/dist/lib/theming/seed-form-parsers-css-color-4.js

@@ -0,0 +1,85 @@
+import { srgbToOklch } from "./color-math.js";
+import { displayP3ToOklch, labToOklch, lchToOklch } from "./css-color-4.js";
+import { isNoneKeyword, parseHueDeg, readNumericToken, splitChannelArgs, } from "./seed-channel-split.js";
+import { badChannelValue, checkOpaqueAlpha, unsupportedColourSpace } from "./seed-refusal.js";
+const COLOR_FUNCTION_SPACES = new Set([
+    'display-p3',
+    'srgb',
+]);
+function parseLabLightness(token) {
+    if (isNoneKeyword(token))
+        return 0;
+    if (token.endsWith('%'))
+        return readNumericToken(token.slice(0, -1));
+    return readNumericToken(token);
+}
+function parseScaledChannel(token, percentReference) {
+    if (isNoneKeyword(token))
+        return 0;
+    if (token.endsWith('%'))
+        return (readNumericToken(token.slice(0, -1)) / 100) * percentReference;
+    return readNumericToken(token);
+}
+function parseColorChannel(token) {
+    if (isNoneKeyword(token))
+        return 0;
+    if (token.endsWith('%'))
+        return readNumericToken(token.slice(0, -1)) / 100;
+    return readNumericToken(token);
+}
+function clampCieLightness(l) {
+    return Math.min(100, Math.max(0, l));
+}
+function readThreeChannels(input, form, parts) {
+    if (parts.length !== 3) {
+        throw badChannelValue(input, form, `it needs three channels and this has ${parts.length}.`);
+    }
+    return [parts[0], parts[1], parts[2]];
+}
+function checkFiniteChannels(input, form, channels) {
+    if (channels.some((n) => !Number.isFinite(n))) {
+        throw badChannelValue(input, form, 'one or more of its channel values could not be read as a number.');
+    }
+}
+export function ingestLab(input, args) {
+    const { alpha, parts } = splitChannelArgs(args);
+    const [lToken, aToken, bToken] = readThreeChannels(input, 'lab()', parts);
+    const l = parseLabLightness(lToken);
+    const a = parseScaledChannel(aToken, 125);
+    const b = parseScaledChannel(bToken, 125);
+    checkFiniteChannels(input, 'lab()', [l, a, b]);
+    checkOpaqueAlpha(input, alpha, 'lab()');
+    return labToOklch({ a, b, l: clampCieLightness(l) });
+}
+export function ingestLch(input, args) {
+    const { alpha, parts } = splitChannelArgs(args);
+    const [lToken, cToken, hToken] = readThreeChannels(input, 'lch()', parts);
+    const l = parseLabLightness(lToken);
+    const c = parseScaledChannel(cToken, 150);
+    const h = parseHueDeg(hToken);
+    checkFiniteChannels(input, 'lch()', [l, c, h]);
+    checkOpaqueAlpha(input, alpha, 'lch()');
+    return lchToOklch({ c: Math.max(0, c), h, l: clampCieLightness(l) });
+}
+export function ingestColor(input, args) {
+    const { alpha, parts } = splitChannelArgs(args);
+    const spaceToken = parts[0];
+    if (spaceToken === undefined) {
+        throw badChannelValue(input, 'color()', 'it needs a colour space and three channels and this has neither.');
+    }
+    const space = spaceToken.toLowerCase();
+    if (!COLOR_FUNCTION_SPACES.has(space))
+        throw unsupportedColourSpace(input, spaceToken);
+    const [rToken, gToken, bToken] = readThreeChannels(input, 'color()', parts.slice(1));
+    const rgb = {
+        b: parseColorChannel(bToken),
+        g: parseColorChannel(gToken),
+        r: parseColorChannel(rToken),
+    };
+    checkFiniteChannels(input, 'color()', [rgb.r, rgb.g, rgb.b]);
+    checkOpaqueAlpha(input, alpha, 'color()');
+    return {
+        space: space,
+        value: space === 'srgb' ? srgbToOklch(rgb) : displayP3ToOklch(rgb),
+    };
+}

package/dist/lib/theming/seed-form-parsers.d.ts

@@ -0,0 +1,6 @@
+import type { Oklch } from './color-math.ts';
+export declare const RECOGNISED_ALIASED_FUNCTIONS: Record<string, 'hsl' | 'oklch' | 'rgb'>;
+export declare function ingestHex(input: string, digits: string): Oklch;
+export declare function ingestRgb(input: string, args: string): Oklch;
+export declare function ingestHsl(input: string, args: string): Oklch;
+export declare function ingestOklch(input: string, args: string): Oklch;