@yahoo/uds 3.143.0 → 3.145.0-beta.1

package/dist/tailwind-v4/dist/generateTheme-DkTgUwTM.cjs

@@ -0,0 +1,643 @@
+/*! © 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;