@navecss/tokens 0.1.0

package/dist/lib/theming/seed-form-parsers.js

@@ -0,0 +1,155 @@
+import { srgbToOklch } from "./color-math.js";
+import { isNoneKeyword, parseHueDeg, readNumericToken, splitChannelArgs, } from "./seed-channel-split.js";
+import { badChannelValue, checkOpaqueAlpha, clamp01 } from "./seed-refusal.js";
+export const RECOGNISED_ALIASED_FUNCTIONS = {
+    hsl: 'hsl',
+    hsla: 'hsl',
+    oklch: 'oklch',
+    rgb: 'rgb',
+    rgba: 'rgb',
+};
+function parseRgbChannel(token) {
+    if (isNoneKeyword(token))
+        return 0;
+    if (token.endsWith('%'))
+        return clamp01(readNumericToken(token.slice(0, -1)) / 100);
+    return clamp01(readNumericToken(token) / 255);
+}
+function parsePercent01(token) {
+    if (isNoneKeyword(token))
+        return 0;
+    const t = token.endsWith('%') ? token.slice(0, -1) : token;
+    return clamp01(readNumericToken(t) / 100);
+}
+function refuseNoneInLegacySyntax(input, form, parts, isLegacySyntax) {
+    if (!isLegacySyntax)
+        return;
+    if (parts.some((part) => isNoneKeyword(part))) {
+        throw badChannelValue(input, form, 'it uses the `none` keyword, which legacy comma-separated syntax does not allow; write the seed in modern space-separated syntax instead.');
+    }
+}
+function hslSectorRgbPrime(hp, c, x) {
+    switch (Math.floor(hp) % 6) {
+        case 0: {
+            return { b: 0, g: x, r: c };
+        }
+        case 1: {
+            return { b: 0, g: c, r: x };
+        }
+        case 2: {
+            return { b: x, g: c, r: 0 };
+        }
+        case 3: {
+            return { b: c, g: x, r: 0 };
+        }
+        case 4: {
+            return { b: c, g: 0, r: x };
+        }
+        default: {
+            return { b: x, g: 0, r: c };
+        }
+    }
+}
+function hslToSrgb(h, s, l) {
+    const hue = ((h % 360) + 360) % 360;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const hp = hue / 60;
+    const x = c * (1 - Math.abs((hp % 2) - 1));
+    const m = l - c / 2;
+    const prime = hslSectorRgbPrime(hp, c, x);
+    return { b: prime.b + m, g: prime.g + m, r: prime.r + m };
+}
+export function ingestHex(input, digits) {
+    let r;
+    let g;
+    let b;
+    let alphaHex;
+    switch (digits.length) {
+        case 3: {
+            r = Number.parseInt(digits[0] + digits[0], 16);
+            g = Number.parseInt(digits[1] + digits[1], 16);
+            b = Number.parseInt(digits[2] + digits[2], 16);
+            break;
+        }
+        case 4: {
+            r = Number.parseInt(digits[0] + digits[0], 16);
+            g = Number.parseInt(digits[1] + digits[1], 16);
+            b = Number.parseInt(digits[2] + digits[2], 16);
+            alphaHex = digits[3] + digits[3];
+            break;
+        }
+        case 6: {
+            r = Number.parseInt(digits.slice(0, 2), 16);
+            g = Number.parseInt(digits.slice(2, 4), 16);
+            b = Number.parseInt(digits.slice(4, 6), 16);
+            break;
+        }
+        default: {
+            r = Number.parseInt(digits.slice(0, 2), 16);
+            g = Number.parseInt(digits.slice(2, 4), 16);
+            b = Number.parseInt(digits.slice(4, 6), 16);
+            alphaHex = digits.slice(6, 8);
+        }
+    }
+    if (alphaHex !== undefined)
+        checkOpaqueAlpha(input, Number.parseInt(alphaHex, 16) / 255, 'hex');
+    return srgbToOklch({ b: b / 255, g: g / 255, r: r / 255 });
+}
+export function ingestRgb(input, args) {
+    const { alpha, isLegacySyntax, parts } = splitChannelArgs(args);
+    if (parts.length !== 3) {
+        throw badChannelValue(input, 'rgb()', `it needs three channels and this has ${parts.length}.`);
+    }
+    refuseNoneInLegacySyntax(input, 'rgb()', parts, isLegacySyntax);
+    const r = parseRgbChannel(parts[0]);
+    const g = parseRgbChannel(parts[1]);
+    const b = parseRgbChannel(parts[2]);
+    if ([r, g, b].some((n) => !Number.isFinite(n))) {
+        throw badChannelValue(input, 'rgb()', 'one or more of its channel values could not be read as a number.');
+    }
+    checkOpaqueAlpha(input, alpha, 'rgb()');
+    return srgbToOklch({ b, g, r });
+}
+export function ingestHsl(input, args) {
+    const { alpha, isLegacySyntax, parts } = splitChannelArgs(args);
+    if (parts.length !== 3) {
+        throw badChannelValue(input, 'hsl()', `it needs three channels and this has ${parts.length}.`);
+    }
+    refuseNoneInLegacySyntax(input, 'hsl()', parts, isLegacySyntax);
+    const h = parseHueDeg(parts[0]);
+    const s = parsePercent01(parts[1]);
+    const l = parsePercent01(parts[2]);
+    if ([h, s, l].some((n) => !Number.isFinite(n))) {
+        throw badChannelValue(input, 'hsl()', 'one or more of its channel values could not be read as a number.');
+    }
+    checkOpaqueAlpha(input, alpha, 'hsl()');
+    return srgbToOklch(hslToSrgb(h, s, l));
+}
+function parseOklchLightness(token) {
+    if (isNoneKeyword(token))
+        return 0;
+    if (token.endsWith('%'))
+        return readNumericToken(token.slice(0, -1)) / 100;
+    return readNumericToken(token);
+}
+function parseOklchChroma(token) {
+    if (isNoneKeyword(token))
+        return 0;
+    if (token.endsWith('%'))
+        return (readNumericToken(token.slice(0, -1)) / 100) * 0.4;
+    return readNumericToken(token);
+}
+export function ingestOklch(input, args) {
+    const { alpha, parts } = splitChannelArgs(args);
+    if (parts.length !== 3) {
+        throw badChannelValue(input, 'oklch()', `it needs three channels and this has ${parts.length}.`);
+    }
+    const l = parseOklchLightness(parts[0]);
+    const c = parseOklchChroma(parts[1]);
+    const h = parseHueDeg(parts[2]);
+    if ([l, c, h].some((n) => !Number.isFinite(n))) {
+        throw badChannelValue(input, 'oklch()', 'one or more of its channel values could not be read as a number.');
+    }
+    checkOpaqueAlpha(input, alpha, 'oklch()');
+    return { c: Math.max(0, c), h, l: clamp01(l) };
+}

package/dist/lib/theming/seed-ingest.d.ts

@@ -0,0 +1,15 @@
+import type { Oklch } from './color-math.ts';
+import type { ConsumerBuildComposition, ConsumerBuildOptions } from './consumer-build.ts';
+import type { SeedInput } from './seed-input.ts';
+export { SeedIngestRefusal } from './seed-refusal.ts';
+export declare function parseSeed(raw: string): SeedInput;
+export declare function ingestSeed(raw: string): Oklch;
+interface RawConsumerSeeds {
+    danger: string;
+    declaredTintHue: number;
+    primary: string;
+}
+export interface RawConsumerBuildOptions extends Omit<ConsumerBuildOptions, 'seedInputs' | 'seeds'> {
+    seeds: RawConsumerSeeds;
+}
+export declare function composeConsumerBuildFromRawSeeds(options: RawConsumerBuildOptions): ConsumerBuildComposition;

package/dist/lib/theming/seed-ingest.js

@@ -0,0 +1,112 @@
+import { composeConsumerBuild } from "./consumer-build.js";
+import { CSS_NAMED_COLOURS } from "./css-named-colours.js";
+import { ingestColor, ingestLab, ingestLch } from "./seed-form-parsers-css-color-4.js";
+import { ingestHex, ingestHsl, ingestOklch, ingestRgb, RECOGNISED_ALIASED_FUNCTIONS, } from "./seed-form-parsers.js";
+import { badChannelValue, CONTEXT_DEPENDENT_FIX, NAMED_COLOUR_FIX, SeedIngestRefusal, unrecognisedForm, } from "./seed-refusal.js";
+export { SeedIngestRefusal } from "./seed-refusal.js";
+function isContextDependentForm(input) {
+    if (/\bcurrentcolor\b/i.test(input))
+        return true;
+    if (/\bvar\(/i.test(input))
+        return true;
+    if (/\(\s*from\s+/i.test(input))
+        return true;
+    if (/\blight-dark\(/i.test(input))
+        return true;
+    if (/\benv\(/i.test(input))
+        return true;
+    return false;
+}
+function contextDependentDetail(input) {
+    if (/\bcurrentcolor\b/i.test(input)) {
+        return 'this seed refers to `currentColor`, which resolves only where an element renders, not at build time.';
+    }
+    if (/\(\s*from\s+/i.test(input)) {
+        return 'this seed uses relative colour syntax, which substitutes at browser time against a live declaration, not against a build-time input.';
+    }
+    if (/\blight-dark\(/i.test(input)) {
+        return 'this seed calls `light-dark()`, which resolves against the active color-scheme at browser time, not at build time.';
+    }
+    if (/\benv\(/i.test(input)) {
+        return "this seed calls `env()`, which resolves against the user agent's environment at browser time, not at build time.";
+    }
+    return 'this seed refers to a custom property or another declaration, which resolves only at browser time, not at build time.';
+}
+function badHexRefusal(raw, input) {
+    const body = input.slice(1);
+    if (/^[\dA-Fa-f]+$/.test(body)) {
+        return badChannelValue(raw, 'hex', `it needs 3, 4, 6 or 8 digits and this has ${body.length}.`);
+    }
+    return badChannelValue(raw, 'hex', 'its digits could not be read as hexadecimal.');
+}
+function ingestFunctionForm(raw, name, args) {
+    if (name === 'lab')
+        return { form: 'lab', raw, value: ingestLab(raw, args) };
+    if (name === 'lch')
+        return { form: 'lch', raw, value: ingestLch(raw, args) };
+    if (name === 'color') {
+        const { space, value } = ingestColor(raw, args);
+        return { form: 'color', raw, space, value };
+    }
+    const recognised = RECOGNISED_ALIASED_FUNCTIONS[name];
+    if (recognised === 'rgb')
+        return { form: 'rgb', raw, value: ingestRgb(raw, args) };
+    if (recognised === 'hsl')
+        return { form: 'hsl', raw, value: ingestHsl(raw, args) };
+    if (recognised === 'oklch')
+        return { form: 'oklch', raw, value: ingestOklch(raw, args) };
+    throw unrecognisedForm(raw);
+}
+export function parseSeed(raw) {
+    const input = raw.trim();
+    if (isContextDependentForm(input)) {
+        throw new SeedIngestRefusal({
+            act: 'form-acceptance',
+            detail: contextDependentDetail(input),
+            fix: CONTEXT_DEPENDENT_FIX,
+            input: raw,
+            refusalClass: 'context-dependent-form',
+        });
+    }
+    const hexMatch = /^#([\dA-Fa-f]{3}|[\dA-Fa-f]{4}|[\dA-Fa-f]{6}|[\dA-Fa-f]{8})$/.exec(input);
+    if (hexMatch) {
+        const digits = hexMatch[1];
+        return {
+            form: 'hex',
+            raw,
+            value: ingestHex(raw, digits),
+            width: digits.length,
+        };
+    }
+    if (input.startsWith('#'))
+        throw badHexRefusal(raw, input);
+    const fnMatch = /^([a-zA-Z-]+)\(([\s\S]*)\)$/.exec(input);
+    if (fnMatch)
+        return ingestFunctionForm(raw, fnMatch[1].toLowerCase(), fnMatch[2]);
+    if (/^[a-zA-Z]+$/.test(input) && CSS_NAMED_COLOURS.has(input.toLowerCase())) {
+        throw new SeedIngestRefusal({
+            act: 'form-acceptance',
+            detail: `\`${input}\` is a valid CSS named colour, not accepted as a seed form at 0.1.0 (a scope limit, not a defect in the input).`,
+            fix: NAMED_COLOUR_FIX,
+            input: raw,
+            refusalClass: 'named-colour',
+        });
+    }
+    throw unrecognisedForm(raw);
+}
+export function ingestSeed(raw) {
+    return parseSeed(raw).value;
+}
+export function composeConsumerBuildFromRawSeeds(options) {
+    const primary = parseSeed(options.seeds.primary);
+    const danger = parseSeed(options.seeds.danger);
+    return composeConsumerBuild({
+        ...options,
+        seedInputs: { danger, primary },
+        seeds: {
+            danger: danger.value,
+            declaredTintHue: options.seeds.declaredTintHue,
+            primary: primary.value,
+        },
+    });
+}

package/dist/lib/theming/seed-input.d.ts

@@ -0,0 +1,22 @@
+import type { Oklch } from './color-math.ts';
+export type ColorFunctionSpace = 'display-p3' | 'srgb';
+export type HexWidth = 3 | 4 | 6 | 8;
+export type SeedInput = {
+    form: 'color';
+    raw: string;
+    space: ColorFunctionSpace;
+    value: Oklch;
+} | {
+    form: 'hex';
+    raw: string;
+    value: Oklch;
+    width: HexWidth;
+} | {
+    form: 'hsl' | 'lab' | 'lch' | 'oklch' | 'rgb';
+    raw: string;
+    value: Oklch;
+} | {
+    form: 'oklch';
+    value: Oklch;
+};
+export type SeedInputs = Partial<Record<'danger' | 'primary', SeedInput>>;

package/dist/lib/theming/seed-input.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/theming/seed-refusal.d.ts

@@ -0,0 +1,21 @@
+export type SeedRefusalAct = 'channel-value' | 'form-acceptance';
+export type SeedRefusalClass = 'context-dependent-form' | 'named-colour' | 'non-opaque-alpha' | 'unrecognised-form';
+export declare const CONTEXT_DEPENDENT_FIX = "replace this seed with a literal colour value the build can resolve on its own, with no reference to a custom property, the current colour, or another declaration.";
+export declare const NAMED_COLOUR_FIX = "write the seed in one of the accepted forms below, never a CSS named colour.";
+export declare class SeedIngestRefusal extends Error {
+    readonly act: SeedRefusalAct;
+    readonly input: string;
+    readonly refusalClass: SeedRefusalClass;
+    constructor(params: {
+        act: SeedRefusalAct;
+        detail: string;
+        fix: string;
+        input: string;
+        refusalClass: SeedRefusalClass;
+    });
+}
+export declare const clamp01: (n: number) => number;
+export declare function unrecognisedForm(input: string): SeedIngestRefusal;
+export declare function badChannelValue(input: string, form: string, detail: string): SeedIngestRefusal;
+export declare function unsupportedColourSpace(input: string, space: string): SeedIngestRefusal;
+export declare function checkOpaqueAlpha(input: string, alpha: number | undefined, form: string): void;

package/dist/lib/theming/seed-refusal.js

@@ -0,0 +1,77 @@
+const ACCEPTED_FORM_POINTER = 'Accepted seed forms: hex (3, 4, 6 or 8 digit), rgb(), hsl(), oklch(), lab(), lch(), color() (srgb, display-p3).';
+const NON_OPAQUE_ALPHA_FIX = "write the seed's alpha channel as fully opaque: drop the alpha channel entirely, or set it to 1 / 100% / an opaque hex pair (f / ff).";
+export const CONTEXT_DEPENDENT_FIX = 'replace this seed with a literal colour value the build can resolve on its own, with no reference to a custom property, the current colour, or another declaration.';
+export const NAMED_COLOUR_FIX = 'write the seed in one of the accepted forms below, never a CSS named colour.';
+const UNRECOGNISED_FORM_FIX = 'write the seed in one of the accepted forms below.';
+const CHANNEL_VALUE_FIX = 'write every channel of this seed as a literal number or percentage, with no missing channel.';
+const UNSUPPORTED_COLOUR_SPACE_FIX = 'write the colour in the `srgb` or `display-p3` colour space of `color()`, or in another accepted form below.';
+export class SeedIngestRefusal extends Error {
+    act;
+    input;
+    refusalClass;
+    constructor(params) {
+        const actPhrase = params.act === 'channel-value' ? 'channel value' : 'form acceptance';
+        super(`${params.detail} Input as given: \`${params.input}\`. Refused at: ${actPhrase}. Fix: ${params.fix} ${ACCEPTED_FORM_POINTER}`);
+        this.name = 'SeedIngestRefusal';
+        this.act = params.act;
+        this.input = params.input;
+        this.refusalClass = params.refusalClass;
+    }
+}
+const ALPHA_EPSILON = 1e-6;
+export const clamp01 = (n) => Math.min(1, Math.max(0, n));
+const roundTo = (n, d) => {
+    const f = 10 ** d;
+    return Math.round(n * f) / f;
+};
+function unrecognisedFormDetail(input) {
+    if (input === '')
+        return 'The seed is empty: nothing was written where a seed is required.';
+    if (input.trim() === '') {
+        return 'The seed is whitespace only: nothing but spaces or blank characters was written where a seed is required.';
+    }
+    return `\`${input}\` is not an accepted seed form.`;
+}
+export function unrecognisedForm(input) {
+    return new SeedIngestRefusal({
+        act: 'form-acceptance',
+        detail: unrecognisedFormDetail(input),
+        fix: UNRECOGNISED_FORM_FIX,
+        input,
+        refusalClass: 'unrecognised-form',
+    });
+}
+export function badChannelValue(input, form, detail) {
+    return new SeedIngestRefusal({
+        act: 'channel-value',
+        detail: `\`${form}\` is an accepted seed form, but ${detail}`,
+        fix: CHANNEL_VALUE_FIX,
+        input,
+        refusalClass: 'unrecognised-form',
+    });
+}
+export function unsupportedColourSpace(input, space) {
+    return new SeedIngestRefusal({
+        act: 'channel-value',
+        detail: `\`color()\` is an accepted seed form, but its colour space \`${space}\` is not one this build converts; only \`srgb\` and \`display-p3\` are.`,
+        fix: UNSUPPORTED_COLOUR_SPACE_FIX,
+        input,
+        refusalClass: 'unrecognised-form',
+    });
+}
+export function checkOpaqueAlpha(input, alpha, form) {
+    if (alpha === undefined)
+        return;
+    if (!Number.isFinite(alpha)) {
+        throw badChannelValue(input, form, 'its alpha channel could not be read as a number.');
+    }
+    if (Math.abs(alpha - 1) > ALPHA_EPSILON) {
+        throw new SeedIngestRefusal({
+            act: 'channel-value',
+            detail: `the alpha channel resolves to ${roundTo(alpha, 4)}, which is not fully opaque.`,
+            fix: NON_OPAQUE_ALPHA_FIX,
+            input,
+            refusalClass: 'non-opaque-alpha',
+        });
+    }
+}

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

@@ -0,0 +1,19 @@
+type Scale = 'neutral' | 'primary' | 'danger';
+export type StepRef = {
+    scale: Scale;
+    step: number;
+} | {
+    alias: string;
+};
+export interface SlotMapping {
+    light: StepRef;
+    dark: StepRef;
+}
+export declare const ACHROMATIC_BRANCH_SLOTS: readonly ["action.primary", "action.primary.hover", "action.primary.active", "on-action.primary", "content.link", "border.focus"];
+export declare const CHROMATIC_MAPPING: Record<string, SlotMapping>;
+export declare const ACHROMATIC_MAPPING: Record<string, SlotMapping>;
+export declare const ACTION_SECONDARY_FOREGROUND = "content.primary";
+export declare const ACTION_SECONDARY_BORDER = "border.control";
+export declare function resolveSlotMapping(slot: string, isAchromaticBranch: boolean): SlotMapping;
+export declare const SEMANTIC_SLOTS: readonly string[];
+export {};

package/dist/lib/theming/semantics.js

@@ -0,0 +1,71 @@
+export const ACHROMATIC_BRANCH_SLOTS = [
+    'action.primary',
+    'action.primary.hover',
+    'action.primary.active',
+    'on-action.primary',
+    'content.link',
+    'border.focus',
+];
+const ref = (scale, step) => ({ scale, step });
+const aliasRef = (slot) => ({ alias: slot });
+export const CHROMATIC_MAPPING = {
+    'surface.base': { light: ref('neutral', 0), dark: ref('neutral', 900) },
+    'surface.raised': { light: ref('neutral', 0), dark: ref('neutral', 850) },
+    'surface.overlay': { light: ref('neutral', 0), dark: ref('neutral', 800) },
+    'surface.sunken': { light: ref('neutral', 50), dark: ref('neutral', 950) },
+    'surface.inverse': { light: ref('neutral', 900), dark: ref('neutral', 100) },
+    'content.primary': { light: ref('neutral', 900), dark: ref('neutral', 100) },
+    'content.secondary': { light: ref('neutral', 700), dark: ref('neutral', 300) },
+    'content.tertiary': { light: ref('neutral', 600), dark: ref('neutral', 400) },
+    'content.disabled': { light: ref('neutral', 300), dark: ref('neutral', 700) },
+    'content.inverse': { light: ref('neutral', 100), dark: ref('neutral', 900) },
+    'content.link': { light: ref('primary', 600), dark: ref('primary', 300) },
+    'border.default': { light: ref('neutral', 200), dark: ref('neutral', 700) },
+    'border.strong': { light: ref('neutral', 400), dark: ref('neutral', 600) },
+    'border.control': { light: ref('neutral', 500), dark: ref('neutral', 500) },
+    'border.disabled': { light: ref('neutral', 150), dark: ref('neutral', 800) },
+    'border.focus': { light: ref('primary', 500), dark: ref('primary', 500) },
+    'action.primary': { light: ref('primary', 600), dark: ref('primary', 300) },
+    'action.primary.hover': { light: ref('primary', 700), dark: ref('primary', 200) },
+    'action.primary.active': { light: ref('primary', 800), dark: ref('primary', 150) },
+    'on-action.primary': { light: ref('neutral', 0), dark: ref('neutral', 900) },
+    'action.secondary': { light: ref('neutral', 100), dark: ref('neutral', 800) },
+    'feedback.danger': { light: ref('danger', 600), dark: ref('danger', 300) },
+    'feedback.danger.foreground': { light: ref('danger', 600), dark: ref('danger', 300) },
+    'on-feedback.danger': { light: ref('neutral', 0), dark: ref('neutral', 900) },
+    'feedback.warning': { light: ref('neutral', 600), dark: ref('neutral', 300) },
+    'feedback.warning.foreground': { light: ref('neutral', 600), dark: ref('neutral', 300) },
+    'on-feedback.warning': { light: ref('neutral', 0), dark: ref('neutral', 900) },
+    'feedback.success': { light: aliasRef('feedback.warning'), dark: aliasRef('feedback.warning') },
+    'feedback.success.foreground': {
+        light: aliasRef('feedback.warning.foreground'),
+        dark: aliasRef('feedback.warning.foreground'),
+    },
+    'on-feedback.success': { light: ref('neutral', 0), dark: ref('neutral', 900) },
+    'feedback.info': { light: aliasRef('feedback.warning'), dark: aliasRef('feedback.warning') },
+    'feedback.info.foreground': {
+        light: aliasRef('feedback.warning.foreground'),
+        dark: aliasRef('feedback.warning.foreground'),
+    },
+    'on-feedback.info': { light: ref('neutral', 0), dark: ref('neutral', 900) },
+};
+export const ACHROMATIC_MAPPING = {
+    'action.primary': { light: ref('neutral', 800), dark: ref('neutral', 200) },
+    'action.primary.hover': { light: ref('neutral', 900), dark: ref('neutral', 150) },
+    'action.primary.active': { light: ref('neutral', 950), dark: ref('neutral', 50) },
+    'on-action.primary': { light: ref('neutral', 0), dark: ref('neutral', 900) },
+    'content.link': { light: aliasRef('content.primary'), dark: aliasRef('content.primary') },
+    'border.focus': { light: ref('neutral', 500), dark: ref('neutral', 500) },
+};
+export const ACTION_SECONDARY_FOREGROUND = 'content.primary';
+export const ACTION_SECONDARY_BORDER = 'border.control';
+export function resolveSlotMapping(slot, isAchromaticBranch) {
+    const achromaticOverride = isAchromaticBranch ? ACHROMATIC_MAPPING[slot] : undefined;
+    if (achromaticOverride)
+        return achromaticOverride;
+    const mapping = CHROMATIC_MAPPING[slot];
+    if (!mapping)
+        throw new Error(`Unknown semantic slot: ${slot}`);
+    return mapping;
+}
+export const SEMANTIC_SLOTS = Object.keys(CHROMATIC_MAPPING);

package/dist/lib/theming/shipped-seeds.d.ts

@@ -0,0 +1,2 @@
+import type { Seeds } from './pipeline.ts';
+export declare const SHIPPED_SEEDS: Seeds;

package/dist/lib/theming/shipped-seeds.js

@@ -0,0 +1,5 @@
+export const SHIPPED_SEEDS = {
+    primary: { l: 0.7859, c: 0.1316, h: 186.17 },
+    danger: { l: 0.6357, c: 0.2072, h: 15.02 },
+    declaredTintHue: 186.17,
+};

package/dist/lib/theming/step-table.d.ts

@@ -0,0 +1,5 @@
+export declare const STEP_TABLE: readonly {
+    l: number;
+    step: number;
+}[];
+export declare function stepLightness(step: number): number;

package/dist/lib/theming/step-table.js

@@ -0,0 +1,26 @@
+export const STEP_TABLE = [
+    { step: 0, l: 1 },
+    { step: 50, l: 0.985 },
+    { step: 100, l: 0.965 },
+    { step: 150, l: 0.94 },
+    { step: 200, l: 0.905 },
+    { step: 300, l: 0.835 },
+    { step: 400, l: 0.72 },
+    { step: 500, l: 0.59 },
+    { step: 600, l: 0.47 },
+    { step: 700, l: 0.37 },
+    { step: 800, l: 0.27 },
+    { step: 850, l: 0.225 },
+    { step: 900, l: 0.18 },
+    { step: 950, l: 0.12 },
+    { step: 1000, l: 0 },
+];
+const STEP_LIGHTNESS = new Map(STEP_TABLE.map((r) => [r.step, r.l]));
+export function stepLightness(step) {
+    const l = STEP_LIGHTNESS.get(step);
+    if (l === undefined) {
+        throw new Error(`Step ${step} is not defined in the shared step table. ` +
+            `Valid steps: ${STEP_TABLE.map((r) => r.step).join(', ')}. Open an issue.`);
+    }
+    return l;
+}

package/dist/lib/theming/third-party-provenance.d.ts

@@ -0,0 +1,9 @@
+export declare const R6_CONSUMER_ARTIFACTS: readonly ["tokens.css", "tokens.js", "tokens.d.ts", "breakpoints.js", "breakpoints.d.ts", "palette-record.json", "build-record.json"];
+export interface ProvenanceArtifact {
+    path: string;
+    content: string;
+}
+export declare const THIRD_PARTY_RESIDUE_PATTERNS: readonly RegExp[];
+export declare function findThirdPartyResidue(artifacts: readonly ProvenanceArtifact[]): string[];
+export declare function findUnattributedHeader(artifacts: readonly ProvenanceArtifact[]): string[];
+export declare const THIRD_PARTY_TEXT_ROUTING_POLICY: string;

package/dist/lib/theming/third-party-provenance.js

@@ -0,0 +1,35 @@
+export const R6_CONSUMER_ARTIFACTS = [
+    'tokens.css',
+    'tokens.js',
+    'tokens.d.ts',
+    'breakpoints.js',
+    'breakpoints.d.ts',
+    'palette-record.json',
+    'build-record.json',
+];
+const RESIDUE_FRAGMENTS = [
+    ['style', '[- ]?', 'dictionar', 'y'],
+    ['terra', 'zzo'],
+    ['tokens', '[- ]', 'studio'],
+    ['fig', 'ma'],
+    ['cul', 'ori'],
+    ['color', String.raw `js\.io`],
+];
+export const THIRD_PARTY_RESIDUE_PATTERNS = RESIDUE_FRAGMENTS.map((fragments) => new RegExp(fragments.join(''), 'i'));
+const NAVE_ATTRIBUTION_PATTERN = /^\/\*\*?\s*\n?\s*\*?\s*Nave (Design System|breakpoints)\b/;
+export function findThirdPartyResidue(artifacts) {
+    return artifacts
+        .filter((artifact) => THIRD_PARTY_RESIDUE_PATTERNS.some((pattern) => pattern.test(artifact.content)))
+        .map((artifact) => artifact.path);
+}
+export function findUnattributedHeader(artifacts) {
+    return artifacts
+        .filter((artifact) => !NAVE_ATTRIBUTION_PATTERN.test(artifact.content))
+        .map((artifact) => artifact.path);
+}
+export const THIRD_PARTY_TEXT_ROUTING_POLICY = 'Any proposal to vendor a colour-space or DTCG 2025.10 parser to make this entry point ' +
+    'self-contained, to reach for a bundler with `noExternal` or a bundled helper, to add a ' +
+    'dependency and then inline it so the tarball looks dependency-free, or to emit text ' +
+    "taken from a third party into a consumer's committed artifact, is routed through this " +
+    "project's own licence review before publication. These are examples, not an " +
+    'enumeration: a prohibition written as a list defaults to permitted.';

package/dist/lib/theming/tokens-source.d.ts

@@ -0,0 +1,3 @@
+export declare const TOKENS_JSON_PATH: string;
+export declare function assertNoDuplicateAdjacencySubjects(rawText: string): void;
+export declare function loadShippedTokensSource(): unknown;

package/dist/lib/theming/tokens-source.js

@@ -0,0 +1,61 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { findPackageRoot } from "../package-root.js";
+export const TOKENS_JSON_PATH = path.join(findPackageRoot(import.meta.url), 'tokens.json');
+function didCloseBlock(char, state) {
+    if (state.escaped) {
+        state.escaped = false;
+        return false;
+    }
+    if (char === '\\') {
+        state.escaped = state.inString;
+        return false;
+    }
+    if (char === '"') {
+        state.inString = !state.inString;
+        return false;
+    }
+    if (state.inString)
+        return false;
+    if (char === '{') {
+        state.depth += 1;
+        return false;
+    }
+    if (char === '}') {
+        state.depth -= 1;
+        return state.depth === 0;
+    }
+    return false;
+}
+function adjacencyBlockText(rawText) {
+    const start = rawText.indexOf('{', rawText.indexOf('"adjacency"'));
+    if (start <= 0)
+        return undefined;
+    const state = { depth: 0, escaped: false, inString: false };
+    for (let i = start; i < rawText.length; i += 1) {
+        if (didCloseBlock(rawText[i], state))
+            return rawText.slice(start, i + 1);
+    }
+    return undefined;
+}
+const SUBJECT_KEY_RE = /"([^"]+)"\s*:\s*\[/g;
+export function assertNoDuplicateAdjacencySubjects(rawText) {
+    const block = adjacencyBlockText(rawText);
+    if (block === undefined)
+        return;
+    const seen = new Set();
+    for (const [, subject] of block.matchAll(SUBJECT_KEY_RE)) {
+        if (seen.has(subject)) {
+            throw new Error(`Adjacency declaration: the adjacency block in @navecss/tokens' own bundled ` +
+                `tokens.json declares the subject "${subject}" twice. JSON.parse keeps only the ` +
+                "last block, so the first one's pairs would be dropped silently: merge the two " +
+                'into one subject key.');
+        }
+        seen.add(subject);
+    }
+}
+export function loadShippedTokensSource() {
+    const rawText = readFileSync(TOKENS_JSON_PATH, 'utf8');
+    assertNoDuplicateAdjacencySubjects(rawText);
+    return JSON.parse(rawText);
+}

package/dist/lib/token-name.d.ts

@@ -0,0 +1,2 @@
+export declare function kebabName(path: readonly string[]): string;
+export declare function nameFromPath(path: readonly string[]): string;