silvery 0.19.2 → 0.21.1

package/dist/src-Dvq-s8iD.mjs

@@ -0,0 +1,939 @@
+import { P as ANSI16_SLOT_HEX, dt as deriveFields, i as STERLING_FLAT_TOKENS, it as deriveTheme, l as COLOR_SCHEME_FIELDS } from "./src-Oe6x5PrS.mjs";
+import { s as getSchemeByName } from "./schemes-DYt2ushj.mjs";
+import { blend, brighten, darken, hexToOklch, hexToRgb, oklchToHex, relativeLuminance } from "@silvery/color";
+//#region packages/theme/src/generate.ts
+/**
+* Resolve an ANSI16 slot name (e.g. "yellow", "blueBright") to its canonical
+* hex value. Falls back to the input string if not found (e.g., already hex).
+*/
+function slotHex(name) {
+	return ANSI16_SLOT_HEX[name] ?? name;
+}
+/**
+* Generate a complete ANSI 16 theme from a primary color + dark/light preference.
+*
+* All token values are hex strings (e.g. "#808000" for yellow).
+* Terminal rendering quantizes these to 4-bit ANSI codes at paint time
+* when colorLevel === "ansi16".
+*/
+function generateTheme(primary, dark) {
+	const primaryHex = slotHex(primary);
+	const fgHex = slotHex(dark ? "whiteBright" : "black");
+	const accentHex = primaryHex;
+	const selectionbgHex = primaryHex;
+	const surfacebgHex = slotHex(dark ? "black" : "white");
+	const derived = deriveFields({
+		primary: primaryHex,
+		accent: accentHex,
+		fg: fgHex,
+		selectionbg: selectionbgHex,
+		surfacebg: surfacebgHex,
+		ring: {
+			red: slotHex(dark ? "redBright" : "red"),
+			orange: slotHex(dark ? "redBright" : "red"),
+			yellow: slotHex("yellow"),
+			green: slotHex(dark ? "greenBright" : "green"),
+			teal: slotHex("cyan"),
+			blue: slotHex(dark ? "blueBright" : "blue"),
+			purple: slotHex("magenta"),
+			pink: slotHex(dark ? "magentaBright" : "magenta")
+		}
+	});
+	return {
+		name: `${dark ? "dark" : "light"}-${primary}`,
+		bg: "",
+		fg: fgHex,
+		muted: slotHex(dark ? "white" : "blackBright"),
+		mutedbg: slotHex(dark ? "black" : "white"),
+		surface: slotHex(dark ? "whiteBright" : "black"),
+		surfacebg: surfacebgHex,
+		popover: slotHex(dark ? "whiteBright" : "black"),
+		popoverbg: slotHex(dark ? "blackBright" : "white"),
+		inverse: slotHex(dark ? "black" : "whiteBright"),
+		inversebg: slotHex(dark ? "whiteBright" : "black"),
+		cursor: slotHex("black"),
+		cursorbg: primaryHex,
+		selection: slotHex("black"),
+		selectionbg: primaryHex,
+		primary: primaryHex,
+		primaryfg: slotHex("black"),
+		secondary: primaryHex,
+		secondaryfg: slotHex("black"),
+		accent: primaryHex,
+		accentfg: slotHex("black"),
+		error: slotHex(dark ? "redBright" : "red"),
+		errorfg: slotHex("black"),
+		warning: primaryHex,
+		warningfg: slotHex("black"),
+		success: slotHex(dark ? "greenBright" : "green"),
+		successfg: slotHex("black"),
+		info: slotHex(dark ? "cyanBright" : "cyan"),
+		infofg: slotHex("black"),
+		border: slotHex("gray"),
+		inputborder: slotHex("gray"),
+		focusborder: slotHex(dark ? "blueBright" : "blue"),
+		disabledfg: slotHex("gray"),
+		palette: [
+			slotHex("black"),
+			slotHex("red"),
+			slotHex("green"),
+			slotHex("yellow"),
+			slotHex("blue"),
+			slotHex("magenta"),
+			slotHex("cyan"),
+			slotHex("white"),
+			slotHex("blackBright"),
+			slotHex("redBright"),
+			slotHex("greenBright"),
+			slotHex("yellowBright"),
+			slotHex("blueBright"),
+			slotHex("magentaBright"),
+			slotHex("cyanBright"),
+			slotHex("whiteBright")
+		],
+		...derived
+	};
+}
+//#endregion
+//#region packages/theme/src/import/types.ts
+/** All Base16 color keys in order. */
+const BASE16_KEYS = [
+	"base00",
+	"base01",
+	"base02",
+	"base03",
+	"base04",
+	"base05",
+	"base06",
+	"base07",
+	"base08",
+	"base09",
+	"base0A",
+	"base0B",
+	"base0C",
+	"base0D",
+	"base0E",
+	"base0F"
+];
+//#endregion
+//#region packages/theme/src/import/base16.ts
+/**
+* Import Base16 YAML/JSON schemes into ColorScheme format.
+*
+* Base16 defines 16 colors (base00–base0F). We map them to ColorScheme's
+* 22 colors, deriving bright variants and special colors.
+*
+* @see https://github.com/chriskempson/base16
+*/
+/**
+* Parse Base16 YAML into a Base16Scheme object.
+* Handles both quoted and unquoted values, comments, and blank lines.
+*/
+function parseBase16Yaml(yaml) {
+	const result = {};
+	for (const raw of yaml.split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("#")) continue;
+		const colonIdx = line.indexOf(":");
+		if (colonIdx === -1) continue;
+		const key = line.slice(0, colonIdx).trim();
+		let value = line.slice(colonIdx + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		const commentIdx = value.indexOf("#");
+		if (commentIdx > 0) value = value.slice(0, commentIdx).trim();
+		result[key] = value;
+	}
+	if (!result.scheme) throw new Error("Base16 YAML missing required field: scheme");
+	for (const key of BASE16_KEYS) {
+		if (!result[key]) throw new Error(`Base16 YAML missing required color: ${key}`);
+		if (!/^[0-9a-fA-F]{6}$/.test(result[key])) throw new Error(`Base16 color ${key} must be a 6-digit hex string without '#', got: "${result[key]}"`);
+	}
+	return result;
+}
+/** Compute relative luminance (WCAG 2.0) from a hex color with `#` prefix. */
+function luminance(hex) {
+	const rgb = hexToRgb(hex);
+	if (!rgb) return 0;
+	const [r, g, b] = rgb.map((c) => {
+		const s = c / 255;
+		return s <= .03928 ? s / 12.92 : Math.pow((s + .055) / 1.055, 2.4);
+	});
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+/** Normalize a bare hex string to `#RRGGBB` (uppercase). */
+function hex(bare) {
+	return `#${bare.toUpperCase()}`;
+}
+/**
+* Import a Base16 YAML (or JSON) scheme into a ColorScheme.
+*
+* Mapping:
+*   base00 → background, base01 → brightBlack, base02 → selectionBackground,
+*   base03 → white (muted fg), base05 → foreground/brightWhite,
+*   base08 → red, base09 → brightRed, base0A → yellow,
+*   base0B → green, base0C → cyan, base0D → blue, base0E → magenta,
+*   base0F → brightMagenta.
+*
+* Bright color variants are derived by brightening normals.
+* `dark` is inferred from base00 luminance.
+*/
+function importBase16(yamlOrJson) {
+	return base16ToColorScheme(parseBase16Yaml(yamlOrJson));
+}
+/** Convert a parsed Base16Scheme to ColorScheme. */
+function base16ToColorScheme(scheme) {
+	const bg = hex(scheme.base00);
+	const fg = hex(scheme.base05);
+	const isDark = luminance(bg) < .179;
+	const black = isDark ? darken(bg, .15) : brighten(bg, .15);
+	const red = hex(scheme.base08);
+	const green = hex(scheme.base0B);
+	const yellow = hex(scheme.base0A);
+	const blue = hex(scheme.base0D);
+	const magenta = hex(scheme.base0E);
+	const cyan = hex(scheme.base0C);
+	return {
+		name: scheme.scheme,
+		dark: isDark,
+		black,
+		red,
+		green,
+		yellow,
+		blue,
+		magenta,
+		cyan,
+		white: hex(scheme.base03),
+		brightBlack: hex(scheme.base01),
+		brightRed: hex(scheme.base09),
+		brightGreen: brighten(green, .15),
+		brightYellow: brighten(yellow, .15),
+		brightBlue: brighten(blue, .15),
+		brightMagenta: hex(scheme.base0F),
+		brightCyan: brighten(cyan, .15),
+		brightWhite: fg,
+		foreground: fg,
+		background: bg,
+		cursorColor: fg,
+		cursorText: bg,
+		selectionBackground: hex(scheme.base02),
+		selectionForeground: fg
+	};
+}
+//#endregion
+//#region packages/theme/src/generators.ts
+/**
+* Palette generators — produce a ColorScheme from various inputs.
+*
+* All generators return a complete ColorScheme (22 fields).
+*/
+function isDarkColor$1(hex) {
+	const L = relativeLuminance(hex);
+	return L === null ? true : L < .5;
+}
+/**
+* Target hues for each accent slot, in OKLCH degrees.
+* OKLCH hues differ from HSL — red ≈ 29, green ≈ 142, blue ≈ 264. Calibrated
+* per Ottosson's reference ramps for perceptually-uniform accent generation.
+*/
+const targetHues = {
+	red: 29,
+	orange: 55,
+	yellow: 90,
+	green: 142,
+	teal: 195,
+	blue: 240,
+	purple: 305,
+	pink: 350
+};
+/** Find which hue slot the primary color best matches by OKLCH hue angle proximity. */
+function assignPrimaryToSlot(primary) {
+	const o = hexToOklch(primary);
+	if (!o) return "blue";
+	const h = o.H;
+	for (const [lo, hi, name] of [
+		[
+			0,
+			15,
+			"red"
+		],
+		[
+			15,
+			42,
+			"orange"
+		],
+		[
+			42,
+			75,
+			"yellow"
+		],
+		[
+			75,
+			170,
+			"green"
+		],
+		[
+			170,
+			210,
+			"teal"
+		],
+		[
+			210,
+			275,
+			"blue"
+		],
+		[
+			275,
+			330,
+			"purple"
+		],
+		[
+			330,
+			360,
+			"pink"
+		]
+	]) if (h >= lo && h < hi) return name;
+	return "red";
+}
+/** Generate 8 accent hues from a primary, placing it in its natural slot. */
+function generateAccentsFromPrimary(primary) {
+	const o = hexToOklch(primary);
+	if (!o) return {
+		red: "#BF616A",
+		orange: "#D08770",
+		yellow: "#EBCB8B",
+		green: "#A3BE8C",
+		teal: "#88C0D0",
+		blue: "#5E81AC",
+		purple: "#B48EAD",
+		pink: "#D4879C"
+	};
+	const slot = assignPrimaryToSlot(primary);
+	const result = {};
+	for (const [name, targetH] of Object.entries(targetHues)) result[name] = name === slot ? primary : oklchToHex({
+		L: o.L,
+		C: o.C,
+		H: targetH
+	});
+	return result;
+}
+/**
+* Generate a ColorScheme from a Base16 YAML scheme.
+*
+* Maps base00–base0F to ANSI palette colors, derives special colors.
+*/
+function fromBase16(yamlOrJson) {
+	return importBase16(yamlOrJson);
+}
+/**
+* Generate a full ColorScheme from 1-3 hex colors.
+*
+* At minimum, provide `background` or `primary`. Missing colors are
+* generated via surface ramp (from bg) and hue rotation (from primary).
+*/
+function fromColors(opts) {
+	const dark = opts.dark ?? (opts.background ? isDarkColor$1(opts.background) : true);
+	const step = dark ? brighten : darken;
+	const bg = opts.background ?? (dark ? "#2E3440" : "#FFFFFF");
+	const fg = opts.foreground ?? step(bg, .85);
+	const accents = opts.primary ? generateAccentsFromPrimary(opts.primary) : {
+		red: "#BF616A",
+		orange: "#D08770",
+		yellow: "#EBCB8B",
+		green: "#A3BE8C",
+		teal: "#88C0D0",
+		blue: "#5E81AC",
+		purple: "#B48EAD",
+		pink: "#D4879C"
+	};
+	const black = dark ? darken(bg, .05) : darken(bg, .1);
+	const white = dark ? blend(fg, bg, .3) : blend(bg, fg, .3);
+	const brightBlack = step(bg, .15);
+	const brightWhite = dark ? fg : brighten(fg, .1);
+	return {
+		name: opts.name ?? (dark ? "generated-dark" : "generated-light"),
+		dark,
+		primary: opts.primary,
+		black,
+		red: accents.red,
+		green: accents.green,
+		yellow: accents.yellow,
+		blue: accents.blue,
+		magenta: accents.purple,
+		cyan: accents.teal,
+		white,
+		brightBlack,
+		brightRed: accents.orange,
+		brightGreen: brighten(accents.green, .15),
+		brightYellow: brighten(accents.yellow, .15),
+		brightBlue: brighten(accents.blue, .15),
+		brightMagenta: accents.pink,
+		brightCyan: brighten(accents.teal, .15),
+		brightWhite,
+		foreground: fg,
+		background: bg,
+		cursorColor: fg,
+		cursorText: bg,
+		selectionBackground: blend(bg, accents.blue, .3),
+		selectionForeground: fg
+	};
+}
+/**
+* Look up a built-in palette by name.
+*
+* @returns The ColorScheme, or undefined if not found.
+*/
+function fromPreset(name) {
+	return getSchemeByName(name);
+}
+//#endregion
+//#region packages/theme/src/builder.ts
+/**
+* Chainable theme builder — create themes from minimal input.
+*
+* @example
+* ```typescript
+* // Just a background color
+* const theme = createTheme().bg('#2E3440').build()
+*
+* // Primary + explicit dark mode
+* const theme = createTheme().primary('#EBCB8B').dark().build()
+*
+* // Three-color input (dark/light inferred from bg luminance)
+* const theme = createTheme()
+*   .bg('#2E3440').fg('#ECEFF4').primary('#EBCB8B').build()
+*
+* // Preset with override
+* const theme = createTheme().preset('nord').primary('#A3BE8C').build()
+* ```
+*/
+function isDarkColor(hex) {
+	const rgb = hexToRgb(hex);
+	if (!rgb) return true;
+	return (rgb[0] + rgb[1] + rgb[2]) / 765 < .5;
+}
+/** Create a chainable theme builder. */
+function createTheme() {
+	const state = { colors: {} };
+	const builder = {
+		bg(color) {
+			state.bgColor = color;
+			return builder;
+		},
+		fg(color) {
+			state.fgColor = color;
+			return builder;
+		},
+		primary(color) {
+			state.primaryColor = color;
+			return builder;
+		},
+		accent(color) {
+			return builder.primary(color);
+		},
+		dark() {
+			state.dark = true;
+			return builder;
+		},
+		light() {
+			state.dark = false;
+			return builder;
+		},
+		color(name, value) {
+			state.colors[name] = value;
+			return builder;
+		},
+		palette(p) {
+			state.presetPalette = p;
+			return builder;
+		},
+		preset(name) {
+			const p = getSchemeByName(name);
+			if (p) state.presetPalette = p;
+			return builder;
+		},
+		build() {
+			const isDark = state.dark ?? (state.bgColor ? isDarkColor(state.bgColor) : true);
+			let palette;
+			if (state.presetPalette) {
+				palette = { ...state.presetPalette };
+				if (state.bgColor) palette.background = state.bgColor;
+				if (state.fgColor) palette.foreground = state.fgColor;
+				if (state.primaryColor) {
+					palette.primary = state.primaryColor;
+					const ansiName = hueToAnsiField(assignPrimaryToSlot(state.primaryColor));
+					palette[ansiName] = state.primaryColor;
+				}
+				palette.dark = isDark;
+			} else palette = fromColors({
+				background: state.bgColor,
+				foreground: state.fgColor,
+				primary: state.primaryColor,
+				dark: isDark
+			});
+			for (const [key, val] of Object.entries(state.colors)) if (val !== void 0 && typeof val === "string") palette[key] = val;
+			return deriveTheme(palette);
+		}
+	};
+	return builder;
+}
+/** Map a HueName to the corresponding ColorScheme field. */
+function hueToAnsiField(hue) {
+	return {
+		red: "red",
+		orange: "brightRed",
+		yellow: "yellow",
+		green: "green",
+		teal: "cyan",
+		blue: "blue",
+		purple: "magenta",
+		pink: "brightMagenta"
+	}[hue];
+}
+/**
+* Quick theme from a primary color or color name.
+*
+* @example
+* ```typescript
+* quickTheme('#EBCB8B', 'dark')  // yellow primary, dark mode
+* quickTheme('blue')              // blue primary, default dark
+* ```
+*/
+function quickTheme(primaryOrHex, mode) {
+	const b = createTheme();
+	if (primaryOrHex.startsWith("#")) b.primary(primaryOrHex);
+	else b.primary({
+		red: "#BF616A",
+		orange: "#D08770",
+		yellow: "#EBCB8B",
+		green: "#A3BE8C",
+		teal: "#88C0D0",
+		cyan: "#88C0D0",
+		blue: "#5E81AC",
+		purple: "#B48EAD",
+		pink: "#D4879C",
+		magenta: "#B48EAD",
+		white: "#ECEFF4"
+	}[primaryOrHex] ?? "#5E81AC");
+	if (mode === "dark") b.dark();
+	else if (mode === "light") b.light();
+	return b.build();
+}
+/**
+* Create a theme from a built-in preset name.
+*
+* @example
+* ```typescript
+* presetTheme('catppuccin-mocha')
+* presetTheme('nord')
+* ```
+*/
+function presetTheme(name) {
+	return createTheme().preset(name).build();
+}
+//#endregion
+//#region packages/theme/src/auto-generate.ts
+/**
+* Auto-generate themes — create a complete Theme from a single primary color.
+*
+* Uses OKLCH color manipulation to derive complementary and analogous colors
+* for the full palette from one input color. OKLCH preserves perceived
+* lightness and chroma across hue rotations, so accent ramps look balanced.
+*/
+/** Standard OKLCH hue positions for semantic accents (degrees).
+* OKLCH hues differ from HSL: red≈29, orange≈55, yellow≈90, green≈142,
+* teal≈195, blue≈240, purple≈305, pink≈350. Calibrated against Ottosson's
+* reference ramps. */
+const HUE = {
+	red: 29,
+	orangeBright: 55,
+	yellow: 90,
+	green: 142,
+	cyan: 195,
+	blue: 240,
+	magenta: 310,
+	pinkBright: 350
+};
+/**
+* Generate a complete Theme from a single primary color.
+*
+* Derives a full ColorScheme using OKLCH color manipulation:
+* - Background/foreground from lightness endpoints using the primary's hue
+* - Complementary and analogous accent colors from hue rotation
+* - Surface ramp from bg lightness offsets
+* - Status colors (error, warning, success, info) from standard hue positions
+*
+* @param primaryColor - A hex color string (e.g. "#5E81AC")
+* @param mode - "dark" or "light" theme mode
+* @returns A complete Theme with all 33 semantic tokens
+*
+* @example
+* ```typescript
+* const theme = autoGenerateTheme("#5E81AC", "dark")
+* // Generates a full dark theme with blue as the primary accent
+*
+* const light = autoGenerateTheme("#E06C75", "light")
+* // Generates a full light theme with red/rose as the primary accent
+* ```
+*/
+function autoGenerateTheme(primaryColor, mode) {
+	const o = hexToOklch(primaryColor);
+	if (!o) return deriveTheme(fromColors({ dark: mode === "dark" }));
+	const dark = mode === "dark";
+	const bgL = dark ? .22 : .96;
+	const fgL = dark ? .9 : .2;
+	const bgC = Math.min(o.C, .03);
+	const bg = oklchToHex({
+		L: bgL,
+		C: bgC,
+		H: o.H
+	});
+	const fg = oklchToHex({
+		L: fgL,
+		C: bgC * .5,
+		H: o.H
+	});
+	const accentL = dark ? .72 : .52;
+	const accentC = Math.max(o.C, .1);
+	const accent = (h) => oklchToHex({
+		L: accentL,
+		C: accentC,
+		H: h
+	});
+	const red = accent(HUE.red);
+	const green = accent(HUE.green);
+	const yellow = accent(HUE.yellow);
+	const blue = accent(HUE.blue);
+	const magenta = accent(HUE.magenta);
+	const cyan = accent(HUE.cyan);
+	const brightL = accentL + (dark ? .1 : -.1);
+	const brightAccent = (h) => oklchToHex({
+		L: brightL,
+		C: accentC,
+		H: h
+	});
+	const brightRed = brightAccent(HUE.orangeBright);
+	const brightGreen = brightAccent(HUE.green);
+	const brightYellow = brightAccent(HUE.yellow);
+	const brightBlue = brightAccent(HUE.blue);
+	const brightMagenta = brightAccent(HUE.pinkBright);
+	const brightCyan = brightAccent(HUE.cyan);
+	const black = oklchToHex({
+		L: dark ? bgL * .7 : bgL * .92,
+		C: bgC,
+		H: o.H
+	});
+	const white = oklchToHex({
+		L: dark ? .6 : .35,
+		C: bgC * .3,
+		H: o.H
+	});
+	const brightBlack = oklchToHex({
+		L: dark ? bgL + .1 : bgL - .08,
+		C: bgC,
+		H: o.H
+	});
+	const brightWhite = dark ? fg : oklchToHex({
+		L: fgL - .05,
+		C: bgC * .5,
+		H: o.H
+	});
+	return deriveTheme({
+		name: `generated-${mode}`,
+		dark,
+		primary: primaryColor,
+		black,
+		red,
+		green,
+		yellow,
+		blue,
+		magenta,
+		cyan,
+		white,
+		brightBlack,
+		brightRed,
+		brightGreen,
+		brightYellow,
+		brightBlue,
+		brightMagenta,
+		brightCyan,
+		brightWhite,
+		foreground: fg,
+		background: bg,
+		cursorColor: fg,
+		cursorText: bg,
+		selectionBackground: blend(bg, primaryColor, .3),
+		selectionForeground: fg
+	});
+}
+//#endregion
+//#region packages/theme/src/validate.ts
+/**
+* Palette validation — checks ColorScheme fields and contrast.
+*/
+/**
+* Validate a ColorScheme.
+*
+* Checks:
+* - All 22 color fields are present and non-empty hex strings
+* - Warns on low-contrast foreground/background combinations
+*/
+function validateColorScheme(p) {
+	const errors = [];
+	const warnings = [];
+	for (const field of COLOR_SCHEME_FIELDS) {
+		const val = p[field];
+		if (!val || typeof val !== "string") errors.push(`${field} is required and must be a non-empty string`);
+	}
+	if (p.foreground && p.background) {
+		const fgRgb = hexToRgb(p.foreground);
+		const bgRgb = hexToRgb(p.background);
+		if (fgRgb && bgRgb) {
+			const fgSum = fgRgb[0] + fgRgb[1] + fgRgb[2];
+			const bgSum = bgRgb[0] + bgRgb[1] + bgRgb[2];
+			if (fgSum > 384 === bgSum > 384) warnings.push(`Low contrast: foreground (${p.foreground}) and background (${p.background}) have similar lightness`);
+		}
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+//#endregion
+//#region packages/theme/src/validate-theme.ts
+/**
+* Theme validation — checks that all required semantic tokens are present.
+*
+* Complements validateColorScheme() which validates the lower-level
+* ColorScheme. This validates the derived Theme object.
+*/
+/**
+* Required semantic token keys on Theme (excludes `name` and `palette`).
+*
+* Sterling owns selection / inverse / link styling via flat tokens
+* (`bg-selected`, `fg-on-selected`, `bg-inverse`, `fg-on-inverse`, `fg-link`)
+* baked in by `inlineSterlingTokens`. The legacy single-hex aliases
+* (`selection`, `selectionbg`, `inverse`, `inversebg`, `link`) were removed
+* in 0.21.0 (sterling-purge-legacy-tokens).
+*/
+const THEME_TOKEN_KEYS = [
+	"bg",
+	"fg",
+	"muted",
+	"mutedbg",
+	"surface",
+	"surfacebg",
+	"popover",
+	"popoverbg",
+	"cursor",
+	"cursorbg",
+	"primary",
+	"primaryfg",
+	"secondary",
+	"secondaryfg",
+	"accent",
+	"accentfg",
+	"error",
+	"errorfg",
+	"warning",
+	"warningfg",
+	"success",
+	"successfg",
+	"info",
+	"infofg",
+	"border",
+	"inputborder",
+	"focusborder",
+	"disabledfg"
+];
+/** All recognized keys on Theme (tokens + metadata). */
+const ALL_KNOWN_KEYS = new Set([
+	...THEME_TOKEN_KEYS,
+	"name",
+	"palette"
+]);
+/**
+* Validate a Theme object — check that all required tokens are present.
+*
+* @param theme - The theme object to validate
+* @returns Validation result with missing and extra token lists
+*
+* @example
+* ```typescript
+* const result = validateTheme(myTheme)
+* if (!result.valid) {
+*   console.log("Missing tokens:", result.missing)
+* }
+* ```
+*/
+function validateTheme(theme) {
+	const missing = [];
+	const extra = [];
+	for (const key of THEME_TOKEN_KEYS) {
+		const val = theme[key];
+		if (val === void 0 || val === null || val === "") missing.push(key);
+	}
+	for (const key of Object.keys(theme)) if (!ALL_KNOWN_KEYS.has(key)) extra.push(key);
+	return {
+		valid: missing.length === 0,
+		missing,
+		extra
+	};
+}
+//#endregion
+//#region packages/theme/src/alias.ts
+/** Maximum depth for alias chain resolution before treating as circular. */
+const MAX_ALIAS_DEPTH = 10;
+/**
+* Resolve all token aliases in a theme.
+*
+* Token values that start with `$` are treated as references to other tokens.
+* Alias chains are followed until a concrete (non-$) value is reached.
+* Circular references are detected via a depth limit and left unresolved.
+*
+* @param theme - A theme-like object where values may reference other tokens via `$name`
+* @returns A new object with all aliases resolved to concrete values
+*
+* @example
+* ```typescript
+* const themed = resolveAliases({
+*   ...baseTheme,
+*   button: "$primary",      // resolves to the value of 'primary'
+*   buttonHover: "$button",  // chain: buttonHover -> button -> primary -> hex
+* })
+* ```
+*/
+function resolveAliases(theme) {
+	const result = {};
+	for (const key of Object.keys(theme)) result[key] = resolveAlias(key, theme, 0);
+	return result;
+}
+/**
+* Resolve a single token's alias chain.
+*
+* @param key - The token key to resolve
+* @param tokens - The full token map
+* @param depth - Current recursion depth (for loop detection)
+* @returns The resolved concrete value, or the raw alias string if unresolvable
+*/
+function resolveAlias(key, tokens, depth) {
+	if (depth >= MAX_ALIAS_DEPTH) return tokens[key] ?? "";
+	const value = tokens[key];
+	if (value === void 0) return "";
+	if (!value.startsWith("$")) return value;
+	const refKey = value.slice(1);
+	if (!(refKey in tokens)) return value;
+	return resolveAlias(refKey, tokens, depth + 1);
+}
+/**
+* Resolve a single alias value against a Theme.
+*
+* Useful for resolving individual values without processing the entire theme.
+*
+* @param value - The value to resolve (may be "$tokenName" or a concrete value)
+* @param theme - The theme to resolve against
+* @returns The resolved concrete value
+*/
+function resolveTokenAlias(value, theme) {
+	if (!value.startsWith("$")) return value;
+	const seen = /* @__PURE__ */ new Set();
+	let current = value;
+	for (let i = 0; i < MAX_ALIAS_DEPTH; i++) {
+		if (!current.startsWith("$")) return current;
+		const key = current.slice(1);
+		if (seen.has(key)) return current;
+		seen.add(key);
+		const resolved = theme[key];
+		if (typeof resolved !== "string") return current;
+		current = resolved;
+	}
+	return current;
+}
+//#endregion
+//#region packages/theme/src/css.ts
+/**
+* Convert a Theme to CSS custom properties.
+*
+* Token names mirror Sterling's flat grammar with a `--` prefix:
+*   - `bg-surface-default` → `--bg-surface-default`
+*   - `fg-accent` → `--fg-accent`
+*   - `border-focus` → `--border-focus`
+*   - Palette entries: `--color0` through `--color15`
+*
+* @param theme - The theme to convert (Sterling flat tokens must be populated)
+* @returns A record mapping CSS custom property names to color values
+*
+* @example
+* ```typescript
+* const vars = themeToCSSVars(myTheme)
+* // { "--bg-surface-default": "#1E1E2E", "--fg-accent": "#F9E2AF", ... }
+*
+* // Apply to an element:
+* Object.assign(element.style, vars)
+* ```
+*/
+function themeToCSSVars(theme) {
+	const vars = {};
+	const flat = theme;
+	for (const key of STERLING_FLAT_TOKENS) {
+		const value = flat[key];
+		if (typeof value === "string") vars[`--${key}`] = value;
+	}
+	if (theme.palette) for (let i = 0; i < theme.palette.length; i++) vars[`--color${i}`] = theme.palette[i];
+	return vars;
+}
+//#endregion
+//#region packages/theme/src/export/base16.ts
+/**
+* Export ColorScheme to Base16 YAML format.
+*
+* Maps ColorScheme fields to base00–base0F. For fields that
+* ColorScheme doesn't store directly (base04/base06/base07),
+* we interpolate between neighboring values.
+*
+* @see https://github.com/chriskempson/base16
+*/
+/** Strip `#` prefix from a hex color string and uppercase. */
+function stripHash(hex) {
+	return (hex.startsWith("#") ? hex.slice(1) : hex).toUpperCase();
+}
+/**
+* Export a ColorScheme to Base16 YAML format.
+*
+* Mapping:
+*   background → base00, brightBlack → base01, selectionBackground → base02,
+*   white → base03, (interpolated) → base04, foreground → base05,
+*   (interpolated) → base06, (interpolated) → base07,
+*   red → base08, brightRed → base09, yellow → base0A, green → base0B,
+*   cyan → base0C, blue → base0D, magenta → base0E, brightMagenta → base0F.
+*/
+function exportBase16(palette) {
+	const dark = palette.dark ?? true;
+	const base04 = blend(palette.white, palette.foreground, .33);
+	const base06 = dark ? blend(palette.foreground, "#FFFFFF", .15) : blend(palette.foreground, "#000000", .15);
+	const base07 = palette.black;
+	return [
+		`scheme: "${palette.name ?? "exported"}"`,
+		`author: ""`,
+		`base00: "${stripHash(palette.background)}"`,
+		`base01: "${stripHash(palette.brightBlack)}"`,
+		`base02: "${stripHash(palette.selectionBackground)}"`,
+		`base03: "${stripHash(palette.white)}"`,
+		`base04: "${stripHash(base04)}"`,
+		`base05: "${stripHash(palette.foreground)}"`,
+		`base06: "${stripHash(base06)}"`,
+		`base07: "${stripHash(base07)}"`,
+		`base08: "${stripHash(palette.red)}"`,
+		`base09: "${stripHash(palette.brightRed)}"`,
+		`base0A: "${stripHash(palette.yellow)}"`,
+		`base0B: "${stripHash(palette.green)}"`,
+		`base0C: "${stripHash(palette.cyan)}"`,
+		`base0D: "${stripHash(palette.blue)}"`,
+		`base0E: "${stripHash(palette.magenta)}"`,
+		`base0F: "${stripHash(palette.brightMagenta)}"`
+	].join("\n") + "\n";
+}
+//#endregion
+export { generateTheme as _, THEME_TOKEN_KEYS as a, autoGenerateTheme as c, quickTheme as d, assignPrimaryToSlot as f, importBase16 as g, fromPreset as h, resolveTokenAlias as i, createTheme as l, fromColors as m, themeToCSSVars as n, validateTheme as o, fromBase16 as p, resolveAliases as r, validateColorScheme as s, exportBase16 as t, presetTheme as u };
+
+//# sourceMappingURL=src-Dvq-s8iD.mjs.map