@menapo/vicss 0.0.0-stage → 1.1.0

package/dist/config.js

@@ -0,0 +1,2690 @@
+//#region src/core/css-value.ts
+/**
+* Well-formedness of the text vicss prints into the one global sheet. A value
+* that leaves a block, a string or a comment open swallows every rule after it,
+* in every module's CSS; one that ends the declaration (`;`, `}`) or carries
+* `!important` escapes the layer order. Nothing here judges whether the
+* browser accepts the value, only that it cannot affect the text around it.
+*/
+const OPENERS = {
+	"(": ")",
+	"[": "]"
+};
+const NEWLINE = /[\n\r\f]/;
+const SPACE = /[ \t\n\r\f]/;
+/**
+* Why `text` is not a self-contained value, selector or at-rule prelude, or
+* `undefined` when it is. None of them holds a `{…}` block outside a string.
+*/
+function malformed(text) {
+	if (/<\/style/i.test(text)) return "it contains `</style`";
+	const stack = [];
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === "\\") {
+			if (i + 1 >= text.length) return "it ends with a backslash";
+			if (NEWLINE.test(text[i + 1])) return "a backslash escapes a line break";
+			i++;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const end = closeString(text, i);
+			if (typeof end === "string") return end;
+			i = end;
+			continue;
+		}
+		if (ch === "/" && text[i + 1] === "*") return "it contains a comment (`/*`)";
+		if (ch === "u" || ch === "U") {
+			const end = unquotedUrl(text, i);
+			if (typeof end === "string") return end;
+			if (end !== void 0) {
+				i = end;
+				continue;
+			}
+		}
+		if (ch === ";") return "it contains `;`, which would end the declaration";
+		if (ch === "!") return "it contains `!`, which would make it `!important` or end it";
+		if (ch === "{") return "it contains `{`";
+		const close = OPENERS[ch];
+		if (close !== void 0) stack.push(close);
+		else if (ch === ")" || ch === "]" || ch === "}") {
+			if (stack.pop() !== ch) return `\`${ch}\` closes nothing`;
+		}
+	}
+	const open = stack.at(-1);
+	return open === void 0 ? void 0 : `\`${open}\` is missing`;
+}
+/** Index of the closing quote, or why the string never closes. */
+function closeString(text, start) {
+	const quote = text[start];
+	for (let i = start + 1; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === quote) return i;
+		if (ch === "\\") {
+			if (i + 1 >= text.length) return "a string ends with a backslash";
+			i++;
+		} else if (NEWLINE.test(ch)) return "a string contains a line break";
+	}
+	return `a string is missing its closing ${quote}`;
+}
+/**
+* An unquoted `url(…)` is one token up to `)`: `;`, `{` and `}` inside it
+* belong to the URL (`url(data:image/png;base64,…)`). Returns the index of
+* the closing `)`, `undefined` when `start` does not begin one, or why it is
+* malformed.
+*/
+function unquotedUrl(text, start) {
+	if (!/^url\(/i.test(text.slice(start, start + 4))) return void 0;
+	if (start > 0 && /[\w-]/.test(text[start - 1])) return void 0;
+	let i = start + 4;
+	while (i < text.length && SPACE.test(text[i])) i++;
+	if (text[i] === "\"" || text[i] === "'") return void 0;
+	for (; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === ")") return i;
+		if (ch === "\\") {
+			if (i + 1 >= text.length || NEWLINE.test(text[i + 1])) return "a url() has a bad escape";
+			i++;
+		} else if (ch === "\"" || ch === "'" || ch === "(" || ch.charCodeAt(0) < 32) return "a url() holds a quote, a parenthesis or a control character";
+		else if (SPACE.test(ch)) {
+			while (i + 1 < text.length && SPACE.test(text[i + 1])) i++;
+			if (text[i + 1] !== ")") return "a url() holds whitespace";
+		}
+	}
+	return "a url() is missing its `)`";
+}
+//#endregion
+//#region src/core/types.ts
+/**
+* What marks a VicssError, shared by every copy of this module in a process:
+* the config entry bundles its own copy, and Vite's `runnerImport` gives a
+* config another instance even of the workspace's source, so an error a
+* preset's utility or `dtcg()` throws is of another class than the one the
+* compiler catches.
+*/
+const BRAND = Symbol.for("@menapo/vicss/error");
+/** Thrown for anything vicss refuses; carries enough to print a code frame. */
+var VicssError = class VicssError extends Error {
+	code;
+	loc;
+	hint;
+	/**
+	* `instanceof VicssError` holds for a VicssError of any copy of vicss.
+	* Subclasses (`ScanConflict`) keep the ordinary prototype check.
+	*/
+	static [Symbol.hasInstance](value) {
+		if (this !== VicssError) return Function.prototype[Symbol.hasInstance].call(this, value);
+		return typeof value === "object" && value !== null && BRAND in value;
+	}
+	constructor(code, message, options = {}) {
+		const limit = Error.stackTraceLimit;
+		Error.stackTraceLimit = 0;
+		super(message);
+		Error.stackTraceLimit = limit;
+		this.name = "VicssError";
+		this.code = code;
+		this.loc = options.loc;
+		this.hint = options.hint;
+		Object.defineProperty(this, BRAND, { value: true });
+	}
+};
+/** `{ base, _dark }` is a value per mode; `{ base: "…" }` alone is a single value. */
+function isModeMap(node) {
+	const keys = Object.keys(node);
+	return keys.some((k) => k.startsWith("_")) || keys.length === 1 && keys[0] === "base" && !isPlainObject$1(node.base);
+}
+function isPlainObject$1(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function configError$1(at, message, options = {}) {
+	return new VicssError("CONFIG", `${at}: ${message}`, options);
+}
+//#endregion
+//#region src/config/refs.ts
+/**
+* Typed token references for the config (PLAN §5.3, D32):
+* `defineConfig(config, ({ colors }) => ({ … colors.gray[900] … }))`. The
+* callback gets a tree of every token the config and its presets define,
+* and each reference is the brace string the config already took
+* (`"{colors.gray.900}"`), so resolution, DTCG export, modes, palettes and
+* the lint snapshot see the config they always did. The tree is built when
+* `defineConfig` runs and the references are strings in the config it
+* returns: a config crosses to worker threads and the CLI as plain data.
+*/
+/**
+* The proxies the callback got, each to its brace string: what `settle`
+* turns them back into, naming the key path when a group cannot be one.
+*/
+const TEXTS = /* @__PURE__ */ new WeakMap();
+/** The keys `defineConfig`'s callback may not return. */
+const BASE_ONLY = ["tokens", "presets"];
+/** The reference tree of `config` and its presets (the shape `TokenRefs` types). */
+function tokenRefs(config) {
+	const nodes = /* @__PURE__ */ new Map();
+	collect(config, nodes, /* @__PURE__ */ new Set());
+	const cache = /* @__PURE__ */ new Map();
+	const root = {};
+	for (const [path, node] of nodes) if (!path.includes(".")) root[path] = refAt(path, node, nodes, cache);
+	return Object.freeze(root);
+}
+function collect(layer, nodes, seen) {
+	if (!isPlainObject$1(layer) || seen.has(layer)) return;
+	seen.add(layer);
+	if (Array.isArray(layer.presets)) for (const preset of layer.presets) collect(preset, nodes, seen);
+	for (const [field, semantic] of [["tokens", false], ["semanticTokens", true]]) {
+		const scales = layer[field];
+		if (!isPlainObject$1(scales)) continue;
+		for (const [scale, tree] of Object.entries(scales)) if (isPlainObject$1(tree)) walk(scale, tree, semantic, nodes);
+	}
+}
+function nodeAt(path, nodes) {
+	let node = nodes.get(path);
+	if (!node) nodes.set(path, node = {
+		token: false,
+		children: /* @__PURE__ */ new Set()
+	});
+	return node;
+}
+function walk(path, tree, semantic, nodes) {
+	const group = nodeAt(path, nodes);
+	for (const [name, value] of Object.entries(tree)) {
+		if (value === void 0) continue;
+		if (name === "DEFAULT") {
+			group.token = true;
+			continue;
+		}
+		const child = `${path}.${name}`;
+		group.children.add(name);
+		if (typeof value === "string" || typeof value === "number") nodeAt(child, nodes).token = true;
+		else if (isPlainObject$1(value)) {
+			if (semantic && isModeMap(value)) nodeAt(child, nodes).token = true;
+			else walk(child, value, semantic, nodes);
+		}
+	}
+}
+/**
+* A token with nothing under it is its brace string; anything else is a
+* proxy that stringifies to one and indexes further. A path no layer
+* defines still makes a reference: resolution names the missing token with
+* the config key that holds it, and a preset package's `dtcg()` result that
+* the loader reads again may define it by then (config/files.ts).
+*/
+function refAt(path, node, nodes, cache) {
+	if (node?.token && node.children.size === 0) return `{${path}}`;
+	const cached = cache.get(path);
+	if (cached !== void 0) return cached;
+	const text = (at) => {
+		if (node && !node.token) throw groupError(path, node, at);
+		return `{${path}}`;
+	};
+	const convert = () => text();
+	const child = (key) => refAt(`${path}.${key}`, nodes.get(`${path}.${key}`), nodes, cache);
+	const proxy = new Proxy(Object.create(null), {
+		get(_, key) {
+			if (typeof key === "string" && node?.children.has(key)) return child(key);
+			if (key === Symbol.toPrimitive || key === "toString" || key === "valueOf" || key === "toJSON") return convert;
+			if (typeof key === "symbol" || key === "then") return void 0;
+			return child(key);
+		},
+		has: (_, key) => typeof key === "string" && node?.children.has(key) === true,
+		ownKeys: () => [...node?.children ?? []],
+		getOwnPropertyDescriptor: (_, key) => typeof key === "string" && node?.children.has(key) ? {
+			value: child(key),
+			enumerable: true,
+			configurable: true,
+			writable: false
+		} : void 0,
+		set: () => false,
+		defineProperty: () => false,
+		deleteProperty: () => false
+	});
+	TEXTS.set(proxy, text);
+	cache.set(path, proxy);
+	return proxy;
+}
+function groupError(path, node, at) {
+	const message = `\`${path}\` is a group of tokens, not a token`;
+	const hint = `Name one of its tokens: ${[...node.children].slice(0, 3).map((name) => `\`${path}.${name}\``).join(", ")}${node.children.size > 3 ? ", …" : ""}.`;
+	return at ? configError$1(at, message, { hint }) : new VicssError("CONFIG", message, { hint });
+}
+/**
+* `value` with every reference replaced by its brace string, copied, never
+* mutated. Functions (a utility's `transform`) return settled values too,
+* and keep their source text, which the system's hash reads.
+*/
+function settle(value, at) {
+	const text = typeof value === "object" && value !== null ? TEXTS.get(value) : void 0;
+	if (text) return text(at);
+	if (typeof value === "function") {
+		const fn = value;
+		const settled = function(...args) {
+			return settle(fn.apply(this, args), `${at}()`);
+		};
+		Object.defineProperty(settled, "toString", { value: () => fn.toString() });
+		return settled;
+	}
+	if (Array.isArray(value)) return value.map((v, i) => settle(v, `${at}[${i}]`));
+	if (isPlainObject$1(value)) {
+		const out = {};
+		for (const [key, v] of Object.entries(value)) out[key] = settle(v, `${at}.${key}`);
+		return out;
+	}
+	return value;
+}
+//#endregion
+//#region src/config/presets/reset.ts
+/**
+* The `reset` preset: `presets: [reset]` is `reset: true`, a modern reset in
+* the `vicss.reset` layer (PLAN §4.9, D15; the rules are in
+* `src/core/reset.ts`). It is opt-in because a reset is the app's choice: a
+* component library's preset must never carry it.
+*/
+const reset = { reset: true };
+//#endregion
+//#region src/config/presets/shorthands.ts
+/** A utility that sets `properties` to its value, typed and checked by `scale`. */
+function alias(name, scale, ...properties) {
+	return {
+		scale,
+		transform: (value) => {
+			if (typeof value === "boolean") throw new VicssError("INVALID_VALUE", `\`${name}\` takes a value of ${properties.join(" and ")}, not \`${value}\``);
+			const style = {};
+			for (const property of properties) style[property] = value;
+			return style;
+		}
+	};
+}
+/** `p`, `px` … `pe` and `m` … `me`: Tailwind v4 spells the axes with logical properties. */
+function box(prefix, property) {
+	return Object.fromEntries([
+		["", ""],
+		["x", "Inline"],
+		["y", "Block"],
+		["t", "Top"],
+		["r", "Right"],
+		["b", "Bottom"],
+		["l", "Left"],
+		["s", "InlineStart"],
+		["e", "InlineEnd"]
+	].map(([suffix, side]) => [`${prefix}${suffix}`, alias(`${prefix}${suffix}`, "spacing", `${property}${side}`)]));
+}
+const radius = (name, ...corners) => alias(name, "radii", ...corners.map((corner) => `border${corner}Radius`));
+const shorthands = { utilities: {
+	...box("p", "padding"),
+	...box("m", "margin"),
+	w: alias("w", "sizes", "width"),
+	h: alias("h", "sizes", "height"),
+	minW: alias("minW", "sizes", "minWidth"),
+	maxW: alias("maxW", "sizes", "maxWidth"),
+	minH: alias("minH", "sizes", "minHeight"),
+	maxH: alias("maxH", "sizes", "maxHeight"),
+	bg: alias("bg", "colors", "background"),
+	rounded: alias("rounded", "radii", "borderRadius"),
+	roundedT: radius("roundedT", "TopLeft", "TopRight"),
+	roundedR: radius("roundedR", "TopRight", "BottomRight"),
+	roundedB: radius("roundedB", "BottomRight", "BottomLeft"),
+	roundedL: radius("roundedL", "TopLeft", "BottomLeft"),
+	roundedS: radius("roundedS", "StartStart", "EndStart"),
+	roundedE: radius("roundedE", "StartEnd", "EndEnd"),
+	shadow: alias("shadow", "shadows", "boxShadow"),
+	z: alias("z", "zIndices", "zIndex"),
+	gapX: alias("gapX", "spacing", "columnGap"),
+	gapY: alias("gapY", "spacing", "rowGap"),
+	insetX: alias("insetX", "spacing", "insetInline"),
+	insetY: alias("insetY", "spacing", "insetBlock"),
+	leading: alias("leading", "lineHeights", "lineHeight"),
+	tracking: alias("tracking", "letterSpacings", "letterSpacing")
+} };
+//#endregion
+//#region src/config/presets/tailwind.ts
+const tailwind = {
+	tokens: {
+		colors: {
+			red: {
+				50: "oklch(97.1% 0.013 17.38)",
+				100: "oklch(93.6% 0.032 17.717)",
+				200: "oklch(88.5% 0.062 18.334)",
+				300: "oklch(80.8% 0.114 19.571)",
+				400: "oklch(70.4% 0.191 22.216)",
+				500: "oklch(63.7% 0.237 25.331)",
+				600: "oklch(57.7% 0.245 27.325)",
+				700: "oklch(50.5% 0.213 27.518)",
+				800: "oklch(44.4% 0.177 26.899)",
+				900: "oklch(39.6% 0.141 25.723)",
+				950: "oklch(25.8% 0.092 26.042)"
+			},
+			orange: {
+				50: "oklch(98% 0.016 73.684)",
+				100: "oklch(95.4% 0.038 75.164)",
+				200: "oklch(90.1% 0.076 70.697)",
+				300: "oklch(83.7% 0.128 66.29)",
+				400: "oklch(75% 0.183 55.934)",
+				500: "oklch(70.5% 0.213 47.604)",
+				600: "oklch(64.6% 0.222 41.116)",
+				700: "oklch(55.3% 0.195 38.402)",
+				800: "oklch(47% 0.157 37.304)",
+				900: "oklch(40.8% 0.123 38.172)",
+				950: "oklch(26.6% 0.079 36.259)"
+			},
+			amber: {
+				50: "oklch(98.7% 0.022 95.277)",
+				100: "oklch(96.2% 0.059 95.617)",
+				200: "oklch(92.4% 0.12 95.746)",
+				300: "oklch(87.9% 0.169 91.605)",
+				400: "oklch(82.8% 0.189 84.429)",
+				500: "oklch(76.9% 0.188 70.08)",
+				600: "oklch(66.6% 0.179 58.318)",
+				700: "oklch(55.5% 0.163 48.998)",
+				800: "oklch(47.3% 0.137 46.201)",
+				900: "oklch(41.4% 0.112 45.904)",
+				950: "oklch(27.9% 0.077 45.635)"
+			},
+			yellow: {
+				50: "oklch(98.7% 0.026 102.212)",
+				100: "oklch(97.3% 0.071 103.193)",
+				200: "oklch(94.5% 0.129 101.54)",
+				300: "oklch(90.5% 0.182 98.111)",
+				400: "oklch(85.2% 0.199 91.936)",
+				500: "oklch(79.5% 0.184 86.047)",
+				600: "oklch(68.1% 0.162 75.834)",
+				700: "oklch(55.4% 0.135 66.442)",
+				800: "oklch(47.6% 0.114 61.907)",
+				900: "oklch(42.1% 0.095 57.708)",
+				950: "oklch(28.6% 0.066 53.813)"
+			},
+			lime: {
+				50: "oklch(98.6% 0.031 120.757)",
+				100: "oklch(96.7% 0.067 122.328)",
+				200: "oklch(93.8% 0.127 124.321)",
+				300: "oklch(89.7% 0.196 126.665)",
+				400: "oklch(84.1% 0.238 128.85)",
+				500: "oklch(76.8% 0.233 130.85)",
+				600: "oklch(64.8% 0.2 131.684)",
+				700: "oklch(53.2% 0.157 131.589)",
+				800: "oklch(45.3% 0.124 130.933)",
+				900: "oklch(40.5% 0.101 131.063)",
+				950: "oklch(27.4% 0.072 132.109)"
+			},
+			green: {
+				50: "oklch(98.2% 0.018 155.826)",
+				100: "oklch(96.2% 0.044 156.743)",
+				200: "oklch(92.5% 0.084 155.995)",
+				300: "oklch(87.1% 0.15 154.449)",
+				400: "oklch(79.2% 0.209 151.711)",
+				500: "oklch(72.3% 0.219 149.579)",
+				600: "oklch(62.7% 0.194 149.214)",
+				700: "oklch(52.7% 0.154 150.069)",
+				800: "oklch(44.8% 0.119 151.328)",
+				900: "oklch(39.3% 0.095 152.535)",
+				950: "oklch(26.6% 0.065 152.934)"
+			},
+			emerald: {
+				50: "oklch(97.9% 0.021 166.113)",
+				100: "oklch(95% 0.052 163.051)",
+				200: "oklch(90.5% 0.093 164.15)",
+				300: "oklch(84.5% 0.143 164.978)",
+				400: "oklch(76.5% 0.177 163.223)",
+				500: "oklch(69.6% 0.17 162.48)",
+				600: "oklch(59.6% 0.145 163.225)",
+				700: "oklch(50.8% 0.118 165.612)",
+				800: "oklch(43.2% 0.095 166.913)",
+				900: "oklch(37.8% 0.077 168.94)",
+				950: "oklch(26.2% 0.051 172.552)"
+			},
+			teal: {
+				50: "oklch(98.4% 0.014 180.72)",
+				100: "oklch(95.3% 0.051 180.801)",
+				200: "oklch(91% 0.096 180.426)",
+				300: "oklch(85.5% 0.138 181.071)",
+				400: "oklch(77.7% 0.152 181.912)",
+				500: "oklch(70.4% 0.14 182.503)",
+				600: "oklch(60% 0.118 184.704)",
+				700: "oklch(51.1% 0.096 186.391)",
+				800: "oklch(43.7% 0.078 188.216)",
+				900: "oklch(38.6% 0.063 188.416)",
+				950: "oklch(27.7% 0.046 192.524)"
+			},
+			cyan: {
+				50: "oklch(98.4% 0.019 200.873)",
+				100: "oklch(95.6% 0.045 203.388)",
+				200: "oklch(91.7% 0.08 205.041)",
+				300: "oklch(86.5% 0.127 207.078)",
+				400: "oklch(78.9% 0.154 211.53)",
+				500: "oklch(71.5% 0.143 215.221)",
+				600: "oklch(60.9% 0.126 221.723)",
+				700: "oklch(52% 0.105 223.128)",
+				800: "oklch(45% 0.085 224.283)",
+				900: "oklch(39.8% 0.07 227.392)",
+				950: "oklch(30.2% 0.056 229.695)"
+			},
+			sky: {
+				50: "oklch(97.7% 0.013 236.62)",
+				100: "oklch(95.1% 0.026 236.824)",
+				200: "oklch(90.1% 0.058 230.902)",
+				300: "oklch(82.8% 0.111 230.318)",
+				400: "oklch(74.6% 0.16 232.661)",
+				500: "oklch(68.5% 0.169 237.323)",
+				600: "oklch(58.8% 0.158 241.966)",
+				700: "oklch(50% 0.134 242.749)",
+				800: "oklch(44.3% 0.11 240.79)",
+				900: "oklch(39.1% 0.09 240.876)",
+				950: "oklch(29.3% 0.066 243.157)"
+			},
+			blue: {
+				50: "oklch(97% 0.014 254.604)",
+				100: "oklch(93.2% 0.032 255.585)",
+				200: "oklch(88.2% 0.059 254.128)",
+				300: "oklch(80.9% 0.105 251.813)",
+				400: "oklch(70.7% 0.165 254.624)",
+				500: "oklch(62.3% 0.214 259.815)",
+				600: "oklch(54.6% 0.245 262.881)",
+				700: "oklch(48.8% 0.243 264.376)",
+				800: "oklch(42.4% 0.199 265.638)",
+				900: "oklch(37.9% 0.146 265.522)",
+				950: "oklch(28.2% 0.091 267.935)"
+			},
+			indigo: {
+				50: "oklch(96.2% 0.018 272.314)",
+				100: "oklch(93% 0.034 272.788)",
+				200: "oklch(87% 0.065 274.039)",
+				300: "oklch(78.5% 0.115 274.713)",
+				400: "oklch(67.3% 0.182 276.935)",
+				500: "oklch(58.5% 0.233 277.117)",
+				600: "oklch(51.1% 0.262 276.966)",
+				700: "oklch(45.7% 0.24 277.023)",
+				800: "oklch(39.8% 0.195 277.366)",
+				900: "oklch(35.9% 0.144 278.697)",
+				950: "oklch(25.7% 0.09 281.288)"
+			},
+			violet: {
+				50: "oklch(96.9% 0.016 293.756)",
+				100: "oklch(94.3% 0.029 294.588)",
+				200: "oklch(89.4% 0.057 293.283)",
+				300: "oklch(81.1% 0.111 293.571)",
+				400: "oklch(70.2% 0.183 293.541)",
+				500: "oklch(60.6% 0.25 292.717)",
+				600: "oklch(54.1% 0.281 293.009)",
+				700: "oklch(49.1% 0.27 292.581)",
+				800: "oklch(43.2% 0.232 292.759)",
+				900: "oklch(38% 0.189 293.745)",
+				950: "oklch(28.3% 0.141 291.089)"
+			},
+			purple: {
+				50: "oklch(97.7% 0.014 308.299)",
+				100: "oklch(94.6% 0.033 307.174)",
+				200: "oklch(90.2% 0.063 306.703)",
+				300: "oklch(82.7% 0.119 306.383)",
+				400: "oklch(71.4% 0.203 305.504)",
+				500: "oklch(62.7% 0.265 303.9)",
+				600: "oklch(55.8% 0.288 302.321)",
+				700: "oklch(49.6% 0.265 301.924)",
+				800: "oklch(43.8% 0.218 303.724)",
+				900: "oklch(38.1% 0.176 304.987)",
+				950: "oklch(29.1% 0.149 302.717)"
+			},
+			fuchsia: {
+				50: "oklch(97.7% 0.017 320.058)",
+				100: "oklch(95.2% 0.037 318.852)",
+				200: "oklch(90.3% 0.076 319.62)",
+				300: "oklch(83.3% 0.145 321.434)",
+				400: "oklch(74% 0.238 322.16)",
+				500: "oklch(66.7% 0.295 322.15)",
+				600: "oklch(59.1% 0.293 322.896)",
+				700: "oklch(51.8% 0.253 323.949)",
+				800: "oklch(45.2% 0.211 324.591)",
+				900: "oklch(40.1% 0.17 325.612)",
+				950: "oklch(29.3% 0.136 325.661)"
+			},
+			pink: {
+				50: "oklch(97.1% 0.014 343.198)",
+				100: "oklch(94.8% 0.028 342.258)",
+				200: "oklch(89.9% 0.061 343.231)",
+				300: "oklch(82.3% 0.12 346.018)",
+				400: "oklch(71.8% 0.202 349.761)",
+				500: "oklch(65.6% 0.241 354.308)",
+				600: "oklch(59.2% 0.249 0.584)",
+				700: "oklch(52.5% 0.223 3.958)",
+				800: "oklch(45.9% 0.187 3.815)",
+				900: "oklch(40.8% 0.153 2.432)",
+				950: "oklch(28.4% 0.109 3.907)"
+			},
+			rose: {
+				50: "oklch(96.9% 0.015 12.422)",
+				100: "oklch(94.1% 0.03 12.58)",
+				200: "oklch(89.2% 0.058 10.001)",
+				300: "oklch(81% 0.117 11.638)",
+				400: "oklch(71.2% 0.194 13.428)",
+				500: "oklch(64.5% 0.246 16.439)",
+				600: "oklch(58.6% 0.253 17.585)",
+				700: "oklch(51.4% 0.222 16.935)",
+				800: "oklch(45.5% 0.188 13.697)",
+				900: "oklch(41% 0.159 10.272)",
+				950: "oklch(27.1% 0.105 12.094)"
+			},
+			slate: {
+				50: "oklch(98.4% 0.003 247.858)",
+				100: "oklch(96.8% 0.007 247.896)",
+				200: "oklch(92.9% 0.013 255.508)",
+				300: "oklch(86.9% 0.022 252.894)",
+				400: "oklch(70.4% 0.04 256.788)",
+				500: "oklch(55.4% 0.046 257.417)",
+				600: "oklch(44.6% 0.043 257.281)",
+				700: "oklch(37.2% 0.044 257.287)",
+				800: "oklch(27.9% 0.041 260.031)",
+				900: "oklch(20.8% 0.042 265.755)",
+				950: "oklch(12.9% 0.042 264.695)"
+			},
+			gray: {
+				50: "oklch(98.5% 0.002 247.839)",
+				100: "oklch(96.7% 0.003 264.542)",
+				200: "oklch(92.8% 0.006 264.531)",
+				300: "oklch(87.2% 0.01 258.338)",
+				400: "oklch(70.7% 0.022 261.325)",
+				500: "oklch(55.1% 0.027 264.364)",
+				600: "oklch(44.6% 0.03 256.802)",
+				700: "oklch(37.3% 0.034 259.733)",
+				800: "oklch(27.8% 0.033 256.848)",
+				900: "oklch(21% 0.034 264.665)",
+				950: "oklch(13% 0.028 261.692)"
+			},
+			zinc: {
+				50: "oklch(98.5% 0 none)",
+				100: "oklch(96.7% 0.001 286.375)",
+				200: "oklch(92% 0.004 286.32)",
+				300: "oklch(87.1% 0.006 286.286)",
+				400: "oklch(70.5% 0.015 286.067)",
+				500: "oklch(55.2% 0.016 285.938)",
+				600: "oklch(44.2% 0.017 285.786)",
+				700: "oklch(37% 0.013 285.805)",
+				800: "oklch(27.4% 0.006 286.033)",
+				900: "oklch(21% 0.006 285.885)",
+				950: "oklch(14.1% 0.005 285.823)"
+			},
+			neutral: {
+				50: "oklch(98.5% 0 none)",
+				100: "oklch(97% 0 none)",
+				200: "oklch(92.2% 0 none)",
+				300: "oklch(87% 0 none)",
+				400: "oklch(70.8% 0 none)",
+				500: "oklch(55.6% 0 none)",
+				600: "oklch(43.9% 0 none)",
+				700: "oklch(37.1% 0 none)",
+				800: "oklch(26.9% 0 none)",
+				900: "oklch(20.5% 0 none)",
+				950: "oklch(14.5% 0 none)"
+			},
+			stone: {
+				50: "oklch(98.5% 0.001 106.423)",
+				100: "oklch(97% 0.001 106.424)",
+				200: "oklch(92.3% 0.003 48.717)",
+				300: "oklch(86.9% 0.005 56.366)",
+				400: "oklch(70.9% 0.01 56.259)",
+				500: "oklch(55.3% 0.013 58.071)",
+				600: "oklch(44.4% 0.011 73.639)",
+				700: "oklch(37.4% 0.01 67.558)",
+				800: "oklch(26.8% 0.007 34.298)",
+				900: "oklch(21.6% 0.006 56.043)",
+				950: "oklch(14.7% 0.004 49.25)"
+			},
+			mauve: {
+				50: "oklch(98.5% 0 none)",
+				100: "oklch(96% 0.003 325.6)",
+				200: "oklch(92.2% 0.005 325.62)",
+				300: "oklch(86.5% 0.012 325.68)",
+				400: "oklch(71.1% 0.019 323.02)",
+				500: "oklch(54.2% 0.034 322.5)",
+				600: "oklch(43.5% 0.029 321.78)",
+				700: "oklch(36.4% 0.029 323.89)",
+				800: "oklch(26.3% 0.024 320.12)",
+				900: "oklch(21.2% 0.019 322.12)",
+				950: "oklch(14.5% 0.008 326)"
+			},
+			olive: {
+				50: "oklch(98.8% 0.003 106.5)",
+				100: "oklch(96.6% 0.005 106.5)",
+				200: "oklch(93% 0.007 106.5)",
+				300: "oklch(88% 0.011 106.6)",
+				400: "oklch(73.7% 0.021 106.9)",
+				500: "oklch(58% 0.031 107.3)",
+				600: "oklch(46.6% 0.025 107.3)",
+				700: "oklch(39.4% 0.023 107.4)",
+				800: "oklch(28.6% 0.016 107.4)",
+				900: "oklch(22.8% 0.013 107.4)",
+				950: "oklch(15.3% 0.006 107.1)"
+			},
+			mist: {
+				50: "oklch(98.7% 0.002 197.1)",
+				100: "oklch(96.3% 0.002 197.1)",
+				200: "oklch(92.5% 0.005 214.3)",
+				300: "oklch(87.2% 0.007 219.6)",
+				400: "oklch(72.3% 0.014 214.4)",
+				500: "oklch(56% 0.021 213.5)",
+				600: "oklch(45% 0.017 213.2)",
+				700: "oklch(37.8% 0.015 216)",
+				800: "oklch(27.5% 0.011 216.9)",
+				900: "oklch(21.8% 0.008 223.9)",
+				950: "oklch(14.8% 0.004 228.8)"
+			},
+			taupe: {
+				50: "oklch(98.6% 0.002 67.8)",
+				100: "oklch(96% 0.002 17.2)",
+				200: "oklch(92.2% 0.005 34.3)",
+				300: "oklch(86.8% 0.007 39.5)",
+				400: "oklch(71.4% 0.014 41.2)",
+				500: "oklch(54.7% 0.021 43.1)",
+				600: "oklch(43.8% 0.017 39.3)",
+				700: "oklch(36.7% 0.016 35.7)",
+				800: "oklch(26.8% 0.011 36.5)",
+				900: "oklch(21.4% 0.009 43.1)",
+				950: "oklch(14.7% 0.004 49.3)"
+			},
+			black: "#000",
+			white: "#fff"
+		},
+		spacing: { step: "0.25rem" },
+		sizes: {
+			"3xs": "{containers.3xs}",
+			"2xs": "{containers.2xs}",
+			xs: "{containers.xs}",
+			sm: "{containers.sm}",
+			md: "{containers.md}",
+			lg: "{containers.lg}",
+			xl: "{containers.xl}",
+			"2xl": "{containers.2xl}",
+			"3xl": "{containers.3xl}",
+			"4xl": "{containers.4xl}",
+			"5xl": "{containers.5xl}",
+			"6xl": "{containers.6xl}",
+			"7xl": "{containers.7xl}"
+		},
+		breakpoints: {
+			sm: "40rem",
+			md: "48rem",
+			lg: "64rem",
+			xl: "80rem",
+			"2xl": "96rem"
+		},
+		containers: {
+			"3xs": "16rem",
+			"2xs": "18rem",
+			xs: "20rem",
+			sm: "24rem",
+			md: "28rem",
+			lg: "32rem",
+			xl: "36rem",
+			"2xl": "42rem",
+			"3xl": "48rem",
+			"4xl": "56rem",
+			"5xl": "64rem",
+			"6xl": "72rem",
+			"7xl": "80rem"
+		},
+		fonts: {
+			sans: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', 'Noto Sans', Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol', 'Noto Color Emoji'",
+			serif: "ui-serif, Georgia, Cambria, 'Times New Roman', Times, serif",
+			mono: "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace"
+		},
+		fontSizes: {
+			xs: "0.75rem",
+			sm: "0.875rem",
+			base: "1rem",
+			lg: "1.125rem",
+			xl: "1.25rem",
+			"2xl": "1.5rem",
+			"3xl": "1.875rem",
+			"4xl": "2.25rem",
+			"5xl": "3rem",
+			"6xl": "3.75rem",
+			"7xl": "4.5rem",
+			"8xl": "6rem",
+			"9xl": "8rem"
+		},
+		fontWeights: {
+			thin: "100",
+			extralight: "200",
+			light: "300",
+			normal: "400",
+			medium: "500",
+			semibold: "600",
+			bold: "700",
+			extrabold: "800",
+			black: "900"
+		},
+		letterSpacings: {
+			tighter: "-0.05em",
+			tight: "-0.025em",
+			normal: "0em",
+			wide: "0.025em",
+			wider: "0.05em",
+			widest: "0.1em"
+		},
+		lineHeights: {
+			tight: "1.25",
+			snug: "1.375",
+			normal: "1.5",
+			relaxed: "1.625",
+			loose: "2"
+		},
+		radii: {
+			xs: "0.125rem",
+			sm: "0.25rem",
+			md: "0.375rem",
+			lg: "0.5rem",
+			xl: "0.75rem",
+			"2xl": "1rem",
+			"3xl": "1.5rem",
+			"4xl": "2rem"
+		},
+		shadows: {
+			"2xs": "0 1px rgb(0 0 0 / 0.05)",
+			xs: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
+			sm: "0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)",
+			md: "0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)",
+			lg: "0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1)",
+			xl: "0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1)",
+			"2xl": "0 25px 50px -12px rgb(0 0 0 / 0.25)"
+		},
+		textShadows: {
+			"2xs": "0px 1px 0px rgb(0 0 0 / 0.15)",
+			xs: "0px 1px 1px rgb(0 0 0 / 0.2)",
+			sm: "0px 1px 0px rgb(0 0 0 / 0.075), 0px 1px 1px rgb(0 0 0 / 0.075), 0px 2px 2px rgb(0 0 0 / 0.075)",
+			md: "0px 1px 1px rgb(0 0 0 / 0.1), 0px 1px 2px rgb(0 0 0 / 0.1), 0px 2px 4px rgb(0 0 0 / 0.1)",
+			lg: "0px 1px 2px rgb(0 0 0 / 0.1), 0px 3px 2px rgb(0 0 0 / 0.1), 0px 4px 8px rgb(0 0 0 / 0.1)"
+		},
+		easings: {
+			in: "cubic-bezier(0.4, 0, 1, 1)",
+			out: "cubic-bezier(0, 0, 0.2, 1)",
+			"in-out": "cubic-bezier(0.4, 0, 0.2, 1)"
+		},
+		blurs: {
+			xs: "4px",
+			sm: "8px",
+			md: "12px",
+			lg: "16px",
+			xl: "24px",
+			"2xl": "40px",
+			"3xl": "64px"
+		},
+		aspectRatios: { video: "16 / 9" }
+	},
+	textStyles: {
+		xs: {
+			fontSize: "xs",
+			lineHeight: "calc(1 / 0.75)"
+		},
+		sm: {
+			fontSize: "sm",
+			lineHeight: "calc(1.25 / 0.875)"
+		},
+		base: {
+			fontSize: "base",
+			lineHeight: "calc(1.5 / 1)"
+		},
+		lg: {
+			fontSize: "lg",
+			lineHeight: "calc(1.75 / 1.125)"
+		},
+		xl: {
+			fontSize: "xl",
+			lineHeight: "calc(1.75 / 1.25)"
+		},
+		"2xl": {
+			fontSize: "2xl",
+			lineHeight: "calc(2 / 1.5)"
+		},
+		"3xl": {
+			fontSize: "3xl",
+			lineHeight: "calc(2.25 / 1.875)"
+		},
+		"4xl": {
+			fontSize: "4xl",
+			lineHeight: "calc(2.5 / 2.25)"
+		},
+		"5xl": {
+			fontSize: "5xl",
+			lineHeight: "1"
+		},
+		"6xl": {
+			fontSize: "6xl",
+			lineHeight: "1"
+		},
+		"7xl": {
+			fontSize: "7xl",
+			lineHeight: "1"
+		},
+		"8xl": {
+			fontSize: "8xl",
+			lineHeight: "1"
+		},
+		"9xl": {
+			fontSize: "9xl",
+			lineHeight: "1"
+		}
+	},
+	keyframes: {
+		spin: { to: { transform: "rotate(360deg)" } },
+		ping: { "75%, 100%": {
+			transform: "scale(2)",
+			opacity: "0"
+		} },
+		pulse: { "50%": { opacity: "0.5" } },
+		bounce: {
+			"0%, 100%": {
+				transform: "translateY(-25%)",
+				animationTimingFunction: "cubic-bezier(0.8, 0, 1, 1)"
+			},
+			"50%": {
+				transform: "none",
+				animationTimingFunction: "cubic-bezier(0, 0, 0.2, 1)"
+			}
+		}
+	}
+};
+//#endregion
+//#region src/core/rules.ts
+/** CSS-wide keywords, and `default`, which CSS reserves: never a name. */
+const CSS_WIDE = /* @__PURE__ */ new Set([
+	"initial",
+	"inherit",
+	"unset",
+	"revert",
+	"revert-layer",
+	"default"
+]);
+/** Generic font families: keywords in `font-family`, so a family named like one is quoted. */
+const GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"system-ui",
+	"ui-serif",
+	"ui-sans-serif",
+	"ui-monospace",
+	"ui-rounded",
+	"math",
+	"emoji",
+	"fangsong"
+]);
+//#endregion
+//#region src/core/hash.ts
+/**
+* Stable identities. Hashes name atoms (`~a1b2c3`) and key caches, so they must
+* be identical across processes, platforms and runtimes: a small synchronous
+* hash in plain JS rather than `node:crypto`.
+*/
+/** cyrb53: a fast 53-bit string hash with good avalanche. Public domain (bryc). */
+function cyrb53(input, seed) {
+	let h1 = 3735928559 ^ seed;
+	let h2 = 1103547991 ^ seed;
+	for (let i = 0; i < input.length; i++) {
+		const ch = input.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+	h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+	h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+const CHUNK = 10;
+const CHUNK_MOD = 36 ** CHUNK;
+/** Deterministic base-36 hash of `input`, `length` characters of `[0-9a-z]`. */
+function hash(input, length = 6) {
+	let out = "";
+	for (let seed = 0; out.length < length; seed++) out += (cyrb53(input, seed) % CHUNK_MOD).toString(36).padStart(CHUNK, "0");
+	return out.slice(0, length);
+}
+//#endregion
+//#region src/config/files.ts
+/**
+* Files a config reads through `fs` rather than `import` (`dtcg()`'s token
+* and resolver files). Vite's config loader only sees the module graph, so
+* without this an edit to one would neither reload the config in dev nor
+* change the build cache's key (PLAN §5.3, D17).
+*
+* Two records, because a config reaches the plugin two ways: loaded from
+* `vicss.config.ts`, every read made while it loads is reported to the
+* plugin's recorder; passed as an object (`vicss({ config })`), it was built
+* before the plugin existed, so each `dtcg()` result carries its own files.
+* Each result can also read its files again: a preset package that Node
+* imported natively stays cached, so its `dtcg()` call never runs twice by
+* itself. All keys are global symbols: the config entry and the plugin are
+* separate bundles once packed, and a config may load a second copy of either.
+*/
+/** Where the plugin installs its recorder (an `AsyncLocalStorage<ConfigLoad>`). */
+const READS = Symbol.for("@menapo/vicss/config-load");
+/** Non-enumerable on a `dtcg()` result: the absolute paths it read. */
+const FILES = Symbol.for("@menapo/vicss/config-files");
+/** Non-enumerable on a `dtcg()` result: a fresh result if a file changed since, else undefined. */
+const RELOAD = Symbol.for("@menapo/vicss/config-reload");
+const current = () => globalThis[READS]?.getStore();
+/** Reports a file read while a config loads, before reading it: a missing file is watched too. */
+function recordRead(file) {
+	current()?.reads.add(file);
+}
+/** The directory of the config file loading now, if one is. */
+function configDir() {
+	return current()?.dir;
+}
+/** What a file held when it was read: undefined when it could not be read. */
+function contentKey(text) {
+	return text === void 0 ? void 0 : hash(text, 16);
+}
+/**
+* Records on `result` the files it read, by path to `contentKey()` of the
+* text read, and how to compute it again, without making either part of the
+* config's data or hash. `read` returns a file's current text, or undefined.
+*/
+function withFiles(result, files, read, again) {
+	Object.defineProperty(result, FILES, { value: [...files.keys()] });
+	Object.defineProperty(result, RELOAD, { value: () => {
+		for (const [file, key] of files) if (contentKey(read(file)) !== key) return again();
+	} });
+	return result;
+}
+//#endregion
+//#region src/config/dtcg.ts
+/**
+* DTCG 2025.10 input (PLAN §4.1, §5.3, D21): a `.tokens.json` file, a
+* `.resolver.json` file or an already-parsed object becomes the token part of
+* a vicss config: raw tokens, semantic tokens (values that differ between the
+* contexts of a resolver modifier, keyed by mode) and text styles (typography
+* tokens).
+*
+* The format has groups but no scales, so a token's scale comes from
+* `options.scales`, else from the name of its top-level group (`color` →
+* colors), else from its `$type` (a `shadow` → shadows). Aliases stay aliases
+* (`{color.blue.500}` → `{colors.blue.500}`): an alias of a switching token
+* then switches with it in nested mode scopes (PLAN §5.9), which a copied
+* value would not. In a typography token they keep the text style reading
+* tokens; its literal sub-values compile into atoms, so changing one is a
+* code change rather than a theme-only deploy (PLAN §4.8, D13).
+*
+* Runs at config load, in Node. Node modules are fetched lazily so the config
+* entry still loads where there is no file system (PLAN §5.1).
+*/
+/** Reverse-domain key of vicss's `$extensions` entry: `{ "value": "<any CSS>" }`. */
+const EXTENSION = "dev.menapo.vicss";
+/** `$extensions` key whose object holds a token's value per mode, as `vicss tokens export` writes it. */
+const MODES_EXTENSION = "dev.menapo.vicss.modes";
+/**
+* `$extensions` key that marks a token private (`tokenVisibility`), as
+* `vicss tokens export` writes it: `true`, or `false` for public.
+*/
+const PRIVATE_EXTENSION = "dev.menapo.vicss.private";
+const TYPES = /* @__PURE__ */ new Set([
+	"color",
+	"dimension",
+	"fontFamily",
+	"fontWeight",
+	"duration",
+	"cubicBezier",
+	"number",
+	"strokeStyle",
+	"border",
+	"transition",
+	"shadow",
+	"gradient",
+	"typography"
+]);
+const TOKEN_PROPS = /* @__PURE__ */ new Set([
+	"$value",
+	"$ref",
+	"$type",
+	"$description",
+	"$extensions",
+	"$deprecated"
+]);
+const GROUP_PROPS = /* @__PURE__ */ new Set([
+	"$type",
+	"$description",
+	"$extensions",
+	"$deprecated",
+	"$extends"
+]);
+/** `{group.token}`: a whole-token alias. */
+const ALIAS = /^\{([^{}]+)\}$/;
+/** Aliases inside a CSS string from vicss's extension. */
+const ALIASES = /\{([^{}]*)\}/g;
+/** What dtcg() writes for an alias: a vicss reference, resolved by the core. */
+const VICSS_REFS = /\{[A-Za-z]+\.[^\s{}]+\}/g;
+const WHOLE_REF = /^\{[A-Za-z]+\.[^\s{}]+\}$/;
+/** Kept in step with the core's scale list by the type. */
+const SCALES = {
+	colors: true,
+	spacing: true,
+	sizes: true,
+	radii: true,
+	fonts: true,
+	fontSizes: true,
+	fontWeights: true,
+	lineHeights: true,
+	letterSpacings: true,
+	shadows: true,
+	textShadows: true,
+	durations: true,
+	easings: true,
+	zIndices: true,
+	opacities: true,
+	blurs: true,
+	aspectRatios: true,
+	breakpoints: true,
+	containers: true
+};
+/**
+* Group names that name a scale, compared lowercase without separators, so
+* `font-size`, `fontSize` and `font_size` all match.
+*/
+const GROUP_NAMES = {
+	color: "colors",
+	colors: "colors",
+	space: "spacing",
+	spacing: "spacing",
+	size: "sizes",
+	sizes: "sizes",
+	radius: "radii",
+	radii: "radii",
+	font: "fonts",
+	fonts: "fonts",
+	fontfamily: "fonts",
+	fontfamilies: "fonts",
+	fontsize: "fontSizes",
+	fontsizes: "fontSizes",
+	fontweight: "fontWeights",
+	fontweights: "fontWeights",
+	lineheight: "lineHeights",
+	lineheights: "lineHeights",
+	letterspacing: "letterSpacings",
+	letterspacings: "letterSpacings",
+	shadow: "shadows",
+	shadows: "shadows",
+	textshadow: "textShadows",
+	textshadows: "textShadows",
+	duration: "durations",
+	durations: "durations",
+	easing: "easings",
+	easings: "easings",
+	cubicbezier: "easings",
+	zindex: "zIndices",
+	zindices: "zIndices",
+	opacity: "opacities",
+	opacities: "opacities",
+	blur: "blurs",
+	blurs: "blurs",
+	aspectratio: "aspectRatios",
+	aspectratios: "aspectRatios",
+	breakpoint: "breakpoints",
+	breakpoints: "breakpoints",
+	container: "containers",
+	containers: "containers",
+	typography: "textStyles"
+};
+/**
+* Two-level paths that name a scale, each name compared like GROUP_NAMES:
+* the common `font.{family,size,weight}` layout and words split in two
+* (`line.height`). A list rather than the two names joined, or `size.s` and
+* `duration.s` (T-shirt sizes) would read as `sizes` and `durations` and
+* lose their `s`.
+*/
+const COMPOUND_NAMES = {
+	"font.family": "fonts",
+	"font.families": "fonts",
+	"font.size": "fontSizes",
+	"font.sizes": "fontSizes",
+	"font.weight": "fontWeights",
+	"font.weights": "fontWeights",
+	"font.lineheight": "lineHeights",
+	"font.lineheights": "lineHeights",
+	"font.letterspacing": "letterSpacings",
+	"font.letterspacings": "letterSpacings",
+	"line.height": "lineHeights",
+	"line.heights": "lineHeights",
+	"letter.spacing": "letterSpacings",
+	"letter.spacings": "letterSpacings",
+	"text.shadow": "textShadows",
+	"text.shadows": "textShadows",
+	"z.index": "zIndices",
+	"z.indices": "zIndices",
+	"aspect.ratio": "aspectRatios",
+	"aspect.ratios": "aspectRatios",
+	"cubic.bezier": "easings"
+};
+/** Placement by `$type` when no group name decides. Lengths have several scales, so none. */
+const TYPE_TARGETS = {
+	color: "colors",
+	duration: "durations",
+	cubicBezier: "easings",
+	shadow: "shadows",
+	fontFamily: "fonts",
+	fontWeight: "fontWeights",
+	typography: "textStyles"
+};
+/**
+* Types a group name may place. A `color` group's opacity numbers are not
+* colours: they fall through to the `$type` rule (and its warning) instead of
+* becoming `color: "opacity.50"`.
+*/
+const LENGTH = ["dimension"];
+const ACCEPTS = {
+	colors: ["color"],
+	spacing: LENGTH,
+	sizes: LENGTH,
+	radii: LENGTH,
+	fonts: ["fontFamily"],
+	fontSizes: LENGTH,
+	fontWeights: ["fontWeight", "number"],
+	lineHeights: ["number", "dimension"],
+	letterSpacings: LENGTH,
+	shadows: ["shadow"],
+	textShadows: ["shadow"],
+	durations: ["duration"],
+	easings: ["cubicBezier"],
+	zIndices: ["number"],
+	opacities: ["number"],
+	blurs: LENGTH,
+	aspectRatios: ["number"],
+	breakpoints: LENGTH,
+	containers: LENGTH,
+	textStyles: ["typography"]
+};
+/** Mode conditions every vicss system has (PLAN D12). */
+const BUILT_IN_MODES = /* @__PURE__ */ new Set(["dark", "light"]);
+function dtcg(source, options = {}) {
+	const opts = checkOptions(options);
+	let doc;
+	let file;
+	let dir;
+	let named = false;
+	/** The file a path or URL names, so that reading it again needs no config load around it. */
+	let abs;
+	const session = new Session(opts);
+	if (typeof source === "string" || source instanceof URL) {
+		const { path, url } = nodeApi();
+		try {
+			abs = typeof source !== "string" || source.startsWith("file:") ? url.fileURLToPath(typeof source === "string" ? source : source.href) : path.resolve(configDir() ?? process.cwd(), source);
+		} catch (e) {
+			throw new VicssError("CONFIG", `dtcg(): \`${String(source)}\` is not a file path or file: URL`, { hint: e.message });
+		}
+		file = displayPath(abs);
+		dir = path.dirname(abs);
+		doc = session.read(abs, file);
+		named = abs.endsWith(".resolver.json");
+	} else if (isPlainObject(source)) {
+		doc = source;
+		file = "dtcg(object)";
+	} else throw new VicssError("CONFIG", "dtcg(): expected a file path, a file: URL or a token object");
+	session.label = file;
+	if (!isPlainObject(doc)) throw new VicssError("CONFIG", `${file}: expected a JSON object`);
+	const result = named || Object.hasOwn(doc, "resolutionOrder") ? fromResolver(doc, file, dir, session) : fromTokens(doc, file, session);
+	session.finish();
+	return withFiles(result, session.files, readText, () => dtcg(abs ?? source, options));
+}
+/** A file's text now, or undefined: what `Session.read` saw is compared with it. */
+function readText(file) {
+	try {
+		return nodeApi().fs.readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+}
+function fromTokens(doc, file, session) {
+	if (session.options.modes.size > 0) throw new VicssError("CONFIG", `${file}: options.modes applies to resolver files only`);
+	session.claim(doc, file);
+	const base = evaluate(doc, file, session);
+	return assemble(session, base, exportedModes(base));
+}
+/**
+* The values per mode that `vicss tokens export --format dtcg` writes into
+* a token's `$extensions["dev.menapo.vicss.modes"]` (`{ "dark": "#f2f2ff" }`),
+* as one context per mode, so a file vicss wrote reads back with its modes.
+* The values are vicss's already: CSS, aliases as `{colors.gray.50}`.
+*/
+function exportedModes(base) {
+	const byMode = /* @__PURE__ */ new Map();
+	for (const [key, outcome] of base) {
+		const extensions = outcome.entry.node.$extensions;
+		const modes = isPlainObject(extensions) ? extensions[MODES_EXTENSION] : void 0;
+		if (modes === void 0) continue;
+		const bad = () => configError(outcome.entry.file, key, `$extensions["${MODES_EXTENSION}"]: expected { "<mode>": "<a CSS value>" }`);
+		if (!isPlainObject(modes)) throw bad();
+		for (const [mode, value] of Object.entries(modes)) {
+			if (typeof value !== "string" || !/^[A-Za-z][A-Za-z0-9]*$/.test(mode)) throw bad();
+			let outcomes = byMode.get(mode);
+			if (!outcomes) byMode.set(mode, outcomes = /* @__PURE__ */ new Map());
+			outcomes.set(key, {
+				...outcome,
+				value
+			});
+		}
+	}
+	return [...byMode].map(([mode, outcomes]) => ({
+		modifier: MODES_EXTENSION,
+		mode,
+		label: `_${mode}`,
+		outcomes: new Map([...base, ...outcomes])
+	}));
+}
+function checkOptions(options) {
+	const bad = (at, message) => new VicssError("CONFIG", `dtcg(): ${at}: ${message}`);
+	const raw = options;
+	if (!isPlainObject(raw)) throw bad("options", "expected an object");
+	const scales = /* @__PURE__ */ new Map();
+	if (raw.scales !== void 0) {
+		if (!isPlainObject(raw.scales)) throw bad("options.scales", "expected an object");
+		for (const [path, target] of Object.entries(raw.scales)) {
+			if (target === void 0) continue;
+			if (target !== false && target !== "textStyles" && !(typeof target === "string" && Object.hasOwn(SCALES, target))) throw bad(`options.scales["${path}"]`, `${describe(target)} is not a scale, "textStyles" or false`);
+			scales.set(path, target);
+		}
+	}
+	const modes = /* @__PURE__ */ new Map();
+	if (raw.modes !== void 0) {
+		if (!isPlainObject(raw.modes)) throw bad("options.modes", "expected an object");
+		for (const [modifier, contexts] of Object.entries(raw.modes)) {
+			if (contexts === void 0) continue;
+			if (!isPlainObject(contexts)) throw bad(`options.modes.${modifier}`, "expected an object of context → mode");
+			const map = /* @__PURE__ */ new Map();
+			for (const [context, mode] of Object.entries(contexts)) {
+				if (mode === void 0) continue;
+				const at = `options.modes.${modifier}.${context}`;
+				if (mode === false || mode === "base") map.set(context, mode);
+				else if (typeof mode === "string" && /^_?[A-Za-z][A-Za-z0-9]*$/.test(mode)) map.set(context, mode.replace(/^_/, ""));
+				else throw bad(at, "expected a mode name like \"dark\", \"base\" or false");
+			}
+			modes.set(modifier, map);
+		}
+	}
+	const onWarn = raw.onWarn;
+	if (onWarn !== void 0 && typeof onWarn !== "function") throw bad("options.onWarn", "expected a function");
+	return {
+		scales,
+		modes,
+		onWarn: onWarn ?? ((message) => console.warn(message))
+	};
+}
+var Skip = class {
+	reason;
+	constructor(reason) {
+		this.reason = reason;
+	}
+};
+var Session = class {
+	/** Which file a token or group object came from, for errors. */
+	origin = /* @__PURE__ */ new WeakMap();
+	#files = /* @__PURE__ */ new Map();
+	/**
+	* Every file read, in order, to `contentKey()` of its text; a missing one
+	* too, since creating it changes the config.
+	*/
+	files = /* @__PURE__ */ new Map();
+	/** Warning kind → token key → detail. Maps, so a token met in several permutations is named once. */
+	unmapped = /* @__PURE__ */ new Map();
+	skipped = /* @__PURE__ */ new Map();
+	partial = /* @__PURE__ */ new Map();
+	extra = /* @__PURE__ */ new Map();
+	fixed = /* @__PURE__ */ new Map();
+	overlap = /* @__PURE__ */ new Map();
+	/** `options.scales` paths that matched a token: the rest are typos. */
+	usedScales = /* @__PURE__ */ new Set();
+	label = "";
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	read(abs, display) {
+		if (this.#files.has(abs)) return this.#files.get(abs);
+		this.files.set(abs, void 0);
+		recordRead(abs);
+		let text;
+		try {
+			text = nodeApi().fs.readFileSync(abs, "utf8");
+			this.files.set(abs, contentKey(text));
+		} catch (e) {
+			const code = e.code;
+			throw new VicssError("CONFIG", `${display}: cannot read the file (${String(code ?? e)})`);
+		}
+		let json;
+		try {
+			json = JSON.parse(text.charCodeAt(0) === 65279 ? text.slice(1) : text);
+		} catch (e) {
+			throw new VicssError("CONFIG", `${display}: not valid JSON: ${e.message}`);
+		}
+		this.#files.set(abs, json);
+		return json;
+	}
+	/** Records `file` as the origin of every group and token object in `tree` not claimed yet. */
+	claim(tree, file) {
+		if (!isPlainObject(tree) || this.origin.has(tree)) return;
+		this.origin.set(tree, file);
+		if (isToken(tree)) return;
+		for (const [key, child] of Object.entries(tree)) if (!key.startsWith("$") || key === "$root") this.claim(child, file);
+	}
+	finish() {
+		const unused = [...this.options.scales.keys()].filter((path) => !this.usedScales.has(path));
+		if (unused.length > 0) throw new VicssError("CONFIG", `${this.label}: options.scales names no group or token: ${unused.map((p) => `"${p}"`).join(", ")}`, { hint: "Paths are DTCG names joined with `.`, as in an alias: `brand.colors`." });
+		const warn = (entries, what, hint) => {
+			if (entries.size === 0) return;
+			const n = entries.size === 1 ? "1 token" : `${entries.size} tokens`;
+			const list = [...entries].map(([key, detail]) => `${key} (${detail})`).join(", ");
+			this.options.onWarn(`vicss: ${this.label}: ${what(n)}: ${list}. ${hint}`);
+		};
+		warn(this.unmapped, (n) => `left out ${n} that no scale takes`, "Place a group with dtcg(…, { scales: { \"group\": \"spacing\" } }), or leave it out silently with false.");
+		warn(this.skipped, (n) => `left out ${n} with no single CSS value`, `Give a token a CSS value with "$extensions": { "${EXTENSION}": { "value": "…" } }.`);
+		warn(this.partial, (n) => `${n} not defined in every context`, "Where a context gives a token no value, the token keeps its base value.");
+		warn(this.extra, (n) => `left out ${n} that only some contexts define and no value there aliases`, "A token a context adds is kept when a value in that context aliases it; define it in the base context to use it directly.");
+		warn(this.fixed, (n) => `kept the base value of ${n} that text styles cannot switch per mode`, "Alias mode-dependent tokens from the typography sub-values instead.");
+		warn(this.overlap, (n) => `${n} switch with the contexts of several modifiers`, "Where two of these modes hold at once, the one that ranks higher among vicss conditions wins, not the modifier later in resolutionOrder, and the combination gets no value of its own.");
+	}
+};
+function nodeApi() {
+	const proc = globalThis.process;
+	if (typeof proc?.getBuiltinModule !== "function") throw new VicssError("CONFIG", "dtcg(): reading token files needs Node.js; pass a parsed token object instead");
+	return {
+		fs: proc.getBuiltinModule("node:fs"),
+		path: proc.getBuiltinModule("node:path"),
+		url: proc.getBuiltinModule("node:url")
+	};
+}
+/** Relative to the working directory when inside it: what a developer recognises in an error. */
+function displayPath(abs) {
+	const { path } = nodeApi();
+	const rel = path.relative(process.cwd(), abs);
+	return rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? rel.split(path.sep).join("/") : abs;
+}
+function isToken(node) {
+	return Object.hasOwn(node, "$value") || Object.hasOwn(node, "$ref");
+}
+function isGroup(node) {
+	return isPlainObject(node) && !isToken(node);
+}
+function configError(file, at, message, hint) {
+	return new VicssError("CONFIG", `${file}: ${at ? `${at}: ` : ""}${message}`, hint === void 0 ? {} : { hint });
+}
+/** Validates the structure (names, `$` properties) and lists every token in document order. */
+function buildIndex(tree, file, session) {
+	const root = resolveExtends(tree, file, session);
+	const tokens = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Map();
+	const fileOf = (node) => session.origin.get(node) ?? file;
+	const token = (node, segments, groupType, parent) => {
+		const key = segments.join(".");
+		const fail = (message, hint) => configError(isPlainObject(node) ? fileOf(node) : fileOf(parent), key, message, hint);
+		if (!isPlainObject(node) || !isToken(node)) throw fail("expected a token: an object with $value");
+		for (const prop of Object.keys(node)) {
+			if (!prop.startsWith("$")) throw fail(`is a token ($value) with a child \`${prop}\``, "A token cannot hold tokens; put the value in `$root` and keep the children in the group.");
+			if (!TOKEN_PROPS.has(prop)) throw fail(`unknown token property \`${prop}\``, "Names cannot start with `$`.");
+		}
+		if (Object.hasOwn(node, "$value") && Object.hasOwn(node, "$ref")) throw fail("has both $value and $ref");
+		if (node.$value === null) throw fail("$value cannot be null");
+		if (Object.hasOwn(node, "$ref") && typeof node.$ref !== "string") throw fail("$ref must be a JSON pointer string");
+		checkMeta(node, fail);
+		const ext = isPlainObject(node.$extensions) ? node.$extensions[EXTENSION] : void 0;
+		if (ext !== void 0) {
+			const keys = isPlainObject(ext) ? Object.keys(ext) : [];
+			if (!isPlainObject(ext) || keys.some((k) => k !== "value") || typeof ext.value !== "string" || ext.value.trim() === "") throw fail(`$extensions["${EXTENSION}"]: expected { "value": "<a CSS value>" }`);
+		}
+		tokens.set(key, {
+			key,
+			segments,
+			node,
+			groupType,
+			file: fileOf(node)
+		});
+	};
+	const visit = (group, segments, inherited) => {
+		const key = segments.join(".");
+		if (segments.length > 0) groups.set(key, group);
+		const fail = (message, hint) => configError(fileOf(group), key, message, hint);
+		checkMeta(group, fail);
+		const type = group.$type === void 0 ? inherited : group.$type;
+		for (const [name, child] of Object.entries(group)) {
+			const here = [...segments, name];
+			if (name === "$root") token(child, here, type, group);
+			else if (name.startsWith("$")) {
+				if (!GROUP_PROPS.has(name) && !(name === "$schema" && segments.length === 0)) throw fail(`unknown group property \`${name}\``, "Names cannot start with `$`.");
+			} else {
+				if (name === "" || /[{}.]/.test(name)) throw configError(fileOf(group), here.join("."), `\`${name}\` is not a token or group name: names are non-empty and contain no {, } or .`);
+				if (!isPlainObject(child)) throw configError(fileOf(group), here.join("."), "expected a token (an object with $value) or a group");
+				if (isToken(child)) token(child, here, type, group);
+				else visit(child, here, type);
+			}
+		}
+	};
+	visit(root, [], void 0);
+	return {
+		root,
+		tokens,
+		groups
+	};
+}
+/** `$description`, `$deprecated`, `$extensions` and `$type` shapes, shared by tokens and groups. */
+function checkMeta(node, fail) {
+	if (node.$type !== void 0 && typeof node.$type !== "string") throw fail("$type must be a string");
+	if (node.$description !== void 0 && typeof node.$description !== "string") throw fail("$description must be a string");
+	if (node.$deprecated !== void 0 && typeof node.$deprecated !== "boolean" && typeof node.$deprecated !== "string") throw fail("$deprecated must be true, false or a string");
+	if (node.$extensions !== void 0 && !isPlainObject(node.$extensions)) throw fail("$extensions must be an object");
+}
+/**
+* Applies `$extends` (format §6.4): the target group's content, deep-merged
+* under the local content, where a local token replaces an inherited one
+* whole. Targets are looked up in the document as written; tokens keep their
+* identity, so their origin and aliases stay what the author wrote.
+*/
+function resolveExtends(tree, file, session) {
+	const done = /* @__PURE__ */ new WeakMap();
+	const active = [];
+	const group = (node, segments) => {
+		const memo = done.get(node);
+		if (memo) return memo;
+		const key = segments.join(".");
+		const fail = (message) => configError(session.origin.get(node) ?? file, key, message);
+		if (active.includes(node)) throw fail("circular $extends");
+		active.push(node);
+		let out = {};
+		if (node.$extends !== void 0) {
+			const path = groupReference(node.$extends);
+			if (!path) throw fail("$extends takes a group reference: \"{group}\" or \"#/group\"");
+			let target = tree;
+			for (const [i, name] of path.entries()) {
+				if (!isPlainObject(target) || isToken(target) || !Object.hasOwn(target, name)) throw fail(`$extends: \`${path.slice(0, i + 1).join(".")}\` is not a group`);
+				target = target[name];
+			}
+			if (!isGroup(target)) throw fail(`$extends: \`${path.join(".")}\` is a token, not a group`);
+			out = { ...group(target, path) };
+		}
+		for (const [name, child] of Object.entries(node)) {
+			if (name === "$extends") continue;
+			if (!name.startsWith("$") && isGroup(child)) {
+				const resolved = group(child, [...segments, name]);
+				const inherited = out[name];
+				out[name] = isGroup(inherited) ? mergeGroups(inherited, resolved) : resolved;
+			} else out[name] = child;
+		}
+		active.pop();
+		const origin = session.origin.get(node);
+		if (origin !== void 0) session.origin.set(out, origin);
+		done.set(node, out);
+		return out;
+	};
+	const mergeGroups = (base, over) => {
+		const out = { ...base };
+		for (const [name, child] of Object.entries(over)) {
+			const prev = out[name];
+			out[name] = !name.startsWith("$") && isGroup(prev) && isGroup(child) ? mergeGroups(prev, child) : child;
+		}
+		return out;
+	};
+	return group(tree, []);
+}
+/** `{a.b}` or `#/a/b` → `["a", "b"]`. */
+function groupReference(ref) {
+	if (typeof ref !== "string") return void 0;
+	const alias = ALIAS.exec(ref);
+	if (alias) return alias[1].split(".");
+	if (ref.startsWith("#/")) return decodePointer(ref);
+}
+/** RFC 6901 segments of `#/a/b~1c`, or `undefined` for a malformed pointer. */
+function decodePointer(ref) {
+	if (!ref.startsWith("#/")) return void 0;
+	const segments = [];
+	for (const raw of ref.slice(2).split("/")) {
+		if (/~(?![01])/.test(raw)) return void 0;
+		segments.push(raw.replaceAll("~1", "/").replaceAll("~0", "~"));
+	}
+	return segments;
+}
+/** Converts every token of one resolved document (one resolver permutation). */
+function evaluate(tree, file, session) {
+	return new Converter(buildIndex(tree, file, session), session).all();
+}
+/** RFC 6901 array index: no sign, no leading zero. */
+const INDEX = /^(?:0|[1-9]\d*)$/;
+var Converter = class {
+	#memo = /* @__PURE__ */ new Map();
+	#stack = [];
+	#types = /* @__PURE__ */ new Map();
+	#typing = [];
+	#places = /* @__PURE__ */ new Map();
+	/** Nesting of pointer resolution: a pointer chain that loops never reaches a value. */
+	#depth = 0;
+	index;
+	session;
+	constructor(index, session) {
+		this.index = index;
+		this.session = session;
+	}
+	all() {
+		const out = /* @__PURE__ */ new Map();
+		for (const entry of this.index.tokens.values()) {
+			const place = this.place(entry);
+			if (place.kind === "excluded") continue;
+			out.set(entry.key, {
+				entry,
+				type: this.type(entry),
+				place,
+				value: this.token(entry)
+			});
+		}
+		return out;
+	}
+	fail(entry, sub, message, hint) {
+		const at = sub.length > 0 ? `${entry.key} (${sub.join(".")})` : entry.key;
+		return configError(entry.file, at, message, hint);
+	}
+	/** Format §5.2.2: explicit `$type`, else the referenced token's type, else the closest group's. */
+	type(entry) {
+		const known = this.#types.get(entry);
+		if (known !== void 0) return known;
+		const at = this.#typing.indexOf(entry);
+		if (at !== -1) throw this.cycle(this.#typing.slice(at), entry);
+		this.#typing.push(entry);
+		try {
+			let type = entry.node.$type;
+			if (type === void 0) {
+				const target = this.aliasTarget(entry);
+				type = target ? this.type(target) : entry.groupType;
+			}
+			if (type === void 0) throw this.fail(entry, [], "has no $type", "Set $type on the token or on a parent group.");
+			if (typeof type !== "string" || !TYPES.has(type)) throw this.fail(entry, [], `${describe(type)} is not a DTCG type`, `Types: ${[...TYPES].join(", ")}. Leave unsupported groups out with dtcg(…, { scales: { "group": false } }).`);
+			this.#types.set(entry, type);
+			return type;
+		} finally {
+			this.#typing.pop();
+		}
+	}
+	/** The token a whole-token alias or a whole-token `$ref` names. */
+	aliasTarget(entry) {
+		const { $value, $ref } = entry.node;
+		if (typeof $value === "string") {
+			const alias = ALIAS.exec($value);
+			return alias ? this.lookup(alias[1], entry, []) : void 0;
+		}
+		if (typeof $ref === "string") {
+			const target = this.pointer($ref, entry, []);
+			return target.kind === "token" ? target.entry : void 0;
+		}
+	}
+	place(entry) {
+		let place = this.#places.get(entry);
+		if (!place) {
+			place = this.computePlace(entry);
+			this.#places.set(entry, place);
+		}
+		return place;
+	}
+	computePlace(entry) {
+		const segments = entry.segments;
+		const { scales } = this.session.options;
+		for (let i = segments.length; i >= 1; i--) {
+			const path = segments.slice(0, i).join(".");
+			const target = scales.get(path);
+			if (target === void 0) continue;
+			this.session.usedScales.add(path);
+			if (target === false) return { kind: "excluded" };
+			const type = this.type(entry);
+			if (target === "textStyles" !== (type === "typography")) throw this.fail(entry, [], type === "typography" ? `options.scales places it in ${target}, but a typography token is a text style` : `options.scales places it in textStyles, but it is a ${type} token, not typography`);
+			const rest = i === segments.length ? segments.slice(-1) : segments.slice(i);
+			const place = this.target(entry, target, rest);
+			if (place) return place;
+		}
+		const type = this.type(entry);
+		for (const depth of [2, 1]) {
+			if (segments.length <= depth) continue;
+			const name = segments.slice(0, depth).map((segment) => segment.toLowerCase().replace(/[^a-z0-9]/g, "")).join(".");
+			const names = depth === 2 ? COMPOUND_NAMES : GROUP_NAMES;
+			const target = Object.hasOwn(names, name) ? names[name] : void 0;
+			if (target && ACCEPTS[target].includes(type)) {
+				const place = this.target(entry, target, segments.slice(depth));
+				if (place) return place;
+			}
+		}
+		const target = Object.hasOwn(TYPE_TARGETS, type) ? TYPE_TARGETS[type] : void 0;
+		return target && this.target(entry, target, segments) || { kind: "none" };
+	}
+	/** The vicss path of `rest` under `target`; `undefined` when nothing is left to name the token. */
+	target(entry, target, rest) {
+		const names = [];
+		for (const name of rest) {
+			if (name === "$root" || name === "DEFAULT") continue;
+			const clean = name.split(/[^A-Za-z0-9-]+/).filter(Boolean).join("-");
+			if (clean === "") throw this.fail(entry, [], `\`${name}\` cannot become part of a CSS custom property name`, "vicss names keep letters, digits and `-`; rename the token or group.");
+			names.push(clean);
+		}
+		if (names.length === 0) return void 0;
+		const path = names.join(".");
+		return target === "textStyles" ? {
+			kind: "text",
+			name: path
+		} : {
+			kind: "scale",
+			scale: target,
+			path
+		};
+	}
+	token(entry) {
+		const done = this.#memo.get(entry);
+		if (done !== void 0) return done;
+		const at = this.#stack.indexOf(entry);
+		if (at !== -1) throw this.cycle(this.#stack.slice(at), entry);
+		this.#stack.push(entry);
+		try {
+			const value = this.compute(entry);
+			this.#memo.set(entry, value);
+			return value;
+		} finally {
+			this.#stack.pop();
+		}
+	}
+	cycle(chain, entry) {
+		return this.fail(entry, [], `alias cycle: ${[...chain, entry].map((e) => e.key).join(" → ")}`);
+	}
+	compute(entry) {
+		const type = this.type(entry);
+		const ext = isPlainObject(entry.node.$extensions) ? entry.node.$extensions[EXTENSION] : void 0;
+		if (isPlainObject(ext) && typeof ext.value === "string") {
+			if (type === "typography") throw this.fail(entry, [`$extensions.${EXTENSION}`], "a typography token is a text style, not one CSS value");
+			return this.rewrite(ext.value, entry);
+		}
+		return this.value(rawOf(entry), type, entry, []);
+	}
+	/**
+	* A token value or a composite's sub-value (format §9): a literal of `type`,
+	* or a reference to a token of that type.
+	*/
+	value(raw, type, entry, sub) {
+		for (let hops = 0; isRef(raw); hops++) {
+			if (hops > 64) throw this.fail(entry, sub, "circular $ref");
+			const target = this.pointer(raw.$ref, entry, sub);
+			if (target.kind === "token") return this.alias(target.entry, type, entry, sub);
+			raw = target.value;
+		}
+		if (typeof raw === "string" && ALIAS.test(raw)) return this.alias(this.lookup(ALIAS.exec(raw)[1], entry, sub), type, entry, sub);
+		switch (type) {
+			case "color": return this.color(raw, entry, sub);
+			case "dimension": return this.measure(raw, entry, sub, "dimension", ["px", "rem"]);
+			case "duration": return this.measure(raw, entry, sub, "duration", ["ms", "s"]);
+			case "cubicBezier": return this.cubicBezier(raw, entry, sub);
+			case "fontFamily": return this.fontFamily(raw, entry, sub);
+			case "fontWeight": return this.fontWeight(raw, entry, sub);
+			case "number": return num(this.number(raw, entry, sub));
+			case "strokeStyle": return this.strokeStyle(raw, entry, sub);
+			case "border": return this.border(raw, entry, sub);
+			case "transition": return this.transition(raw, entry, sub);
+			case "shadow": return this.shadow(raw, entry, sub);
+			case "gradient": return this.gradient(raw, entry, sub);
+			default: return this.typography(raw, entry, sub);
+		}
+	}
+	/** A sub-value that is one CSS value: every type but typography. */
+	css(raw, type, entry, sub) {
+		const value = this.value(raw, type, entry, sub);
+		if (typeof value === "string" || value instanceof Skip) return value;
+		throw this.fail(entry, sub, "expected one CSS value, not a text style");
+	}
+	/** An alias keeps the reference when its target has a scale, and inlines the value otherwise. */
+	alias(target, type, entry, sub) {
+		const actual = this.type(target);
+		if (actual !== type) throw this.fail(entry, sub, `\`{${target.key}}\` is a ${actual} token, where a ${type} is expected`);
+		const value = this.token(target);
+		if (value instanceof Skip) return new Skip(`uses ${target.key}: ${value.reason}`);
+		if (typeof value !== "string") return { ...value };
+		const place = this.place(target);
+		return place.kind === "scale" ? `{${place.scale}.${place.path}}` : value;
+	}
+	lookup(path, entry, sub) {
+		const target = this.index.tokens.get(path);
+		if (target) return target;
+		const group = this.index.groups.get(path);
+		if (group) throw this.fail(entry, sub, `\`{${path}}\` names a group, not a token`, Object.hasOwn(group, "$root") ? `Write {${path}.$root} for the group's own token.` : void 0);
+		const segments = path.split(".");
+		let prefix = "";
+		for (let i = segments.length - 1; i > 0; i--) {
+			const candidate = segments.slice(0, i).join(".");
+			if (this.index.groups.has(candidate)) {
+				prefix = `${candidate}.`;
+				break;
+			}
+		}
+		const close = [...this.index.tokens.keys()].filter((k) => k.startsWith(prefix)).slice(0, 5);
+		throw this.fail(entry, sub, `\`{${path}}\` names no token`, close.length > 0 ? `Tokens nearby: ${close.map((k) => `{${k}}`).join(", ")}.` : void 0);
+	}
+	/**
+	* Resolves a same-document JSON pointer (format §7.1.2): a whole token (or
+	* its `$value`) is an alias; a part of a value is that literal part, found by
+	* following the aliases on the way.
+	*/
+	pointer(ref, entry, sub) {
+		if (typeof ref !== "string") throw this.fail(entry, sub, "$ref must be a JSON pointer string");
+		const segments = decodePointer(ref);
+		if (!segments) throw this.fail(entry, sub, `\`${ref}\` is not a JSON pointer into this document`, "A token file references its own tokens: \"#/color/blue/$value\".");
+		if (++this.#depth > 64) throw this.fail(entry, sub, `\`${ref}\`: circular $ref`);
+		try {
+			let node = this.index.root;
+			let i = 0;
+			while (i < segments.length && isGroup(node)) {
+				const name = segments[i];
+				if (name.startsWith("$") && name !== "$root") throw this.fail(entry, sub, `\`${ref}\` points into ${name}, not to a token value`);
+				if (!Object.hasOwn(node, name)) throw this.fail(entry, sub, `\`${ref}\` points to nothing: there is no \`${name}\``);
+				node = node[name];
+				i++;
+			}
+			if (!isPlainObject(node) || !isToken(node)) throw this.fail(entry, sub, `\`${ref}\` points to a group, not to a token value`);
+			const target = this.index.tokens.get(segments.slice(0, i).join("."));
+			if (segments[i] !== "$value") throw this.fail(entry, sub, i === segments.length ? `\`${ref}\` points to a token object, not to a value` : `\`${ref}\` points to ${segments[i]}; only $value is a value`, `Point to the value: "#/${segments.slice(0, i).map((n) => n.replaceAll("~", "~0").replaceAll("/", "~1")).join("/")}/$value".`);
+			if (++i === segments.length) return {
+				kind: "token",
+				entry: target
+			};
+			let value = this.raw(target, entry, sub);
+			for (; i < segments.length; i++) {
+				value = this.follow(value, entry, sub);
+				const name = segments[i];
+				if (Array.isArray(value) && INDEX.test(name) && Number(name) < value.length) value = value[Number(name)];
+				else if (isPlainObject(value) && Object.hasOwn(value, name)) value = value[name];
+				else throw this.fail(entry, sub, `\`${ref}\` points to nothing: there is no \`${name}\``);
+			}
+			return {
+				kind: "value",
+				value
+			};
+		} finally {
+			this.#depth--;
+		}
+	}
+	/** A token's literal `$value`, through whole-token aliases and pointers. */
+	raw(target, entry, sub) {
+		return this.follow(rawOf(target), entry, sub);
+	}
+	/** Follows `$ref` objects and whole-token aliases until a literal. */
+	follow(value, entry, sub) {
+		for (let hops = 0;; hops++) {
+			if (hops > 64) throw this.fail(entry, sub, "circular $ref");
+			if (isRef(value)) {
+				const target = this.pointer(value.$ref, entry, sub);
+				value = target.kind === "token" ? rawOf(target.entry) : target.value;
+			} else if (typeof value === "string" && ALIAS.test(value)) value = rawOf(this.lookup(ALIAS.exec(value)[1], entry, sub));
+			else return value;
+		}
+	}
+	/** A primitive part (a component, a unit): pointers allowed, aliases not. */
+	part(raw, entry, sub) {
+		for (let hops = 0; isRef(raw); hops++) {
+			if (hops > 64) throw this.fail(entry, sub, "circular $ref");
+			const target = this.pointer(raw.$ref, entry, sub);
+			raw = target.kind === "token" ? this.raw(target.entry, entry, sub) : target.value;
+		}
+		if (typeof raw === "string" && ALIAS.test(raw)) throw this.fail(entry, sub, `\`${raw}\`: a curly-brace alias names a whole token, not part of a value`, "Reference part of a value with { \"$ref\": \"#/path/to/token/$value/…\" }.");
+		return raw;
+	}
+	/** An object with exactly `required` (plus `optional`) keys, pointers resolved. */
+	object(raw, entry, sub, what, required, optional = []) {
+		const value = this.part(raw, entry, sub);
+		if (!isPlainObject(value)) throw this.fail(entry, sub, `expected ${what}`);
+		for (const key of Object.keys(value)) if (!required.includes(key) && !optional.includes(key)) throw this.fail(entry, sub, `unknown property \`${key}\` in ${what}`);
+		for (const key of required) if (!Object.hasOwn(value, key)) throw this.fail(entry, sub, `${what} lacks \`${key}\``);
+		return value;
+	}
+	number(raw, entry, sub) {
+		const value = this.part(raw, entry, sub);
+		if (typeof value !== "number" || !Number.isFinite(value)) throw this.fail(entry, sub, `expected a number, got ${describe(value)}`);
+		return value;
+	}
+	color(raw, entry, sub) {
+		const c = this.object(raw, entry, sub, "a color { colorSpace, components, alpha?, hex? }", ["colorSpace", "components"], ["alpha", "hex"]);
+		const space = this.part(c.colorSpace, entry, sub);
+		const spec = typeof space === "string" && Object.hasOwn(SPACES, space) ? SPACES[space] : void 0;
+		if (!spec || typeof space !== "string") throw this.fail(entry, [...sub, "colorSpace"], `${describe(space)} is not a DTCG color space`, `Color spaces: ${Object.keys(SPACES).join(", ")}.`);
+		const list = this.part(c.components, entry, sub);
+		if (!Array.isArray(list) || list.length !== 3) throw this.fail(entry, [...sub, "components"], `expected 3 components, got ${describe(list)}`);
+		const components = list.map((item, i) => {
+			const at = [...sub, `components.${i}`];
+			const value = this.part(item, entry, at);
+			if (value === "none") return value;
+			const [min, max, open] = spec.ranges[i];
+			if (typeof value !== "number" || !Number.isFinite(value) || value < min || (open ? value >= max : value > max)) throw this.fail(entry, at, `expected "none" or a number in [${min}, ${max}${open ? ")" : "]"} for ${space}, got ${describe(value)}`);
+			return value;
+		});
+		let alpha = 1;
+		if (c.alpha !== void 0) {
+			alpha = this.number(c.alpha, entry, [...sub, "alpha"]);
+			if (alpha < 0 || alpha > 1) throw this.fail(entry, [...sub, "alpha"], "alpha is in [0, 1]");
+		}
+		const hex = c.hex === void 0 ? void 0 : this.part(c.hex, entry, sub);
+		if (hex !== void 0 && (typeof hex !== "string" || !/^#[0-9a-fA-F]{6}$/.test(hex))) throw this.fail(entry, [...sub, "hex"], `expected a 6-digit hex color, got ${describe(hex)}`);
+		if (space === "srgb" && typeof hex === "string" && !components.includes("none")) {
+			const lower = hex.toLowerCase();
+			return alpha < 1 ? lower + Math.round(alpha * 255).toString(16).padStart(2, "0") : lower;
+		}
+		const parts = components.map((v, i) => v === "none" ? v : spec.percent?.includes(i) ? `${num(v)}%` : num(v));
+		const slash = alpha < 1 ? ` / ${num(alpha)}` : "";
+		return spec.fn ? `${space}(${parts.join(" ")}${slash})` : `color(${space} ${parts.join(" ")}${slash})`;
+	}
+	measure(raw, entry, sub, what, units) {
+		const d = this.object(raw, entry, sub, `a ${what} { value, unit }`, ["value", "unit"]);
+		const value = this.number(d.value, entry, [...sub, "value"]);
+		const unit = this.part(d.unit, entry, sub);
+		if (typeof unit !== "string" || !units.includes(unit)) throw this.fail(entry, [...sub, "unit"], `\`${String(unit)}\` is not a ${what} unit: DTCG allows ${units.join(" and ")}`, `Write any other CSS value with "$extensions": { "${EXTENSION}": { "value": "…" } }.`);
+		return `${num(value)}${unit}`;
+	}
+	cubicBezier(raw, entry, sub) {
+		const list = this.part(raw, entry, sub);
+		if (!Array.isArray(list) || list.length !== 4) throw this.fail(entry, sub, `a cubicBezier is [x1, y1, x2, y2], got ${describe(list)}`);
+		const [x1, y1, x2, y2] = list.map((v, i) => this.number(v, entry, [...sub, String(i)]));
+		if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) throw this.fail(entry, sub, "the x coordinates of a cubicBezier are in [0, 1]");
+		return `cubic-bezier(${num(x1)}, ${num(y1)}, ${num(x2)}, ${num(y2)})`;
+	}
+	fontFamily(raw, entry, sub) {
+		const value = this.part(raw, entry, sub);
+		const names = Array.isArray(value) ? value.map((v) => this.part(v, entry, sub)) : [value];
+		if (names.length === 0 || names.some((n) => typeof n !== "string" || n.trim() === "")) throw this.fail(entry, sub, `a fontFamily is a font name or an array of them, got ${describe(value)}`);
+		return names.flatMap((n) => n.split(",")).map((n) => fontName(n.trim().replace(/^(["'])(.*)\1$/, "$2"))).join(", ");
+	}
+	fontWeight(raw, entry, sub) {
+		const value = this.part(raw, entry, sub);
+		if (typeof value === "string" && Object.hasOwn(WEIGHTS, value)) return String(WEIGHTS[value]);
+		if (typeof value !== "number" || !(value >= 1 && value <= 1e3)) throw this.fail(entry, sub, `a fontWeight is a number in [1, 1000] or a weight name, got ${describe(value)}`, `Names: ${Object.keys(WEIGHTS).join(", ")}.`);
+		return num(value);
+	}
+	strokeStyle(raw, entry, sub) {
+		const value = this.part(raw, entry, sub);
+		if (typeof value === "string") {
+			if (STROKES.has(value)) return value;
+			throw this.fail(entry, sub, `\`${value}\` is not a stroke style`, `Styles: ${[...STROKES].join(", ")}.`);
+		}
+		const s = this.object(value, entry, sub, "a strokeStyle { dashArray, lineCap }", ["dashArray", "lineCap"]);
+		const dashes = this.part(s.dashArray, entry, sub);
+		if (!Array.isArray(dashes) || dashes.length === 0) throw this.fail(entry, [...sub, "dashArray"], "expected a non-empty array of dimensions");
+		for (const [i, dash] of dashes.entries()) this.value(dash, "dimension", entry, [...sub, `dashArray.${i}`]);
+		const cap = this.part(s.lineCap, entry, sub);
+		if (cap !== "round" && cap !== "butt" && cap !== "square") throw this.fail(entry, [...sub, "lineCap"], "expected \"round\", \"butt\" or \"square\"");
+		return new Skip("a dash pattern, which no CSS line style draws");
+	}
+	border(raw, entry, sub) {
+		const b = this.object(raw, entry, sub, "a border { color, width, style }", [
+			"color",
+			"width",
+			"style"
+		]);
+		return joined([
+			this.css(b.width, "dimension", entry, [...sub, "width"]),
+			this.css(b.style, "strokeStyle", entry, [...sub, "style"]),
+			this.css(b.color, "color", entry, [...sub, "color"])
+		], " ");
+	}
+	/** `<duration> <timing> <delay>`: a `transition` value for every property. */
+	transition(raw, entry, sub) {
+		const t = this.object(raw, entry, sub, "a transition { duration, delay, timingFunction }", [
+			"duration",
+			"delay",
+			"timingFunction"
+		]);
+		return joined([
+			this.css(t.duration, "duration", entry, [...sub, "duration"]),
+			this.css(t.timingFunction, "cubicBezier", entry, [...sub, "timingFunction"]),
+			this.css(t.delay, "duration", entry, [...sub, "delay"])
+		], " ");
+	}
+	shadow(raw, entry, sub) {
+		const value = this.part(raw, entry, sub);
+		if (!Array.isArray(value)) return this.shadowLayer(value, entry, sub);
+		if (value.length === 0) throw this.fail(entry, sub, "a shadow array needs at least one shadow");
+		return joined(value.map((layer, i) => {
+			const at = [...sub, String(i)];
+			return isRef(layer) || typeof layer === "string" && ALIAS.test(layer) ? this.css(layer, "shadow", entry, at) : this.shadowLayer(layer, entry, at);
+		}), ", ");
+	}
+	shadowLayer(raw, entry, sub) {
+		const s = this.object(raw, entry, sub, "a shadow { color, offsetX, offsetY, blur, spread, inset? }", [
+			"color",
+			"offsetX",
+			"offsetY",
+			"blur",
+			"spread"
+		], ["inset"]);
+		const inset = s.inset === void 0 ? false : this.part(s.inset, entry, sub);
+		if (typeof inset !== "boolean") throw this.fail(entry, [...sub, "inset"], "expected a boolean");
+		const layer = joined([...[
+			"offsetX",
+			"offsetY",
+			"blur",
+			"spread"
+		].map((key) => this.css(s[key], "dimension", entry, [...sub, key])), this.css(s.color, "color", entry, [...sub, "color"])], " ");
+		return inset && typeof layer === "string" ? `inset ${layer}` : layer;
+	}
+	gradient(raw, entry, sub) {
+		const stops = this.part(raw, entry, sub);
+		if (!Array.isArray(stops) || stops.length === 0) throw this.fail(entry, sub, "a gradient is a non-empty array of stops { color, position }");
+		for (const [i, stop] of stops.entries()) {
+			const at = [...sub, String(i)];
+			if (isRef(stop) || typeof stop === "string" && ALIAS.test(stop)) {
+				this.value(stop, "gradient", entry, at);
+				continue;
+			}
+			const s = this.object(stop, entry, at, "a gradient stop { color, position }", ["color", "position"]);
+			this.value(s.color, "color", entry, [...at, "color"]);
+			this.value(s.position, "number", entry, [...at, "position"]);
+		}
+		return new Skip("a gradient, and DTCG gradients carry no shape or direction");
+	}
+	typography(raw, entry, sub) {
+		const t = this.object(raw, entry, sub, "a typography { fontFamily, fontSize, fontWeight, letterSpacing, lineHeight }", [
+			"fontFamily",
+			"fontSize",
+			"fontWeight",
+			"letterSpacing",
+			"lineHeight"
+		]);
+		const field = (key, type) => {
+			const value = this.value(t[key], type, entry, [...sub, key]);
+			if (typeof value !== "string") throw this.fail(entry, [...sub, key], "expected a CSS value");
+			return (type === "number" || type === "fontWeight") && /^-?[\d.]+$/.test(value) ? Number(value) : value;
+		};
+		const family = String(field("fontFamily", "fontFamily"));
+		return {
+			fontFamily: WHOLE_REF.test(family) || !/^-?[A-Za-z_][\w-]*$/.test(family) || GENERIC_FAMILIES.has(family.toLowerCase()) ? family : `"${family}"`,
+			fontSize: field("fontSize", "dimension"),
+			fontWeight: field("fontWeight", "fontWeight"),
+			lineHeight: field("lineHeight", "number"),
+			letterSpacing: field("letterSpacing", "dimension")
+		};
+	}
+	/** The extension's CSS, with DTCG aliases turned into vicss references or values. */
+	rewrite(css, entry) {
+		const sub = [`$extensions.${EXTENSION}`];
+		let skip;
+		const out = css.replace(ALIASES, (match, path) => {
+			const target = this.lookup(path, entry, sub);
+			const value = this.token(target);
+			if (value instanceof Skip) {
+				skip ??= new Skip(`uses ${target.key}: ${value.reason}`);
+				return match;
+			}
+			if (typeof value !== "string") throw this.fail(entry, sub, `\`${match}\` is typography, which is not one CSS value`);
+			const place = this.place(target);
+			return place.kind === "scale" ? `{${place.scale}.${place.path}}` : value;
+		});
+		if (skip) return skip;
+		const bad = malformed(out.replace(VICSS_REFS, "0"));
+		if (bad) throw this.fail(entry, sub, `\`${css}\` is not a CSS value: ${bad}`);
+		return out.trim();
+	}
+};
+/** What a token holds: its `$value`, or its whole-token `$ref` as a reference object. */
+function rawOf(entry) {
+	return Object.hasOwn(entry.node, "$ref") ? { $ref: entry.node.$ref } : entry.node.$value;
+}
+/** Sub-values joined into one CSS value, unless one of them has none. */
+function joined(values, separator) {
+	const out = [];
+	for (const value of values) {
+		if (value instanceof Skip) return value;
+		out.push(value);
+	}
+	return out.join(separator);
+}
+function isRef(value) {
+	return isPlainObject(value) && Object.hasOwn(value, "$ref");
+}
+const UNIT = [0, 1];
+const HUE = [
+	0,
+	360,
+	true
+];
+const PERCENT = [0, 100];
+const ANY = [-Infinity, Infinity];
+const CHROMA = [0, Infinity];
+/**
+* Color module §4.2. `fn` spaces have their own CSS function; the rest are
+* predefined `color()` spaces. HSL and HWB take percentages in CSS where DTCG
+* writes plain numbers.
+*/
+const SPACES = {
+	srgb: { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] },
+	"srgb-linear": { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] },
+	hsl: {
+		ranges: [
+			HUE,
+			PERCENT,
+			PERCENT
+		],
+		fn: true,
+		percent: [1, 2]
+	},
+	hwb: {
+		ranges: [
+			HUE,
+			PERCENT,
+			PERCENT
+		],
+		fn: true,
+		percent: [1, 2]
+	},
+	lab: {
+		ranges: [
+			PERCENT,
+			ANY,
+			ANY
+		],
+		fn: true
+	},
+	lch: {
+		ranges: [
+			PERCENT,
+			CHROMA,
+			HUE
+		],
+		fn: true
+	},
+	oklab: {
+		ranges: [
+			UNIT,
+			ANY,
+			ANY
+		],
+		fn: true
+	},
+	oklch: {
+		ranges: [
+			UNIT,
+			CHROMA,
+			HUE
+		],
+		fn: true
+	},
+	"display-p3": { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] },
+	"a98-rgb": { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] },
+	"prophoto-rgb": { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] },
+	rec2020: { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] },
+	"xyz-d65": { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] },
+	"xyz-d50": { ranges: [
+		UNIT,
+		UNIT,
+		UNIT
+	] }
+};
+/** Format §8.4. */
+const WEIGHTS = {
+	thin: 100,
+	hairline: 100,
+	"extra-light": 200,
+	"ultra-light": 200,
+	light: 300,
+	normal: 400,
+	regular: 400,
+	book: 400,
+	medium: 500,
+	"semi-bold": 600,
+	"demi-bold": 600,
+	bold: 700,
+	"extra-bold": 800,
+	"ultra-bold": 800,
+	black: 900,
+	heavy: 900,
+	"extra-black": 950,
+	"ultra-black": 950
+};
+const STROKES = /* @__PURE__ */ new Set([
+	"solid",
+	"dashed",
+	"dotted",
+	"double",
+	"groove",
+	"ridge",
+	"outset",
+	"inset"
+]);
+/**
+* Generic families must stay unquoted. Other names are quoted unless they are
+* one plain identifier: several words parse as one family unquoted too, but
+* quoting them is what every stack (Tailwind's included) does.
+*/
+function fontName(name) {
+	if (GENERIC_FAMILIES.has(name.toLowerCase())) return name;
+	if (/^-?[A-Za-z_][A-Za-z0-9_-]*$/.test(name) && !CSS_WIDE.has(name.toLowerCase())) return name;
+	return `"${name.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+/** Plain decimal, rounded past float noise from design tools (0.20000000298 → 0.2). */
+function num(n) {
+	const rounded = Number(n.toFixed(6));
+	return Object.is(rounded, -0) ? "0" : String(rounded);
+}
+function describe(value) {
+	if (value === void 0) return "nothing";
+	const json = JSON.stringify(value);
+	return json.length > 60 ? `${json.slice(0, 57)}…` : json;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function sameValue(a, b) {
+	return typeof a === "string" || typeof b === "string" ? a === b : JSON.stringify(a) === JSON.stringify(b);
+}
+/** The vicss tokens a value references: `colors.bg` for `{colors.bg}`. */
+function referencesOf(value) {
+	if (typeof value === "string") return [...value.matchAll(VICSS_REFS)].map(([ref]) => ref.slice(1, -1)).filter((id) => Object.hasOwn(SCALES, id.slice(0, id.indexOf("."))));
+	return isPlainObject(value) ? Object.values(value).flatMap(referencesOf) : [];
+}
+const valuesOf = (item) => [item.base, ...item.modes.map(([, v]) => v)];
+/**
+* Base values plus the values that differ per mode. A token with a value per
+* mode is semantic; so is one that aliases a semantic token, since the core
+* lets raw tokens alias raw tokens only and an alias of a switching token must
+* switch with it.
+*/
+function assemble(session, base, variants) {
+	const items = [];
+	for (const { entry, type, place, value } of base.values()) {
+		if (place.kind === "none" || place.kind === "excluded") {
+			if (place.kind === "none") session.unmapped.set(entry.key, type);
+			continue;
+		}
+		if (value instanceof Skip) {
+			session.skipped.set(entry.key, value.reason);
+			continue;
+		}
+		const modes = [];
+		for (const variant of variants) {
+			const other = variant.outcomes.get(entry.key);
+			if (!other || other.place.kind === "excluded") {
+				session.partial.set(entry.key, `missing in ${variant.label}, which keeps the base value`);
+				continue;
+			}
+			if (placeId(other.place) !== placeId(place)) throw configError(other.entry.file, entry.key, `changes type or place in ${variant.label} (${placeId(other.place)} instead of ${placeId(place)})`);
+			if (other.value instanceof Skip) {
+				session.partial.set(entry.key, `no CSS value in ${variant.label}, which keeps the base value`);
+				continue;
+			}
+			if (!sameValue(other.value, value)) modes.push([variant.mode, other.value]);
+		}
+		items.push({
+			entry,
+			place,
+			base: value,
+			modes
+		});
+	}
+	const added = /* @__PURE__ */ new Map();
+	for (const variant of variants) for (const [key, outcome] of variant.outcomes) {
+		if (base.has(key) || outcome.place.kind === "none") continue;
+		const first = added.get(key)?.[0];
+		if (first && placeId(first.outcome.place) !== placeId(outcome.place)) throw configError(outcome.entry.file, key, `changes type or place in ${variant.label} (${placeId(outcome.place)} instead of ${placeId(first.outcome.place)})`);
+		push(added, key, {
+			variant,
+			outcome
+		});
+	}
+	const addedAt = /* @__PURE__ */ new Map();
+	for (const [key, list] of added) addedAt.set(placeId(list[0].outcome.place), key);
+	const emitted = new Set(items.map((item) => placeId(item.place)));
+	const kept = /* @__PURE__ */ new Set();
+	for (let i = 0; i < items.length; i++) for (const id of valuesOf(items[i]).flatMap(referencesOf)) {
+		const key = addedAt.get(id);
+		if (key === void 0 || emitted.has(id)) continue;
+		const defined = added.get(key).filter(({ outcome }) => !(outcome.value instanceof Skip));
+		const first = defined[0];
+		if (!first) continue;
+		const value = first.outcome.value;
+		items.push({
+			entry: first.outcome.entry,
+			place: first.outcome.place,
+			base: value,
+			modes: defined.slice(1).flatMap(({ variant, outcome }) => {
+				const other = outcome.value;
+				return sameValue(other, value) ? [] : [[variant.mode, other]];
+			})
+		});
+		emitted.add(id);
+		kept.add(key);
+	}
+	for (const [key, list] of added) if (!kept.has(key)) session.extra.set(key, `only in ${list.map(({ variant }) => variant.label).join(", ")}`);
+	for (const item of items) {
+		const missing = valuesOf(item).flatMap(referencesOf).find((id) => !emitted.has(id));
+		if (missing === void 0) continue;
+		const target = [base, ...variants.map((v) => v.outcomes)].flatMap((outcomes) => [...outcomes.values()]).find((o) => placeId(o.place) === missing);
+		throw configError(item.entry.file, item.entry.key, `aliases ${target?.entry.key ?? missing} in a context, but it has no CSS value in the base context, so vicss leaves it out`, `Give it a CSS value with "$extensions": { "${EXTENSION}": { "value": "…" } }.`);
+	}
+	const modifierOf = new Map(variants.map((v) => [v.mode, v]));
+	for (const item of items) {
+		if (item.place.kind !== "scale") continue;
+		if (item.modes.some(([mode, value], i) => item.modes.slice(i + 1).some(([other, v]) => modifierOf.get(mode)?.modifier !== modifierOf.get(other)?.modifier && !sameValue(value, v)))) session.overlap.set(item.entry.key, item.modes.map(([mode]) => `_${mode} from ${modifierOf.get(mode)?.label}`).join(", "));
+	}
+	const byId = /* @__PURE__ */ new Map();
+	for (const item of items) if (item.place.kind === "scale") byId.set(`${item.place.scale}.${item.place.path}`, item);
+	const semantic = /* @__PURE__ */ new Map();
+	const isSemantic = (item) => {
+		const known = semantic.get(item);
+		if (known !== void 0) return known;
+		semantic.set(item, false);
+		let result = item.modes.length > 0;
+		for (const value of [item.base, ...item.modes.map(([, v]) => v)]) {
+			if (result) break;
+			if (typeof value !== "string") continue;
+			for (const [ref] of value.matchAll(VICSS_REFS)) {
+				const target = byId.get(ref.slice(1, -1));
+				if (target && isSemantic(target)) {
+					result = true;
+					break;
+				}
+			}
+		}
+		semantic.set(item, result);
+		return result;
+	};
+	const raw = /* @__PURE__ */ new Map();
+	const switching = /* @__PURE__ */ new Map();
+	const textStyles = {};
+	const visibility = {};
+	const claimed = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const { entry, place } = item;
+		const extensions = entry.node.$extensions;
+		const hidden = isPlainObject(extensions) ? extensions[PRIVATE_EXTENSION] : void 0;
+		if (hidden !== void 0) {
+			if (typeof hidden !== "boolean" || place.kind !== "scale") throw configError(entry.file, entry.key, `$extensions["${PRIVATE_EXTENSION}"]: expected true or false on a token of a scale`);
+			visibility[`${place.scale}.${place.path}`] = hidden ? "private" : "public";
+		}
+		const id = place.kind === "scale" ? `${place.scale}.${place.path}` : `textStyles.${place.name}`;
+		const first = claimed.get(id);
+		if (first) throw configError(entry.file, entry.key, `becomes ${id}, like ${first.key} in ${first.file}`, "Rename one of them, or place one group elsewhere with options.scales.");
+		claimed.set(id, entry);
+		if (place.kind === "text") {
+			if (item.modes.length > 0) session.fixed.set(entry.key, `differs in ${item.modes.map(([m]) => `_${m}`).join(", ")}`);
+			textStyles[place.name] = item.base;
+			continue;
+		}
+		const base = item.base;
+		if (!isSemantic(item)) {
+			push(raw, place.scale, [place.path, base]);
+			continue;
+		}
+		if (place.scale === "breakpoints" || place.scale === "containers") throw configError(entry.file, entry.key, `${place.scale} cannot change with a mode: media and container queries cannot read custom properties`);
+		const value = item.modes.length === 0 ? base : Object.fromEntries([["base", base], ...item.modes.map(([mode, v]) => [`_${mode}`, v])]);
+		push(switching, place.scale, [place.path, value]);
+	}
+	const out = {};
+	if (raw.size > 0) {
+		const tokens = {};
+		for (const [scale, leaves] of raw) tokens[scale] = buildTree(leaves, false);
+		out.tokens = tokens;
+	}
+	if (switching.size > 0) {
+		const semanticTokens = {};
+		for (const [scale, leaves] of switching) semanticTokens[scale] = buildTree(leaves, true);
+		out.semanticTokens = semanticTokens;
+	}
+	if (Object.keys(textStyles).length > 0) out.textStyles = textStyles;
+	if (Object.keys(visibility).length > 0) out.tokenVisibility = visibility;
+	return out;
+}
+function placeId(place) {
+	return place.kind === "scale" ? `${place.scale}.${place.path}` : place.kind === "text" ? `textStyles.${place.name}` : place.kind;
+}
+function push(map, key, value) {
+	const list = map.get(key);
+	if (list) list.push(value);
+	else map.set(key, [value]);
+}
+/**
+* Nests dotted paths. A path that is also a group (a `$root` token next to
+* its siblings) goes under `DEFAULT`. In a semantic tree, a group whose only
+* child is `base` would read as a value per mode (`{ base }`), so that child
+* goes one level down, under `DEFAULT`, which names the same path.
+*/
+function buildTree(leaves, semantic) {
+	const groups = /* @__PURE__ */ new Set();
+	for (const [path] of leaves) {
+		const segments = path.split(".");
+		for (let i = 1; i < segments.length; i++) groups.add(segments.slice(0, i).join("."));
+	}
+	const root = {};
+	const values = /* @__PURE__ */ new WeakSet();
+	for (const [path, value] of leaves) {
+		const segments = path.split(".");
+		if (groups.has(path)) segments.push("DEFAULT");
+		let node = root;
+		for (const name of segments.slice(0, -1)) node = node[name] ??= {};
+		node[segments.at(-1)] = value;
+		if (typeof value === "object" && value !== null) values.add(value);
+	}
+	if (semantic) {
+		const fix = (node) => {
+			for (const [name, child] of Object.entries(node)) {
+				if (!isPlainObject(child) || values.has(child)) continue;
+				const keys = Object.keys(child);
+				if (keys.length === 1 && keys[0] === "base" && typeof child.base === "string") child.base = { DEFAULT: child.base };
+				if (name !== "DEFAULT") fix(child);
+			}
+		};
+		fix(root);
+	}
+	return root;
+}
+const ROOT_KEYS = /* @__PURE__ */ new Set([
+	"$schema",
+	"name",
+	"version",
+	"description",
+	"sets",
+	"modifiers",
+	"resolutionOrder",
+	"$defs"
+]);
+const SET_KEYS = /* @__PURE__ */ new Set([
+	"description",
+	"sources",
+	"$extensions"
+]);
+const MODIFIER_KEYS = /* @__PURE__ */ new Set([
+	"description",
+	"contexts",
+	"default",
+	"$extensions"
+]);
+function fromResolver(doc, file, dir, session) {
+	const items = parseResolver(doc, file, dir, session);
+	const plan = planModes(items, file, session.options);
+	const merged = (input) => {
+		let tree = {};
+		for (const item of items) {
+			const sources = item.contexts.get(item.kind === "set" ? "" : input.get(item.name));
+			for (const source of sources) tree = mergeTrees(tree, source.tree, session);
+		}
+		return tree;
+	};
+	return assemble(session, evaluate(merged(plan.base), file, session), plan.variants.map((v) => {
+		const input = new Map(plan.base).set(v.modifier, v.context);
+		return {
+			modifier: v.modifier,
+			mode: v.mode,
+			label: `${v.modifier}: ${v.context}`,
+			outcomes: evaluate(merged(input), file, session)
+		};
+	}));
+}
+/** Resolver §6.2: a later source replaces a token whole and merges groups. */
+function mergeTrees(base, over, session) {
+	const out = { ...base };
+	for (const [name, child] of Object.entries(over)) {
+		const prev = out[name];
+		out[name] = !name.startsWith("$") && isGroup(prev) && isGroup(child) ? mergeTrees(prev, child, session) : child;
+	}
+	const origin = session.origin.get(over) ?? session.origin.get(base);
+	if (origin !== void 0) session.origin.set(out, origin);
+	return out;
+}
+function parseResolver(doc, file, dir, session) {
+	const fail = (at, message, hint) => configError(file, at, message, hint);
+	for (const key of Object.keys(doc)) if (!ROOT_KEYS.has(key)) throw fail("", `unknown resolver property \`${key}\``);
+	if (doc.version !== "2025.10") throw fail("version", `expected "2025.10", got ${describe(doc.version)}`);
+	for (const key of ["sets", "modifiers"]) if (doc[key] !== void 0 && !isPlainObject(doc[key])) throw fail(key, "expected an object");
+	const sets = doc.sets ?? {};
+	const modifiers = doc.modifiers ?? {};
+	const order = doc.resolutionOrder;
+	if (!Array.isArray(order) || order.length === 0) throw fail("resolutionOrder", "expected a non-empty array of sets and modifiers");
+	const baseDir = () => dir ?? process.cwd();
+	const checkKeys = (def, allowed, at) => {
+		for (const key of Object.keys(def)) if (!allowed.has(key)) throw fail(at, `unknown property \`${key}\``);
+	};
+	/** Token sources of a set or a modifier context, with `#/sets/…` expanded in place. */
+	const sources = (list, at, setStack) => {
+		if (!Array.isArray(list)) throw fail(at, "expected an array of token sources");
+		return list.flatMap((source, i) => {
+			const here = `${at}[${i}]`;
+			if (!isPlainObject(source)) throw fail(here, "expected a { $ref } or inline tokens");
+			if (!Object.hasOwn(source, "$ref")) {
+				session.claim(source, file);
+				return [{ tree: source }];
+			}
+			const { $ref: ref, ...overrides } = source;
+			if (typeof ref !== "string") throw fail(here, "$ref must be a string");
+			if (ref.startsWith("#/modifiers/") || ref === "#/modifiers") throw fail(here, `\`${ref}\`: sets and modifiers cannot reference a modifier`);
+			if (ref.startsWith("#/resolutionOrder")) throw fail(here, `\`${ref}\`: nothing can reference resolutionOrder items`);
+			const set = /^#\/sets\/([^/]+)$/.exec(ref);
+			if (set) {
+				const name = decodePointer(`#/${set[1]}`)?.[0] ?? set[1];
+				if (setStack.includes(name)) throw fail(here, `circular set reference: ${[...setStack, name].join(" → ")}`);
+				const def = sets[name];
+				if (!isPlainObject(def)) throw fail(here, `\`${ref}\` names no set`);
+				const merged = {
+					...def,
+					...overrides
+				};
+				checkKeys(merged, SET_KEYS, `sets.${name}`);
+				return sources(merged.sources, `sets.${name}.sources`, [...setStack, name]);
+			}
+			let tree;
+			let origin = file;
+			if (ref.startsWith("#")) {
+				const segments = decodePointer(ref);
+				tree = segments && navigate(doc, segments);
+			} else {
+				if (/^[A-Za-z][A-Za-z0-9+.-]+:/.test(ref) && !ref.startsWith("file:")) throw fail(here, `\`${ref}\`: only local files can be referenced`);
+				const { path, url } = nodeApi();
+				const hash = ref.indexOf("#");
+				const target = hash === -1 ? ref : ref.slice(0, hash);
+				const abs = target.startsWith("file:") ? url.fileURLToPath(target) : path.resolve(baseDir(), decodeUri(target));
+				origin = displayPath(abs);
+				const json = session.read(abs, origin);
+				if (hash === -1) tree = json;
+				else {
+					const fragment = ref.slice(hash);
+					const segments = decodePointer(fragment.startsWith("#/") ? fragment : `#/${fragment.slice(1)}`);
+					tree = segments && navigate(json, segments);
+				}
+			}
+			if (!isPlainObject(tree)) throw fail(here, `\`${ref}\` points to no token object`);
+			if (Object.hasOwn(tree, "resolutionOrder")) throw fail(here, `\`${ref}\` is a resolver document; reference its token files instead`);
+			session.claim(tree, origin);
+			if (Object.keys(overrides).length === 0) return [{ tree }];
+			session.claim(overrides, file);
+			const combined = {
+				...tree,
+				...overrides
+			};
+			session.origin.set(combined, origin);
+			return [{ tree: combined }];
+		});
+	};
+	const modifier = (def, name, at) => {
+		const contexts = def.contexts;
+		if (!isPlainObject(contexts)) throw fail(`${at}.contexts`, "expected an object of contexts");
+		const names = Object.keys(contexts);
+		if (names.length < 2) throw fail(`${at}.contexts`, names.length === 0 ? "a modifier needs contexts" : "a modifier with one context is a set; declare it as one");
+		if (def.default !== void 0 && (typeof def.default !== "string" || !names.includes(def.default))) throw fail(`${at}.default`, `${describe(def.default)} is not one of the contexts: ${names.join(", ")}`);
+		const map = /* @__PURE__ */ new Map();
+		for (const context of names) map.set(context, sources(contexts[context], `${at}.contexts.${context}`, []));
+		return {
+			kind: "modifier",
+			name,
+			at,
+			contexts: map,
+			...typeof def.default === "string" && { default: def.default }
+		};
+	};
+	const items = [];
+	const refs = /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	const inline = /* @__PURE__ */ new Set();
+	for (const [i, raw] of order.entries()) {
+		const at = `resolutionOrder[${i}]`;
+		if (!isPlainObject(raw)) throw fail(at, "expected a { $ref } or an inline set or modifier");
+		let item;
+		if (Object.hasOwn(raw, "$ref")) {
+			const { $ref: ref, ...overrides } = raw;
+			const match = typeof ref === "string" ? /^#\/(sets|modifiers)\/([^/]+)$/.exec(ref) : null;
+			if (!match) throw fail(at, `${describe(ref)}: resolutionOrder references a set ("#/sets/…") or a modifier ("#/modifiers/…")`);
+			const kind = match[1];
+			const name = decodePointer(`#/${match[2]}`)?.[0] ?? match[2];
+			const def = (kind === "sets" ? sets : modifiers)[name];
+			if (!isPlainObject(def)) throw fail(at, `\`${String(ref)}\` names no ${kind.slice(0, -1)}`);
+			const merged = {
+				...def,
+				...overrides
+			};
+			if (kind === "sets") {
+				checkKeys(merged, SET_KEYS, `sets.${name}`);
+				item = {
+					kind: "set",
+					name,
+					at,
+					contexts: /* @__PURE__ */ new Map([["", sources(merged.sources, `sets.${name}.sources`, [name])]])
+				};
+			} else {
+				checkKeys(merged, MODIFIER_KEYS, `modifiers.${name}`);
+				item = modifier(merged, name, `modifiers.${name}`);
+			}
+		} else {
+			const { type, name, ...def } = raw;
+			if (typeof name !== "string" || name === "") throw fail(at, "an inline item needs a name");
+			if (type === "set") {
+				checkKeys(def, SET_KEYS, at);
+				item = {
+					kind: "set",
+					name,
+					at,
+					contexts: /* @__PURE__ */ new Map([["", sources(def.sources, `${at}.sources`, [])]])
+				};
+			} else if (type === "modifier") {
+				checkKeys(def, MODIFIER_KEYS, at);
+				item = modifier(def, name, at);
+			} else throw fail(at, "an inline item needs \"type\": \"set\" or \"modifier\"");
+		}
+		const isRef = Object.hasOwn(raw, "$ref");
+		const ref = `${item.kind}:${item.name}`;
+		if (isRef ? refs.has(ref) || inline.has(item.name) : names.has(item.name)) throw fail(at, `\`${item.name}\` appears twice in resolutionOrder`);
+		if (isRef) refs.add(ref);
+		else inline.add(item.name);
+		names.add(item.name);
+		items.push(item);
+	}
+	return items;
+}
+/** References are URI references (`my%20tokens.json`), but a literal `%` must not throw. */
+function decodeUri(ref) {
+	try {
+		return decodeURIComponent(ref);
+	} catch {
+		return ref;
+	}
+}
+function navigate(doc, segments) {
+	let node = doc;
+	for (const name of segments) if (Array.isArray(node) && INDEX.test(name)) node = node[Number(name)];
+	else if (isPlainObject(node) && Object.hasOwn(node, name)) node = node[name];
+	else return void 0;
+	return node;
+}
+/**
+* One permutation per non-base context, every other modifier at its base:
+* vicss modes are independent conditions, so combinations of contexts (dark
+* and high contrast at once) have no slot of their own.
+*/
+function planModes(items, file, options) {
+	const base = /* @__PURE__ */ new Map();
+	const variants = [];
+	const owners = /* @__PURE__ */ new Map();
+	const modifiers = items.filter((item) => item.kind === "modifier");
+	for (const [name, map] of options.modes) {
+		const item = modifiers.find((m) => m.name === name);
+		if (!item) throw configError(file, `options.modes.${name}`, "names no modifier", `Modifiers: ${modifiers.map((m) => m.name).join(", ") || "none"}.`);
+		for (const context of map.keys()) if (!item.contexts.has(context)) throw configError(file, `options.modes.${name}.${context}`, "names no context", `Contexts: ${[...item.contexts.keys()].join(", ")}.`);
+	}
+	for (const item of modifiers) {
+		const explicit = options.modes.get(item.name) ?? /* @__PURE__ */ new Map();
+		const contexts = [...item.contexts.keys()];
+		const named = contexts.filter((c) => explicit.get(c) === "base");
+		if (named.length > 1) throw configError(file, `options.modes.${item.name}`, `maps ${named.join(" and ")} to "base"; one context holds the base values`);
+		const baseContext = named[0] ?? item.default ?? contexts[0];
+		if (explicit.has(baseContext) && explicit.get(baseContext) !== "base") throw configError(file, `options.modes.${item.name}`, "maps no context to \"base\"", `Map the context that holds the unconditioned values: { ${item.name}: { ${baseContext}: "base" } }.`);
+		base.set(item.name, baseContext);
+		for (const context of contexts) {
+			if (context === baseContext) continue;
+			const mode = explicit.has(context) ? explicit.get(context) : modeName(context);
+			if (mode === false) continue;
+			const owner = `${item.name}: ${context}`;
+			const prev = owners.get(mode);
+			if (prev) throw configError(file, `options.modes.${item.name}.${context}`, `mode \`${mode}\` is already the mode of ${prev}`);
+			owners.set(mode, owner);
+			variants.push({
+				modifier: item.name,
+				context,
+				mode
+			});
+		}
+	}
+	return {
+		base,
+		variants
+	};
+}
+/** `high-contrast` → `highContrast`, `Dark` → `dark`. */
+function modeName(context) {
+	const name = context.split(/[^A-Za-z0-9]+/).filter(Boolean).map((w, i) => i === 0 ? w[0].toLowerCase() + w.slice(1) : w[0].toUpperCase() + w.slice(1)).join("");
+	if (!/^[A-Za-z][A-Za-z0-9]*$/.test(name)) throw new VicssError("CONFIG", `dtcg(): context \`${context}\` makes no mode name`, { hint: "Name its mode with options.modes, or leave it out with false." });
+	return BUILT_IN_MODES.has(name.toLowerCase()) ? name.toLowerCase() : name;
+}
+//#endregion
+//#region src/config/index.ts
+/**
+* `@menapo/vicss/config`: what a `vicss.config.ts` imports (PLAN §5.1). The
+* presets are data and `dtcg()` is a reader; neither imports the compiler
+* (only its error class, the token-tree checks and the CSS value check), so
+* loading a config stays cheap and works where there is no file system until
+* `dtcg()` reads a file.
+*/
+function defineConfig(config, derive) {
+	if (derive === void 0) return config;
+	if (typeof derive !== "function") throw configError$1("defineConfig", "the second argument is a function of the tokens: ({ colors }) => ({ semanticTokens: … })");
+	const derived = derive(tokenRefs(config));
+	if (!isPlainObject$1(derived)) throw configError$1("defineConfig", "the second argument must return a config object");
+	for (const key of BASE_ONLY) if (Object.hasOwn(derived, key)) throw configError$1(key, "belongs in defineConfig's first argument, not in its callback's result", { hint: "The callback's tokens are those of the first argument and its presets." });
+	return {
+		...config,
+		...settle(derived, "config")
+	};
+}
+/**
+* Types a design system shared as a preset: `presets: [myPreset]`. Its token
+* names stay in its type, for the callback of `defineConfig`.
+*/
+function definePreset(preset) {
+	return preset;
+}
+//#endregion
+export { defineConfig, definePreset, dtcg, reset, shorthands, tailwind };