@tenphi/glaze 0.0.0-snapshot.c8281e2 → 0.0.0-snapshot.cdd8acc

package/dist/index.mjs

@@ -344,6 +344,11 @@ function gamutClampedLuminance(linearRgb) {
 const linearSrgbToOklab = (rgb) => {
 	return transform(cbrt3(transform(rgb, linear_sRGB_to_LMS_M)), LMS_to_OKLab_M);
 };
+/**
+* Convert OKLab to OKHSL.
+* Input: [L, a, b] where L: 0–1, a/b: roughly -0.5 to 0.5.
+* Returns [h, s, l] where h: 0–360, s: 0–1, l: 0–1.
+*/
 const oklabToOkhsl = (lab) => {
 	const L = lab[0];
 	const a = lab[1];
@@ -391,6 +396,39 @@ function srgbToOkhsl(rgb) {
 	]));
 }
 /**
+* Convert CSS HSL (sRGB-based) to gamma-encoded sRGB [r, g, b] in 0–1 range.
+* h: 0–360, s: 0–1, l: 0–1.
+*
+* Note: CSS HSL is not the same as OKHSL — it's HSL in the sRGB color space.
+* Use this when parsing `hsl(...)` strings before passing to `srgbToOkhsl`.
+*/
+function hslToSrgb(h, s, l) {
+	const hh = (h % 360 + 360) % 360 / 360;
+	const ss = clampVal(s, 0, 1);
+	const ll = clampVal(l, 0, 1);
+	if (ss === 0) return [
+		ll,
+		ll,
+		ll
+	];
+	const q = ll < .5 ? ll * (1 + ss) : ll + ss - ll * ss;
+	const p = 2 * ll - q;
+	const hueToChannel = (t) => {
+		let tt = t;
+		if (tt < 0) tt += 1;
+		if (tt > 1) tt -= 1;
+		if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+		if (tt < 1 / 2) return q;
+		if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+		return p;
+	};
+	return [
+		hueToChannel(hh + 1 / 3),
+		hueToChannel(hh),
+		hueToChannel(hh - 1 / 3)
+	];
+}
+/**
 * Parse a hex color string (#rgb or #rrggbb) to sRGB [r, g, b] in 0–1 range.
 * Returns null if the string is not a valid hex color.
 */
@@ -618,7 +656,7 @@ function coarseScan(h, s, lo, hi, yBase, target, epsilon, maxIter) {
 function findLightnessForContrast(options) {
 	const { hue, saturation, preferredLightness, baseLinearRgb, contrast: contrastInput, lightnessRange = [0, 1], epsilon = 1e-4, maxIterations = 14 } = options;
 	const target = resolveMinContrast(contrastInput);
-	const searchTarget = target * 1.007;
+	const searchTarget = target * 1.01;
 	const yBase = gamutClampedLuminance(baseLinearRgb);
 	const crPref = contrastRatioFromLuminance(cachedLuminance(hue, saturation, preferredLightness), yBase);
 	if (crPref >= searchTarget) return {
@@ -812,6 +850,7 @@ let globalConfig = {
 	lightLightness: [10, 100],
 	darkLightness: [15, 95],
 	darkDesaturation: .1,
+	darkCurve: .5,
 	states: {
 		dark: "@dark",
 		highContrast: "@high-contrast"
@@ -959,25 +998,42 @@ function topoSort(defs) {
 	for (const name of Object.keys(defs)) visit(name);
 	return result;
 }
+function lightnessWindow(isHighContrast, kind) {
+	if (isHighContrast) return [0, 100];
+	return kind === "dark" ? globalConfig.darkLightness : globalConfig.lightLightness;
+}
 function mapLightnessLight(l, mode, isHighContrast) {
-	if (mode === "static" || isHighContrast) return l;
-	const [lo, hi] = globalConfig.lightLightness;
+	if (mode === "static") return l;
+	const [lo, hi] = lightnessWindow(isHighContrast, "light");
 	return l * (hi - lo) / 100 + lo;
 }
+function mobiusCurve(t, beta) {
+	if (beta >= 1) return t;
+	return t / (t + beta * (1 - t));
+}
 function mapLightnessDark(l, mode, isHighContrast) {
 	if (mode === "static") return l;
-	if (isHighContrast) return mode === "fixed" ? l : 100 - l;
-	const [lo, hi] = globalConfig.darkLightness;
-	if (mode === "fixed") return l * (hi - lo) / 100 + lo;
-	return (100 - l) * (hi - lo) / 100 + lo;
+	const beta = isHighContrast ? pairHC(globalConfig.darkCurve) : pairNormal(globalConfig.darkCurve);
+	const [darkLo, darkHi] = lightnessWindow(isHighContrast, "dark");
+	if (mode === "fixed") return l * (darkHi - darkLo) / 100 + darkLo;
+	const [lightLo, lightHi] = lightnessWindow(isHighContrast, "light");
+	const t = (lightHi - (l * (lightHi - lightLo) / 100 + lightLo)) / (lightHi - lightLo);
+	return darkLo + (darkHi - darkLo) * mobiusCurve(t, beta);
+}
+function lightMappedToDark(lightL, isHighContrast) {
+	const beta = isHighContrast ? pairHC(globalConfig.darkCurve) : pairNormal(globalConfig.darkCurve);
+	const [lightLo, lightHi] = lightnessWindow(isHighContrast, "light");
+	const [darkLo, darkHi] = lightnessWindow(isHighContrast, "dark");
+	const t = (lightHi - clamp(lightL, lightLo, lightHi)) / (lightHi - lightLo);
+	return darkLo + (darkHi - darkLo) * mobiusCurve(t, beta);
 }
 function mapSaturationDark(s, mode) {
 	if (mode === "static") return s;
 	return s * (1 - globalConfig.darkDesaturation);
 }
 function schemeLightnessRange(isDark, mode, isHighContrast) {
-	if (mode === "static" || isHighContrast) return [0, 1];
-	const [lo, hi] = isDark ? globalConfig.darkLightness : globalConfig.lightLightness;
+	if (mode === "static") return [0, 1];
+	const [lo, hi] = lightnessWindow(isHighContrast, isDark ? "dark" : "light");
 	return [lo / 100, hi / 100];
 }
 function clamp(v, min, max) {
@@ -1036,9 +1092,9 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 	else {
 		const parsed = parseRelativeOrAbsolute(isHighContrast ? pairHC(rawLightness) : pairNormal(rawLightness));
 		if (parsed.relative) {
-			let delta = parsed.value;
-			if (isDark && mode === "auto") delta = -delta;
-			preferredL = clamp(baseL + delta, 0, 100);
+			const delta = parsed.value;
+			if (isDark && mode === "auto") preferredL = lightMappedToDark(clamp(getSchemeVariant(baseResolved, false, isHighContrast).l * 100 + delta, 0, 100), isHighContrast);
+			else preferredL = clamp(baseL + delta, 0, 100);
 		} else if (isDark) preferredL = mapLightnessDark(parsed.value, mode, isHighContrast);
 		else preferredL = mapLightnessLight(parsed.value, mode, isHighContrast);
 	}
@@ -1047,15 +1103,15 @@ function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effective
 		const minCr = isHighContrast ? pairHC(rawContrast) : pairNormal(rawContrast);
 		const effectiveSat = isDark ? mapSaturationDark(satFactor * ctx.saturation / 100, mode) : satFactor * ctx.saturation / 100;
 		const baseLinearRgb = okhslToLinearSrgb(baseVariant.h, baseVariant.s, baseVariant.l);
-		const lightnessRange = schemeLightnessRange(isDark, mode, isHighContrast);
+		const windowRange = schemeLightnessRange(isDark, mode, isHighContrast);
 		return {
 			l: findLightnessForContrast({
 				hue: effectiveHue,
 				saturation: effectiveSat,
-				preferredLightness: clamp(preferredL / 100, lightnessRange[0], lightnessRange[1]),
+				preferredLightness: clamp(preferredL / 100, windowRange[0], windowRange[1]),
 				baseLinearRgb,
 				contrast: minCr,
-				lightnessRange
+				lightnessRange: [0, 1]
 			}).lightness * 100,
 			satFactor
 		};
@@ -1395,10 +1451,14 @@ function createTheme(hue, saturation, initialColors) {
 			};
 		},
 		extend(options) {
-			return createTheme(options.hue ?? hue, options.saturation ?? saturation, options.colors ? {
-				...colorDefs,
+			const newHue = options.hue ?? hue;
+			const newSat = options.saturation ?? saturation;
+			const inheritedColors = {};
+			for (const [name, def] of Object.entries(colorDefs)) if (def.inherit !== false) inheritedColors[name] = def;
+			return createTheme(newHue, newSat, options.colors ? {
+				...inheritedColors,
 				...options.colors
-			} : { ...colorDefs });
+			} : { ...inheritedColors });
 		},
 		resolve() {
 			return resolveAllColors(hue, saturation, colorDefs);
@@ -1432,40 +1492,74 @@ function validatePrimaryTheme(primary, themes) {
 		throw new Error(`glaze: primary theme "${primary}" not found in palette. Available: ${available}.`);
 	}
 }
-function createPalette(themes) {
+/**
+* Resolve the effective primary for an export call.
+* `false` disables, a string overrides, `undefined` inherits from palette.
+*/
+function resolveEffectivePrimary(exportPrimary, palettePrimary) {
+	if (exportPrimary === false) return void 0;
+	return exportPrimary ?? palettePrimary;
+}
+/**
+* Filter a resolved color map, skipping keys already in `seen`.
+* Warns on collision and keeps the first-written value (first-write-wins).
+* Returns a new map containing only non-colliding entries.
+*/
+function filterCollisions(resolved, prefix, seen, themeName, isPrimary) {
+	const filtered = /* @__PURE__ */ new Map();
+	const label = isPrimary ? `${themeName} (primary)` : themeName;
+	for (const [name, color] of resolved) {
+		const key = `${prefix}${name}`;
+		if (seen.has(key)) {
+			console.warn(`glaze: token "${key}" from theme "${label}" collides with theme "${seen.get(key)}" — skipping.`);
+			continue;
+		}
+		seen.set(key, label);
+		filtered.set(name, color);
+	}
+	return filtered;
+}
+function createPalette(themes, paletteOptions) {
+	validatePrimaryTheme(paletteOptions?.primary, themes);
 	return {
 		tokens(options) {
-			validatePrimaryTheme(options?.primary, themes);
+			const effectivePrimary = resolveEffectivePrimary(options?.primary, paletteOptions?.primary);
+			if (options?.primary !== void 0) validatePrimaryTheme(effectivePrimary, themes);
 			const modes = resolveModes(options?.modes);
 			const allTokens = {};
+			const seen = /* @__PURE__ */ new Map();
 			for (const [themeName, theme] of Object.entries(themes)) {
 				const resolved = theme.resolve();
-				const tokens = buildFlatTokenMap(resolved, resolvePrefix(options, themeName, true), modes, options?.format);
+				const prefix = resolvePrefix(options, themeName, true);
+				const tokens = buildFlatTokenMap(filterCollisions(resolved, prefix, seen, themeName), prefix, modes, options?.format);
 				for (const variant of Object.keys(tokens)) {
 					if (!allTokens[variant]) allTokens[variant] = {};
 					Object.assign(allTokens[variant], tokens[variant]);
 				}
-				if (themeName === options?.primary) {
-					const unprefixed = buildFlatTokenMap(resolved, "", modes, options?.format);
+				if (themeName === effectivePrimary) {
+					const unprefixed = buildFlatTokenMap(filterCollisions(resolved, "", seen, themeName, true), "", modes, options?.format);
 					for (const variant of Object.keys(unprefixed)) Object.assign(allTokens[variant], unprefixed[variant]);
 				}
 			}
 			return allTokens;
 		},
 		tasty(options) {
-			validatePrimaryTheme(options?.primary, themes);
+			const effectivePrimary = resolveEffectivePrimary(options?.primary, paletteOptions?.primary);
+			if (options?.primary !== void 0) validatePrimaryTheme(effectivePrimary, themes);
 			const states = {
 				dark: options?.states?.dark ?? globalConfig.states.dark,
 				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
 			};
 			const modes = resolveModes(options?.modes);
 			const allTokens = {};
+			const seen = /* @__PURE__ */ new Map();
 			for (const [themeName, theme] of Object.entries(themes)) {
 				const resolved = theme.resolve();
-				const tokens = buildTokenMap(resolved, resolvePrefix(options, themeName, true), states, modes, options?.format);
+				const prefix = resolvePrefix(options, themeName, true);
+				const tokens = buildTokenMap(filterCollisions(resolved, prefix, seen, themeName), prefix, states, modes, options?.format);
 				Object.assign(allTokens, tokens);
-				if (themeName === options?.primary) {
-					const unprefixed = buildTokenMap(resolved, "", states, modes, options?.format);
+				if (themeName === effectivePrimary) {
+					const unprefixed = buildTokenMap(filterCollisions(resolved, "", seen, themeName, true), "", states, modes, options?.format);
 					Object.assign(allTokens, unprefixed);
 				}
 			}
@@ -1478,7 +1572,8 @@ function createPalette(themes) {
 			return result;
 		},
 		css(options) {
-			validatePrimaryTheme(options?.primary, themes);
+			const effectivePrimary = resolveEffectivePrimary(options?.primary, paletteOptions?.primary);
+			if (options?.primary !== void 0) validatePrimaryTheme(effectivePrimary, themes);
 			const suffix = options?.suffix ?? "-color";
 			const format = options?.format ?? "rgb";
 			const allLines = {
@@ -1487,17 +1582,19 @@ function createPalette(themes) {
 				lightContrast: [],
 				darkContrast: []
 			};
+			const seen = /* @__PURE__ */ new Map();
 			for (const [themeName, theme] of Object.entries(themes)) {
 				const resolved = theme.resolve();
-				const css = buildCssMap(resolved, resolvePrefix(options, themeName, true), suffix, format);
+				const prefix = resolvePrefix(options, themeName, true);
+				const css = buildCssMap(filterCollisions(resolved, prefix, seen, themeName), prefix, suffix, format);
 				for (const key of [
 					"light",
 					"dark",
 					"lightContrast",
 					"darkContrast"
 				]) if (css[key]) allLines[key].push(css[key]);
-				if (themeName === options?.primary) {
-					const unprefixed = buildCssMap(resolved, "", suffix, format);
+				if (themeName === effectivePrimary) {
+					const unprefixed = buildCssMap(filterCollisions(resolved, "", seen, themeName, true), "", suffix, format);
 					for (const key of [
 						"light",
 						"dark",
@@ -1515,33 +1612,183 @@ function createPalette(themes) {
 		}
 	};
 }
-function createColorToken(input) {
-	const defs = { __color__: {
-		lightness: input.lightness,
-		saturation: input.saturationFactor,
-		mode: input.mode
-	} };
+/** Matches CSS color functions Glaze itself emits, plus their legacy alpha aliases. */
+const COLOR_FN_RE = /^(rgba?|hsla?|okhsl|oklch)\(\s*([^)]*)\s*\)$/i;
+function parseNumberOrPercent(raw, percentScale) {
+	if (raw.endsWith("%")) return parseFloat(raw) / 100 * percentScale;
+	return parseFloat(raw);
+}
+function parseColorString(input) {
+	if (input.startsWith("#")) {
+		const rgb = parseHex(input);
+		if (!rgb) throw new Error(`glaze: invalid hex color "${input}".`);
+		const [h, s, l] = srgbToOkhsl(rgb);
+		return {
+			h,
+			s,
+			l
+		};
+	}
+	const m = input.match(COLOR_FN_RE);
+	if (!m) throw new Error(`glaze: unsupported color string "${input}".`);
+	const fn = m[1].toLowerCase();
+	const body = m[2].trim();
+	let parts;
+	let hasAlpha = false;
+	const slashIdx = body.indexOf("/");
+	if (slashIdx !== -1) {
+		parts = body.slice(0, slashIdx).trim().split(/[\s,]+/).filter(Boolean);
+		hasAlpha = body.slice(slashIdx + 1).trim().length > 0;
+	} else {
+		parts = body.split(/[\s,]+/).filter(Boolean);
+		if (parts.length === 4) {
+			parts.pop();
+			hasAlpha = true;
+		}
+	}
+	if (hasAlpha) console.warn(`glaze: alpha component dropped from "${input}" (standalone color has no opacity field).`);
+	if (parts.length !== 3) throw new Error(`glaze: expected 3 components in "${input}".`);
+	switch (fn) {
+		case "rgb":
+		case "rgba": {
+			const [h, s, l] = srgbToOkhsl([
+				parseNumberOrPercent(parts[0], 255) / 255,
+				parseNumberOrPercent(parts[1], 255) / 255,
+				parseNumberOrPercent(parts[2], 255) / 255
+			]);
+			return {
+				h,
+				s,
+				l
+			};
+		}
+		case "hsl":
+		case "hsla": {
+			const [oh, os, ol] = srgbToOkhsl(hslToSrgb(parseFloat(parts[0]), parseNumberOrPercent(parts[1], 1), parseNumberOrPercent(parts[2], 1)));
+			return {
+				h: oh,
+				s: os,
+				l: ol
+			};
+		}
+		case "okhsl": return {
+			h: parseFloat(parts[0]),
+			s: parseNumberOrPercent(parts[1], 1),
+			l: parseNumberOrPercent(parts[2], 1)
+		};
+		case "oklch": {
+			const L = parseNumberOrPercent(parts[0], 1);
+			const C = parseFloat(parts[1]);
+			const hRad = parseFloat(parts[2]) * Math.PI / 180;
+			const [h, s, l] = oklabToOkhsl([
+				L,
+				C * Math.cos(hRad),
+				C * Math.sin(hRad)
+			]);
+			return {
+				h,
+				s,
+				l
+			};
+		}
+	}
+	throw new Error(`glaze: unsupported color function "${fn}".`);
+}
+function extractOkhslFromValue(value) {
+	if (typeof value === "string") return parseColorString(value);
+	if (Array.isArray(value)) {
+		const [r, g, b] = value;
+		const [h, s, l] = srgbToOkhsl([
+			r / 255,
+			g / 255,
+			b / 255
+		]);
+		return {
+			h,
+			s,
+			l
+		};
+	}
+	return value;
+}
+function buildValueDefs(main, options) {
+	const absoluteSeedHue = typeof options?.hue === "number" ? options.hue : main.h;
+	const seedSaturation = options?.saturation ?? main.s * 100;
+	const relativeHue = typeof options?.hue === "string" ? options.hue : void 0;
+	if (options?.base !== void 0) {
+		const baseOkhsl = extractOkhslFromValue(options.base);
+		const baseSatFactor = seedSaturation > 0 ? Math.min(baseOkhsl.s * 100 / seedSaturation, 1) : 0;
+		return {
+			seedHue: absoluteSeedHue,
+			seedSaturation,
+			defs: {
+				__base__: {
+					hue: baseOkhsl.h,
+					saturation: baseSatFactor,
+					lightness: baseOkhsl.l * 100,
+					mode: options.mode
+				},
+				__color__: {
+					base: "__base__",
+					hue: relativeHue,
+					saturation: options.saturationFactor,
+					lightness: options.lightness ?? main.l * 100,
+					contrast: options.contrast,
+					mode: options.mode
+				}
+			},
+			primary: "__color__"
+		};
+	}
+	return {
+		seedHue: absoluteSeedHue,
+		seedSaturation,
+		defs: { __color__: {
+			hue: relativeHue,
+			saturation: options?.saturationFactor,
+			lightness: options?.lightness ?? main.l * 100,
+			contrast: options?.contrast,
+			mode: options?.mode
+		} },
+		primary: "__color__"
+	};
+}
+function createColorTokenFromDefs(seedHue, seedSaturation, defs, primary) {
+	const resolveStates = (options) => ({
+		dark: options?.states?.dark ?? globalConfig.states.dark,
+		highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
+	});
 	return {
 		resolve() {
-			return resolveAllColors(input.hue, input.saturation, defs).get("__color__");
+			return resolveAllColors(seedHue, seedSaturation, defs).get(primary);
 		},
 		token(options) {
-			return buildTokenMap(resolveAllColors(input.hue, input.saturation, defs), "", {
-				dark: options?.states?.dark ?? globalConfig.states.dark,
-				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
-			}, resolveModes(options?.modes), options?.format)["#__color__"];
+			return buildTokenMap(resolveAllColors(seedHue, seedSaturation, defs), "", resolveStates(options), resolveModes(options?.modes), options?.format)[`#${primary}`];
 		},
 		tasty(options) {
-			return buildTokenMap(resolveAllColors(input.hue, input.saturation, defs), "", {
-				dark: options?.states?.dark ?? globalConfig.states.dark,
-				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
-			}, resolveModes(options?.modes), options?.format)["#__color__"];
+			return buildTokenMap(resolveAllColors(seedHue, seedSaturation, defs), "", resolveStates(options), resolveModes(options?.modes), options?.format)[`#${primary}`];
 		},
 		json(options) {
-			return buildJsonMap(resolveAllColors(input.hue, input.saturation, defs), resolveModes(options?.modes), options?.format)["__color__"];
+			return buildJsonMap(resolveAllColors(seedHue, seedSaturation, defs), resolveModes(options?.modes), options?.format)[primary];
+		},
+		css(options) {
+			const resolved = resolveAllColors(seedHue, seedSaturation, defs);
+			return buildCssMap(new Map([[options.name, resolved.get(primary)]]), "", options.suffix ?? "-color", options.format ?? "rgb");
 		}
 	};
 }
+function createColorToken(input) {
+	const defs = { __color__: {
+		lightness: input.lightness,
+		saturation: input.saturationFactor,
+		mode: input.mode
+	} };
+	return createColorTokenFromDefs(input.hue, input.saturation, defs, "__color__");
+}
+function createColorTokenFromValue(value, options) {
+	const { seedHue, seedSaturation, defs, primary } = buildValueDefs(extractOkhslFromValue(value), options);
+	return createColorTokenFromDefs(seedHue, seedSaturation, defs, primary);
+}
 /**
 * Create a single-hue glaze theme.
 *
@@ -1564,6 +1811,7 @@ glaze.configure = function configure(config) {
 		lightLightness: config.lightLightness ?? globalConfig.lightLightness,
 		darkLightness: config.darkLightness ?? globalConfig.darkLightness,
 		darkDesaturation: config.darkDesaturation ?? globalConfig.darkDesaturation,
+		darkCurve: config.darkCurve ?? globalConfig.darkCurve,
 		states: {
 			dark: config.states?.dark ?? globalConfig.states.dark,
 			highContrast: config.states?.highContrast ?? globalConfig.states.highContrast
@@ -1578,8 +1826,8 @@ glaze.configure = function configure(config) {
 /**
 * Compose multiple themes into a palette.
 */
-glaze.palette = function palette(themes) {
-	return createPalette(themes);
+glaze.palette = function palette(themes, options) {
+	return createPalette(themes, options);
 };
 /**
 * Create a theme from a serialized export.
@@ -1587,11 +1835,24 @@ glaze.palette = function palette(themes) {
 glaze.from = function from(data) {
 	return createTheme(data.hue, data.saturation, data.colors);
 };
+function isStructuredColorInput(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input) && "hue" in input && "lightness" in input;
+}
 /**
 * Create a standalone single-color token.
+*
+* Two overloads:
+* - `glaze.color(input)` — structured form: `{ hue, saturation, lightness, ... }`.
+* - `glaze.color(value, overrides?)` — value-shorthand: a hex string,
+*   one of the CSS color functions Glaze itself emits
+*   (`rgb()`, `hsl()`, `okhsl()`, `oklch()`), an `OkhslColor` object
+*   `{ h, s, l }`, or an `[r, g, b]` (0–255) tuple. Optional overrides
+*   accept absolute or relative `hue` / `lightness`, `saturation`,
+*   `mode`, `base` (any value form), and `contrast` against the base.
 */
-glaze.color = function color(input) {
-	return createColorToken(input);
+glaze.color = function color(input, options) {
+	if (isStructuredColorInput(input)) return createColorToken(input);
+	return createColorTokenFromValue(input, options);
 };
 /**
 * Compute a shadow color from a bg/fg pair and intensity.
@@ -1663,6 +1924,7 @@ glaze.resetConfig = function resetConfig() {
 		lightLightness: [10, 100],
 		darkLightness: [15, 95],
 		darkDesaturation: .1,
+		darkCurve: .5,
 		states: {
 			dark: "@dark",
 			highContrast: "@high-contrast"
@@ -1675,5 +1937,5 @@ glaze.resetConfig = function resetConfig() {
 };
 
 //#endregion
-export { contrastRatioFromLuminance, findLightnessForContrast, findValueForMixContrast, formatHsl, formatOkhsl, formatOklch, formatRgb, gamutClampedLuminance, glaze, okhslToLinearSrgb, okhslToOklab, okhslToSrgb, parseHex, relativeLuminanceFromLinearRgb, resolveMinContrast, srgbToOkhsl };
+export { contrastRatioFromLuminance, findLightnessForContrast, findValueForMixContrast, formatHsl, formatOkhsl, formatOklch, formatRgb, gamutClampedLuminance, glaze, hslToSrgb, okhslToLinearSrgb, okhslToOklab, okhslToSrgb, oklabToOkhsl, parseHex, relativeLuminanceFromLinearRgb, resolveMinContrast, srgbToOkhsl };
 //# sourceMappingURL=index.mjs.map