@ui0/theme 0.0.0-stage → 0.1.1

package/dist/generate-BPYE5ALG.mjs

@@ -0,0 +1,1037 @@
+import config from "./config.default.mjs";
+import { SPACES, blend, darken, isArray, isLiteralColor, isNumberish, isString, lighten, sha256hex, toRgb, toUnits, tryToUnits } from "@ui0/util";
+// src/types.ts
+function schemesOf(preset) {
+	return preset;
+}
+// src/generator/base.ts
+/**
+* The base `body` reset every theme ships: margin 0 and the base font size.
+* Themed colors stay on the themed subtrees - the body itself stays neutral.
+*
+* @returns the `body {...}` rule
+*/
+function generateBaseCss() {
+	return "body {\n  margin: 0;\n  font-size: 1rem;\n}";
+}
+/** marker attribute of the injected base-reset <style> element */
+const BASE_STYLE_ATTR = "data-ui0-theme-base";
+/**
+* Inject the base body reset into a document, idempotently - a second call
+* finds the previously created `<style>` and returns it untouched.
+*
+* @param doc - the document to inject into (defaults to the global one)
+* @returns the style element carrying the reset
+*/
+function ensureThemeBaseStyle(doc = document) {
+	const selector = `style[${BASE_STYLE_ATTR}]`;
+	const existing = doc.head.querySelector(selector);
+	if (existing) return existing;
+	const el = doc.createElement("style");
+	el.setAttribute(BASE_STYLE_ATTR, "");
+	el.textContent = generateBaseCss();
+	doc.head.appendChild(el);
+	return el;
+}
+// src/contracts/backdrop/backdrop.module.css.ui0-map
+var backdrop_module_css_default = { "backdrop": "ba_d486" };
+// src/contracts/backdrop/backdrop.generator.ts
+/** fallback value per function when the config omits the value */
+const DEFAULTS = {
+	blur: "4px",
+	brightness: "0.5",
+	contrast: "0.5",
+	"drop-shadow": "0 4px 8px rgba(0, 0, 0, 0.5)",
+	grayscale: "1",
+	"hue-rotate": "90deg",
+	invert: "1",
+	opacity: "0.5",
+	saturate: "0.5",
+	sepia: "1"
+};
+const backdropGenerator = (ctx) => {
+	const { hash } = ctx;
+	const config = ctx.config.backdrop;
+	const backdropSettings = ctx.settings.backdrop;
+	const fnSettings = backdropSettings === false ? {} : backdropSettings ?? {};
+	const fromConfig = config ? Object.keys(config) : ["blur"];
+	const enabled = [.../* @__PURE__ */ new Set([...fromConfig, ...Object.keys(fnSettings).filter((fn) => fnSettings[fn])])].filter((fn) => fnSettings[fn] !== false);
+	function vars() {
+		const backdrop = {};
+		for (const fn of enabled) backdrop[fn] = `${config?.[fn] ?? DEFAULTS[fn]}`;
+		return { backdrop };
+	}
+	console.log("hash", backdrop_module_css_default.backdrop);
+	return {
+		namespace: "bd",
+		vars: (scheme) => scheme ? {} : vars(),
+		css: () => {
+			return `.${backdrop_module_css_default.backdrop} {\n  backdrop-filter: var(--0-backdrop);\n  -webkit-backdrop-filter: var(--0-backdrop);\n  will-change: backdrop-filter;\n}`;
+		},
+		class: () => ({ ...backdrop_module_css_default }),
+		styles: () => ({})
+	};
+};
+// src/generator/pool.ts
+const DEFAULT_RAMP_TYPES = ["l", "d"];
+/** Read the per-color options out of a pool entry's 3rd tuple element. */
+function colorOptions(raw) {
+	const opt = Array.isArray(raw) ? raw[2] : void 0;
+	if (Array.isArray(opt)) return {
+		ramps: opt,
+		space: "hsl"
+	};
+	if (opt && typeof opt === "object") return {
+		ramps: opt.ramps || [],
+		space: opt.space || "hsl"
+	};
+	return {
+		ramps: [],
+		space: "hsl"
+	};
+}
+/**
+* The ramp types a pool entry wants generated: the defaults (l/d) plus any
+* extras (c/s) from its options, deduped, order-stable.
+*
+* @param raw - the pool entry to read options from
+* @returns the ramp types to emit for this entry
+*/
+function requestedRampTypes(raw) {
+	return [.../* @__PURE__ */ new Set([...DEFAULT_RAMP_TYPES, ...colorOptions(raw).ramps])];
+}
+/** merge a scheme's pool over the base pool (scheme wins per entry) */
+function buildPool(base, scheme) {
+	return {
+		...base,
+		...scheme
+	};
+}
+/**
+* Resolve a whole color pool into base RGB triples plus per-color ramps.
+*
+* Entries may be literals (`'#fff'`, `'rgb(...)'`, named), aliases (`'brand'`),
+* ramp-step references (`'brand-l2'`) or blend expressions
+* (`[['#0d654e', '#000', 50], 3]`); cycles (background referencing a ramp
+* that needs background's lightness) are broken by resolving only what each
+* step needs - ramp arrays are built lazily and cached per (color, type).
+*
+* @param pool - the pool slice of an appearance config
+* @returns resolved base colors and the generated ramps
+* @throws on circular references and unknown color names
+*/
+function resolvePool(pool) {
+	const resolvedBase = {};
+	const resolvedRampArrays = {};
+	const resolvingBase = /* @__PURE__ */ new Set();
+	/** Resolve any reference form to an RGB triple (literal / ramp step / alias). */
+	function resolveRef(ref) {
+		if (isLiteralColor(ref)) return toRgb(ref);
+		const m = ref.match(/^(.+)-([ldcs])(\d+)$/);
+		if (m) {
+			const [, refName, type, stepStr] = m;
+			return getRampArray(refName, type)[Number(stepStr) - 1];
+		}
+		resolveBase(ref);
+		return resolvedBase[ref];
+	}
+	/** Resolve a non-string entry: a [color, steps] tuple or a blend expression. */
+	function resolveExpr(expr) {
+		if (Array.isArray(expr[0])) {
+			const [c1, c2, depth] = expr[0];
+			return {
+				base: blend(typeof c1 === "string" ? resolveRef(c1) : c1, typeof c2 === "string" ? resolveRef(c2) : c2, depth),
+				steps: expr[1]
+			};
+		}
+		return {
+			base: resolveRef(expr[0]),
+			steps: expr[1]
+		};
+	}
+	/**
+	* Resolve ONLY the base value - never needs the scheme's background lightness,
+	* so it can be called while resolving background itself without a cycle.
+	*/
+	function resolveBase(name) {
+		if (name in resolvedBase) return;
+		if (resolvingBase.has(name)) throw new Error(`circular color reference: ${name}`);
+		resolvingBase.add(name);
+		const raw = pool[name];
+		if (raw === void 0) throw new Error(`unknown color reference: ${name}`);
+		resolvedBase[name] = typeof raw === "string" ? resolveRef(raw) : resolveExpr(raw).base;
+		resolvingBase.delete(name);
+	}
+	/**
+	* The background's lightness, read in the SAME space as the color being
+	* ramped, so the "which side of 50" comparison stays apples-to-apples.
+	*/
+	function baseLightness(space) {
+		resolveBase("background");
+		return SPACES[space].lightnessOf(resolvedBase.background);
+	}
+	/** Build (and cache) one color's ramp of one type, lazily. */
+	function getRampArray(name, type) {
+		resolvedRampArrays[name] = resolvedRampArrays[name] || {};
+		const cached = resolvedRampArrays[name][type];
+		if (cached) return cached;
+		resolveBase(name);
+		const raw = pool[name];
+		const steps = raw[1];
+		const base = resolvedBase[name];
+		const { space } = colorOptions(raw);
+		let arr;
+		if (type === "l") arr = Array.from({ length: steps }, (_, i) => lighten(base, i + 1, steps, space));
+		else if (type === "d") arr = Array.from({ length: steps }, (_, i) => darken(base, i + 1, steps, space));
+		else {
+			const bg = name === "background" ? SPACES[space].lightnessOf(base) : baseLightness(space);
+			arr = type === "c" ? Array.from({ length: steps }, (_, i) => bg < 50 ? lighten(base, i + 1, steps, space) : darken(base, i + 1, steps, space)) : Array.from({ length: steps }, (_, i) => bg < 50 ? darken(base, i + 1, steps, space) : lighten(base, i + 1, steps, space));
+		}
+		resolvedRampArrays[name][type] = arr;
+		return arr;
+	}
+	for (const name of Object.keys(pool)) {
+		resolveBase(name);
+		if (typeof pool[name] !== "string") for (const type of requestedRampTypes(pool[name])) getRampArray(name, type);
+	}
+	return {
+		base: resolvedBase,
+		ramps: resolvedRampArrays
+	};
+}
+// src/contracts/color/color.token.ts
+const ColorSchemeValues = ["light", "dark"];
+const ColorPseudoValues = [
+	"hover",
+	"active",
+	"focus"
+];
+const SPACE = /\s+/;
+/** parse a `<ref>[@pct]` tail into ref + opacity (0..1) */
+function parseRef(raw) {
+	const at = raw.lastIndexOf("@");
+	if (at === -1) return { ref: raw };
+	const ref = raw.slice(0, at);
+	const pct = raw.slice(at + 1);
+	if (!ref || !isNumberish(pct)) throw new Error(`ui0 color: invalid ref "${raw}" (expected name[@pct])`);
+	const n = Number(pct);
+	if (n < 0 || n > 100) throw new Error(`ui0 color: opacity ${pct} out of 0..100 in "${raw}"`);
+	return {
+		ref,
+		opacity: n / 100
+	};
+}
+function parseToken(raw) {
+	const segments = raw.split(":");
+	const out = { ref: "" };
+	while (segments.length > 1) {
+		const head = segments[0];
+		if (ColorSchemeValues.includes(head)) out.scheme = head;
+		else if (ColorPseudoValues.includes(head)) out.pseudo = head;
+		else throw new Error(`ui0 color: unknown prefix "${head}" in "${raw}" (expected light|dark|hover|active|focus)`);
+		segments.shift();
+	}
+	Object.assign(out, parseRef(segments[0]));
+	if (!out.ref) throw new Error(`ui0 color: missing color ref in "${raw}"`);
+	return out;
+}
+/** parse a color/fill prop value into tokens (one per layer) */
+function parseColorProp(value) {
+	const raws = (isString(value) ? value.split(SPACE) : isArray(value) ? value : []).map((x) => String(x).trim()).filter(Boolean);
+	const tokens = [];
+	let sawPair = false;
+	let sawNamedScheme = false;
+	for (const raw of raws) if (raw.includes("/")) {
+		const pair = raw.split("/");
+		if (pair.length !== 2 || !pair[0] || !pair[1]) throw new Error(`ui0 color: "${raw}" is not a light/dark pair (spell single-scheme as dark:ref)`);
+		if (pair[0].includes(":") || pair[1].includes(":")) throw new Error(`ui0 color: "${raw}" - pair segments must be plain refs (name[-ramp][@pct]); prefixed parts need the named form: light:<ref> [pseudo:]<ref>`);
+		tokens.push({
+			scheme: "light",
+			...parseRef(pair[0])
+		});
+		tokens.push({
+			scheme: "dark",
+			...parseRef(pair[1])
+		});
+		sawPair = true;
+	} else {
+		const token = parseToken(raw);
+		if (token.scheme) sawNamedScheme = true;
+		tokens.push(token);
+	}
+	if (sawPair && sawNamedScheme) throw new Error("ui0 color: a positional `a/b` pair cannot mix with light:/dark: prefixes in one prop");
+	return tokens;
+}
+// src/contracts/color/color.inject.module.css.ui0-inject
+var color_inject_module_css_default = ".co_ca8c { /* slot marker */ }\n.fi_8a2f { /* slot marker */ }\n.gr_9658 { /* slot marker */ }";
+// src/contracts/color/color.module.css.ui0-map
+var color_module_css_default = {
+	"colored": "co_ca8c",
+	"filled": "fi_8a2f",
+	"gradiented": "gr_9658"
+};
+// src/contracts/color/color.generator.ts
+function channels(rgb) {
+	return rgb.map((v) => Math.round(v)).join(" ");
+}
+const PSEUDOS = [void 0, ...ColorPseudoValues];
+const GATINGS = [{
+	prefix: "",
+	selector: ""
+}, ...ColorSchemeValues.map((s) => ({
+	prefix: `${s}-`,
+	selector: `.theme_${s} `
+}))];
+const SLOTS = ["c", "f"];
+const colorGenerator = (ctx) => {
+	const { config, hash } = ctx;
+	function vars() {
+		const pool = config.color;
+		const merged = buildPool(pool, void 0);
+		if (!Object.keys(merged).length) return {};
+		const { base, ramps } = resolvePool(merged);
+		const c = {};
+		for (const [name, rgb] of Object.entries(base)) {
+			c[`${name}-v`] = channels(rgb);
+			const ramp = ramps[name];
+			if (!ramp) continue;
+			for (const [type, steps] of Object.entries(ramp)) steps?.forEach((rgbStep, i) => {
+				c[`${name}-${type}${i + 1}-v`] = channels(rgbStep);
+			});
+		}
+		if ("foreground" in base) c["cur-v"] = "var(--0-c-foreground-v)";
+		c.cur = "rgb(var(--0-c-cur-v, var(--0-c-foreground-v)) / var(--0-c-o, 1))";
+		const f = {};
+		if ("background" in base) f["cur-v"] = "var(--0-c-background-v)";
+		f.cur = "rgb(var(--0-f-cur-v, var(--0-c-background-v)) / var(--0-f-o, 1))";
+		return {
+			c,
+			f
+		};
+	}
+	function css() {
+		const pool = config.color;
+		const names = Object.keys(buildPool(pool, void 0));
+		if (!names.length) return color_inject_module_css_default;
+		const lines = [];
+		for (const { prefix, selector } of GATINGS) for (const pseudo of PSEUDOS) {
+			const pseudoPrefix = pseudo ? `${pseudo}-` : "";
+			const pseudoSuffix = pseudo ? `:${pseudo}` : "";
+			for (const name of names) for (const slot of SLOTS) {
+				const cls = `${prefix}${pseudoPrefix}${slot}-${name}`;
+				const ns = slot === "c" ? "--0-c" : "--0-f";
+				lines.push(`${selector}.${hash(cls)}${pseudoSuffix} { ${ns}-cur-v: var(--0-c-${name}-v); }`);
+			}
+		}
+		return `${color_inject_module_css_default}\n${lines.join("\n")}`;
+	}
+	function classes() {
+		const out = { ...color_module_css_default };
+		const pool = config.color;
+		const names = Object.keys(buildPool(pool, void 0));
+		for (const { prefix } of GATINGS) for (const pseudo of PSEUDOS) {
+			const pseudoPrefix = pseudo ? `${pseudo}-` : "";
+			for (const name of names) for (const slot of SLOTS) out[`${prefix}${pseudoPrefix}${slot}-${name}`] = hash(`${prefix}${pseudoPrefix}${slot}-${name}`);
+		}
+		return out;
+	}
+	return {
+		namespace: "c",
+		vars: (scheme) => scheme ? {} : vars(),
+		css,
+		class: classes,
+		styles: () => ({})
+	};
+};
+// src/contracts/disabled/disabled.inject.module.css.ui0-inject
+var disabled_inject_module_css_default = ".di_17eb {\n  opacity: var(--0-dis-o, 0.5);\n}";
+// src/contracts/disabled/disabled.module.css.ui0-map
+var disabled_module_css_default = { "disabled": "di_17eb" };
+// src/contracts/disabled/disabled.generator.ts
+const disabledGenerator = (ctx) => {
+	const { config } = ctx;
+	function vars() {
+		const disabled = config.disabled;
+		if (disabled?.opacity === void 0) return {};
+		return { dis: { o: disabled.opacity } };
+	}
+	return {
+		namespace: "dis",
+		vars: (scheme) => scheme ? {} : vars(),
+		css: () => disabled_inject_module_css_default,
+		class: () => ({ ...disabled_module_css_default }),
+		styles: () => ({})
+	};
+};
+// src/contracts/display/display.module.css.ui0-map
+var display_module_css_default = {
+	"displayed": "di_e228",
+	"displayNormal": "di_bf77"
+};
+// src/contracts/display/display.generator.ts
+const displayGenerator = (ctx) => {
+	const { config } = ctx;
+	function vars() {
+		const display = config.display;
+		if (display?.base === void 0) return {};
+		return { display: { base: display.base } };
+	}
+	return {
+		namespace: "d",
+		vars: (scheme) => scheme ? {} : vars(),
+		css: () => `.${display_module_css_default.displayed} { /* point the component slot at the theme var */ }`,
+		localScss: () => {
+			const brp = ctx.settings.display?.breakpoints;
+			const out = {};
+			if (brp) Object.keys(brp).forEach((k) => {
+				out[`$${k}`] = toUnits(brp[k]);
+			});
+			return out;
+		},
+		class: () => ({ ...display_module_css_default }),
+		styles: () => {
+			const brp = ctx.settings.display?.breakpoints;
+			const out = {};
+			if (brp) Object.keys(brp).forEach((k) => {
+				out[`--0-display-${k}`] = toUnits(brp[k]);
+			});
+			return out;
+		}
+	};
+};
+// src/contracts/elevation/elevation.module.css.ui0-map
+var elevation_module_css_default = {
+	"elv": "el_b4e0",
+	"elv1": "el_5e0f",
+	"elv1n": "el_5995",
+	"elv2": "el_fb8f",
+	"elv2n": "el_af23",
+	"elv3": "el_8867",
+	"elv3n": "el_6c3d",
+	"elv4": "el_4d5e",
+	"elv4n": "el_a211",
+	"elv5": "el_1ab1",
+	"elv5n": "el_2df9",
+	"elv6": "el_56bd",
+	"elv6n": "el_b036",
+	"elv7": "el_61ea",
+	"elv7n": "el_8003",
+	"elv8": "el_8924",
+	"elv8n": "el_7bc0",
+	"elv9": "el_1bb1",
+	"elv9n": "el_734f",
+	"elv10": "el_40d4",
+	"elv10n": "el_ef94",
+	"elv11": "el_a016",
+	"elv11n": "el_fcd8",
+	"elv12": "el_1c39",
+	"elv12n": "el_ba0c",
+	"elv13": "el_5602",
+	"elv13n": "el_d306",
+	"elv14": "el_3f15",
+	"elv14n": "el_ece8",
+	"elv15": "el_3130",
+	"elv15n": "el_5599",
+	"elv16": "el_c651",
+	"elv16n": "el_f2d2"
+};
+// src/contracts/elevation/elevation.generator.ts
+const BASE_CLASS_BODY = `  box-shadow:
+    0 0 0 1px rgba(255 255 255 / .1),
+    var(--0-elv-i, ) 0px 1px 1px rgba(var(--0-elv-c, 0 0 0) / 0.1),
+    var(--0-elv-i, ) var(--0-elv-x1, 0px) var(--0-elv-y1, 0px) rgba(var(--0-elv-c, 0 0 0) / 0.095),
+    var(--0-elv-i, ) var(--0-elv-x2, 0px) var(--0-elv-y2, 0px) rgba(var(--0-elv-c, 0 0 0) / 0.13);`;
+const elevationGenerator = (ctx) => {
+	const { config, hash } = ctx;
+	const steps = config.elevation?.steps ?? 16;
+	function vars() {
+		return { elv: {
+			x1: "1px",
+			y1: "calc(var(--0-elv-x1) * 3)",
+			x2: "calc(var(--0-elv-x1) * 1.5)",
+			y2: "calc(var(--0-elv-x1) * 1.5)"
+		} };
+	}
+	function stepVars(i, inset) {
+		const lines = [`  --0-elv-x1: ${i}px;`];
+		if (inset) lines.push("  --0-elv-i: inset;");
+		return lines.join("\n");
+	}
+	function css() {
+		const lines = [`.${elevation_module_css_default.elv} {\n${BASE_CLASS_BODY}\n}`];
+		for (let i = 1; i <= steps; i++) {
+			lines.push(`.${hash(`elv${i}`)} {\n${stepVars(i, false)}\n}`);
+			lines.push(`.${hash(`elv${i}n`)} {\n${stepVars(i, true)}\n}`);
+		}
+		return lines.join("\n");
+	}
+	function classes() {
+		const out = { ...elevation_module_css_default };
+		for (let i = 1; i <= steps; i++) {
+			out[`elv${i}`] = hash(`elv${i}`);
+			out[`elv${i}n`] = hash(`elv${i}n`);
+		}
+		return out;
+	}
+	return {
+		namespace: "e",
+		vars,
+		css,
+		class: classes,
+		styles: () => ({})
+	};
+};
+// src/contracts/round/round.inject.module.scss.ui0-inject
+var round_inject_module_scss_default = ".rF_7ee9 {\n  --0-r-tl: var(--0c-r-full, var(--0-r-full));\n  --0-r-tr: var(--0c-r-full, var(--0-r-full));\n  --0-r-bl: var(--0c-r-full, var(--0-r-full));\n  --0-r-br: var(--0c-r-full, var(--0-r-full));\n}\n\n.rS_e0da {\n  --0-r-tl: var(--0c-r-smooth, var(--0-r-smooth));\n  --0-r-tr: var(--0c-r-smooth, var(--0-r-smooth));\n  --0-r-bl: var(--0c-r-smooth, var(--0-r-smooth));\n  --0-r-br: var(--0c-r-smooth, var(--0-r-smooth));\n}\n\n.rB_2f08 {\n  --0-r-tl: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-tr: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-bl: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-br: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.rH_7415 {\n  --0-r-tl: var(--0c-r-hard, var(--0-r-hard));\n  --0-r-tr: var(--0c-r-hard, var(--0-r-hard));\n  --0-r-bl: var(--0c-r-hard, var(--0-r-hard));\n  --0-r-br: var(--0c-r-hard, var(--0-r-hard));\n}\n\n.rN_2296 {\n  --0-r-tl: var(--0c-r-none, var(--0-r-none));\n  --0-r-tr: var(--0c-r-none, var(--0-r-none));\n  --0-r-bl: var(--0c-r-none, var(--0-r-none));\n  --0-r-br: var(--0c-r-none, var(--0-r-none));\n}\n\n.ro_0102 {\n  --0-r-tl: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-tr: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-bl: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-br: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.rl_52df {\n  --0-r-tl: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-bl: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.rr_597c {\n  --0-r-tr: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-br: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.rt_cdff {\n  --0-r-tl: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-tr: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.rb_64f2 {\n  --0-r-bl: var(--0c-r-basic, var(--0-r-basic));\n  --0-r-br: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.tl_e660 {\n  --0-r-tl: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.tr_7817 {\n  --0-r-tr: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.bl_29d9 {\n  --0-r-bl: var(--0c-r-basic, var(--0-r-basic));\n}\n\n.br_8850 {\n  --0-r-br: var(--0c-r-basic, var(--0-r-basic));\n}";
+// src/contracts/round/round.module.css.ui0-map
+var round_module_css_default = {
+	"rounded": "ro_0102",
+	"rBasic": "rB_2f08",
+	"rSmooth": "rS_e0da",
+	"rHard": "rH_7415",
+	"rNone": "rN_2296",
+	"rFull": "rF_7ee9",
+	"rl": "rl_52df",
+	"rr": "rr_597c",
+	"rt": "rt_cdff",
+	"rb": "rb_64f2",
+	"br": "br_8850",
+	"bl": "bl_29d9",
+	"tl": "tl_e660",
+	"tr": "tr_7817"
+};
+// src/contracts/round/round.generator.ts
+const roundGenerator = () => {
+	return {
+		namespace: "r",
+		vars: () => ({}),
+		css: () => round_inject_module_scss_default,
+		class: () => ({ ...round_module_css_default }),
+		styles: () => ({
+			"--0-r-base": "4px",
+			"--0-r-tl": "0px",
+			"--0-r-tr": "0px",
+			"--0-r-bl": "0px",
+			"--0-r-basic": "calc(var(--0-s-m, 42px) * var(--0-s-density, 1))",
+			"--0-r-br": "0px"
+		})
+	};
+};
+// src/generator/scales.ts
+const SCALE_RATIO = 1.2;
+const SCALE_STEPS = [
+	"xxxs",
+	"xxs",
+	"xs",
+	"s",
+	"m",
+	"l",
+	"xl",
+	"xxl",
+	"xxxl"
+];
+/** The step -> value map of one geometric scale. */
+function scaleValues(base, ratio) {
+	const out = {};
+	for (const step of SCALE_STEPS) out[step] = base * ratio ** (SCALE_STEPS.indexOf(step) - SCALE_STEPS.indexOf("m"));
+	return out;
+}
+/**
+* Expand a single base value into the xxxs..xxxl scale with PURE step names
+* (no `--0-` prefix - the caller assigns the namespace).
+*
+* Three scales use this: `fs` (text font-size), `s` (control heights - a
+* component's `size` prop picks a step) and `sc` (a control's child heights).
+* An unparseable value (e.g. 'inherit') emits only the `m` step verbatim.
+*
+* @param value - the base value (the "m" step)
+* @param ratio - the geometric ratio between steps
+* @returns the pure step -> value map
+*/
+function renderScale(value, ratio = SCALE_RATIO) {
+	const m = String(value).match(/^([\d.]+)([a-z%]*)$/i);
+	if (!m) return { m: value };
+	const base = parseFloat(m[1]);
+	const unit = m[2] || "px";
+	const round = (n) => unit === "px" ? Math.round(n) : Math.round(n * 1e3) / 1e3;
+	const values = scaleValues(base, ratio);
+	return Object.fromEntries(SCALE_STEPS.map((step) => [step, `${round(values[step])}${unit}`]));
+}
+/**
+* The global unit scales, emitted on the theme so they ALWAYS exist - a
+* component that doesn't opt into the `sizeable()` mixin simply inherits
+* them. Each is a calc() off the theme's own base vars (same formula the
+* SCSS `sizeable()` mixin uses locally, so a component can re-derive the
+* control units under its own `size`):
+*
+*   `--0-u{1..8}`   <- `--0-u-base`                (spacing / typography)
+*   `--0-uc{1..8}`  <- `--0-s-m` x density / 14    (control units)
+*   `--0-ucc{1..4}` <- `--0-sc-m` x density / 10   (control-child units)
+*
+* @param ns - the namespace step 1 lands in (only used for the calc refs to
+*   `--0-<ns>-1`)
+* @param first - the value of the `1` step (usually a calc off the base)
+* @param count - how many steps to emit
+* @returns the pure step -> value map
+*/
+function renderUnits(ns, first, count) {
+	const out = { 1: first };
+	for (let i = 2; i <= count; i++) out[i] = `calc(var(--0-${ns}1) * ${i})`;
+	return out;
+}
+// src/contracts/size/size.inject.module.scss.ui0-inject
+var size_inject_module_scss_default = ".si_bce5 {\n  --0-s: var(--0-s-xxxs);\n}\n\n.si_87d4 {\n  --0-s: var(--0-s-xxs);\n}\n\n.si_0820 {\n  --0-s: var(--0-s-xs);\n}\n\n.si_9329 {\n  --0-s: var(--0-s-s);\n}\n\n.si_96e7 {\n  --0-s: var(--0-s-m);\n}\n\n.si_05f9 {\n  --0-s: var(--0-s-l);\n}\n\n.si_81de {\n  --0-s: var(--0-s-xl);\n}\n\n.si_d16b {\n  --0-s: var(--0-s-xxl);\n}\n\n.si_5136 {\n  --0-s: var(--0-s-xxxl);\n}\n\n.si_e681 {\n  --0-s: var(--0-s-custom);\n}";
+// src/contracts/size/size.module.css.ui0-map
+var size_module_css_default = {
+	"sizeXl": "si_81de",
+	"sizeM": "si_96e7",
+	"sizeXs": "si_0820",
+	"sizeS": "si_9329",
+	"sizeL": "si_05f9",
+	"sizeXxs": "si_87d4",
+	"sizeXxxs": "si_bce5",
+	"sizeXxxl": "si_5136",
+	"sizeXxl": "si_d16b",
+	"sizeCustom": "si_e681",
+	"sized": "si_3f5b",
+	"child": "ch_ddc9",
+	"fontSizing": "fo_5e6f"
+};
+// src/contracts/size/size.generator.ts
+const CONTROL_UNIT_DIVIDER = 14;
+const CONTROL_CHILD_UNIT_DIVIDER = 10;
+const sizeGenerator = (ctx) => {
+	const { config } = ctx;
+	function vars() {
+		const out = {};
+		const size = config.size;
+		if (size?.control !== void 0) {
+			out.s = renderScale(size.control, SCALE_RATIO);
+			out.uc = renderUnits("uc", `calc(var(--0-s-m) * var(--0-s-density, 1) / ${CONTROL_UNIT_DIVIDER})`, 8);
+		}
+		if (size?.child !== void 0) {
+			out.sc = renderScale(size.child);
+			out.ucc = renderUnits("ucc", `calc(var(--0-sc-m) * var(--0-s-density, 1) / ${CONTROL_CHILD_UNIT_DIVIDER})`, 4);
+		}
+		if (size?.control !== void 0 || size?.child !== void 0) out.s = {
+			...out.s,
+			density: 1
+		};
+		return out;
+	}
+	return {
+		namespace: "s",
+		vars: (scheme) => scheme ? {} : vars(),
+		css: () => size_inject_module_scss_default,
+		class: () => ({ ...size_module_css_default }),
+		styles: () => ({})
+	};
+};
+// src/contracts/style/style.generator.ts
+const styleGenerator = (ctx) => {
+	const { config } = ctx;
+	function vars() {
+		const style = config.style;
+		if (!style?.vars) return {};
+		return { style: Object.fromEntries(Object.entries(style.vars)) };
+	}
+	function styles() {
+		const style = config.style;
+		if (!style?.raw) return {};
+		return { ...style.raw };
+	}
+	return {
+		namespace: "style",
+		vars: (scheme) => scheme ? {} : vars(),
+		css: () => "",
+		class: () => ({}),
+		styles: (scheme) => scheme ? {} : styles()
+	};
+};
+// src/contracts/typography/typography.inject.module.css.ui0-inject
+var typography_inject_module_css_default = ".fw_f5d2 { font-weight: 100 }\n.fw_25c0 { font-weight: 200 }\n.fw_de2b { font-weight: 300 }\n.fw_a02f { font-weight: 400 }\n.fw_c057 { font-weight: 500 }\n.fw_aee5 { font-weight: 600 }\n.fw_3207 { font-weight: 700 }\n.fw_d808 { font-weight: 800 }\n.fw_bb66 { font-weight: 900 }\n\n.tt_c60d { text-transform: uppercase }\n.tt_56d5 { text-transform: lowercase }\n.tt_ce2a { text-transform: capitalize }\n.tt_1ff4 { text-transform: none }\n.tt_59a5 { text-transform: full-width }\n.tt_50f0 { text-transform: full-size-kana }\n\n.ta_c49e { text-align: start }\n.ta_e1d2 { text-align: end }\n.ta_d725 { text-align: center }\n.ta_3342 { text-align: left }\n.ta_e5b8 { text-align: right }\n.ta_010c { text-align: justify }\n.ta_0241 { text-align: match-parent }\n\n.to_a88e { text-orientation: mixed }\n.to_4919 { text-orientation: sideways }\n.to_2640 { text-orientation: sideways-right }\n.to_de51 { text-orientation: use-glyph-orientation }\n.to_35e5 { text-orientation: upright }\n\n.tw_83bf { text-wrap: nowrap }\n.tw_d03a { text-wrap: wrap }\n.tw_4fdb { text-wrap: balance }\n.tw_f5a3 { text-wrap: pretty }\n.tw_698e { text-wrap: stable }\nh1, h2, h3, h4, h5, h6 {\n    --0-typo-step: 0.25rem; /* шаг (длина) */\n    font-size: calc(var(--0-typo-h-fs, var(--0-typo-fs, 1rem)) + var(--0-typo-step) * var(--0-typo-x));\n    line-height: calc(1 + 1 / var(--0-typo-x));\n\n}\nh1 { --0-typo-x: 6; }\nh2 { --0-typo-x: 5; }\nh3 { --0-typo-x: 4; }\nh4 { --0-typo-x: 3; }\nh5 { --0-typo-x: 2; }\nh6 { --0-typo-x: 1; }";
+// src/contracts/typography/typography.module.css.ui0-map
+var typography_module_css_default = {
+	"fw100": "fw_f5d2",
+	"fw200": "fw_25c0",
+	"fw300": "fw_de2b",
+	"fw400": "fw_a02f",
+	"fw500": "fw_c057",
+	"fw600": "fw_aee5",
+	"fw700": "fw_3207",
+	"fw800": "fw_d808",
+	"fw900": "fw_bb66",
+	"tt-uppercase": "tt_c60d",
+	"tt-lowercase": "tt_56d5",
+	"tt-capitalize": "tt_ce2a",
+	"tt-none": "tt_1ff4",
+	"tt-full": "tt_59a5",
+	"tt-full-size-kana": "tt_50f0",
+	"ta-center": "ta_d725",
+	"ta-end": "ta_e1d2",
+	"ta-justify": "ta_010c",
+	"ta-left": "ta_3342",
+	"ta-match-parent": "ta_0241",
+	"ta-right": "ta_e5b8",
+	"ta-start": "ta_c49e",
+	"to-mixed": "to_a88e",
+	"to-sideways": "to_4919",
+	"to-sideways-right": "to_2640",
+	"to-use-glyph-orientation": "to_de51",
+	"to-upright": "to_35e5",
+	"tw-nowrap": "tw_83bf",
+	"tw-wrap": "tw_d03a",
+	"tw-balance": "tw_4fdb",
+	"tw-pretty": "tw_f5a3",
+	"tw-stable": "tw_698e"
+};
+// src/contracts/typography/typography.generator.ts
+const typographyGenerator = (ctx) => {
+	function vars() {
+		if (ctx.settings.typography) {
+			const { headingRatio, fontSizeHeading, fontSize } = ctx.settings.typography;
+			return { typo: {
+				fs: tryToUnits(fontSize),
+				"h-ratio": headingRatio,
+				"h-fs": toUnits(fontSizeHeading) || tryToUnits(fontSize)
+			} };
+		}
+		return {};
+	}
+	return {
+		namespace: "t",
+		vars: (scheme) => scheme ? {} : vars(),
+		css: () => typography_inject_module_css_default,
+		class: () => ({ ...typography_module_css_default }),
+		styles: () => ({})
+	};
+};
+// src/generator.ts
+const contractGenerators = {
+	size: sizeGenerator,
+	color: colorGenerator,
+	round: roundGenerator,
+	backdrop: backdropGenerator,
+	elevation: elevationGenerator,
+	disabled: disabledGenerator,
+	display: displayGenerator,
+	typography: typographyGenerator,
+	style: styleGenerator
+};
+// src/generator/hash.ts
+/** deterministic scoped name for a class-registry entry: xx_<sha256(name):4> */
+function hashClassName(name) {
+	const hash = sha256hex(name).slice(0, 4);
+	return `${name.slice(0, 2)}_${hash}`;
+}
+// src/generator/contracts.ts
+/**
+* Run every registered contract factory against one resolved appearance
+* config. See {@link ContractGeneratorResult} for the collected shape.
+*
+* @param presetName - the preset being generated (goes into the context)
+* @param config - the resolved appearance config (extends flattened, base
+*   merged under the scheme)
+* @param hash - class-name hasher; defaults to the distiller-lockstep hasher
+* @param settings - the consumer's contract settings (ThemePluginConfig.contracts)
+* @param factories - the registry to run; defaults to the built-in
+*   {@link contractGenerators} - external contract packages merge their own
+*   default-exported factories in and pass the merged map
+*/
+function runContractGenerators(presetName, config, hash = hashClassName, settings = {}, factories = contractGenerators) {
+	const ctx = {
+		presetName,
+		config,
+		settings,
+		hash
+	};
+	const generators = {};
+	const themeVars = {};
+	const themeStyles = {};
+	const themeBlocks = [];
+	const schemeVars = {
+		default: {},
+		dark: {},
+		light: {}
+	};
+	const schemeStyles = {
+		default: {},
+		dark: {},
+		light: {}
+	};
+	const contractCss = {};
+	const contractLocalScss = {};
+	for (const [name, factory] of Object.entries(factories)) {
+		if (settings[name] === false) continue;
+		const generator = factory(ctx);
+		generators[name] = generator;
+		const vars = flattenVars(generator.vars());
+		const styles = generator.styles();
+		Object.assign(themeVars, vars);
+		Object.assign(themeStyles, styles);
+		themeBlocks.push({
+			contract: name,
+			vars,
+			styles
+		});
+		for (const scheme of [
+			"default",
+			"dark",
+			"light"
+		]) {
+			Object.assign(schemeVars[scheme], flattenVars(generator.vars(scheme)));
+			Object.assign(schemeStyles[scheme], generator.styles(scheme));
+		}
+		const css = generator.css();
+		if (css) contractCss[name] = css;
+		const localScss = generator.localScss?.();
+		if (localScss && Object.keys(localScss).length) contractLocalScss[name] = localScss;
+	}
+	return {
+		generators,
+		themeStyles,
+		themeVars,
+		themeBlocks,
+		schemeVars,
+		schemeStyles,
+		contractCss,
+		contractLocalScss
+	};
+}
+/**
+* Expand a generator's namespaced pure vars into the flat global form:
+* `{ s: { m: '32px' } }` -> `{ '--0-s-m': '32px' }`. Numeric keys join the
+* namespace directly (`{ uc: { 1: x } }` -> `--0-uc1`) - the unit-scale
+* convention; every other key takes a dash (`--0-<ns>-<name>`).
+*/
+function flattenVars(namespaced) {
+	const out = {};
+	for (const [ns, list] of Object.entries(namespaced)) for (const [k, v] of Object.entries(list)) out[/^\d/.test(k) ? `--0-${ns}${k}` : `--0-${ns}-${k}`] = v;
+	return out;
+}
+// src/generator/theme-def.ts
+/** Type guard: a plain record (not an array, not null) - deepMerge recurses
+* into these and overwrites anything else. */
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Deep-merge `from` over `to` and return a new object.
+*
+* Nested plain objects merge key by key; anything else (scalars, arrays,
+* class instances, mismatched types) is replaced wholesale - `from` wins.
+* Neither input is mutated.
+*
+* @param to - the base object (weakest)
+* @param from - the object merged on top (strongest)
+* @returns the merged object
+*/
+function deepMerge(to, from) {
+	const result = { ...to };
+	for (const key in from) if (key in to && isPlainObject(to[key]) && isPlainObject(from[key])) result[key] = deepMerge(to[key], from[key]);
+	else result[key] = from[key];
+	return result;
+}
+/**
+* Resolve one preset into a self-complete preset, flattening its `extends`
+* chain: the extended preset is merged UNDER this preset's own appearance
+* configs. Results are memoized in `cache` - pass the same cache across a
+* whole generation run so shared ancestors resolve once.
+*
+* @param presets - the preset map to resolve against
+* @param name - the preset to resolve
+* @param cache - per-run memo of already-resolved presets
+* @returns the flattened preset
+* @throws when `name` (or a preset in its `extends` chain) is undeclared
+*/
+function resolvePreset(presets, name, cache) {
+	if (cache[name]) return cache[name];
+	const raw = presets[name];
+	if (!raw) throw new Error(`unknown theme preset: ${name}`);
+	const resolved = raw.extends ? deepMerge(resolvePreset(presets, raw.extends, cache), raw) : raw;
+	cache[name] = resolved;
+	return resolved;
+}
+// src/generator/generate.ts
+/**
+* Merge the built-in default preset UNDER every preset of the consumer's
+* config (weakest -> strongest: built-in default <- the preset itself), so
+* any setting a preset omits falls back to the default. The default preset
+* itself is always present; an empty consumer config gets exactly the
+* built-in default. Contract settings follow the same rule - the built-in
+* `contracts` map sits under the consumer's one (deep-merged per contract).
+*/
+function withDefaults(config$1 = {
+	default: config.default,
+	contracts: {},
+	presets: {}
+}) {
+	const base = config.presets[config.default];
+	if (!base) return config$1;
+	const presets = config$1.presets ?? {};
+	const keys = /* @__PURE__ */ new Set([...Object.keys(config.presets), ...Object.keys(presets)]);
+	const out = {
+		default: keys.has(config$1.default) ? config$1.default : config.default,
+		contracts: deepMerge(config.contracts ?? {}, config$1.contracts ?? {}),
+		presets: {}
+	};
+	for (const key of keys) {
+		const preset = presets[key] ?? config.presets[key];
+		out.presets[key] = preset ? deepMerge(base, preset) : structuredClone(base);
+	}
+	return out;
+}
+/**
+* Generate the theme for a resolved config: one base block per preset
+* (`.theme-{preset}`) plus a scheme block per declared appearance
+* (`.theme_{scheme}`, re-declaring the full merged config), and every
+* contract's setter classes, deduped across presets, inside `@layer theme`.
+*
+* @param config - a config already passed through {@link withDefaults}
+* @param emitPresets - which presets get a css block. Defaults to every
+*   preset of `config`; pass the consumer's own preset names to keep the
+*   built-in default out of the emitted css while it still back-fills the
+*   consumer's presets with fallback values
+* @returns the assembled theme css and the per-contract css/scss pieces
+*/
+function generateThemeArtifacts(config, emitPresets) {
+	const cache = {};
+	const contractCss = /* @__PURE__ */ new Map();
+	const localScss = /* @__PURE__ */ new Map();
+	let css = "";
+	for (const presetName of emitPresets ?? Object.keys(config.presets)) {
+		const preset = resolvePreset(config.presets, presetName, cache);
+		const base = runContractGenerators(presetName, schemesOf(preset).default, void 0, config.contracts);
+		collectContractPieces(contractCss, base.contractCss);
+		collectContractPieces(localScss, base.contractLocalScss);
+		css += emitThemeBlocks(`.theme-${presetName}`, base.themeBlocks);
+		const baseBlocks = new Map(base.themeBlocks.map((b) => [b.contract, b]));
+		for (const scheme of ["dark", "light"]) {
+			const schemeConf = schemesOf(preset)[scheme];
+			if (!schemeConf) continue;
+			const run = runContractGenerators(presetName, deepMerge(schemesOf(preset).default, schemeConf), void 0, config.contracts);
+			collectContractPieces(contractCss, run.contractCss);
+			collectContractPieces(localScss, run.contractLocalScss);
+			const selector = `.theme-${presetName}.theme_${scheme}`;
+			css += `${selector} {\n  color-scheme: ${scheme};\n}\n`;
+			for (const block of run.themeBlocks) {
+				const baseBlock = baseBlocks.get(block.contract);
+				css += emitThemeBlocks(selector, [{
+					contract: block.contract,
+					vars: diffList(baseBlock?.vars ?? {}, block.vars),
+					styles: diffList(baseBlock?.styles ?? {}, block.styles)
+				}]);
+			}
+			const additions = [...declLines(run.schemeVars[scheme]), ...declLines(run.schemeStyles[scheme])];
+			if (additions.length) css += `${selector} {\n  /* ${scheme} additions */\n${additions.join("\n")}\n}\n`;
+		}
+	}
+	const contractBody = [...contractCss.values()].join("\n");
+	return {
+		themeCss: `@layer theme, ui0;\n@layer theme {\n${`${generateBaseCss()}\n${css}${contractBody ? contractBody + "\n" : ""}`}}\n`,
+		contractCss: Object.fromEntries(contractCss),
+		localScss: Object.fromEntries(localScss)
+	};
+}
+/**
+* Generate the complete theme CSS for a resolved config - the single-string
+* form of {@link generateThemeArtifacts}. Pass the result through
+* `withDefaults` first unless the config is already self-complete.
+*
+* @param config - a config already passed through {@link withDefaults}
+* @param emitPresets - which presets get a css block (see
+*   {@link generateThemeArtifacts})
+* @returns the theme css (preset + scheme blocks + setter classes)
+*/
+function generateThemeCss(config, emitPresets) {
+	return generateThemeArtifacts(config, emitPresets).themeCss;
+}
+/**
+* Merge a run's per-contract pieces into the cross-preset dedupe map - the
+* first preset to emit a contract's setters/scss wins (they are
+* config-independent).
+*/
+function collectContractPieces(map, pieces) {
+	for (const [name, body] of Object.entries(pieces)) if (!map.has(name)) map.set(name, body);
+}
+/**
+* VarList/StyleList -> theme-block declaration lines. Keys pass through
+* verbatim (css custom properties keep their exact spelling); values are
+* interpolated as authored - numbers print bare (`--0-dis-o: 1;`).
+*/
+function declLines(list) {
+	return Object.entries(list).map(([k, v]) => `  ${k}: ${v};`);
+}
+/**
+* Emit one theme block per contract that produced declarations: the same
+* selector repeated, each block carrying a `/* <contract> *\/` comment, so
+* the generated css reads per-contract and a disabled (or silent) contract
+* simply has no block. Contracts with nothing to declare are skipped.
+*/
+function emitThemeBlocks(selector, blocks) {
+	let out = "";
+	for (const block of blocks) {
+		const decls = [...declLines(block.vars), ...declLines(block.styles)];
+		if (!decls.length) continue;
+		out += `${selector} {\n  /* ${block.contract} */\n${decls.join("\n")}\n}\n`;
+	}
+	return out;
+}
+/**
+* The entries of `next` whose value differs from `prev`. Scheme blocks only
+* re-declare what actually changes against the base block - everything else
+* inherits, so an unchanged scheme adds no declarations at all.
+*/
+function diffList(prev, next) {
+	const out = {};
+	for (const [k, v] of Object.entries(next)) if (prev[k] !== v) out[k] = v;
+	return out;
+}
+/**
+* Generate a .d.ts that augments the global Ui0Theme* registries so the
+* editor can suggest what exists: Ui0ThemeNames (presets for ThemeProvider),
+* Ui0ThemeSchemeNames (appearances), Ui0ThemeColorNames (pool refs incl.
+* ramp steps, unioned across every emitted preset and scheme). Pass
+* withDefaults(config).
+*
+* @param config - a config already passed through {@link withDefaults}
+* @param emitPresets - which presets contribute names (see
+*   {@link generateThemeArtifacts}); defaults to every preset of `config`
+*/
+function generateThemeTypes(config, emitPresets) {
+	const names = emitPresets ?? Object.keys(config.presets);
+	const schemes = /* @__PURE__ */ new Set();
+	const colors = /* @__PURE__ */ new Set();
+	const cache = {};
+	for (const presetName of names) {
+		const appearances = schemesOf(resolvePreset(config.presets, presetName, cache));
+		const base = appearances.default;
+		for (const [scheme, appearance] of Object.entries(appearances)) {
+			if (scheme !== "default") schemes.add(scheme);
+			const pool = deepMerge(base, appearance).color;
+			if (!pool) continue;
+			const { base: poolBase, ramps } = resolvePool(buildPool(pool, void 0));
+			for (const name of Object.keys(poolBase)) {
+				colors.add(name);
+				const ramp = ramps[name];
+				if (!ramp) continue;
+				for (const [type, steps] of Object.entries(ramp)) steps?.forEach((_, i) => colors.add(`${name}-${type}${i + 1}`));
+			}
+		}
+	}
+	const registry = (name, keys) => `  interface ${name} {\n${[...keys].sort().map((k) => `    '${k}': true`).join("\n")}\n  }`;
+	return `// GENERATED by @ui0/theme — do not edit
+declare global {
+  interface Ui0ThemeNames {
+${names.map((k) => `    '${k}': true`).join("\n")}
+  }
+${registry("Ui0ThemeSchemeNames", schemes)}
+${registry("Ui0ThemeColorNames", colors)}
+}
+
+export {}
+`;
+}
+export { schemesOf as S, parseRef as _, deepMerge as a, backdrop_module_css_default as b, contractGenerators as c, round_module_css_default as d, elevation_module_css_default as f, parseColorProp as g, color_module_css_default as h, withDefaults as i, typography_module_css_default as l, disabled_module_css_default as m, generateThemeCss as n, resolvePreset as o, display_module_css_default as p, generateThemeTypes as r, hashClassName as s, generateThemeArtifacts as t, size_module_css_default as u, buildPool as v, ensureThemeBaseStyle as x, resolvePool as y };
+
+//# sourceMappingURL=generate-BPYE5ALG.mjs.map