/*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
const require_index = require("../../fixtures/dist/index.cjs");
require("../../modes/dist/index.cjs");
const require_index$2 = require("../../fonts/dist/index.cjs");
//#region ../tailwind-v4/dist/generateTheme-DkTgUwTM.js
/*! © 2026 Yahoo, Inc. UDS Tailwind v4 v0.0.0-development */
function buildRadiusDeclarations(config) {
	const vars = {};
	const radiusScale = config.scaleMode?.["large"]?.borderRadius ?? {};
	for (const [name, value] of Object.entries(radiusScale)) vars[`--uds-radius-${name}`] = `${value / 16}rem`;
	return vars;
}
function buildBorderWidthDeclarations(config) {
	const vars = {};
	const borderWidths = config.scaleMode?.["large"]?.borderWidth ?? {};
	for (const [name, value] of Object.entries(borderWidths)) vars[`--uds-border-width-${name}`] = `${value}px`;
	return vars;
}
function buildBreakpointDeclarations(config, warnings) {
	const vars = {};
	for (const [name, breakpoint] of Object.entries(config.breakpoints)) {
		if (breakpoint.type !== "px") {
			warnings.push({
				path: `breakpoints.${name}`,
				message: `Unsupported breakpoint type '${String(breakpoint.type)}'.`
			});
			continue;
		}
		vars[`--uds-breakpoint-${name}`] = `${breakpoint.value / 16}rem`;
	}
	return vars;
}
function normalizeOpacity(opacity) {
	if (!opacity) return;
	const parsed = Number(opacity);
	if (Number.isNaN(parsed)) return;
	return Math.max(0, Math.min(100, parsed));
}
function formatRgbString(rgb, opacity) {
	if (opacity === void 0 || opacity === 100) return `rgb(${rgb.r} ${rgb.g} ${rgb.b})`;
	return `rgb(${rgb.r} ${rgb.g} ${rgb.b} / ${opacity}%)`;
}
function formatColor({ rgb, opacity }) {
	return formatRgbString(rgb, normalizeOpacity(opacity));
}
function sortObjectEntries(source) {
	return Object.entries(source).sort(([a], [b]) => a.localeCompare(b));
}
function resolveSpectrumRgb(spectrum, hue, step) {
	return spectrum?.[hue]?.[step]?.rgb;
}
function buildPaletteVars({ colorMode, warnings }) {
	const vars = {};
	if (!colorMode.palette || !colorMode.spectrum) return vars;
	for (const [group, groupValues] of sortObjectEntries(colorMode.palette)) for (const [semanticName, token] of sortObjectEntries(groupValues)) {
		const rgb = resolveSpectrumRgb(colorMode.spectrum, token.hue, token.step);
		if (!rgb) {
			warnings.push({
				path: `palette.${group}.${semanticName}`,
				message: `Unable to resolve spectrum value for ${token.hue}/${token.step}.`
			});
			continue;
		}
		vars[`--uds-color-${group}-${semanticName}`] = formatColor({
			rgb,
			opacity: token.opacity
		});
	}
	return vars;
}
function buildSpectrumVars({ colorMode }) {
	const vars = {};
	if (!colorMode.spectrum) return vars;
	for (const [hue, steps] of sortObjectEntries(colorMode.spectrum)) for (const [step, rgbValue] of sortObjectEntries(steps)) vars[`--uds-color-${hue}-${step}`] = formatColor({ rgb: rgbValue.rgb });
	return vars;
}
function toNativeAliases(sourceVars) {
	const aliases = {};
	for (const key of Object.keys(sourceVars)) {
		if (!key.startsWith("--uds-color-")) continue;
		aliases[key.replace("--uds-color-", "--color-")] = `var(${key})`;
	}
	return aliases;
}
function buildColorDeclarations(config, warnings) {
	const lightVars = {
		...buildPaletteVars({
			colorMode: config.colorMode.light,
			warnings
		}),
		...buildSpectrumVars({
			colorMode: config.colorMode.light,
			warnings
		})
	};
	const darkVars = {
		...buildPaletteVars({
			colorMode: config.colorMode.dark,
			warnings
		}),
		...buildSpectrumVars({
			colorMode: config.colorMode.dark,
			warnings
		})
	};
	return {
		light: lightVars,
		dark: darkVars,
		lightAliases: toNativeAliases(lightVars),
		darkAliases: toNativeAliases(darkVars)
	};
}
const ALWAYS_RGB = {
	white: {
		r: 255,
		g: 255,
		b: 255
	},
	"always/white": {
		r: 255,
		g: 255,
		b: 255
	},
	black: {
		r: 0,
		g: 0,
		b: 0
	},
	"always/black": {
		r: 0,
		g: 0,
		b: 0
	},
	"always/brand": {
		r: 127,
		g: 91,
		b: 255
	},
	"always/accent": {
		r: 0,
		g: 212,
		b: 170
	}
};
function toChannel(value) {
	return Number(value);
}
function formatAlwaysColor(value) {
	const rgb = ALWAYS_RGB[value];
	if (!rgb) return;
	return formatColor({ rgb });
}
function formatRgbValue(rgb) {
	return formatColor({ rgb: {
		r: toChannel(rgb.r),
		g: toChannel(rgb.g),
		b: toChannel(rgb.b)
	} });
}
function formatRgbaValue(rgba) {
	return formatColor({
		rgb: {
			r: toChannel(rgba.r),
			g: toChannel(rgba.g),
			b: toChannel(rgba.b)
		},
		opacity: String(toChannel(rgba.a))
	});
}
/**
* Resolves a single shadow preset layer to a CSS box-shadow fragment.
* Color is emitted as a reference to the existing --uds-shadow-color-* or
* --uds-color-* vars so changes in colorMode are automatically reflected.
*/
function presetToLayer(preset, shadowType) {
	const offsetX = require_index.shadowOffsetMap[preset.offsetX] ?? 0;
	const offsetY = require_index.shadowOffsetMap[preset.offsetY] ?? 0;
	const blur = require_index.spacingMap[preset.blur] ?? 0;
	const spread = require_index.shadowSpreadRadiusMap[preset.spread] ?? 0;
	const opacityFraction = Number(preset.opacity) / 100;
	let colorVar;
	if (preset.color.type === "palette") colorVar = `--uds-color-shadow-${preset.color.value}`;
	else if (preset.color.type === "spectrum") colorVar = `--uds-color-${preset.color.value}`;
	else {
		const layer = `${offsetX}px ${offsetY}px ${blur}px ${spread}px rgb(${{
			"always/white": "255 255 255",
			white: "255 255 255",
			"always/black": "0 0 0",
			black: "0 0 0"
		}[preset.color.value] ?? "0 0 0"} / ${opacityFraction})`;
		return shadowType === "inset" ? `inset ${layer}` : layer;
	}
	const layer = `${offsetX}px ${offsetY}px ${blur}px ${spread}px rgb(var(${colorVar}) / ${opacityFraction})`;
	return shadowType === "inset" ? `inset ${layer}` : layer;
}
function shadowPresetsToValue(presets, shadowType) {
	if (presets.length === 0) return "none";
	return presets.map((preset) => presetToLayer(preset, shadowType)).join(", ");
}
function buildShadowTypeVars(config, shadowType) {
	const vars = {};
	const typeConfig = config.shadow?.[shadowType];
	if (!typeConfig) return vars;
	for (const [variant, presets] of Object.entries(typeConfig)) {
		const value = shadowPresetsToValue(presets, shadowType);
		vars[`--uds-${shadowType}-shadow-${variant}`] = value;
	}
	return vars;
}
/**
* Builds drop-shadow and inset-shadow CSS custom property declarations.
*
* Emitted vars: --uds-drop-shadow-{variant} / --uds-inset-shadow-{variant}
* Native aliases: --drop-shadow-{variant} / --shadow-{variant}
*
* Color values reference --uds-shadow-color-* palette vars so they respond
* to the active color mode via @media (prefers-color-scheme: dark) overrides.
*/
function buildShadowDeclarations(config) {
	const drop = buildShadowTypeVars(config, "drop");
	const inset = buildShadowTypeVars(config, "inset");
	const shadows = {
		...drop,
		...inset
	};
	const dropAliases = {};
	for (const key of Object.keys(drop)) dropAliases[key.replace("--uds-drop-shadow-", "--shadow-")] = `var(${key})`;
	const insetAliases = {};
	for (const key of Object.keys(inset)) insetAliases[key.replace("--uds-inset-shadow-", "--inset-shadow-")] = `var(${key})`;
	return {
		shadows,
		dropAliases,
		insetAliases
	};
}
function resolveElevationColor(color, warnings, path) {
	if (color.type === "line") return `var(--uds-color-line-${color.value})`;
	if (color.type === "spectrum") {
		const value = color.value;
		return `var(--uds-color-${value.hue}-${value.step})`;
	}
	const alwaysColor = formatAlwaysColor(String(color.value));
	if (alwaysColor) return alwaysColor;
	warnings.push({
		path,
		message: `Unsupported always color '${String(color.value)}'. Falling back to black.`
	});
	return formatAlwaysColor("black") ?? "rgb(0 0 0)";
}
function buildModeDeclarations$1(levels, mode, warnings) {
	const vars = {};
	if (!levels) return vars;
	for (const [level, byMode] of sortObjectEntries(levels)) {
		const preset = byMode[mode];
		vars[`--uds-background-color-elevation-${level}`] = formatRgbaValue(preset.finalBackgroundValue);
		vars[`--uds-background-blur-fallback-color-elevation-${level}`] = formatRgbValue(preset.fallbackBlurredBackgroundValue);
		vars[`--uds-background-blur-radius-elevation-${level}`] = `blur(${preset.backgroundBlurRadius}px)`;
		vars[`--uds-border-width-elevation-${level}`] = `var(--uds-border-width-${preset.borderWidth})`;
		vars[`--uds-line-color-elevation-${level}`] = resolveElevationColor(preset.borderColor, warnings, `elevation.${level}.${mode}.borderColor`);
		vars[`--uds-drop-shadow-elevation-${level}`] = Array.isArray(preset.dropShadow) ? shadowPresetsToValue(preset.dropShadow, "drop") : `var(--uds-drop-shadow-${preset.dropShadow})`;
		vars[`--uds-inset-shadow-elevation-${level}`] = Array.isArray(preset.insetShadow) ? shadowPresetsToValue(preset.insetShadow, "inset") : `var(--uds-inset-shadow-${preset.insetShadow})`;
	}
	return vars;
}
function buildAliases(sourceVars) {
	const aliases = {};
	for (const key of Object.keys(sourceVars)) {
		if (key.startsWith("--uds-border-width-elevation-")) aliases[key.replace("--uds-border-width-elevation-", "--border-width-elevation-")] = `var(${key})`;
		if (key.startsWith("--uds-drop-shadow-elevation-")) aliases[key.replace("--uds-drop-shadow-elevation-", "--shadow-elevation-")] = `var(${key})`;
		if (key.startsWith("--uds-inset-shadow-elevation-")) aliases[key.replace("--uds-inset-shadow-elevation-", "--inset-shadow-elevation-")] = `var(${key})`;
	}
	return aliases;
}
function buildElevationDeclarations(config, warnings) {
	const light = buildModeDeclarations$1(config.elevation, "light", warnings);
	return {
		light,
		dark: buildModeDeclarations$1(config.elevation, "dark", warnings),
		aliases: buildAliases(light)
	};
}
function resolveFocusRingColor(color, warnings, path) {
	if (color.type === "line") return `var(--uds-color-line-${color.value})`;
	if (color.type === "spectrum") {
		const value = color.value;
		return `var(--uds-color-${value.hue}-${value.step})`;
	}
	const alwaysColor = formatAlwaysColor(String(color.value));
	if (alwaysColor) return alwaysColor;
	warnings.push({
		path,
		message: `Unsupported always color '${String(color.value)}'. Falling back to black.`
	});
	return formatAlwaysColor("black") ?? "rgb(0 0 0)";
}
function buildModeDeclarations(config, warnings, mode) {
	if (!config) return {};
	return {
		"--uds-outline-color": resolveFocusRingColor(config.color, warnings, `focusRing.${mode}.color`),
		"--uds-outline-offset": `${config.offset}px`,
		"--uds-outline-style": "solid",
		"--uds-outline-width": `${config.width}px`
	};
}
function buildFocusRingDeclarations(config, warnings) {
	return {
		light: buildModeDeclarations(config.focusRing?.light, warnings, "light"),
		dark: buildModeDeclarations(config.focusRing?.dark, warnings, "dark")
	};
}
/**
* Build @font-face declarations from config.font values.
* Auto-discovers fonts by reading FontIDs from config.font.
*/
function buildFontFaceDeclarations(config) {
	const fontIds = /* @__PURE__ */ new Set();
	for (const fontId of Object.values(config.font ?? {})) if (fontId && fontId in require_index$2.FONT_DECLARATIONS_MAP) fontIds.add(fontId);
	const fontFaceRules = [];
	for (const fontId of fontIds) {
		const { fontFamily, declarations, isVariableFont } = require_index$2.FONT_DECLARATIONS_MAP[fontId];
		for (const declaration of declarations) {
			let src;
			if (isVariableFont) src = `url('${declaration.src}') format("woff2 supports variations"), url('${declaration.src}') format('woff2-variations')`;
			else src = `url('${declaration.src}') format('woff2')`;
			const fontFaceProps = [];
			fontFaceProps.push(`font-family: '${fontFamily}';`);
			fontFaceProps.push("font-display: swap;");
			if ("fontStyle" in declaration && declaration.fontStyle) fontFaceProps.push(`font-style: ${declaration.fontStyle};`);
			if ("fontWeight" in declaration && declaration.fontWeight) fontFaceProps.push(`font-weight: ${declaration.fontWeight};`);
			fontFaceProps.push(`src: ${src};`);
			fontFaceRules.push(`@font-face {\n  ${fontFaceProps.join("\n  ")}\n}`);
		}
	}
	return fontFaceRules.join("\n\n");
}
function buildSpacingDeclarations() {
	return {
		"--uds-spacing-4.5": "1.125rem",
		"--uds-spacing-5.5": "1.375rem"
	};
}
const GENERIC_FONT_FAMILIES = new Set([
	"serif",
	"sans-serif",
	"monospace",
	"cursive",
	"fantasy",
	"system-ui",
	"ui-serif",
	"ui-sans-serif",
	"ui-monospace",
	"ui-rounded",
	"emoji",
	"math",
	"fangsong"
]);
function normalizeTokenKey(name) {
	return name.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "token";
}
function toCssLength(value) {
	switch (value.type) {
		case "px": return `${value.value / 16}rem`;
		case "unitless": return String(value.value);
		default: return;
	}
}
function toCssValue(value) {
	switch (value.type) {
		case "px": return `${value.value / 16}rem`;
		case "unitless": return String(value.value);
		default: return;
	}
}
function quoteFontFamilyName(fontFamily) {
	if (GENERIC_FONT_FAMILIES.has(fontFamily)) return fontFamily;
	return `"${fontFamily.replace(/"/g, "\\\"")}"`;
}
function formatFontStack(fontId) {
	const font = require_index$2.FONT_DECLARATIONS_MAP[fontId];
	return [font.fontFamily, ...font.fallback].map(quoteFontFamilyName).join(", ");
}
function buildVariationSettings(fontId) {
	const font = require_index$2.FONT_DECLARATIONS_MAP[fontId];
	if (!font.isVariableFont) return;
	const axes = [`"wght" ${font.defaults.fontWeight}`];
	if (typeof font.defaults.fontSlant === "number") {
		axes.push(`"slnt" ${font.defaults.fontSlant}`);
		axes.push(`"ital" ${font.defaults.fontSlant}`);
	}
	if (typeof font.defaults.fontWidth === "number") axes.push(`"wdth" ${font.defaults.fontWidth}`);
	return axes.join(", ");
}
function buildTextDeclarations(config, warnings) {
	const vars = {};
	for (const [name, token] of Object.entries(config.typography)) {
		const tokenName = normalizeTokenKey(name);
		if (!token.fontSize?.base) continue;
		const fontSize = toCssLength(token.fontSize.base);
		if (!fontSize) {
			warnings.push({
				path: `typography.${name}.fontSize.base`,
				message: `Unsupported font size type '${token.fontSize.base.type}'.`
			});
			continue;
		}
		vars[`--uds-text-${tokenName}`] = fontSize;
		const lineHeight = token.lineHeight?.base ? toCssLength(token.lineHeight.base) : void 0;
		if (lineHeight) {
			vars[`--uds-text-${tokenName}--line-height`] = lineHeight;
			vars[`--uds-leading-${tokenName}`] = lineHeight;
		}
	}
	return vars;
}
function buildFontDeclarations(config) {
	const vars = {};
	for (const [name, family] of Object.entries(config.font)) {
		const tokenName = normalizeTokenKey(name);
		if (!(family in require_index$2.FONT_DECLARATIONS_MAP)) throw new Error(`Unknown font ID '${family}' for config.font.${name}. Expected one of: ${Object.keys(require_index$2.FONT_DECLARATIONS_MAP).join(", ")}`);
		const fontId = family;
		vars[`--uds-font-${tokenName}`] = formatFontStack(fontId);
		const variationSettings = buildVariationSettings(fontId);
		if (variationSettings) vars[`--uds-font-${tokenName}--font-variation-settings`] = variationSettings;
	}
	return vars;
}
function buildFontWeightDeclarations(config, warnings) {
	const vars = {};
	for (const [name, token] of Object.entries(config.typography)) {
		const tokenName = normalizeTokenKey(name);
		if (!token.fontWeight?.base) continue;
		const value = toCssValue(token.fontWeight.base);
		if (!value) {
			warnings.push({
				path: `typography.${name}.fontWeight.base`,
				message: `Unsupported font weight type '${token.fontWeight.base.type}'.`
			});
			continue;
		}
		vars[`--uds-font-weight-${tokenName}`] = value;
	}
	return vars;
}
function buildLetterSpacingDeclarations(config, warnings) {
	const vars = {};
	for (const [name, token] of Object.entries(config.typography)) {
		const tokenName = normalizeTokenKey(name);
		if (!token.letterSpacing?.base) continue;
		const value = toCssLength(token.letterSpacing.base);
		if (!value) {
			warnings.push({
				path: `typography.${name}.letterSpacing.base`,
				message: `Unsupported letter spacing type '${token.letterSpacing.base.type}'.`
			});
			continue;
		}
		vars[`--uds-letter-spacing-${tokenName}`] = value;
	}
	return vars;
}
function formatDeclarations(pairs) {
	return pairs.map(({ name, value }) => `  ${name}: ${value};`).join("\n");
}
/**
* Generates color mode CSS output based on the selected strategy.
*
* - **system mode**: `:root` gets light values (or dark if default is dark), media query handles switching
* - **class mode**: `:root` gets default, class selectors (`.light`, `.dark`, `.system`) provide overrides
* - **light mode**: `:root` gets only light values, no switching
* - **dark mode**: `:root` gets only dark values, no switching
*/
function generateColorModeCSS(input) {
	const { lightVars, darkVars, colorScheme, defaultColorMode, lightModeClass, darkModeClass, systemModeClass } = input;
	const lines = [];
	if (colorScheme === "light") {
		lines.push(":root {");
		lines.push("  color-scheme: light;");
		lines.push(formatDeclarations(Object.entries(lightVars).map(([name, value]) => ({
			name,
			value
		}))));
		lines.push("}");
		return lines;
	}
	if (colorScheme === "dark") {
		lines.push(":root {");
		lines.push("  color-scheme: dark;");
		lines.push(formatDeclarations(Object.entries(darkVars).map(([name, value]) => ({
			name,
			value
		}))));
		lines.push("}");
		return lines;
	}
	const isDefaultDark = defaultColorMode === "dark";
	const oppositeMode = isDefaultDark ? "light" : "dark";
	const oppositeModeVars = isDefaultDark ? lightVars : darkVars;
	const defaultModeVars = isDefaultDark ? darkVars : lightVars;
	lines.push(":root {");
	lines.push(`  color-scheme: ${defaultColorMode};`);
	lines.push(formatDeclarations(Object.entries(defaultModeVars).map(([name, value]) => ({
		name,
		value
	}))));
	lines.push("}");
	lines.push("");
	if (colorScheme === "system") {
		lines.push(`@media (prefers-color-scheme: ${oppositeMode}) {`);
		lines.push("  :root {");
		lines.push(formatDeclarations(Object.entries(oppositeModeVars).map(([name, value]) => ({
			name,
			value
		}))).split("\n").map((line) => `  ${line}`).join("\n"));
		lines.push("  }");
		lines.push("}");
	} else {
		lines.push(`.${lightModeClass} {`);
		lines.push("  color-scheme: light;");
		lines.push(formatDeclarations(Object.entries(lightVars).map(([name, value]) => ({
			name,
			value
		}))));
		lines.push("}");
		lines.push("");
		lines.push(`.${darkModeClass} {`);
		lines.push("  color-scheme: dark;");
		lines.push(formatDeclarations(Object.entries(darkVars).map(([name, value]) => ({
			name,
			value
		}))));
		lines.push("}");
		lines.push("");
		lines.push(`.${systemModeClass} {`);
		lines.push("  color-scheme: light dark;");
		lines.push(formatDeclarations(Object.entries(lightVars).map(([name, value]) => ({
			name,
			value
		}))));
		lines.push("}");
		lines.push("");
		lines.push(`@media (prefers-color-scheme: dark) {`);
		lines.push(`  .${systemModeClass} {`);
		lines.push(formatDeclarations(Object.entries(darkVars).map(([name, value]) => ({
			name,
			value
		}))).split("\n").map((line) => `    ${line}`).join("\n"));
		lines.push("  }");
		lines.push("}");
	}
	return lines;
}
function normalizeOptions(options) {
	return { disableOverrideTailwindTheme: options?.disableOverrideTailwindTheme ?? [] };
}
function aliasCategory(sourceVars, sourcePrefix, targetPrefix) {
	const result = {};
	for (const key of Object.keys(sourceVars)) {
		if (!key.startsWith(sourcePrefix)) continue;
		result[key.replace(sourcePrefix, targetPrefix)] = `var(${key})`;
	}
	return result;
}
function inlineAliasCategory(sourceVars, sourcePrefix, targetPrefix) {
	const result = {};
	for (const [key, value] of Object.entries(sourceVars)) {
		if (!key.startsWith(sourcePrefix)) continue;
		result[key.replace(sourcePrefix, targetPrefix)] = value;
	}
	return result;
}
function mergeSorted(...records) {
	const merged = Object.assign({}, ...records);
	return Object.fromEntries(sortObjectEntries(merged));
}
function generateThemeResult(config, options) {
	const normalizedOptions = normalizeOptions(options);
	const warnings = [];
	const includeFontFace = options?.includeFontFace !== false;
	const color = buildColorDeclarations(config, warnings);
	const borderWidth = buildBorderWidthDeclarations(config);
	const breakpoints = buildBreakpointDeclarations(config, warnings);
	const elevation = buildElevationDeclarations(config, warnings);
	const focusRing = buildFocusRingDeclarations(config, warnings);
	const radius = buildRadiusDeclarations(config);
	const spacing = buildSpacingDeclarations();
	const text = buildTextDeclarations(config, warnings);
	const font = buildFontDeclarations(config);
	const fontWeight = buildFontWeightDeclarations(config, warnings);
	const letterSpacing = buildLetterSpacingDeclarations(config, warnings);
	const shadow = buildShadowDeclarations(config);
	const fontFace = includeFontFace ? buildFontFaceDeclarations(config) : "";
	const disable = new Set(normalizedOptions.disableOverrideTailwindTheme);
	const lightVars = mergeSorted(color.light, borderWidth, breakpoints, elevation.light, focusRing.light, radius, spacing, text, font, fontWeight, letterSpacing, shadow.shadows, disable.has("breakpoint") ? {} : inlineAliasCategory(breakpoints, "--uds-breakpoint-", "--breakpoint-"));
	const inlineAliasVars = mergeSorted(disable.has("border") ? {} : aliasCategory(borderWidth, "--uds-border-width-", "--border-width-"), disable.has("color") ? {} : color.lightAliases, disable.has("elevation") ? {} : elevation.aliases, disable.has("radius") ? {} : aliasCategory(radius, "--uds-radius-", "--radius-"), disable.has("spacing") ? {} : aliasCategory(spacing, "--uds-spacing-", "--spacing-"), disable.has("text") ? {} : {
		...aliasCategory(text, "--uds-text-", "--text-"),
		...aliasCategory(text, "--uds-leading-", "--leading-"),
		...aliasCategory(letterSpacing, "--uds-letter-spacing-", "--tracking-")
	}, disable.has("font") ? {} : {
		...aliasCategory(font, "--uds-font-", "--font-"),
		...aliasCategory(fontWeight, "--uds-font-weight-", "--font-weight-")
	}, disable.has("shadow") ? {} : {
		...shadow.dropAliases,
		...shadow.insetAliases
	});
	const colorModeRootLightVars = mergeSorted(color.light, elevation.light, focusRing.light);
	const colorModeRootDarkVars = mergeSorted(color.dark, elevation.dark, focusRing.dark);
	const themeParts = [
		"@theme {",
		formatDeclarations(Object.entries(lightVars).map(([name, value]) => ({
			name,
			value
		}))),
		"}",
		"",
		"@theme inline {",
		formatDeclarations(Object.entries(inlineAliasVars).map(([name, value]) => ({
			name,
			value
		}))),
		"}",
		""
	];
	const colorModeCSS = generateColorModeCSS({
		lightVars: colorModeRootLightVars,
		darkVars: colorModeRootDarkVars,
		colorScheme: options?.colorScheme ?? "system",
		defaultColorMode: options?.defaultColorMode ?? "light",
		lightModeClass: options?.lightModeClass ?? "light",
		darkModeClass: options?.darkModeClass ?? "dark",
		systemModeClass: options?.systemModeClass ?? "system"
	});
	themeParts.push(...colorModeCSS);
	return {
		css: [...fontFace ? [
			fontFace,
			"",
			""
		] : [], ...themeParts].join("\n"),
		warnings
	};
}
//#endregion
exports.generateThemeResult = generateThemeResult;
