@menapo/vicss 0.0.0-stage → 1.1.0

package/dist/types-file-D6Iu4kzv.js

@@ -0,0 +1,2481 @@
+import { $ as isPaletteAtom, A as PROPERTIES, C as globToRegExp, J as placeholdersIn, P as scaleNumberKind, Q as isAnyPalette, T as checkAtoms, W as isRelating, _t as VicssError, at as SCALE_NAMESPACES, bt as compareStrings, et as keepAtom, ft as isScaleName, ht as scaleTokens, it as SCALES, lt as cssVarName, nt as paletteTarget, ot as SPACING_STEP, pt as lookupToken, tt as paletteKeyOf, x as hasPrivateAccess, y as FLAG_RESETS, z as markerStates } from "./print-B_mn7wBu.js";
+import { _ as isSfc, h as extractScripts, n as WorkerLost, u as resolvesAlike, x as SourceEdits } from "./pool-F3qb30Fy.js";
+import { d as baseRule, f as checkBases, l as responsiveConditions, n as compileTheme, u as baseAtoms } from "./theme-zBcr5DHi.js";
+import { t as SNAPSHOT_FILE } from "./snapshot-DAJ8FLU4.js";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
+import { glob, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { gzipSync } from "node:zlib";
+import { createFilter, normalizePath } from "vite";
+import { createHash } from "node:crypto";
+//#region src/core/frame.ts
+/**
+* Code frames for diagnostics (PLAN §5.4, §5.14): the line an error points
+* at, with the line before and after it, and a caret under the column.
+* Three lines keep a frame readable in a terminal that lists every error
+* of a project (`vicss check`) as well as in Vite's overlay.
+*/
+/**
+* `line` is 1-based and `column` 0-based, as in `SourceLocation`. Lines end
+* at `\n`, as `createLocator` counts them; a trailing `\r` is not shown.
+* Undefined when `line` is outside `code`.
+*/
+function codeFrame(code, line, column) {
+	const lines = code.split("\n").map((text) => text.replace(/\r$/, ""));
+	const target = lines[line - 1];
+	if (target === void 0) return void 0;
+	const first = Math.max(1, line - 1);
+	const last = Math.min(lines.length, line + 1);
+	const width = String(last).length;
+	const out = [];
+	for (let n = first; n <= last; n++) {
+		const text = lines[n - 1];
+		out.push(`${n === line ? ">" : " "} ${String(n).padStart(width)} |${text ? ` ${text}` : ""}`);
+		if (n === line) {
+			const at = Math.max(0, Math.min(column, target.length));
+			const pad = target.slice(0, at).replace(/[^\t]/g, " ");
+			out.push(`  ${" ".repeat(width)} | ${pad}^`);
+		}
+	}
+	return out.join("\n");
+}
+/**
+* The manifest of a library's styles, compiled with the library's own
+* system; `classes` maps each identity its code names to the class it ships.
+*/
+function createManifest(input, system, pkg, classes = {}) {
+	const tokens = /* @__PURE__ */ new Map();
+	const use = (refs) => {
+		for (const ref of refs) tokens.set(refKey(ref), {
+			scale: ref.scale,
+			path: ref.path
+		});
+	};
+	const conditions = /* @__PURE__ */ new Set();
+	const scales = /* @__PURE__ */ new Set();
+	const palettes = /* @__PURE__ */ new Set();
+	const toManifest = (atom) => {
+		use(atom.tokens);
+		for (const name of atom.chain) conditions.add(name);
+		if (isPaletteAtom(atom) && !isAnyPalette(atom)) palettes.add(atom.value);
+		const { variable, scales: named } = atom;
+		for (const scale of named ?? []) scales.add(scale);
+		return {
+			className: atom.className,
+			key: atom.key,
+			tier: atom.tier,
+			chain: [...atom.chain],
+			property: atom.property,
+			value: toPlaceholders(atom.value, atom.tokens, system),
+			tokens: atom.tokens.map(plainRef),
+			...typeof variable === "string" ? { variable } : {},
+			...named && named.length > 0 ? { scales: [...named] } : {},
+			...isAnyPalette(atom) ? { anyPalette: true } : {},
+			...atom.systemTokens ? { systemTokens: atom.systemTokens.map(plainRef) } : {}
+		};
+	};
+	const atoms = [...input.atoms].sort((a, b) => compareStrings(a.className, b.className)).map(toManifest);
+	const rules = [...input.rules].sort((a, b) => compareStrings(a.id, b.id)).map((rule) => {
+		use(rule.tokens);
+		if (rule.kind === "base") return {
+			id: rule.id,
+			kind: "base",
+			atoms: (rule.atoms ?? []).map(toManifest),
+			tokens: rule.tokens.map(plainRef)
+		};
+		if (rule.kind === "keyframes") return {
+			id: rule.id,
+			kind: "keyframes",
+			css: toPlaceholders(rule.css, rule.tokens, system),
+			tokens: rule.tokens.map(plainRef)
+		};
+		if (rule.overrides === void 0) throw new VicssError("BAD_MANIFEST", `the theme ${rule.id} carries no overrides to write into the manifest`);
+		return {
+			id: rule.id,
+			kind: "theme",
+			overrides: rule.overrides,
+			tokens: rule.tokens.map(plainRef)
+		};
+	});
+	use(input.tokens);
+	return {
+		format: 4,
+		package: pkg,
+		cssVarPrefix: system.cssVarPrefix,
+		atoms,
+		rules,
+		tokens: [...tokens.entries()].sort(([a], [b]) => compareStrings(a, b)).map(([, ref]) => ref),
+		scales: [...scales].sort(compareStrings),
+		conditions: [...conditions].sort(compareStrings),
+		palettes: [...palettes].sort(compareStrings),
+		classes: Object.fromEntries(Object.entries(classes).sort(([a], [b]) => compareStrings(a, b)))
+	};
+}
+/**
+* The library's styles for the app's system. Every token, condition and
+* palette the library uses must exist in the app, and its styles may name
+* none of the app's private tokens: a breach is an error that names the
+* library and everything at fault.
+*/
+function applyManifest(manifest, system, library, options = {}) {
+	const missingTokens = manifest.tokens.filter((ref) => !lookupToken(system, ref.scale, ref.path)).map((ref) => `${ref.scale}.${ref.path}`);
+	const keys = manifest.tokens.filter((ref) => ref.scale === "colors" && lookupToken(system, ref.scale, ref.path)?.palette).map((ref) => paletteKeyOf(ref.path));
+	const groups = system.palettes?.groups;
+	const missingPalettes = manifest.palettes.filter((name) => !groups?.has(name));
+	const open = manifest.atoms.filter((atom) => atom.anyPalette);
+	if (!groups && open.length > 0 && missingPalettes.length === 0) missingPalettes.push("(any, chosen at runtime)");
+	if (system.palettes) {
+		const selected = open.length > 0 ? groups.keys() : manifest.palettes;
+		for (const name of /* @__PURE__ */ new Set([system.palettes.default, ...selected])) {
+			const has = groups.get(name);
+			if (!has) continue;
+			for (const key of keys) if (!has.has(key)) missingTokens.push(`colors.${paletteTarget(name, key)}`);
+		}
+	}
+	const styles = [...manifest.atoms, ...manifest.rules.flatMap((rule) => rule.kind === "base" ? rule.atoms : [])];
+	const ruled = /* @__PURE__ */ new Set([...manifest.rules.flatMap((rule) => rule.kind === "base" ? [] : rule.tokens.map(refKey)), ...styles.flatMap((atom) => (atom.systemTokens ?? []).map(refKey))]);
+	const atomic = new Set(styles.flatMap((atom) => {
+		const written = new Set((atom.systemTokens ?? []).map(refKey));
+		return atom.tokens.map(refKey).filter((key) => !written.has(key));
+	}));
+	const hidden = options.privateAccess ? [] : manifest.tokens.filter((ref) => atomic.has(refKey(ref)) || !ruled.has(refKey(ref))).filter((ref) => lookupToken(system, ref.scale, ref.path)?.private).map((ref) => `${ref.scale}.${ref.path}`);
+	const missingConditions = manifest.conditions.filter((name) => !system.conditions.has(name)).map((name) => `_${name}`);
+	const missingScales = manifest.scales.filter((scale) => scaleTokens(system, scale).length === 0);
+	if (missingTokens.length > 0 || missingConditions.length > 0 || missingScales.length > 0 || missingPalettes.length > 0) {
+		const parts = [
+			missingTokens.length > 0 ? `tokens ${[...new Set(missingTokens)].join(", ")}` : "",
+			missingScales.length > 0 ? `tokens of the scales ${missingScales.join(", ")}` : "",
+			missingConditions.length > 0 ? `conditions ${missingConditions.join(", ")}` : "",
+			missingPalettes.length > 0 ? `palettes ${missingPalettes.join(", ")}` : ""
+		].filter(Boolean);
+		const palette = keys.length > 0 || missingPalettes.length > 0 || missingTokens.some((t) => t.startsWith(`colors.palette`));
+		const any = open.length > 0 && groups ? " Its colorPalette takes any of the app's palettes at runtime: narrow palettes.names to the groups that have them." : "";
+		throw new VicssError("LIBRARY_CONTRACT", `${library} uses ${parts.join(" and ")}, which the app's design system lacks`, { hint: `Add them to vicss.config.ts (the library's preset lists what it uses), or use a version of the library that matches the design system.${palette ? " palette.* keys need palettes (palettes in the config) whose groups have them." : ""}${any}` });
+	}
+	if (hidden.length > 0) throw new VicssError("LIBRARY_CONTRACT", `${library} names ${hidden.join(", ")}, which the app's design system keeps private`, { hint: `A library styles with the app's public tokens. Make these public (tokenVisibility), let the library name them (privateAccess: ["node_modules/${library}/**"]), or use a version of the library built on the semantic tokens.` });
+	const fromManifest = (atom) => {
+		const out = {
+			className: atom.className,
+			key: atom.key,
+			tier: atom.tier,
+			chain: [...atom.chain],
+			property: atom.property,
+			value: fromPlaceholders(atom.value, atom.tokens, system),
+			tokens: atom.tokens
+		};
+		if (atom.variable !== void 0) out.variable = atom.variable;
+		if (atom.scales !== void 0) out.scales = atom.scales;
+		return out;
+	};
+	const atoms = manifest.atoms.filter((atom) => !atom.anyPalette).map(fromManifest);
+	const classes = new Set(atoms.map((atom) => atom.className));
+	for (const atom of open) {
+		const prefix = atom.className.slice(0, -atom.value.length);
+		for (const name of groups?.keys() ?? []) {
+			if (classes.has(prefix + name)) continue;
+			classes.add(prefix + name);
+			atoms.push({
+				className: prefix + name,
+				key: atom.key,
+				tier: atom.tier,
+				chain: [...atom.chain],
+				property: atom.property,
+				value: name,
+				tokens: []
+			});
+		}
+	}
+	atoms.sort((a, b) => compareStrings(a.className, b.className));
+	return {
+		atoms,
+		rules: manifest.rules.map((rule) => {
+			if (rule.kind === "base") return baseRule(rule.id, rule.atoms.map(fromManifest), system);
+			if (rule.kind === "keyframes") return {
+				id: rule.id,
+				kind: "keyframes",
+				css: fromPlaceholders(rule.css, rule.tokens, system),
+				tokens: rule.tokens
+			};
+			let compiled;
+			try {
+				compiled = compileTheme(rule.overrides, system);
+			} catch (error) {
+				if (!(error instanceof VicssError)) throw error;
+				throw new VicssError(error.code, `${library}: the theme ${rule.id}: ${error.message}`, error.hint === void 0 ? {} : { hint: error.hint });
+			}
+			return {
+				...compiled,
+				id: rule.id,
+				css: compiled.css.replaceAll(compiled.id, rule.id)
+			};
+		}),
+		tokens: manifest.tokens,
+		classes: manifest.classes
+	};
+}
+function customPropertyRenames(manifest, system) {
+	const from = manifest.cssVarPrefix;
+	if (from === system.cssVarPrefix) return void 0;
+	const exact = /* @__PURE__ */ new Map();
+	for (const ref of manifest.tokens) {
+		const token = lookupToken(system, ref.scale, ref.path);
+		if (token) exact.set(`var(${cssVarName(from, ref.scale, ref.path)})`, `var(${token.cssVar})`);
+	}
+	return {
+		exact,
+		prefixes: new Map(manifest.scales.map((scale) => [`var(--${from}${SCALE_NAMESPACES[scale]}-`, `var(--${system.cssVarPrefix}${SCALE_NAMESPACES[scale]}-`]))
+	};
+}
+/**
+* A manifest read from disk, checked field by field: anything unexpected is
+* an error naming the library, rather than CSS printed from half a file.
+*/
+function parseManifest(data, library) {
+	const fail = (why) => {
+		throw new VicssError("BAD_MANIFEST", `${library}'s vicss manifest is not valid: ${why}`, { hint: "Build the library again with the same version of @menapo/vicss as the app." });
+	};
+	if (!isRecord$1(data)) return fail("expected an object");
+	if (data.format !== 4) return fail(`format ${JSON.stringify(data.format)}, while this vicss reads format 4`);
+	if (typeof data.package !== "string") return fail("`package` is not a string");
+	if (typeof data.cssVarPrefix !== "string") return fail("`cssVarPrefix` is not a string");
+	if (!isScales(data.scales)) return fail("`scales` is not a list of scale names");
+	if (!Array.isArray(data.atoms) || !data.atoms.every(isManifestAtom)) return fail("`atoms` is not a list of atoms");
+	if (!Array.isArray(data.rules) || !data.rules.every(isManifestRule)) return fail("`rules` is not a list of keyframes, themes and flattened bases");
+	if (!isRefs(data.tokens)) return fail("`tokens` is not a list of token references");
+	if (!Array.isArray(data.conditions) || !data.conditions.every((c) => typeof c === "string")) return fail("`conditions` is not a list of names");
+	if (!Array.isArray(data.palettes) || !data.palettes.every((p) => typeof p === "string")) return fail("`palettes` is not a list of names");
+	if (!isRecord$1(data.classes) || !Object.values(data.classes).every((c) => typeof c === "string")) return fail("`classes` is not an object of class names");
+	return data;
+}
+/** `var(--color-accent)` → `{colors.accent}` for each token `refs` names. */
+function toPlaceholders(text, refs, system) {
+	let out = text;
+	for (const ref of refs) {
+		const token = lookupToken(system, ref.scale, ref.path);
+		if (token) out = out.replaceAll(`var(${token.cssVar})`, `{${ref.scale}.${ref.path}}`);
+	}
+	return out;
+}
+/** `{colors.accent}` → the app's `var(--…)` for each token `refs` names; other braces stay. */
+function fromPlaceholders(text, refs, system) {
+	let out = text;
+	for (const ref of refs) {
+		const token = lookupToken(system, ref.scale, ref.path);
+		out = out.replaceAll(`{${ref.scale}.${ref.path}}`, `var(${token.cssVar})`);
+	}
+	return out;
+}
+const refKey = (ref) => `${ref.scale}:${ref.path}`;
+const plainRef = (ref) => ({
+	scale: ref.scale,
+	path: ref.path
+});
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRefs(value) {
+	return Array.isArray(value) && value.every((ref) => isRecord$1(ref) && typeof ref.scale === "string" && isScaleName(ref.scale) && typeof ref.path === "string");
+}
+function isScales(value) {
+	return Array.isArray(value) && value.every((scale) => typeof scale === "string" && isScaleName(scale));
+}
+function isManifestAtom(value) {
+	return isRecord$1(value) && typeof value.className === "string" && typeof value.key === "string" && typeof value.tier === "number" && Array.isArray(value.chain) && value.chain.every((name) => typeof name === "string") && typeof value.property === "string" && typeof value.value === "string" && isRefs(value.tokens) && (value.variable === void 0 || typeof value.variable === "string") && (value.scales === void 0 || isScales(value.scales)) && (value.anyPalette === void 0 || value.anyPalette === true) && (value.systemTokens === void 0 || isRefs(value.systemTokens));
+}
+function isManifestRule(value) {
+	if (!isRecord$1(value) || typeof value.id !== "string" || !isRefs(value.tokens)) return false;
+	if (value.kind === "keyframes") return typeof value.css === "string";
+	if (value.kind === "base") return Array.isArray(value.atoms) && value.atoms.every(isManifestAtom);
+	return value.kind === "theme" && value.overrides !== void 0;
+}
+//#endregion
+//#region src/core/types-gen.ts
+/**
+* The generated `vicss.d.ts` (PLAN §5.11, D7): the design system as flat
+* literal unions that augment `Register` in `@menapo/vicss`, so style objects
+* type-check against the project's tokens, conditions, text styles,
+* utilities and strictness, recipes' responsive props against the
+* breakpoints and containers, markers against the states the config
+* gives an element, and `sx()`'s result against the project's framework
+* (§5.12). One union per scale and no derived types keep the checker's
+* work proportional to the tokens a file uses.
+*/
+/** The line width the members of a union are wrapped at, as a formatter would. */
+const WIDTH = 100;
+/** The declaration text of `vicss.d.ts` for `system`. */
+function generateTypes(system, options = {}) {
+	const tokens = SCALES.map((scale) => {
+		const paths = [...system.tokens.get(scale)?.values() ?? []].filter((token) => !token.private).map((token) => token.path).filter((path) => !(scale === "spacing" && path === "step")).sort(compareStrings);
+		const members = paths.map((path) => JSON.stringify(path));
+		members.push(...paths.filter((path) => Number.isFinite(Number(path)) && String(Number(path)) === path));
+		if (scale === "spacing" && system.spacingStep !== void 0) members.unshift("number");
+		return union(`${scale}:`, members, "      ");
+	});
+	const conditions = [...system.conditions.keys()].sort(compareStrings).map((name) => JSON.stringify(`_${name}`));
+	const textStyles = [...system.textStyles.keys()].sort(compareStrings).map((name) => JSON.stringify(name));
+	const utilities = [...system.utilities].sort(([a], [b]) => compareStrings(a, b)).map(([name, def]) => {
+		return `      ${name}: ${def.boolean ? "boolean" : def.scale ? JSON.stringify(def.scale) : "unknown"};`;
+	});
+	const setLines = [...setters$1(system)].sort(([a], [b]) => compareStrings(a, b)).map(([name, set]) => {
+		const members = set.has("*") ? ["string"] : [...set].sort(compareStrings).map((property) => JSON.stringify(property));
+		return union(`${name}:`, members, "      ");
+	});
+	const names = [...[...PROPERTIES.values()].map((info) => [info.name, info.scale]), ...[...system.utilities].map(([name, def]) => [name, def.scale])];
+	const strict = SCALES.map((scale) => {
+		const level = system.strictness(scale);
+		const open = names.some(([name, of]) => of === scale && system.strictness(scale, name) !== "tokens");
+		return `      ${scale}: ${JSON.stringify(level === "tokens" && open ? "css" : level)};`;
+	});
+	const responsive = responsiveConditions(system).props.map((condition) => JSON.stringify(`_${condition.name}`)).sort(compareStrings);
+	const states = markerStates(system).sort(compareStrings).map((name) => JSON.stringify(name));
+	const palettes = system.palettes ? [union("palettes:", [...system.palettes.groups.keys()].sort(compareStrings).map((n) => JSON.stringify(n)), "    ")] : [];
+	return `${[
+		"// Generated by vicss from the design system in vicss.config.ts. Do not edit:",
+		"// the Vite plugin rewrites it whenever the config loads, and `vicss types` in CI.",
+		"import \"@menapo/vicss\";",
+		"",
+		"declare module \"@menapo/vicss\" {",
+		"  interface Register {",
+		"    tokens: {",
+		...tokens,
+		"    };",
+		union("conditions:", conditions, "    "),
+		union("textStyles:", textStyles, "    "),
+		"    utilities: {",
+		...utilities,
+		"    };",
+		"    sets: {",
+		...setLines,
+		"    };",
+		"    strict: {",
+		...strict,
+		"    };",
+		union("responsive:", responsive, "    "),
+		union("markerStates:", states, "    "),
+		...palettes,
+		...options.framework ? [`    framework: ${JSON.stringify(options.framework)};`] : [],
+		"  }",
+		"}",
+		"",
+		"export {};"
+	].join("\n")}\n`;
+}
+/** `head` and a union of `members` with `;`: one line when it fits, else one member per line. */
+function union(head, members, indent) {
+	if (members.length === 0) return `${indent}${head} never;`;
+	const line = `${indent}${head} ${members.join(" | ")};`;
+	if (line.length <= WIDTH) return line;
+	return `${[`${indent}${head}`, ...members.map((member) => `${indent}  | ${member}`)].join("\n")};`;
+}
+/**
+* The style keys each utility and `textStyle` set, which `Style<K>` records
+* in their place (`p` sets `padding`), so `Style<"margin">` takes `css({ m: 4 })`.
+* A utility's transform is a function of its value: it runs here on sample
+* values (a token of its scale, a number, a flag), and what any of them sets
+* counts. `"*"` stands for a utility none of them could run: any property.
+*/
+function setters$1(system) {
+	const out = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	const keysOf = (style, into) => {
+		if (typeof style !== "object" || style === null) return;
+		for (const [key, value] of Object.entries(style)) {
+			if (key.startsWith("_") || key.startsWith("__vx:")) {
+				if (system.conditions.has(key.slice(1)) || key.startsWith("__vx:")) keysOf(value, into);
+				continue;
+			}
+			const nested = key === "textStyle" || system.utilities.has(key) ? setOf(key) : void 0;
+			for (const property of nested ?? [key]) into.add(property);
+		}
+	};
+	const setOf = (name) => {
+		const known = out.get(name);
+		if (known) return known;
+		if (visiting.has(name)) return /* @__PURE__ */ new Set();
+		visiting.add(name);
+		const set = /* @__PURE__ */ new Set();
+		if (name === "textStyle") for (const style of system.textStyles.values()) keysOf(style, set);
+		else {
+			const def = system.utilities.get(name);
+			let ran = false;
+			for (const sample of samples(system, def)) try {
+				keysOf(def.transform(sample), set);
+				ran = true;
+			} catch {}
+			keysOf(FLAG_RESETS.get(def), set);
+			if (!ran) set.add("*");
+		}
+		visiting.delete(name);
+		out.set(name, set);
+		return set;
+	};
+	for (const name of system.utilities.keys()) setOf(name);
+	setOf("textStyle");
+	return out;
+}
+function samples(system, def) {
+	if (def.boolean) return [true, false];
+	if (!def.scale) return [
+		"auto",
+		1,
+		true
+	];
+	const token = [...system.tokens.get(def.scale)?.keys() ?? []].find((path) => path !== SPACING_STEP);
+	const number = scaleNumberKind(def.scale) === void 0 ? [] : [1];
+	return [
+		...token === void 0 ? [] : [token],
+		...number,
+		"auto"
+	];
+}
+/**
+* The installed vicss's version is part of every key: an upgrade can compile
+* the same input to other atoms without anyone bumping FORMAT_VERSION.
+*/
+const VERSION = (() => {
+	try {
+		return createRequire(import.meta.url)("@menapo/vicss/package.json").version;
+	} catch {
+		return "";
+	}
+})();
+function toOutput(result) {
+	const { changed, code, map, warnings } = result;
+	return {
+		code: changed ? code : null,
+		map: map && {
+			names: map.names,
+			mappings: map.mappings
+		},
+		warnings
+	};
+}
+/**
+* The compile result an entry stands for, for the module `id` whose code is
+* `code`; without `own`, which only dev's check of framework files reads.
+*/
+function compiledOf(entry, id, code) {
+	const { output } = entry;
+	const names = entry.classes.filter((cls) => cls.startsWith("!")).map((cls) => cls.slice(1));
+	return {
+		code: output.code ?? code,
+		map: output.map && {
+			version: 3,
+			file: id,
+			sources: [id],
+			sourcesContent: [code],
+			...output.map
+		},
+		atoms: [...entry.atoms],
+		tokens: [...entry.tokens],
+		rules: [...entry.rules],
+		arbitrary: entry.arbitrary,
+		...names.length > 0 && { names },
+		dependencies: Object.keys(entry.deps),
+		changed: output.code !== null,
+		resolutions: entry.resolutions,
+		warnings: output.warnings
+	};
+}
+function hashCode(code) {
+	return createHash("sha1").update(code).digest("base64url");
+}
+var CompileCache = class {
+	#entries = /* @__PURE__ */ new Map();
+	/** `configHash` covers the design system and the files that define it. */
+	key(code, configHash) {
+		return `${hashCode(code)}:${configHash}:14:${VERSION}`;
+	}
+	/**
+	* The entry for `id` if it is still valid. `depHash` reads a dependency's
+	* current hash (undefined when it is gone) and `resolve` what an import
+	* resolves to now; a scan memoises both, since a design system's modules
+	* are dependencies of most files.
+	*/
+	async lookup(id, key, depHash, resolve) {
+		const entry = this.#entries.get(id);
+		if (entry?.key !== key) return void 0;
+		for (const [dep, hash] of Object.entries(entry.deps)) if (await depHash(dep) !== hash) return void 0;
+		return await resolvesAlike(entry.resolutions, resolve) ? entry : void 0;
+	}
+	set(id, entry) {
+		this.#entries.set(id, entry);
+	}
+	clear() {
+		this.#entries.clear();
+	}
+	/**
+	* Reads `<cacheDir>/vicss/scan.json`. Paths are stored relative to the root,
+	* so a project that moves keeps its cache. Anything unexpected — a missing,
+	* corrupt or foreign file — leaves the cache as it is.
+	*/
+	async read(file, root) {
+		let data;
+		try {
+			data = JSON.parse(await readFile(file, "utf8"));
+		} catch {
+			return;
+		}
+		if (!isRecord(data) || data.format !== 14 || !isRecord(data.entries)) return;
+		const table = data.atoms;
+		const rules = data.rules;
+		if (!Array.isArray(table) || !table.every(isAtom)) return;
+		if (!Array.isArray(rules) || !rules.every(isRule)) return;
+		for (const [rel, entry] of Object.entries(data.entries)) {
+			if (!isStored(entry, table.length, rules.length)) continue;
+			const deps = {};
+			for (const [dep, hash] of Object.entries(entry.deps)) deps[absolute(root, dep)] = hash;
+			const resolutions = mapResolutions(entry.resolutions, (p) => absolute(root, p));
+			this.#entries.set(absolute(root, rel), {
+				...entry,
+				deps,
+				resolutions,
+				atoms: entry.atoms.map((index) => table[index]),
+				rules: entry.rules.map((index) => rules[index])
+			});
+		}
+	}
+	/**
+	* Writes the entries of `ids` (one scan's files), so deleted files drop out.
+	* Most atoms are shared by many files, and a theme by every module that
+	* applies it: each is written once, in a table the entries index, which
+	* keeps the file a fraction of their size.
+	*/
+	async write(file, root, ids) {
+		const atoms = interner();
+		const rules = interner();
+		const entries = {};
+		for (const id of ids) {
+			const entry = this.#entries.get(id);
+			if (!entry) continue;
+			const deps = {};
+			for (const [dep, hash] of Object.entries(entry.deps)) deps[relative(root, dep)] = hash;
+			const resolutions = mapResolutions(entry.resolutions, (p) => relative(root, p));
+			entries[relative(root, id)] = {
+				...entry,
+				deps,
+				resolutions,
+				atoms: entry.atoms.map(atoms.intern),
+				rules: entry.rules.map(rules.intern)
+			};
+		}
+		await mkdir(path.dirname(file), { recursive: true });
+		const temp = `${file}.${process.pid}.tmp`;
+		const data = {
+			format: 14,
+			atoms: atoms.table,
+			rules: rules.table,
+			entries
+		};
+		await writeFile(temp, JSON.stringify(data));
+		await rename(temp, file);
+	}
+};
+/**
+* A table of values and their indices. By content, not by class name or id:
+* an entry left from another config can hold an atom whose class name is
+* the same and whose value is not.
+*/
+function interner() {
+	const table = [];
+	const indices = /* @__PURE__ */ new Map();
+	const intern = (value) => {
+		const json = JSON.stringify(value);
+		let index = indices.get(json);
+		if (index === void 0) indices.set(json, index = table.push(value) - 1);
+		return index;
+	};
+	return {
+		table,
+		intern
+	};
+}
+/** A dependency's current hash, or undefined when it cannot be read. */
+function readHash(file) {
+	try {
+		return hashCode(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+const relative = (root, id) => path.relative(root, id).split(path.sep).join("/");
+const absolute = (root, rel) => path.resolve(root, rel).split(path.sep).join("/");
+/** Rewrites the paths of `importer\0source` → file; the specifier and "" stay. */
+function mapResolutions(resolutions, map) {
+	const out = {};
+	for (const [request, file] of Object.entries(resolutions)) {
+		const at = request.indexOf("\0");
+		out[`${map(request.slice(0, at))}${request.slice(at)}`] = file && map(file);
+	}
+	return out;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const isIndices = (value, length) => Array.isArray(value) && value.every((index) => Number.isInteger(index) && index >= 0 && index < length);
+const isTokenRefs = (value) => Array.isArray(value) && value.every((ref) => isRecord(ref) && typeof ref.scale === "string" && typeof ref.path === "string");
+function isStored(value, atoms, rules) {
+	return isRecord(value) && typeof value.key === "string" && isRecord(value.deps) && Object.values(value.deps).every((hash) => typeof hash === "string") && isRecord(value.resolutions) && Object.entries(value.resolutions).every(([request, file]) => request.includes("\0") && typeof file === "string") && isIndices(value.atoms, atoms) && isIndices(value.rules, rules) && isTokenRefs(value.tokens) && typeof value.arbitrary === "number" && isStrings(value.classes) && isOutput(value.output);
+}
+function isOutput(value) {
+	if (!isRecord(value)) return false;
+	const { code, map, warnings } = value;
+	return (code === null || typeof code === "string") && (map === null || isRecord(map) && isStrings(map.names) && typeof map.mappings === "string") && isStrings(warnings);
+}
+const isStrings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function isAtom(value) {
+	return isRecord(value) && typeof value.className === "string" && typeof value.key === "string" && typeof value.tier === "number" && Array.isArray(value.chain) && typeof value.property === "string" && typeof value.value === "string" && Array.isArray(value.tokens);
+}
+function isRule(value) {
+	return isRecord(value) && typeof value.id === "string" && (value.kind === "keyframes" || value.kind === "theme" || value.kind === "base" && Array.isArray(value.atoms) && value.atoms.every(isAtom)) && typeof value.css === "string" && isTokenRefs(value.tokens);
+}
+//#endregion
+//#region src/vite/critical.ts
+/**
+* Critical CSS for prerendered pages (PLAN D16, §5.10). Each stylesheet of a
+* page that holds vicss's CSS becomes an inline `<style>` in its place,
+* holding what the page's markup can use, and the stylesheet itself loads
+* from the end of `<body>` (its link stays, disabled, where a framework
+* hydrating the document expects it). A parser-created stylesheet in the
+* body does not block the rendering of what precedes it, so the page paints
+* with the inline CSS and the full sheet applies when it arrives, with no
+* inline script: an `onload` handler would need `'unsafe-inline'` under a
+* strict CSP.
+*
+* It works on built files only, the CSS Vite wrote (minified, its `url()`s
+* resolved) and the page's HTML, so the build hook and `vicss critical`
+* behave alike and need neither the config nor a scan. Class names are
+* deterministic, so a page's atoms are the rules whose selectors need only
+* classes its markup has. The inline CSS is the file with rules removed, in
+* the same layers and order, so the full sheet's copies, arriving later,
+* change no computed style (report 06 §3.2).
+*/
+const DEFAULT_BUDGET = 14e3;
+const DEFAULT_HASHES_FILE = "vicss-critical.json";
+/** The plugin's `critical` option, checked: what the build hook needs, or undefined when off. */
+function criticalSettings(option) {
+	if (option === void 0 || option === false) return void 0;
+	const fail = (what) => {
+		throw new Error(`vicss: critical ${what}; use "prerendered" or { budget, hashes }`);
+	};
+	if (option === "prerendered") return {
+		budget: DEFAULT_BUDGET,
+		hashes: DEFAULT_HASHES_FILE
+	};
+	if (typeof option !== "object" || option === null || Array.isArray(option)) return fail(`must be "prerendered" or an object, not ${JSON.stringify(option)}`);
+	const { budget, hashes, ...rest } = option;
+	const unknown = Object.keys(rest);
+	if (unknown.length > 0) fail(`has no option ${unknown.join(", ")}`);
+	return {
+		budget: checkBudget(budget, fail),
+		hashes: checkHashes(hashes, fail)
+	};
+}
+function checkBudget(budget, fail) {
+	if (budget === void 0) return DEFAULT_BUDGET;
+	if (typeof budget !== "number" || !Number.isFinite(budget) || budget <= 0) return fail(`budget must be a positive number of gzip bytes, not ${typeof budget === "number" ? String(budget) : JSON.stringify(budget)}`);
+	return budget;
+}
+function checkHashes(hashes, fail) {
+	if (hashes === void 0) return DEFAULT_HASHES_FILE;
+	if (hashes === false) return false;
+	if (typeof hashes !== "string") return fail(`hashes must be a path relative to the output directory, or false`);
+	const problem = hashesProblem(hashes);
+	if (problem !== void 0) fail(`hashes ${problem}`);
+	return path.posix.normalize(hashes.replaceAll("\\", "/"));
+}
+/**
+* What is wrong with `file` as the hashes file, as the plugin's option and
+* `vicss critical --hashes` say it: it must stay inside the output, which
+* is deployed with the pages it describes.
+*/
+function hashesProblem(file) {
+	if (file === "" || path.isAbsolute(file)) return "must be a path relative to the output directory";
+	const normal = path.posix.normalize(file.replaceAll("\\", "/"));
+	if (normal === ".." || normal.startsWith("../")) return "must stay inside the output directory";
+	if (normal === "." || normal.endsWith("/")) return "must name a file inside the output directory";
+}
+/**
+* Inlines the critical CSS of every page under `dir`: the HTML a framework
+* writes after `vite build` (Astro, SvelteKit, Vike, React Router
+* prerendering), which no build hook sees. Pages are rewritten in place,
+* a page processed before is left alone, and the hashes file is written.
+*/
+async function critical(dir, options = {}) {
+	const fail = (what) => {
+		throw new Error(`vicss: critical() ${what}`);
+	};
+	const budget = checkBudget(options.budget, fail);
+	const hashes = checkHashes(options.hashes, fail);
+	const root = path.resolve(dir);
+	if (!existsSync(root)) fail(`found no directory ${root}`);
+	const files = await listOutput(root);
+	const css = files.filter((file) => file.endsWith(".css"));
+	const sources = /* @__PURE__ */ new Map();
+	await Promise.all(css.map(async (file) => sources.set(file, await readFile(path.join(root, file), "utf8"))));
+	const sheets = new SheetCache((file) => sources.get(file));
+	const pages = [];
+	const html = files.filter((file) => file.endsWith(".html"));
+	for (const page of html) {
+		if (options.filter && !options.filter(page)) continue;
+		const result = criticalPage({
+			page,
+			html: await readFile(path.join(root, page), "utf8"),
+			files: css,
+			sheets
+		});
+		pages.push(result);
+		if (result.html !== void 0 && !options.dryRun) await writeFile(path.join(root, page), result.html);
+	}
+	let hashesFile;
+	if (hashes !== false && !options.dryRun && pages.some((page) => page.html !== void 0)) {
+		const file = path.join(root, hashes);
+		const earlier = await readFile(file, "utf8").then(parseHashesFile, () => void 0);
+		const kept = Object.entries(earlier?.pages ?? {}).filter(([page]) => html.includes(page));
+		await mkdir(path.dirname(file), { recursive: true });
+		await writeFile(file, hashesJson(pages, budget, Object.fromEntries(kept)));
+		hashesFile = hashes;
+	}
+	return report(pages, budget, hashesFile);
+}
+/** Every file under `root`, relative to it, sorted; `node_modules` and dot directories skipped. */
+async function listOutput(root) {
+	return (await readdir(root, {
+		recursive: true,
+		withFileTypes: true
+	})).filter((entry) => entry.isFile()).map((entry) => path.relative(root, path.join(entry.parentPath, entry.name)).replaceAll("\\", "/")).filter((file) => !file.split("/").some((part) => part === "node_modules" || part.startsWith("."))).sort();
+}
+function parseHashesFile(text) {
+	try {
+		const value = JSON.parse(text);
+		return value.version === 1 && typeof value.pages === "object" ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* `{ version, budget, pages: { "index.html": { hashes, bytes, gzip } } }`,
+* pages sorted; `earlier` holds the entries of pages an earlier run processed.
+*/
+function hashesJson(pages, budget, earlier = {}) {
+	const entries = { ...earlier };
+	for (const page of pages) if (page.html !== void 0) entries[page.page] = {
+		hashes: [...page.hashes],
+		bytes: page.bytes,
+		gzip: page.gzip
+	};
+	const file = {
+		version: 1,
+		budget,
+		pages: Object.fromEntries(Object.entries(entries).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+	};
+	return `${JSON.stringify(file, null, 2)}\n`;
+}
+const kB = (bytes) => `${(bytes / 1e3).toFixed(2)} kB`;
+const PART_NAMES = {
+	layers: "layer statements",
+	tokens: "tokens",
+	global: "global CSS and reset",
+	atoms: "atoms",
+	fonts: "@font-face",
+	keyframes: "keyframes",
+	other: "CSS bundled with vicss's"
+};
+function report(pages, budget, hashesFile) {
+	const inlined = pages.filter((page) => page.html !== void 0);
+	const warnings = [];
+	for (const page of pages) {
+		if (page.skipped !== void 0 && page.warning) warnings.push(`${page.page}: left render-blocking: ${page.skipped}`);
+		if (page.html !== void 0 && page.gzip > budget) {
+			const parts = Object.entries(page.parts).filter(([, bytes]) => bytes > 0).sort((a, b) => b[1] - a[1]).map(([part, bytes]) => `${PART_NAMES[part]} ${kB(bytes)}`);
+			warnings.push(`${page.page}: its critical CSS is ${kB(page.gzip)} gzip, over the ${kB(budget)} budget (raw: ${parts.join(", ")}). It is inlined all the same: the page still paints without waiting for a stylesheet, but its HTML takes more than the first round trip.`);
+		}
+	}
+	const sizes = inlined.map((page) => page.gzip).sort((a, b) => a - b);
+	const range = sizes.length === 0 ? "" : sizes.length === 1 ? `, ${kB(sizes[0])} gzip` : `, ${kB(sizes[0])}–${kB(sizes.at(-1))} gzip (median ${kB(sizes[Math.floor(sizes.length / 2)])})`;
+	const over = inlined.filter((page) => page.gzip > budget).length;
+	const left = pages.length - inlined.length;
+	const summary = `vicss: critical CSS inlined in ${inlined.length} of ${pages.length} pages${range}` + (over > 0 ? `; ${over} over the ${kB(budget)} budget` : "") + (left > 0 ? `; ${left} left as they were` : "") + (hashesFile ? `; CSP hashes in ${hashesFile}` : "");
+	return {
+		pages,
+		budget,
+		...hashesFile ? { hashesFile } : {},
+		summary,
+		warnings
+	};
+}
+const EMPTY_PARTS = {
+	layers: 0,
+	tokens: 0,
+	global: 0,
+	atoms: 0,
+	fonts: 0,
+	keyframes: 0,
+	other: 0
+};
+/** One page: its critical CSS, or why it keeps its stylesheets as they are. */
+function criticalPage(input) {
+	const { page, html } = input;
+	const left = (skipped, warning = false) => ({
+		page,
+		skipped,
+		...warning ? { warning } : {},
+		hashes: [],
+		bytes: 0,
+		gzip: 0,
+		parts: { ...EMPTY_PARTS },
+		deferred: []
+	});
+	const scan = scanHtml(html);
+	if (scan.processed) return left("it has critical CSS already");
+	const elements = scan.css.map((element) => {
+		if (element.kind === "style") return {
+			element,
+			file: void 0,
+			sheet: void 0
+		};
+		const file = element.href === void 0 ? void 0 : resolveHref(element.href, page, input.files);
+		return {
+			element,
+			file,
+			sheet: file === void 0 ? void 0 : input.sheets.get(file)
+		};
+	});
+	const deferred = elements.filter((entry) => entry.sheet?.vicss === true);
+	if (deferred.length === 0) {
+		const unread = elements.filter((entry) => entry.element.kind === "link" && !entry.sheet);
+		if (scan.css.some((element) => element.kind === "style" && /@layer\s+vicss\.[\w.-]+\s*\{/.test(element.text ?? ""))) return left("its vicss CSS is inline already");
+		return unread.length === 0 ? left("it links no stylesheet holding vicss's CSS") : left(`it links no stylesheet holding vicss's CSS among those found in the output (not found: ${unread.map((entry) => entry.element.href).join(", ")})`, true);
+	}
+	for (const entry of deferred) {
+		const media = entry.element.media?.trim().toLowerCase();
+		if (media !== void 0 && media !== "" && media !== "all") return left(`${entry.file} has media="${entry.element.media}": inline, its rules would apply to every medium. Link it without a media attribute`, true);
+		if (entry.sheet.anonymous) return left(`${entry.file} has an anonymous @layer block: its copy in the full sheet, arriving after the inline one, would be a layer of its own after every other. Give the layer a name`, true);
+		if (entry.sheet.ordered) {
+			const index = elements.indexOf(entry);
+			const later = elements.slice(index + 1).find((other) => !deferred.includes(other));
+			if (later) {
+				const what = later.element.kind === "style" ? "a <style> element" : `the stylesheet ${later.element.href}`;
+				return left(`${entry.file} holds CSS besides vicss's, and ${what} comes after it: moved to the end of <body>, its rules would win over that one's where they lost before. Import that CSS before vicss's sheet, or keep it out of the sheet's chunk`, true);
+			}
+		}
+	}
+	const roots = [...scan.styles];
+	for (const entry of elements) {
+		if (deferred.includes(entry)) continue;
+		if (entry.element.kind === "style") roots.push(entry.element.text ?? "");
+		else if (entry.file !== void 0) {
+			const text = input.sheets.text(entry.file);
+			if (text !== void 0) roots.push(text);
+		}
+	}
+	const plan = planCritical(deferred.map((entry) => entry.sheet), scan.classes, roots);
+	if (input.requireClasses && plan.classRules === 0) return left("no vicss class in its markup: a client-rendered page or a template a server renders into, whose sheet must stay in <head>");
+	const parts = { ...EMPTY_PARTS };
+	const declared = /* @__PURE__ */ new Set();
+	const styles = deferred.map((entry) => {
+		return escapeStyle(rebaseUrls(printSheet(entry.sheet, plan, declared, parts), entry.element.href));
+	});
+	const hashes = styles.map((css) => `sha256-${createHash("sha256").update(css, "utf8").digest("base64")}`);
+	const all = styles.join("");
+	const edits = [];
+	deferred.forEach((entry, i) => {
+		const { start, end } = entry.element;
+		const charset = scan.charset;
+		const between = (from, to) => scan.css.some((element) => element.start >= from && element.start < to);
+		const style = `<style ${MARKER}>${styles[i]}</style>`;
+		const inert = entry.element.tag.replace(/^<link/i, "$& disabled");
+		if (charset && charset.start >= end && !between(end, charset.start)) {
+			edits.push({
+				start: charset.end,
+				end: charset.end,
+				text: style
+			});
+			edits.push({
+				start,
+				end,
+				text: inert
+			});
+		} else edits.push({
+			start,
+			end,
+			text: style + inert
+		});
+	});
+	const end = scan.bodyEnd ?? scan.htmlEnd ?? html.length;
+	const tail = Math.min(scan.trailingScript ?? end, end);
+	edits.push({
+		start: tail,
+		end: tail,
+		text: `${deferred.map((entry) => entry.element.tag).join("\n")}\n`
+	});
+	for (const policy of scan.policies) {
+		const allowed = allowStyles(policy.content, hashes);
+		if (allowed === void 0) continue;
+		const value = allowed.replaceAll("&", "&amp;").replaceAll("\"", "&quot;");
+		const tag = html.slice(policy.start, policy.end).replace(/(\scontent\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s"'>]+)/i, (_, name) => {
+			return `${name}"${value}"`;
+		});
+		edits.push({
+			start: policy.start,
+			end: policy.end,
+			text: tag
+		});
+	}
+	edits.sort((a, b) => a.start - b.start || a.end - b.end);
+	let out = "";
+	let at = 0;
+	for (const edit of edits) {
+		out += html.slice(at, edit.start) + edit.text;
+		at = edit.end;
+	}
+	out += html.slice(at);
+	return {
+		page,
+		html: out,
+		hashes,
+		bytes: Buffer.byteLength(all),
+		gzip: gzipSync(all).length,
+		parts,
+		deferred: deferred.map((entry) => entry.file)
+	};
+}
+/**
+* `policy` with the inline styles' hashes allowed for `<style>` elements, or
+* undefined when it allows them already. They answer to `style-src-elem`,
+* else `style-src`, else `default-src`; this one gets the hashes (a
+* `style-src` copied from `default-src`). `'unsafe-inline'` allows them
+* unless a hash or nonce is listed, and `'none'` is left as it is: it
+* blocks the stylesheets too.
+*/
+function allowStyles(policy, hashes) {
+	const directives = policy.split(";").map((directive) => directive.trim().split(/[\t\n\f\r ]+/)).filter(([name]) => name !== "");
+	const names = directives.map(([name]) => name.toLowerCase());
+	const index = [
+		"style-src-elem",
+		"style-src",
+		"default-src"
+	].map((name) => names.indexOf(name)).find((i) => i !== -1);
+	if (index === void 0) return void 0;
+	const sources = directives[index].slice(1);
+	const lower = sources.map((source) => source.toLowerCase());
+	if (lower.includes("'none'")) return void 0;
+	const keyed = lower.some((source) => /^'(?:sha(?:256|384|512)-|nonce-)/.test(source));
+	if (lower.includes("'unsafe-inline'") && !keyed) return void 0;
+	const added = hashes.map((hash) => `'${hash}'`).filter((hash) => !sources.includes(hash));
+	if (added.length === 0) return void 0;
+	if (names[index] === "default-src") directives.push([
+		"style-src",
+		...sources,
+		...added
+	]);
+	else directives[index].push(...added);
+	return directives.map((directive) => directive.join(" ")).join("; ");
+}
+/** Marks the inline styles, so a page is never processed twice. */
+const MARKER = "data-vicss-critical";
+/**
+* The output file a stylesheet's `href` names. A relative one resolves from
+* the page; an absolute path or URL (a `base`, a CDN) ends with the file's
+* path: the longest that matches wins.
+*/
+function resolveHref(href, page, files) {
+	let target = href.trim().replace(/[?#].*$/s, "");
+	try {
+		target = decodeURI(target);
+	} catch {}
+	if (target === "") return void 0;
+	if (!/^(?:[a-z][a-z\d+.-]*:|\/)/i.test(target)) {
+		const file = path.posix.normalize(path.posix.join(path.posix.dirname(page), target));
+		return files.includes(file) ? file : void 0;
+	}
+	if (/^[a-z][a-z\d+.-]*:/i.test(target) && !/^https?:/i.test(target)) return void 0;
+	const pathname = target.replace(/^[a-z][a-z\d+.-]*:\/\/[^/]*/i, "").replace(/^\/\/[^/]*/, "");
+	let best;
+	for (const file of files) if (pathname === `/${file}` || pathname.endsWith(`/${file}`)) {
+		if (!best || file.length > best.length) best = file;
+	}
+	return best;
+}
+/** Elements whose content is text, not markup. */
+const RAW_TEXT = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"textarea",
+	"title",
+	"xmp",
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"plaintext"
+]);
+const TAG_NAME = /[a-zA-Z][^\s/>]*/y;
+/**
+* A tokenizer, not a parser: tags, their attributes, comments and raw-text
+* elements are all critical CSS needs from a page, and it never builds a tree.
+*/
+function scanHtml(html) {
+	const css = [];
+	const classes = /* @__PURE__ */ new Set();
+	const styles = [];
+	let charset;
+	let trailingScript;
+	const policies = [];
+	let bodyEnd;
+	let htmlEnd;
+	let processed = false;
+	let template = 0;
+	let i = 0;
+	while (i < html.length) {
+		const lt = html.indexOf("<", i);
+		if (lt === -1) break;
+		if (html.startsWith("<!--", lt)) {
+			const end = html.indexOf("-->", lt + 4);
+			i = end === -1 ? html.length : end + 3;
+			continue;
+		}
+		const next = html[lt + 1];
+		if (next === "!" || next === "?") {
+			const end = html.indexOf(">", lt + 2);
+			i = end === -1 ? html.length : end + 1;
+			continue;
+		}
+		if (next === "/") {
+			TAG_NAME.lastIndex = lt + 2;
+			const name = TAG_NAME.exec(html)?.[0].toLowerCase();
+			const end = html.indexOf(">", lt + 2);
+			if (name === "template") template = Math.max(0, template - 1);
+			else if (name === "body") bodyEnd = lt;
+			else if (name === "html") htmlEnd = lt;
+			i = end === -1 ? html.length : end + 1;
+			continue;
+		}
+		TAG_NAME.lastIndex = lt + 1;
+		const match = TAG_NAME.exec(html);
+		if (!match) {
+			i = lt + 1;
+			continue;
+		}
+		const name = match[0].toLowerCase();
+		const { attrs, end } = readAttributes(html, lt + 1 + match[0].length);
+		for (const token of (attrs.get("class") ?? "").split(/[\t\n\f\r ]+/)) if (token !== "") classes.add(token);
+		const style = attrs.get("style");
+		if (style !== void 0) styles.push(style);
+		if (template === 0) {
+			if (name !== "script") trailingScript = void 0;
+			else if (blocksParser(attrs)) trailingScript ??= lt;
+		}
+		if (name === "template") template++;
+		else if (name === "meta") {
+			const equiv = attrs.get("http-equiv")?.trim().toLowerCase();
+			if (!charset && (attrs.has("charset") || equiv === "content-type")) charset = {
+				start: lt,
+				end
+			};
+			if (equiv === "content-security-policy" && attrs.has("content") && template === 0) policies.push({
+				start: lt,
+				end,
+				content: attrs.get("content")
+			});
+		} else if (name === "link" && template === 0) {
+			const rel = (attrs.get("rel") ?? "").toLowerCase().split(/\s+/);
+			if (rel.includes("stylesheet") && !rel.includes("alternate") && !attrs.has("disabled")) css.push({
+				kind: "link",
+				start: lt,
+				end,
+				tag: html.slice(lt, end),
+				...attrs.has("href") ? { href: attrs.get("href") } : {},
+				...attrs.has("media") ? { media: attrs.get("media") } : {}
+			});
+		}
+		if (RAW_TEXT.has(name) && html[end - 2] !== "/") {
+			const close = new RegExp(`</${name}(?=[\\s/>])`, "gi");
+			close.lastIndex = end;
+			const found = name === "plaintext" ? null : close.exec(html);
+			const contentEnd = found ? found.index : html.length;
+			const after = found ? html.indexOf(">", contentEnd) : -1;
+			const elementEnd = after === -1 ? html.length : after + 1;
+			if (name === "noscript") {
+				const inner = scanHtml(html.slice(end, contentEnd));
+				for (const name of inner.classes) classes.add(name);
+				styles.push(...inner.styles);
+			} else if (name === "style") {
+				if (attrs.has(MARKER)) processed = true;
+				if (template === 0) css.push({
+					kind: "style",
+					start: lt,
+					end: elementEnd,
+					text: html.slice(end, contentEnd),
+					tag: html.slice(lt, end)
+				});
+				else styles.push(html.slice(end, contentEnd));
+			}
+			i = elementEnd;
+			continue;
+		}
+		i = end;
+	}
+	return {
+		css,
+		classes,
+		styles,
+		...charset ? { charset } : {},
+		...trailingScript === void 0 ? {} : { trailingScript },
+		policies,
+		...bodyEnd === void 0 ? {} : { bodyEnd },
+		...htmlEnd === void 0 ? {} : { htmlEnd },
+		processed
+	};
+}
+/** JavaScript MIME types, which the HTML spec matches whole, parameters and all. */
+const SCRIPT_TYPE = /^(?:(?:text|application)\/(?:x-)?(?:java|ecma)script|text\/(?:javascript1\.[0-5]|jscript|livescript))$/;
+/**
+* A classic script the parser stops for: inline, or external and neither
+* `async` nor `defer`. Module and deferred scripts wait for every
+* stylesheet before them wherever they are; async ones wait for none.
+*/
+function blocksParser(attrs) {
+	const type = attrs.get("type")?.trim().toLowerCase();
+	if (type !== void 0 && type !== "" && !SCRIPT_TYPE.test(type)) return false;
+	return !attrs.has("src") || !(attrs.has("async") || attrs.has("defer"));
+}
+/** A start tag's attributes from after its name; names lowercased, values decoded, the first of each kept. */
+function readAttributes(html, from) {
+	const attrs = /* @__PURE__ */ new Map();
+	let i = from;
+	for (;;) {
+		while (i < html.length && /[\s/]/.test(html[i])) i++;
+		if (i >= html.length) return {
+			attrs,
+			end: html.length
+		};
+		if (html[i] === ">") return {
+			attrs,
+			end: i + 1
+		};
+		let j = i;
+		while (j < html.length && !/[\s/>=]/.test(html[j])) j++;
+		if (j === i) j++;
+		const name = html.slice(i, j).toLowerCase();
+		i = j;
+		while (i < html.length && /\s/.test(html[i])) i++;
+		let value = "";
+		if (html[i] === "=") {
+			i++;
+			while (i < html.length && /\s/.test(html[i])) i++;
+			const quote = html[i];
+			if (quote === "\"" || quote === "'") {
+				const close = html.indexOf(quote, i + 1);
+				const end = close === -1 ? html.length : close;
+				value = html.slice(i + 1, end);
+				i = end + 1;
+			} else {
+				let k = i;
+				while (k < html.length && !/[\s>]/.test(html[k])) k++;
+				value = html.slice(i, k);
+				i = k;
+			}
+		}
+		if (!attrs.has(name)) attrs.set(name, decodeEntities(value));
+	}
+}
+const NAMED = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: "\xA0"
+};
+function decodeEntities(text) {
+	if (!text.includes("&")) return text;
+	return text.replace(/&(#x[\da-f]+|#\d+|[a-z]+);?/gi, (entity, body) => {
+		if (body[0] === "#") {
+			const code = body[1] === "x" || body[1] === "X" ? parseInt(body.slice(2), 16) : Number(body.slice(1));
+			return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : entity;
+		}
+		return NAMED[body.toLowerCase()] ?? entity;
+	});
+}
+/** At-rules whose blocks hold rules. */
+const GROUPS = /* @__PURE__ */ new Set([
+	"media",
+	"supports",
+	"container",
+	"layer",
+	"scope",
+	"starting-style",
+	"document",
+	"-moz-document"
+]);
+/** At-rules whose order between stylesheets never matters in practice. */
+const UNORDERED = /* @__PURE__ */ new Set([
+	"layer",
+	"property",
+	"font-face",
+	"keyframes",
+	"-webkit-keyframes",
+	"charset"
+]);
+/**
+* Index of the first of `stops` at nesting depth 0 from `from`, or `to`.
+* Strings, comments, escapes and unquoted `url()`s never stop it.
+*/
+function find(text, from, to, stops) {
+	const stack = [];
+	for (let i = from; i < to; i++) {
+		const c = text[i];
+		if (c === "\\") {
+			i++;
+			continue;
+		}
+		if (c === "/" && text[i + 1] === "*") {
+			const end = text.indexOf("*/", i + 2);
+			i = end === -1 || end >= to ? to : end + 1;
+			continue;
+		}
+		if (c === "\"" || c === "'") {
+			i = stringEnd(text, i, to) - 1;
+			continue;
+		}
+		if ((c === "u" || c === "U") && /^url\(/i.test(text.slice(i, i + 4)) && !/[\w-]/.test(text[i - 1] ?? "")) {
+			const end = urlEnd(text, i + 4, to);
+			if (end !== -1) {
+				i = end;
+				continue;
+			}
+		}
+		if (stack.length === 0 && stops.includes(c)) return i;
+		if (c === "(") stack.push(")");
+		else if (c === "[") stack.push("]");
+		else if (c === "{") stack.push("}");
+		else if ((c === ")" || c === "]" || c === "}") && stack.at(-1) === c) stack.pop();
+	}
+	return to;
+}
+/** After the string opening at `at`. */
+function stringEnd(text, at, to) {
+	const quote = text[at];
+	for (let i = at + 1; i < to; i++) if (text[i] === "\\") i++;
+	else if (text[i] === quote || text[i] === "\n") return i + 1;
+	return to;
+}
+/** The `)` of an unquoted `url(` whose content starts at `from`; -1 for a quoted one. */
+function urlEnd(text, from, to) {
+	let i = from;
+	while (i < to && /\s/.test(text[i])) i++;
+	if (text[i] === "\"" || text[i] === "'") return -1;
+	for (; i < to; i++) if (text[i] === "\\") i++;
+	else if (text[i] === ")") return i;
+	return to;
+}
+function skipSpace(text, from, to) {
+	let i = from;
+	for (;;) {
+		while (i < to && /\s/.test(text[i])) i++;
+		if (text.startsWith("/*", i)) {
+			const end = text.indexOf("*/", i + 2);
+			i = end === -1 ? to : end + 2;
+			continue;
+		}
+		return i;
+	}
+}
+function parseCss(text, from = 0, to = text.length) {
+	const nodes = [];
+	let i = from;
+	for (;;) {
+		i = skipSpace(text, i, to);
+		if (i >= to) return nodes;
+		const start = i;
+		if (text[i] === "@") {
+			const name = /^@(-?[\w-]*)/.exec(text.slice(i, i + 64))[1].toLowerCase();
+			const stop = find(text, i + 1 + name.length, to, "{;}");
+			const prelude = text.slice(i + 1 + name.length, stop).trim();
+			if (stop >= to || text[stop] !== "{") {
+				const end = stop >= to ? to : stop + 1;
+				nodes.push({
+					type: name,
+					start,
+					end,
+					prelude
+				});
+				i = end;
+				continue;
+			}
+			const close = find(text, stop + 1, to, "}");
+			nodes.push({
+				type: name,
+				start,
+				end: Math.min(close + 1, to),
+				prelude,
+				bodyStart: stop + 1,
+				bodyEnd: close,
+				...GROUPS.has(name) ? { children: parseCss(text, stop + 1, close) } : {}
+			});
+			i = close + 1;
+			continue;
+		}
+		const open = find(text, i, to, "{;}");
+		if (open >= to || text[open] !== "{") {
+			const end = open >= to ? to : open + 1;
+			nodes.push({
+				type: "raw",
+				start,
+				end,
+				prelude: text.slice(start, open).trim()
+			});
+			i = end;
+			continue;
+		}
+		const close = find(text, open + 1, to, "}");
+		nodes.push({
+			type: "rule",
+			start,
+			end: Math.min(close + 1, to),
+			prelude: text.slice(start, open).trim(),
+			bodyStart: open + 1,
+			bodyEnd: close
+		});
+		i = close + 1;
+	}
+}
+/** Parts of `text` between separators at depth 0, each with its offset. */
+function splitTop(text, separator) {
+	const parts = [];
+	let start = 0;
+	for (;;) {
+		const at = find(text, start, text.length, separator);
+		parts.push({
+			text: text.slice(start, at),
+			start
+		});
+		if (at >= text.length) return parts;
+		start = at + 1;
+	}
+}
+/** A CSS identifier from `from`, escapes resolved, and where it ends. */
+function readIdent(text, from) {
+	let name = "";
+	let i = from;
+	while (i < text.length) {
+		const c = text[i];
+		if (c === "\\") {
+			const hex = /^[\da-fA-F]{1,6}/.exec(text.slice(i + 1, i + 7));
+			if (hex) {
+				const code = parseInt(hex[0], 16);
+				name += code === 0 || code > 1114111 ? "�" : String.fromCodePoint(code);
+				i += 1 + hex[0].length;
+				if (/\s/.test(text[i] ?? "")) i += text.startsWith("\r\n", i) ? 2 : 1;
+			} else if (i + 1 < text.length && text[i + 1] !== "\n") {
+				name += text[i + 1];
+				i += 2;
+			} else break;
+			continue;
+		}
+		if (/[\w-]/.test(c) || c.charCodeAt(0) >= 128) {
+			name += c;
+			i++;
+			continue;
+		}
+		break;
+	}
+	return [name, i];
+}
+/** Pseudo-classes whose selector argument must match in the page for theirs to. */
+const REQUIRING = /* @__PURE__ */ new Set([
+	"is",
+	"where",
+	"matches",
+	"-webkit-any",
+	"-moz-any",
+	"has"
+]);
+/**
+* The classes some element of the page must have for `selector` to match
+* there: those of its compounds, and those every alternative of an `:is()`,
+* `:where()` or `:has()` requires. Never those under `:not()` and other
+* functional pseudo-classes, whose arguments may match by being absent.
+*
+* In vicss's layers (`vicss`), a class under `:where()` that vicss did not
+* name comes from the config, a condition's or a mode's selector (`.dark`
+* of `darkMode: { selector: ".dark" }`): a script in `<head>` sets it before
+* the first paint, from a stored preference the build cannot see. Only the
+* classes vicss names itself, markers and themes (`relates`), are in the
+* markup. Readable ones say so (`vx-…`); a build's hashes only its namer
+* knows (PLAN D31), so without it (`vicss critical`) a hashed theme's or
+* marker's rules count as the page's: more bytes, never a missing style.
+*/
+function requiredClasses(selector, vicss = false, relates = isRelating) {
+	const out = [];
+	const end = selector.length;
+	let i = 0;
+	while (i < end) {
+		const c = selector[i];
+		if (c === "\\") i += 2;
+		else if (c === "\"" || c === "'") i = stringEnd(selector, i, end);
+		else if (c === "[") i = find(selector, i + 1, end, "]") + 1;
+		else if (c === ".") {
+			const [name, next] = readIdent(selector, i + 1);
+			if (name !== "") out.push(name);
+			i = Math.max(next, i + 1);
+		} else if (c === ":") {
+			const [name, next] = readIdent(selector, selector[i + 1] === ":" ? i + 2 : i + 1);
+			if (selector[next] !== "(") {
+				i = Math.max(next, i + 1);
+				continue;
+			}
+			const close = find(selector, next + 1, end, ")");
+			const pseudo = name.toLowerCase();
+			if (REQUIRING.has(pseudo)) {
+				const [first = [], ...rest] = splitTop(selector.slice(next + 1, close), ",").map((part) => requiredClasses(part.text, vicss, relates));
+				const all = first.filter((name) => rest.every((other) => other.includes(name)));
+				out.push(...vicss && pseudo === "where" ? all.filter(relates) : all);
+			}
+			i = close + 1;
+		} else i++;
+	}
+	return out;
+}
+/** Whether `selector` is one `:where()` and nothing else. */
+function isLoneWhere(selector) {
+	const text = selector.trim();
+	return /^:where\(/i.test(text) && find(text, 7, text.length, ")") === text.length - 1;
+}
+const IDENT = String.raw`(?:[\w-]|\\[\s\S]|[^\x00-\x7f])+`;
+/** Custom properties a value reads, by `var()` or a container style query. */
+const REFERENCE = new RegExp(String.raw`(?:var|style)\(\s*(--${IDENT})`, "g");
+function references(text, into) {
+	for (const match of text.matchAll(REFERENCE)) into.add(match[1]);
+}
+/** A custom property declaration and its value, up to the end of the declaration. */
+const DECLARATION$1 = new RegExp(String.raw`(--${IDENT})\s*:([^;}]*)`, "g");
+const REGISTRATION = new RegExp(String.raw`@property\s+(--${IDENT})`, "gi");
+const VAR = new RegExp(String.raw`^var\(\s*(--${IDENT})\s*([,)])`, "i");
+/**
+* Custom properties `text` sets to a value, as a declaration anywhere in it
+* (a container query's `style(--x: y)` too: more is safe), but for those it
+* sets to `initial` only.
+*/
+function setters(text, into) {
+	for (const match of text.matchAll(DECLARATION$1)) if (match[2].trim().toLowerCase() !== "initial") into.add(match[1]);
+}
+/**
+* The custom properties `value` reads with no fallback, outside any
+* `var()`'s fallback: when one holds nothing, so does the value (invalid
+* at computed-value time).
+*/
+function strictReads(value) {
+	const out = [];
+	let depth = 0;
+	const fallbacks = [];
+	for (let i = 0; i < value.length; i++) {
+		const c = value[i];
+		if (c === "\\") i++;
+		else if (c === "\"" || c === "'") i = stringEnd(value, i, value.length) - 1;
+		else if (c === "(") depth++;
+		else if (c === ")") {
+			if (fallbacks.at(-1) === depth) fallbacks.pop();
+			depth--;
+		} else if ((c === "v" || c === "V") && !/[\w-]/.test(value[i - 1] ?? "")) {
+			const match = VAR.exec(value.slice(i));
+			if (!match) continue;
+			i += match[0].length - 1;
+			if (match[2] === ",") fallbacks.push(++depth);
+			else if (fallbacks.length === 0) out.push(match[1]);
+		}
+	}
+	return out;
+}
+/** Output stylesheets by file, read and parsed once for every page. */
+var SheetCache = class {
+	#sheets = /* @__PURE__ */ new Map();
+	#read;
+	#relates;
+	/**
+	* `relates` tells a theme's or a marker's class from a config's
+	* (`requiredClasses`): a build's namer knows its hashed ones.
+	*/
+	constructor(read, relates = isRelating) {
+		this.#read = read;
+		this.#relates = relates;
+	}
+	text(file) {
+		return this.get(file)?.text;
+	}
+	get(file) {
+		if (this.#sheets.has(file)) return this.#sheets.get(file);
+		const raw = this.#read(file);
+		const sheet = raw === void 0 ? void 0 : analyse(file, raw.replace(/^/, ""), this.#relates);
+		this.#sheets.set(file, sheet);
+		return sheet;
+	}
+};
+const isVicssLayer = (layer) => layer !== void 0 && (layer === "vicss" || layer.startsWith("vicss."));
+/** The full name of a layer block's layer, inside `outer`; undefined for an anonymous one. */
+function layerOf(node, outer) {
+	const name = node.prelude.trim();
+	if (name === "") return void 0;
+	return outer === void 0 ? name : `${outer}.${name}`;
+}
+function analyse(file, text, relates) {
+	const nodes = parseCss(text);
+	const rules = /* @__PURE__ */ new Map();
+	const declarations = /* @__PURE__ */ new Map();
+	let vicss = false;
+	let ordered = false;
+	let anonymous = false;
+	const visit = (list, layer, top) => {
+		for (const node of list) {
+			if (node.type === "rule") {
+				const own = layer?.startsWith("vicss.a.") === true;
+				const selectors = splitTop(node.prelude, ",").map((part) => ({
+					text: part.text.trim(),
+					required: own && isLoneWhere(part.text) ? requiredClasses(part.text.trim().slice(7, -1), true, relates) : requiredClasses(part.text, isVicssLayer(layer), relates)
+				}));
+				rules.set(node, {
+					selectors,
+					prefixed: selectors.some((selector) => /(?:^|[^\\]):{1,2}-/.test(selector.text))
+				});
+				if (layer === "vicss.tokens") {
+					const body = text.slice(node.bodyStart, node.bodyEnd);
+					declarations.set(node, splitTop(body, ";").filter((part) => part.text.trim() !== "").map((part) => {
+						const property = /^\s*(--[^:\s]+)\s*:/.exec(part.text)?.[1];
+						return property === void 0 ? { text: part.text } : {
+							text: part.text,
+							property
+						};
+					}));
+				}
+				if (isVicssLayer(layer)) vicss = true;
+				else ordered = true;
+				continue;
+			}
+			if (node.type === "layer" && node.children) {
+				const inner = layerOf(node, layer);
+				if (inner === void 0) anonymous = true;
+				visit(node.children, inner, top);
+				continue;
+			}
+			if (node.children) {
+				visit(node.children, layer, false);
+				continue;
+			}
+			if (!(top && UNORDERED.has(node.type)) && !isVicssLayer(layer)) ordered = true;
+		}
+	};
+	visit(nodes, void 0, true);
+	const custom = new Set([...text.matchAll(DECLARATION$1)].map((match) => match[1]));
+	return {
+		file,
+		text,
+		nodes,
+		vicss,
+		ordered,
+		anonymous,
+		rules,
+		declarations,
+		custom
+	};
+}
+/**
+* What the inline CSS holds, over the files a page defers: the rules whose
+* selectors need only classes the page has; then, until nothing changes,
+* the custom properties those rules, the page's other CSS and its style
+* attributes read (and the ones those read), and the keyframes they name.
+*/
+function planCritical(sheets, classes, roots) {
+	const kept = /* @__PURE__ */ new Map();
+	const properties = /* @__PURE__ */ new Set();
+	const corpus = [...roots];
+	const tokenRules = [];
+	const keyframes = [];
+	let classRules = 0;
+	const outside = /* @__PURE__ */ new Set();
+	const registered = /* @__PURE__ */ new Set();
+	for (const root of roots) {
+		references(root, properties);
+		setters(root, outside);
+		for (const match of root.matchAll(REGISTRATION)) registered.add(match[1]);
+	}
+	const visit = (sheet, list, layer) => {
+		for (const node of list) {
+			const source = sheet.text.slice(node.start, node.end);
+			if (node.type === "rule") {
+				const info = sheet.rules.get(node);
+				const selectors = info.selectors.filter((s) => s.required.every((c) => classes.has(c)));
+				if (selectors.length === 0) continue;
+				kept.set(node, selectors.map((s) => s.text));
+				const global = layer === "vicss.global" || layer === "vicss.reset";
+				if (isVicssLayer(layer) && !global && info.selectors.some((s) => s.required.length > 0)) classRules++;
+				if (layer === "vicss.tokens") {
+					tokenRules.push({
+						sheet,
+						node
+					});
+					const read = node.prelude + sheet.declarations.get(node).filter((d) => d.property === void 0).map((d) => d.text).join(";");
+					references(read, properties);
+					corpus.push(read);
+				} else {
+					references(source, properties);
+					setters(source, outside);
+					corpus.push(source);
+				}
+				continue;
+			}
+			if (node.type === "layer" && node.children) {
+				visit(sheet, node.children, layerOf(node, layer));
+				continue;
+			}
+			if (node.children) {
+				references(node.prelude, properties);
+				visit(sheet, node.children, layer);
+				continue;
+			}
+			if (node.type === "keyframes" || node.type === "-webkit-keyframes") {
+				const name = node.prelude.replace(/^["']|["']$/g, "");
+				keyframes.push({
+					sheet,
+					node,
+					name: new RegExp(`(?<![\\w-])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`)
+				});
+				continue;
+			}
+			if (node.type === "property") {
+				registered.add(node.prelude.trim());
+				continue;
+			}
+			references(source, properties);
+		}
+	};
+	for (const sheet of sheets) visit(sheet, sheet.nodes, void 0);
+	const invalid = invalidProperties(sheets, tokenRules, outside, registered);
+	const needed = /* @__PURE__ */ new Set();
+	const done = /* @__PURE__ */ new Set();
+	for (let changed = true; changed;) {
+		changed = false;
+		for (const { sheet, node } of tokenRules) for (const declaration of sheet.declarations.get(node)) {
+			const key = `${sheet.file}\0${node.start}\0${declaration.text}`;
+			if (declaration.property === void 0 || done.has(key)) continue;
+			if (!properties.has(declaration.property) || invalid.has(declaration.property)) continue;
+			done.add(key);
+			changed = true;
+			references(declaration.text, properties);
+			corpus.push(declaration.text);
+		}
+		for (const { sheet, node, name } of keyframes) {
+			if (needed.has(node) || !corpus.some((text) => name.test(text))) continue;
+			needed.add(node);
+			changed = true;
+			references(sheet.text.slice(node.start, node.end), properties);
+		}
+	}
+	for (const name of invalid) properties.delete(name);
+	return {
+		kept,
+		properties,
+		keyframes: needed,
+		classRules
+	};
+}
+/**
+* Custom properties that hold no value on any element of the page at its
+* first paint, so that leaving out their declarations changes nothing:
+* every declaration of one is in `vicss.tokens`, and is `initial` or reads,
+* with no fallback, one of the sheets' own custom properties that nothing
+* the page keeps sets (transitively), and none is registered, which would
+* give it a value. A palette's candidates
+* (`--color-palette-600_red: var(--palette_red) var(--color-red-600)`) are
+* such properties on a page where no element selects the palette, since
+* only the palette's atom sets its flag: the page inlines the tokens of its
+* own palettes. Custom properties the sheets never declare are assumed set,
+* by a script for one.
+*/
+function invalidProperties(sheets, tokenRules, outside, registered) {
+	const own = (name) => sheets.some((sheet) => sheet.custom.has(name));
+	const values = /* @__PURE__ */ new Map();
+	for (const { sheet, node } of tokenRules) for (const { text, property } of sheet.declarations.get(node)) {
+		if (property === void 0 || outside.has(property) || registered.has(property)) continue;
+		const value = text.slice(text.indexOf(":") + 1).trim();
+		const initial = value.toLowerCase() === "initial";
+		const reads = initial ? [] : strictReads(value).filter(own);
+		let list = values.get(property);
+		if (!list) values.set(property, list = []);
+		list.push({
+			initial,
+			reads
+		});
+	}
+	const set = /* @__PURE__ */ new Set([...outside, ...registered]);
+	for (const [name, list] of values) if (list.some((value) => !value.initial)) set.add(name);
+	const invalid = /* @__PURE__ */ new Set();
+	for (let changed = true; changed;) {
+		changed = false;
+		for (const [name, list] of values) {
+			if (invalid.has(name)) continue;
+			if (!list.every((value) => value.initial || value.reads.some((read) => !set.has(read)))) continue;
+			invalid.add(name);
+			set.delete(name);
+			changed = true;
+		}
+	}
+	return invalid;
+}
+/**
+* One file's inline CSS: its text with what the page cannot use removed.
+* A layer block whose rules all went still declares its layer, as a
+* statement, unless the inline CSS declared it already: Lightning CSS
+* folds vicss's layer statement into the blocks that follow it, and a
+* layer first declared by the full sheet would land last in the order.
+*/
+function printSheet(sheet, plan, declared, parts) {
+	const { text } = sheet;
+	const print = (node, layer, conditional) => {
+		const source = text.slice(node.start, node.end);
+		switch (node.type) {
+			case "rule": {
+				const selectors = plan.kept.get(node);
+				if (!selectors) return "";
+				const info = sheet.rules.get(node);
+				const prelude = selectors.length === info.selectors.length || info.prefixed ? node.prelude : selectors.join(",");
+				let body = text.slice(node.bodyStart, node.bodyEnd);
+				if (layer === "vicss.tokens") {
+					const declarations = sheet.declarations.get(node).filter((d) => d.property === void 0 || plan.properties.has(d.property));
+					if (declarations.length === 0) return "";
+					body = declarations.map((d) => d.text).join(";");
+				}
+				return prelude === node.prelude && body === text.slice(node.bodyStart, node.bodyEnd) ? source : `${prelude}{${body}}`;
+			}
+			case "layer": {
+				if (!node.children) {
+					if (!conditional) for (const name of node.prelude.split(",")) declared.add(layer === void 0 ? name.trim() : `${layer}.${name.trim()}`);
+					return source;
+				}
+				const inner = layerOf(node, layer);
+				const known = inner !== void 0 && declared.has(inner);
+				if (inner !== void 0 && !conditional) declared.add(inner);
+				const children = node.children.map((child) => print(child, inner, conditional)).join("");
+				if (children !== "") return `${text.slice(node.start, node.bodyStart - 1)}{${children}}`;
+				return inner === void 0 || known ? "" : `@layer ${node.prelude.trim()};`;
+			}
+			case "keyframes":
+			case "-webkit-keyframes": return plan.keyframes.has(node) ? source : "";
+			case "property": return plan.properties.has(node.prelude.trim()) ? source : "";
+			default: {
+				if (!node.children) return source;
+				const children = node.children.map((child) => print(child, layer, true)).join("");
+				return children === "" ? "" : `${text.slice(node.start, node.bodyStart - 1)}{${children}}`;
+			}
+		}
+	};
+	let out = "";
+	for (const node of sheet.nodes) {
+		const printed = print(node, void 0, false);
+		if (printed === "") continue;
+		parts[partOf(node)] += Buffer.byteLength(printed);
+		out += printed;
+	}
+	return out;
+}
+/** What a top-level node's bytes are for. */
+function partOf(node) {
+	if (node.type === "layer" && !node.children) return "layers";
+	if (node.type === "property") return "tokens";
+	if (node.type === "font-face") return "fonts";
+	if (node.type === "keyframes" || node.type === "-webkit-keyframes") return "keyframes";
+	const layer = firstLayer(node, void 0);
+	if (layer === "vicss.tokens") return "tokens";
+	if (layer === "vicss.global" || layer === "vicss.reset") return "global";
+	if (layer?.startsWith("vicss.a.")) return "atoms";
+	return isVicssLayer(layer) ? "global" : "other";
+}
+function firstLayer(node, outer) {
+	if (node.type === "layer" && node.children) return layerOf(node, outer) ?? outer;
+	for (const child of node.children ?? []) {
+		const layer = firstLayer(child, outer);
+		if (layer !== void 0) return layer;
+	}
+	return outer;
+}
+/**
+* Relative `url()`s and `@import`s resolve from the stylesheet's URL;
+* inline, they would resolve from the page's (a `base: "./"` build writes
+* them). They are rebased on the stylesheet's URL as the page's link names
+* it: relative to the page when the link is, else absolute, the same on
+* every path that serves the page (a 404 page, an SPA's fallback) and on
+* the stylesheet's host (a CDN).
+*/
+function rebaseUrls(css, href) {
+	const sheet = href.trim().replace(/[?#].*$/s, "");
+	const from = path.posix.dirname(sheet);
+	const host = /^(?:[a-z][a-z\d+.-]*:)?\/\/[^/]*/i.exec(sheet)?.[0];
+	if (host === void 0 && (from === "." || from === "")) return css;
+	const rebase = (url) => {
+		if (url === "" || /^(?:[a-z][a-z\d+.-]*:|\/|#)/i.test(url)) return url;
+		const suffix = /[?#].*$/s.exec(url)?.[0] ?? "";
+		const target = url.slice(0, url.length - suffix.length);
+		if (host === void 0) return path.posix.join(from, target) + suffix;
+		return host + path.posix.join(from.slice(host.length) || "/", target) + suffix;
+	};
+	return css.replace(/(\burl\(\s*)(?:"([^"]*)"|'([^']*)'|([^)\s"']*))(\s*\))/gi, (_, open, double, single, bare, close) => {
+		if (double !== void 0) return `${open}"${rebase(double)}"${close}`;
+		if (single !== void 0) return `${open}'${rebase(single)}'${close}`;
+		return `${open}${rebase(bare ?? "")}${close}`;
+	}).replace(/(@import\s+)(["'])([^"']*)\2/gi, (_, at, quote, url) => {
+		return `${at}${quote}${rebase(url)}${quote}`;
+	});
+}
+/**
+* `</style` would end the element early; `\/` is `/` to CSS, in strings and
+* `url()`s alike. The HTML parser turns CR LF and CR into LF before the
+* browser hashes the style for its CSP, and so does this.
+*/
+function escapeStyle(css) {
+	return css.replace(/<\/(style)/gi, "<\\/$1").replace(/\r\n?/g, "\n");
+}
+//#endregion
+//#region src/vite/libraries.ts
+/**
+* Component libraries an app installs (PLAN §5.13): the root `package.json`'s
+* dependencies whose own `package.json` has a `"vicss"` field naming their
+* manifest, and the libraries those depend on in turn. Their atoms join the
+* app's sheet, printed with the app's tokens and conditions; no file under
+* `node_modules` is scanned or compiled.
+*/
+/**
+* The libraries installed for the app: the root `package.json`'s
+* dependencies with a `vicss` field, then the dependencies and peers of
+* each library that have one (a forms library on a design system's
+* components), resolved from that library's directory, and so on. A
+* library's classes include those of the libraries it renders, which ship
+* no CSS without their manifests. Each installed copy once, by real path.
+*/
+function findLibraries(root) {
+	const pkg = readJson(path.join(root, "package.json"));
+	if (!pkg) return [];
+	const found = /* @__PURE__ */ new Map();
+	const sorted = (names) => [...new Set(names)].sort(compareStrings);
+	let level = sorted([...keys(pkg.dependencies), ...keys(pkg.devDependencies)]).map((name) => ({
+		name,
+		from: root
+	}));
+	while (level.length > 0) {
+		const next = [];
+		for (const { name, from } of level) {
+			const pkgFile = packageJsonOf(name, from);
+			const own = pkgFile && readJson(pkgFile);
+			if (!own || typeof own.vicss !== "string") continue;
+			const dir = normalizePath(path.dirname(pkgFile));
+			const real = normalizePath(realpath(dir));
+			if (found.has(real)) continue;
+			found.set(real, {
+				name,
+				packageFile: `${real}/package.json`,
+				manifest: normalizePath(path.resolve(real, own.vicss)),
+				dirs: [.../* @__PURE__ */ new Set([dir, real])],
+				field: own.vicss
+			});
+			for (const dep of sorted([...keys(own.dependencies), ...keys(own.peerDependencies)])) next.push({
+				name: dep,
+				from: real
+			});
+		}
+		level = next;
+	}
+	return [...found.values()];
+}
+/** The installed libraries with a manifest, each checked against `system`. */
+function loadLibraries(root, system) {
+	return findLibraries(root).map(({ name, packageFile, manifest: file, dirs, field }) => {
+		let data;
+		try {
+			data = JSON.parse(readFileSync(file, "utf8"));
+		} catch (error) {
+			throw new VicssError("BAD_MANIFEST", `${name}'s vicss manifest ${field} cannot be read: ${error instanceof Error ? error.message : String(error)}`, { hint: "Build the library (its `vicss` field names the manifest its build writes)." });
+		}
+		const manifest = parseManifest(data, name);
+		const styles = applyManifest(manifest, system, name, { privateAccess: dirs.some((dir) => hasPrivateAccess(system, root, path.posix.join(dir, field))) });
+		const renames = customPropertyRenames(manifest, system);
+		return {
+			name,
+			files: [packageFile, file],
+			dirs,
+			...styles,
+			renames
+		};
+	});
+}
+/**
+* A library module's code with the custom properties its JS names renamed
+* to the app's (`renames`), and the map of the edit; undefined when it
+* names none. Only the names the library's manifest lists: a string the
+* library wrote for another purpose stays as it is.
+*/
+function renameCustomProperties(code, id, renames) {
+	const exact = [...renames.exact.keys()];
+	const prefixes = [...renames.prefixes.keys()];
+	if (exact.length === 0 && prefixes.length === 0) return void 0;
+	const pattern = new RegExp([...exact.sort((a, b) => b.length - a.length).map(escapeRegExp), ...prefixes.map((prefix) => `${escapeRegExp(prefix)}(?=["'\`$])`)].join("|"), "g");
+	const edits = new SourceEdits(code);
+	for (const match of code.matchAll(pattern)) {
+		const to = renames.exact.get(match[0]) ?? renames.prefixes.get(match[0]);
+		edits.overwrite(match.index, match.index + match[0].length, to);
+	}
+	if (!edits.hasChanged()) return void 0;
+	return {
+		code: edits.toString(),
+		map: edits.generateMap({
+			source: id,
+			file: id,
+			hires: true
+		})
+	};
+}
+/**
+* The name in the nearest `package.json` at or above `root`: the package a
+* project's modules belong to, which marker ids hash and a library's
+* manifest names.
+*/
+function ownPackageName(root) {
+	for (let dir = root;; dir = path.dirname(dir)) {
+		const pkg = readJson(path.join(dir, "package.json"));
+		if (pkg) return typeof pkg.name === "string" ? pkg.name : "";
+		if (path.dirname(dir) === dir) return "";
+	}
+}
+/** The scan's styles and the libraries', one entry per class and rule id. */
+function withLibraries(scan, libraries, system) {
+	if (libraries.length === 0) return scan;
+	const atoms = new Map(scan.atoms.map((atom) => [atom.className, atom]));
+	const owners = /* @__PURE__ */ new Map();
+	for (const library of libraries) for (const atom of library.atoms) if (!atoms.has(atom.className)) {
+		atoms.set(atom.className, atom);
+		owners.set(atom.className, library.name);
+	}
+	const all = [...atoms.values()].sort((a, b) => compareStrings(a.className, b.className));
+	const everyRule = [...scan.rules, ...libraries.flatMap((library) => library.rules)];
+	const [conflict] = [...checkAtoms([
+		...scan.atoms,
+		...libraries.flatMap((library) => library.atoms),
+		...baseAtoms(everyRule)
+	], system), ...checkBases(everyRule)];
+	if (conflict) {
+		const named = [...new Set(owners.values())].join(", ");
+		throw new VicssError(conflict.code, `${conflict.message} (between the app and ${named})`, conflict.hint === void 0 ? {} : { hint: conflict.hint });
+	}
+	const rules = new Map(scan.rules.map((rule) => [rule.id, rule]));
+	for (const rule of libraries.flatMap((library) => library.rules)) if (!rules.has(rule.id)) rules.set(rule.id, rule);
+	return {
+		...scan,
+		atoms: all,
+		rules: [...rules.values()].sort((a, b) => compareStrings(a.id, b.id)),
+		tokens: [...scan.tokens, ...libraries.flatMap((library) => library.tokens)]
+	};
+}
+/** `<name>/package.json` as Node resolves it from `from`, or under a `node_modules` above it. */
+function packageJsonOf(name, from) {
+	try {
+		return createRequire(path.join(from, "package.json")).resolve(`${name}/package.json`);
+	} catch {}
+	for (let dir = from;; dir = path.dirname(dir)) {
+		const file = path.join(dir, "node_modules", name, "package.json");
+		if (existsSync(file)) return file;
+		if (path.dirname(dir) === dir) return void 0;
+	}
+}
+/** The library `id` (without a query) is a module of, not of a package it installs. */
+function libraryOf(libraries, id) {
+	return libraries.find((library) => library.dirs.some((dir) => id.startsWith(`${dir}/`) && !id.slice(dir.length).includes("/node_modules/")));
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function realpath(dir) {
+	try {
+		return realpathSync(dir);
+	} catch {
+		return dir;
+	}
+}
+function readJson(file) {
+	try {
+		const data = JSON.parse(readFileSync(file, "utf8"));
+		return typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
+	} catch {
+		return;
+	}
+}
+function keys(value) {
+	return typeof value === "object" && value !== null ? Object.keys(value) : [];
+}
+//#endregion
+//#region src/vite/glob.ts
+/**
+* Listing `include` without `exclude` for the pre-scan, fast. `fs.glob` and
+* Vite's `createFilter` (which compiles its patterns again on every call)
+* took a tenth of a cold scan; this compiles each pattern once to a regular
+* expression and walks the directories the patterns can reach. It keeps
+* their semantics: `include` matches like `fs.glob` (wildcards skip dot
+* files), `exclude` like `createFilter` (wildcards match them; a pattern is
+* relative to the root unless it is absolute or starts with `**`). Patterns
+* it does not compile (extglobs, ranges, negations) take the slow path.
+*/
+/** Absolute, forward-slash paths of the files `include` matches and `exclude` does not, sorted. */
+async function listFiles$1(root, include, exclude) {
+	return listFast(root, include, exclude) ?? listWithGlob(root, include, exclude);
+}
+/** The reference: `fs.glob` for `include`, Vite's `createFilter` for `exclude`. */
+async function listWithGlob(root, include, exclude) {
+	const kept = createFilter(null, exclude, { resolve: root });
+	const files = /* @__PURE__ */ new Set();
+	const skip = (entry) => path.basename(typeof entry === "string" ? entry : entry.name) === "node_modules";
+	for await (const file of glob(include, {
+		cwd: root,
+		exclude: skip
+	})) {
+		const id = normalizePath(path.resolve(root, file));
+		if (kept(id)) files.add(id);
+	}
+	return [...files].sort(compareStrings);
+}
+function listFast(root, include, exclude) {
+	const base = normalizePath(root).replace(/\/$/, "");
+	const includes = [];
+	for (const pattern of include) {
+		const clean = normalizePath(pattern).replace(/^\.\//, "");
+		if (path.isAbsolute(clean)) return void 0;
+		const dir = staticPrefix(clean);
+		if (hasDotSegment(clean.slice(dir.length))) return void 0;
+		const regex = globToRegExp(clean, false);
+		if (!regex) return void 0;
+		includes.push({
+			dir,
+			test: regex
+		});
+	}
+	const outside = includes.some(({ dir }) => hasDotSegment(dir));
+	const excludes = [];
+	for (const pattern of exclude) {
+		const clean = normalizePath(pattern);
+		const on = path.isAbsolute(clean) ? "absolute" : clean.startsWith("**") ? "bare" : "relative";
+		const regex = globToRegExp(on === "relative" ? path.posix.normalize(clean) : clean, true);
+		if (!regex) return void 0;
+		excludes.push({
+			regex,
+			on
+		});
+	}
+	const dotDirs = include.some((p) => p.split("/").some((segment) => segment.startsWith(".") && !isDotSegment(segment)));
+	const files = /* @__PURE__ */ new Set();
+	const walked = /* @__PURE__ */ new Set();
+	const walk = (rel) => {
+		if (walked.has(rel)) return;
+		walked.add(rel);
+		let entries;
+		try {
+			entries = readdirSync(rel ? `${base}/${rel}` : base, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const child = rel ? `${rel}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) {
+				if (entry.name !== "node_modules" && (dotDirs || !entry.name.startsWith("."))) walk(child);
+			} else if (entry.isFile() || entry.isSymbolicLink()) {
+				if (!includes.some((p) => p.test.test(child))) continue;
+				const id = outside ? path.posix.normalize(`${base}/${child}`) : `${base}/${child}`;
+				const relative = outside ? path.posix.relative(base, id) : child;
+				const bare = id.replace(/^\//, "");
+				if (!excludes.some(({ regex, on }) => regex.test(on === "absolute" ? id : on === "bare" ? bare : relative))) files.add(id);
+			}
+		}
+	};
+	for (const { dir } of includes) walk(dir);
+	return [...files].sort(compareStrings);
+}
+const isDotSegment = (segment) => segment === "." || segment === "..";
+const hasDotSegment = (pattern) => pattern.split("/").some(isDotSegment);
+/** The directories before the first segment with a wildcard: where a walk starts. */
+function staticPrefix(pattern) {
+	const segments = pattern.split("/");
+	const fixed = [];
+	for (const segment of segments.slice(0, -1)) {
+		if (/[*?[{\\]/.test(segment)) break;
+		fixed.push(segment);
+	}
+	return fixed.join("/");
+}
+//#endregion
+//#region src/vite/scan.ts
+/**
+* The build pre-scan (PLAN §5.10): every file under `include` is compiled
+* before the bundle exists, so the one sheet holds every atom and rule the
+* app can use, whatever order environments and modules are built in. A
+* framework file (`.vue`, `.svelte`, `.astro`) is compiled by its scripts,
+* extracted from its source; with more than `POOL_MIN` modules to compile,
+* worker threads share the work (D17).
+*/
+const DEFAULT_INCLUDE = ["src/**/*.{js,jsx,ts,tsx,mjs,mts,cjs,cts,vue,svelte,astro}", "app/**/*.{js,jsx,ts,tsx,mjs,mts,cjs,cts,vue,svelte,astro}"];
+const DEFAULT_EXCLUDE = [
+	"**/*.{test,spec,stories}.*",
+	"**/node_modules/**",
+	"**/dist/**"
+];
+/** Files compiled at once: enough to overlap reads with parsing, few enough to bound memory. */
+const CONCURRENCY = 16;
+/** The main thread's share once a worker thread is ready: it also answers their resolutions. */
+const CONCURRENCY_WITH_POOL = 1;
+const DECLARATION = /\.d\.[cm]?ts$/;
+/** A conflict between the atoms of two files, which carry no location. */
+var ScanConflict = class extends VicssError {
+	/** The later of the files, which the build reports the error on. */
+	id;
+	constructor(error, id, message) {
+		super(error.code, message, error.hint === void 0 ? {} : { hint: error.hint });
+		this.id = id;
+	}
+};
+async function listFiles(root, include = DEFAULT_INCLUDE, exclude = DEFAULT_EXCLUDE) {
+	return (await listFiles$1(root, include, exclude)).filter((id) => !DECLARATION.test(id));
+}
+/**
+* About how many of `files` name one of `sources`, read from an even sample
+* of them: whether a build starts scan threads before its config, and so
+* its `include` and import sources, has loaded (pool.ts).
+*/
+function estimateStyled(files, sources, sample = 100) {
+	const read = Math.min(sample, files.length);
+	let styled = 0;
+	for (let k = 0; k < read; k++) {
+		const i = read === files.length ? k : Math.floor(k * GOLDEN % 1 * files.length);
+		try {
+			const code = readFileSync(files[i], "utf8");
+			if (sources.some((source) => code.includes(source))) styled++;
+		} catch {}
+	}
+	return read === 0 ? 0 : Math.round(styled / read * files.length);
+}
+const GOLDEN = (Math.sqrt(5) - 1) / 2;
+async function scan(options) {
+	const { root, system, cache } = options;
+	const config = system.config;
+	const files = await listFiles(root, config.include, config.exclude);
+	const sources = ["@menapo/vicss", ...options.importSources];
+	const depHashes = /* @__PURE__ */ new Map();
+	const depHash = (dep) => {
+		if (!depHashes.has(dep)) depHashes.set(dep, readHash(dep));
+		return depHashes.get(dep);
+	};
+	const results = Array.from({ length: files.length });
+	const failures = [];
+	const work = [];
+	for (const [index, id] of files.entries()) try {
+		const code = readFileSync(id, "utf8");
+		if (!sources.some((source) => code.includes(source))) continue;
+		const key = cache.key(code, options.configHash);
+		const entry = await cache.lookup(id, key, depHash, options.resolve);
+		if (entry) {
+			if (!isSfc(id)) options.cached?.(id, code, entry);
+			results[index] = entry;
+			continue;
+		}
+		const jobs = isSfc(id) ? extractScripts(id, code).map(({ code: text, ...script }) => ({
+			id,
+			code: text,
+			script
+		})) : [{
+			id,
+			code
+		}];
+		work.push({
+			index,
+			id,
+			code,
+			key,
+			jobs,
+			results: [],
+			left: jobs.length
+		});
+	} catch (error) {
+		failures.push({
+			index,
+			error
+		});
+	}
+	const complete = (item) => {
+		const parts = item.results;
+		const deps = {};
+		for (const dep of parts.flatMap((part) => part.dependencies)) {
+			const hash = depHash(dep);
+			if (hash !== void 0) deps[dep] = hash;
+		}
+		const sfc = isSfc(item.id);
+		const classes = [...new Set(parts.flatMap((part) => [...placeholdersIn(part.code), ...(part.names ?? []).map((name) => "!" + name)]))].sort(compareStrings);
+		const entry = !sfc && parts.length === 1 ? {
+			key: item.key,
+			deps,
+			resolutions: parts[0].resolutions,
+			atoms: parts[0].atoms,
+			tokens: parts[0].tokens,
+			rules: parts[0].rules,
+			arbitrary: parts[0].arbitrary,
+			classes,
+			output: toOutput(parts[0])
+		} : {
+			key: item.key,
+			deps,
+			resolutions: Object.assign({}, ...parts.map((part) => part.resolutions)),
+			atoms: uniqueAtoms(parts.flatMap((part) => part.atoms)),
+			tokens: uniqueBy(parts.flatMap((part) => part.tokens), (ref) => `${ref.scale}:${ref.path}`),
+			rules: uniqueBy(parts.flatMap((part) => part.rules), (rule) => rule.id),
+			arbitrary: parts.reduce((sum, part) => sum + part.arbitrary, 0),
+			classes,
+			output: {
+				code: null,
+				map: null,
+				warnings: []
+			}
+		};
+		cache.set(item.id, entry);
+		results[item.index] = entry;
+		if (!sfc) item.deferred?.resolve(parts[0]);
+	};
+	const queue = work.flatMap((item) => item.jobs.map((job, unit) => ({
+		item,
+		job,
+		unit,
+		taken: false
+	})));
+	for (const item of work) if (item.left === 0) complete(item);
+	const urgent = [];
+	let next = 0;
+	let stopAt = Infinity;
+	const take = () => {
+		for (let task = urgent.pop(); task; task = urgent.pop()) if (!task.taken && task.item.index < stopAt) return task.taken = true, task;
+		for (let task = queue[next]; task; task = queue[++next]) {
+			if (task.item.index >= stopAt) return void 0;
+			if (!task.taken) return task.taken = true, task;
+		}
+	};
+	const failed = (task, error) => {
+		failures.push({
+			index: task.item.index,
+			error
+		});
+		if (!options.keepGoing) stopAt = Math.min(stopAt, task.item.index);
+		task.item.deferred?.reject(error);
+	};
+	const settle = (task, result) => {
+		task.item.results[task.unit] = result;
+		if (--task.item.left === 0) complete(task.item);
+	};
+	for (const task of queue) {
+		const { item } = task;
+		if (isSfc(item.id)) continue;
+		item.deferred = defer();
+		options.queued?.(item.id, item.code, item.deferred.promise, () => {
+			if (!task.taken) urgent.push(task);
+		});
+	}
+	options.allQueued?.();
+	const local = (task) => options.compile(task.job.id, task.job.code, task.job.script);
+	const pool = queue.length > 200 ? options.pool?.(queue.length) : void 0;
+	/** Workers that built their compiler; until one has, this thread compiles at full width. */
+	let ready = 0;
+	let localRunners = 0;
+	const width = () => ready > 0 ? CONCURRENCY_WITH_POOL : CONCURRENCY;
+	const runLocal = async () => {
+		localRunners++;
+		try {
+			while (!(pool && localRunners > width())) {
+				const task = take();
+				if (!task) return;
+				try {
+					settle(task, await local(task));
+				} catch (error) {
+					failed(task, error);
+				}
+				if (pool) await new Promise((resolve) => setImmediate(resolve));
+			}
+		} finally {
+			localRunners--;
+		}
+	};
+	/** Local runners up to the width: no worker can take a share. */
+	const topUp = () => Array.from({ length: Math.max(0, width() - localRunners) }, () => runLocal());
+	const runRemote = async (worker) => {
+		for (let task = take(); task; task = take()) try {
+			settle(task, await worker.compile(task.job));
+		} catch (error) {
+			if (!(error instanceof WorkerLost)) {
+				failed(task, error);
+				continue;
+			}
+			try {
+				settle(task, await local(task));
+			} catch (inner) {
+				failed(task, inner);
+			}
+		}
+	};
+	try {
+		const runners = [];
+		for (let i = 0; i < Math.min(CONCURRENCY, queue.length); i++) runners.push(runLocal());
+		for (const worker of pool?.workers ?? []) runners.push(worker.ready.then((ok) => {
+			if (!ok) return Promise.all(topUp());
+			ready++;
+			return Promise.all(Array.from({ length: worker.capacity }, () => runRemote(worker)));
+		}));
+		await Promise.all(runners);
+	} finally {
+		await pool?.close();
+		const error = failures.sort((a, b) => a.index - b.index)[0]?.error;
+		for (const item of work) item.deferred?.reject(error ?? /* @__PURE__ */ new Error("vicss: the scan stopped"));
+	}
+	failures.sort((a, b) => a.index - b.index);
+	const [failure] = failures;
+	if (failure && !options.keepGoing) throw failure.error;
+	const all = results.flatMap((entry) => entry?.atoms ?? []);
+	const conflicts = conflictsOf(all, results.flatMap((entry) => entry?.rules ?? []), system);
+	const located = [];
+	if (conflicts.length > 0) {
+		const styled = files.flatMap((id, i) => results[i] ? [{
+			id,
+			atoms: results[i].atoms,
+			rules: results[i].rules
+		}] : []);
+		for (const conflict of options.keepGoing ? conflicts : conflicts.slice(0, 1)) {
+			const error = locate(conflict, styled, root, system);
+			if (!options.keepGoing) throw error;
+			located.push(error);
+		}
+	}
+	const atoms = uniqueAtoms(all);
+	const refs = /* @__PURE__ */ new Map();
+	for (const ref of results.flatMap((entry) => entry?.tokens ?? [])) refs.set(`${ref.scale}:${ref.path}`, ref);
+	const tokens = [...refs.entries()].sort(([a], [b]) => compareStrings(a, b)).map(([, r]) => r);
+	const byId = /* @__PURE__ */ new Map();
+	for (const rule of results.flatMap((entry) => entry?.rules ?? [])) if (!byId.has(rule.id)) byId.set(rule.id, rule);
+	return {
+		files,
+		atoms,
+		tokens,
+		rules: [...byId.values()].sort((a, b) => compareStrings(a.id, b.id)),
+		classes: new Set(atoms.map((atom) => atom.className)),
+		ruleIds: new Set(byId.keys()),
+		names: new Set(results.flatMap((entry) => entry?.classes ?? [])),
+		arbitrary: results.reduce((sum, entry) => sum + (entry?.arbitrary ?? 0), 0),
+		failures: [...failures.map(({ index, error }) => ({
+			id: files[index],
+			error
+		})), ...located.map((error) => ({
+			id: error.id,
+			error
+		}))]
+	};
+}
+function defer() {
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => (resolve = res, reject = rej));
+	promise.catch(() => {});
+	return {
+		promise,
+		resolve,
+		reject
+	};
+}
+/** One atom per class, sorted by class (`keepAtom`: a style's palette over a runtime value's twin). */
+function uniqueAtoms(atoms) {
+	const out = /* @__PURE__ */ new Map();
+	for (const atom of atoms) keepAtom(out, atom);
+	return [...out.values()].sort((a, b) => compareStrings(a.className, b.className));
+}
+/** One item per key, the first kept, sorted by key. */
+function uniqueBy(items, keyOf) {
+	const out = /* @__PURE__ */ new Map();
+	for (const item of items) if (!out.has(keyOf(item))) out.set(keyOf(item), item);
+	return [...out.entries()].sort(([a], [b]) => compareStrings(a, b)).map(([, item]) => item);
+}
+/** The ordering invariant's conflicts over atoms and rules: their flattened bases' atoms too. */
+function conflictsOf(atoms, rules, system) {
+	return [...checkAtoms([...atoms, ...baseAtoms(rules)], system), ...checkBases(rules)];
+}
+/**
+* Names the files behind a conflict found over every file's atoms: the first
+* file whose atoms, after those before it, raise it, and the first earlier
+* file that raises it together with that one. `checkAtoms` reports the first
+* conflict in atom order, so both searches are monotonic. Only the error
+* path pays for them.
+*/
+function locate(conflict, styled, root, system) {
+	const raises = (files) => conflictsOf(files.flatMap((file) => file.atoms), files.flatMap((file) => file.rules), system).some((e) => e.code === conflict.code && e.message === conflict.message);
+	const before = (n) => styled.slice(0, n);
+	const first = (lo, hi, holds) => {
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (holds(mid)) hi = mid;
+			else lo = mid + 1;
+		}
+		return lo;
+	};
+	const later = styled[first(1, styled.length, (n) => raises(before(n))) - 1];
+	const rel = (id) => path.relative(root, id) || id;
+	const files = [later.id];
+	if (!raises([later])) {
+		const at = first(1, styled.indexOf(later), (n) => raises([...before(n), later]));
+		files.unshift(styled[at - 1].id);
+	}
+	const message = `${conflict.message} (${files.map(rel).join(" and ")})`;
+	return new ScanConflict(conflict, later.id, message);
+}
+//#endregion
+//#region src/vite/types-file.ts
+/**
+* Where the generated `vicss.d.ts` goes and how it is written (PLAN §5.11),
+* shared by the plugin, which writes it whenever the config loads, and by
+* `vicss types` and `vicss init`. The lint snapshot (core/snapshot.ts) goes
+* next to it, with it: the rules find it there.
+*/
+/**
+* The directories a default `vicss.d.ts` goes in, the first the root has:
+* where a tsconfig's `include` usually looks, `app/` for Nuxt 4 and React
+* Router.
+*/
+const SOURCE_DIRS = ["src", "app"];
+/**
+* `output` relative to the root, else `vicss.d.ts` in the first of
+* `SOURCE_DIRS` the root has, else in the root.
+*/
+function typesFile(root, output) {
+	if (output !== void 0) return normalizePath(path.resolve(root, output));
+	const dir = SOURCE_DIRS.map((name) => path.join(root, name)).find((dir) => existsSync(dir));
+	return normalizePath(path.join(dir ?? root, "vicss.d.ts"));
+}
+/** `vicss.lint.json` in the directory of the types file. */
+function snapshotFile(types) {
+	return normalizePath(path.join(path.dirname(types), SNAPSHOT_FILE));
+}
+/**
+* The project root as the snapshot records it (`LintSnapshot.root`):
+* relative to the snapshot's directory, so a committed snapshot is the same
+* on every machine and the rules match `privateAccess` against the root.
+*/
+function snapshotRoot(snapshot, root) {
+	return normalizePath(path.relative(path.dirname(snapshot), root)) || ".";
+}
+/**
+* Writes `text` to `file` unless it holds it already, so an unchanged config
+* never touches the file (a type checker or a watcher would see an edit).
+* Returns whether it wrote.
+*/
+function writeIfChanged(file, text) {
+	try {
+		if (readFileSync(file, "utf8") === text) return false;
+	} catch {}
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, text);
+	return true;
+}
+//#endregion
+export { CompileCache as C, generateTypes as D, readHash as E, createManifest as O, report as S, hashCode as T, critical as _, ScanConflict as a, hashesJson as b, scan as c, libraryOf as d, loadLibraries as f, SheetCache as g, withLibraries as h, writeIfChanged as i, codeFrame as k, escapeRegExp as l, renameCustomProperties as m, snapshotRoot as n, estimateStyled as o, ownPackageName as p, typesFile as r, listFiles as s, snapshotFile as t, findLibraries as u, criticalPage as v, compiledOf as w, hashesProblem as x, criticalSettings as y };