silvery 0.19.1 → 0.21.0

package/dist/src-5w9QR6_8.mjs

@@ -0,0 +1,1071 @@
+import { n as __esmMin, r as __exportAll } from "./chunk-BSw8zbkd.mjs";
+import { D as bakeFlat, L as detectTerminalScheme, O as defaultFlattenRule, P as ANSI16_SLOT_HEX, R as detectTheme, a as STERLING_FLAT_TOKENS, at as deriveRoles, c as detectScheme, ct as WCAG_AA, dt as deriveFields, i as defaultScheme, it as deriveTheme, l as detectSchemeTheme, lt as autoLift, n as sterling, ot as deriveTheme$1, r as defineDesignSystem, st as ContrastError, t as init_src$1, u as COLOR_SCHEME_FIELDS, ut as checkAA, z as probeColors } from "./src-BNTToU7l.mjs";
+import { A as monokaiPro, B as gruvboxLight, C as ayuLight, D as materialLight, E as materialDark, F as kanagawaWave, G as solarizedDark, H as tokyoNight, I as rosePine, J as nord, K as solarizedLight, L as rosePineDawn, M as everforestLight, N as kanagawaDragon, O as snazzy, P as kanagawaLotus, Q as catppuccinMocha, R as rosePineMoon, S as ayuDark, T as palenight, U as tokyoNightDay, V as oneDark, W as tokyoNightStorm, X as catppuccinLatte, Y as catppuccinFrappe, Z as catppuccinMacchiato, _ as nightfly, a as defaultDarkTheme, b as dawnfox, c as getThemeByName, d as modusVivendi, f as edgeDark, g as oxocarbonLight, h as oxocarbonDark, i as builtinThemes, j as everforestDark, k as monokai, l as init_schemes, m as sonokai, n as ansi16LightTheme, o as defaultLightTheme, p as edgeLight, q as dracula, r as builtinPalettes, s as getSchemeByName, t as ansi16DarkTheme, u as modusOperandi, v as moonfly, w as ayuMirage, x as nightfox, y as horizon, z as gruvboxDark } from "./schemes-JjNp4aSl.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
+	};
+}
+var init_generate = __esmMin((() => {
+	init_src$1();
+}));
+//#endregion
+//#region packages/theme/src/import/types.ts
+var BASE16_KEYS;
+var init_types = __esmMin((() => {
+	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
+	};
+}
+var init_base16$1 = __esmMin((() => {
+	init_types();
+}));
+//#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;
+}
+/** 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);
+}
+var targetHues;
+var init_generators = __esmMin((() => {
+	init_base16$1();
+	init_schemes();
+	targetHues = {
+		red: 29,
+		orange: 55,
+		yellow: 90,
+		green: 142,
+		teal: 195,
+		blue: 240,
+		purple: 305,
+		pink: 350
+	};
+}));
+//#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();
+}
+var init_builder = __esmMin((() => {
+	init_src$1();
+	init_generators();
+	init_schemes();
+}));
+//#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.
+*/
+/**
+* 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
+	});
+}
+var HUE;
+var init_auto_generate = __esmMin((() => {
+	init_generators();
+	init_src$1();
+	HUE = {
+		red: 29,
+		orangeBright: 55,
+		yellow: 90,
+		green: 142,
+		cyan: 195,
+		blue: 240,
+		magenta: 310,
+		pinkBright: 350
+	};
+}));
+//#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
+	};
+}
+var init_validate = __esmMin((() => {
+	init_src$1();
+}));
+//#endregion
+//#region packages/theme/src/validate-theme.ts
+/**
+* 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
+	};
+}
+var THEME_TOKEN_KEYS, ALL_KNOWN_KEYS;
+var init_validate_theme = __esmMin((() => {
+	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_KNOWN_KEYS = new Set([
+		...THEME_TOKEN_KEYS,
+		"name",
+		"palette"
+	]);
+}));
+//#endregion
+//#region packages/theme/src/alias.ts
+/**
+* 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;
+}
+var MAX_ALIAS_DEPTH;
+var init_alias = __esmMin((() => {
+	MAX_ALIAS_DEPTH = 10;
+}));
+//#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;
+}
+var init_css = __esmMin((() => {
+	init_src$1();
+}));
+//#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";
+}
+var init_base16 = __esmMin((() => {}));
+//#endregion
+//#region packages/theme/src/detect.ts
+var init_detect = __esmMin((() => {
+	init_src$1();
+}));
+//#endregion
+//#region packages/theme/src/sterling/index.ts
+var init_sterling = __esmMin((() => {
+	init_src$1();
+}));
+//#endregion
+//#region packages/theme/src/theme.ts
+var init_theme = __esmMin((() => {
+	init_src$1();
+	init_generate();
+	init_generators();
+	init_builder();
+	init_auto_generate();
+	init_validate();
+	init_validate_theme();
+	init_alias();
+	init_css();
+	init_base16$1();
+	init_base16();
+	init_schemes();
+	init_detect();
+	init_sterling();
+}));
+//#endregion
+//#region packages/theme/src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	COLOR_SCHEME_FIELDS: () => COLOR_SCHEME_FIELDS,
+	STERLING_FLAT_TOKENS: () => STERLING_FLAT_TOKENS,
+	SterlingContrastError: () => ContrastError,
+	THEME_TOKEN_KEYS: () => THEME_TOKEN_KEYS,
+	WCAG_AA: () => WCAG_AA,
+	ansi16DarkTheme: () => ansi16DarkTheme,
+	ansi16LightTheme: () => ansi16LightTheme,
+	assignPrimaryToSlot: () => assignPrimaryToSlot,
+	autoGenerateTheme: () => autoGenerateTheme,
+	ayuDark: () => ayuDark,
+	ayuLight: () => ayuLight,
+	ayuMirage: () => ayuMirage,
+	bakeFlat: () => bakeFlat,
+	builtinPalettes: () => builtinPalettes,
+	builtinThemes: () => builtinThemes,
+	catppuccinFrappe: () => catppuccinFrappe,
+	catppuccinLatte: () => catppuccinLatte,
+	catppuccinMacchiato: () => catppuccinMacchiato,
+	catppuccinMocha: () => catppuccinMocha,
+	createTheme: () => createTheme,
+	dawnfox: () => dawnfox,
+	defaultDarkTheme: () => defaultDarkTheme,
+	defaultFlattenRule: () => defaultFlattenRule,
+	defaultLightTheme: () => defaultLightTheme,
+	defineDesignSystem: () => defineDesignSystem,
+	detectScheme: () => detectScheme,
+	detectSchemeTheme: () => detectSchemeTheme,
+	detectTerminalScheme: () => detectTerminalScheme,
+	detectTheme: () => detectTheme,
+	dracula: () => dracula,
+	edgeDark: () => edgeDark,
+	edgeLight: () => edgeLight,
+	everforestDark: () => everforestDark,
+	everforestLight: () => everforestLight,
+	exportBase16: () => exportBase16,
+	fromBase16: () => fromBase16,
+	fromColors: () => fromColors,
+	fromPreset: () => fromPreset,
+	generateTheme: () => generateTheme,
+	getSchemeByName: () => getSchemeByName,
+	getThemeByName: () => getThemeByName,
+	gruvboxDark: () => gruvboxDark,
+	gruvboxLight: () => gruvboxLight,
+	horizon: () => horizon,
+	importBase16: () => importBase16,
+	kanagawaDragon: () => kanagawaDragon,
+	kanagawaLotus: () => kanagawaLotus,
+	kanagawaWave: () => kanagawaWave,
+	materialDark: () => materialDark,
+	materialLight: () => materialLight,
+	modusOperandi: () => modusOperandi,
+	modusVivendi: () => modusVivendi,
+	monokai: () => monokai,
+	monokaiPro: () => monokaiPro,
+	moonfly: () => moonfly,
+	nightfly: () => nightfly,
+	nightfox: () => nightfox,
+	nord: () => nord,
+	oneDark: () => oneDark,
+	oxocarbonDark: () => oxocarbonDark,
+	oxocarbonLight: () => oxocarbonLight,
+	palenight: () => palenight,
+	presetTheme: () => presetTheme,
+	probeColors: () => probeColors,
+	quickTheme: () => quickTheme,
+	resolveAliases: () => resolveAliases,
+	resolveTokenAlias: () => resolveTokenAlias,
+	rosePine: () => rosePine,
+	rosePineDawn: () => rosePineDawn,
+	rosePineMoon: () => rosePineMoon,
+	snazzy: () => snazzy,
+	solarizedDark: () => solarizedDark,
+	solarizedLight: () => solarizedLight,
+	sonokai: () => sonokai,
+	sterling: () => sterling,
+	sterlingAutoLift: () => autoLift,
+	sterlingCheckAA: () => checkAA,
+	sterlingDefaultScheme: () => defaultScheme,
+	sterlingDeriveRoles: () => deriveRoles,
+	sterlingDeriveTheme: () => deriveTheme$1,
+	themeToCSSVars: () => themeToCSSVars,
+	tokyoNight: () => tokyoNight,
+	tokyoNightDay: () => tokyoNightDay,
+	tokyoNightStorm: () => tokyoNightStorm,
+	validateColorScheme: () => validateColorScheme,
+	validateTheme: () => validateTheme
+});
+var init_src = __esmMin((() => {
+	init_theme();
+}));
+//#endregion
+export { fromPreset as _, resolveAliases as a, validateTheme as c, createTheme as d, presetTheme as f, fromColors as g, fromBase16 as h, themeToCSSVars as i, validateColorScheme as l, assignPrimaryToSlot as m, src_exports as n, resolveTokenAlias as o, quickTheme as p, exportBase16 as r, THEME_TOKEN_KEYS as s, init_src as t, autoGenerateTheme as u, importBase16 as v, generateTheme as y };
+
+//# sourceMappingURL=src-5w9QR6_8.mjs.map