@tenphi/glaze 0.0.0-snapshot.042c9e4

package/dist/index.cjs

@@ -0,0 +1,1716 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/okhsl-color-math.ts
+const OKLab_to_LMS_M = [
+	[
+		1,
+		.3963377773761749,
+		.2158037573099136
+	],
+	[
+		1,
+		-.1055613458156586,
+		-.0638541728258133
+	],
+	[
+		1,
+		-.0894841775298119,
+		-1.2914855480194092
+	]
+];
+const LMS_to_linear_sRGB_M = [
+	[
+		4.076741636075959,
+		-3.307711539258062,
+		.2309699031821041
+	],
+	[
+		-1.2684379732850313,
+		2.6097573492876878,
+		-.3413193760026569
+	],
+	[
+		-.004196076138675526,
+		-.703418617935936,
+		1.7076146940746113
+	]
+];
+const linear_sRGB_to_LMS_M = [
+	[
+		.4122214708,
+		.5363325363,
+		.0514459929
+	],
+	[
+		.2119034982,
+		.6806995451,
+		.1073969566
+	],
+	[
+		.0883024619,
+		.2817188376,
+		.6299787005
+	]
+];
+const LMS_to_OKLab_M = [
+	[
+		.2104542553,
+		.793617785,
+		-.0040720468
+	],
+	[
+		1.9779984951,
+		-2.428592205,
+		.4505937099
+	],
+	[
+		.0259040371,
+		.7827717662,
+		-.808675766
+	]
+];
+const OKLab_to_linear_sRGB_coefficients = [
+	[[-1.8817030993265873, -.8093650129914302], [
+		1.19086277,
+		1.76576728,
+		.59662641,
+		.75515197,
+		.56771245
+	]],
+	[[1.8144407988010998, -1.194452667805235], [
+		.73956515,
+		-.45954404,
+		.08285427,
+		.1254107,
+		.14503204
+	]],
+	[[.13110757611180954, 1.813339709266608], [
+		1.35733652,
+		-.00915799,
+		-1.1513021,
+		-.50559606,
+		.00692167
+	]]
+];
+const TAU = 2 * Math.PI;
+const K1 = .206;
+const K2 = .03;
+const K3 = (1 + K1) / (1 + K2);
+const EPSILON = 1e-10;
+const constrainAngle = (angle) => (angle % 360 + 360) % 360;
+const toe = (x) => .5 * (K3 * x - K1 + Math.sqrt((K3 * x - K1) * (K3 * x - K1) + 4 * K2 * K3 * x));
+const toeInv = (x) => (x ** 2 + K1 * x) / (K3 * (x + K2));
+const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const dotXY = (a, b) => a[0] * b[0] + a[1] * b[1];
+const transform = (input, matrix) => [
+	dot3(input, matrix[0]),
+	dot3(input, matrix[1]),
+	dot3(input, matrix[2])
+];
+const cubed3 = (lms) => [
+	lms[0] ** 3,
+	lms[1] ** 3,
+	lms[2] ** 3
+];
+const cbrt3 = (lms) => [
+	Math.cbrt(lms[0]),
+	Math.cbrt(lms[1]),
+	Math.cbrt(lms[2])
+];
+const clampVal = (v, min, max) => Math.max(min, Math.min(max, v));
+const OKLabToLinearSRGB = (lab) => {
+	return transform(cubed3(transform(lab, OKLab_to_LMS_M)), LMS_to_linear_sRGB_M);
+};
+const computeMaxSaturationOKLC = (a, b) => {
+	const okCoeff = OKLab_to_linear_sRGB_coefficients;
+	const lmsToRgb = LMS_to_linear_sRGB_M;
+	const tmp2 = [a, b];
+	const tmp3 = [
+		0,
+		a,
+		b
+	];
+	let chnlCoeff;
+	let chnlLMS;
+	if (dotXY(okCoeff[0][0], tmp2) > 1) {
+		chnlCoeff = okCoeff[0][1];
+		chnlLMS = lmsToRgb[0];
+	} else if (dotXY(okCoeff[1][0], tmp2) > 1) {
+		chnlCoeff = okCoeff[1][1];
+		chnlLMS = lmsToRgb[1];
+	} else {
+		chnlCoeff = okCoeff[2][1];
+		chnlLMS = lmsToRgb[2];
+	}
+	const [k0, k1, k2, k3, k4] = chnlCoeff;
+	const [wl, wm, ws] = chnlLMS;
+	let sat = k0 + k1 * a + k2 * b + k3 * (a * a) + k4 * a * b;
+	const dotYZ = (mat, vec) => mat[1] * vec[1] + mat[2] * vec[2];
+	const kl = dotYZ(OKLab_to_LMS_M[0], tmp3);
+	const km = dotYZ(OKLab_to_LMS_M[1], tmp3);
+	const ks = dotYZ(OKLab_to_LMS_M[2], tmp3);
+	const l_ = 1 + sat * kl;
+	const m_ = 1 + sat * km;
+	const s_ = 1 + sat * ks;
+	const l = l_ ** 3;
+	const m = m_ ** 3;
+	const s = s_ ** 3;
+	const lds = 3 * kl * l_ * l_;
+	const mds = 3 * km * m_ * m_;
+	const sds = 3 * ks * s_ * s_;
+	const lds2 = 6 * kl * kl * l_;
+	const mds2 = 6 * km * km * m_;
+	const sds2 = 6 * ks * ks * s_;
+	const f = wl * l + wm * m + ws * s;
+	const f1 = wl * lds + wm * mds + ws * sds;
+	const f2 = wl * lds2 + wm * mds2 + ws * sds2;
+	sat = sat - f * f1 / (f1 * f1 - .5 * f * f2);
+	return sat;
+};
+const findCuspOKLCH = (a, b) => {
+	const S_cusp = computeMaxSaturationOKLC(a, b);
+	const rgb_at_max = OKLabToLinearSRGB([
+		1,
+		S_cusp * a,
+		S_cusp * b
+	]);
+	const L_cusp = Math.cbrt(1 / Math.max(Math.max(rgb_at_max[0], rgb_at_max[1]), Math.max(rgb_at_max[2], 0)));
+	return [L_cusp, L_cusp * S_cusp];
+};
+const findGamutIntersectionOKLCH = (a, b, l1, c1, l0, cusp) => {
+	const lmsToRgb = LMS_to_linear_sRGB_M;
+	const tmp3 = [
+		0,
+		a,
+		b
+	];
+	const floatMax = Number.MAX_VALUE;
+	let t;
+	const dotYZ = (mat, vec) => mat[1] * vec[1] + mat[2] * vec[2];
+	const dotXYZ = (vec, x, y, z) => vec[0] * x + vec[1] * y + vec[2] * z;
+	if ((l1 - l0) * cusp[1] - (cusp[0] - l0) * c1 <= 0) {
+		const denom = c1 * cusp[0] + cusp[1] * (l0 - l1);
+		t = denom === 0 ? 0 : cusp[1] * l0 / denom;
+	} else {
+		const denom = c1 * (cusp[0] - 1) + cusp[1] * (l0 - l1);
+		t = denom === 0 ? 0 : cusp[1] * (l0 - 1) / denom;
+		const dl = l1 - l0;
+		const dc = c1;
+		const kl = dotYZ(OKLab_to_LMS_M[0], tmp3);
+		const km = dotYZ(OKLab_to_LMS_M[1], tmp3);
+		const ks = dotYZ(OKLab_to_LMS_M[2], tmp3);
+		const L = l0 * (1 - t) + t * l1;
+		const C = t * c1;
+		const l_ = L + C * kl;
+		const m_ = L + C * km;
+		const s_ = L + C * ks;
+		const l = l_ ** 3;
+		const m = m_ ** 3;
+		const s = s_ ** 3;
+		const ldt = 3 * (dl + dc * kl) * l_ * l_;
+		const mdt = 3 * (dl + dc * km) * m_ * m_;
+		const sdt = 3 * (dl + dc * ks) * s_ * s_;
+		const ldt2 = 6 * (dl + dc * kl) ** 2 * l_;
+		const mdt2 = 6 * (dl + dc * km) ** 2 * m_;
+		const sdt2 = 6 * (dl + dc * ks) ** 2 * s_;
+		const r_ = dotXYZ(lmsToRgb[0], l, m, s) - 1;
+		const r1 = dotXYZ(lmsToRgb[0], ldt, mdt, sdt);
+		const r2 = dotXYZ(lmsToRgb[0], ldt2, mdt2, sdt2);
+		const ur = r1 / (r1 * r1 - .5 * r_ * r2);
+		let tr = -r_ * ur;
+		const g_ = dotXYZ(lmsToRgb[1], l, m, s) - 1;
+		const g1 = dotXYZ(lmsToRgb[1], ldt, mdt, sdt);
+		const g2 = dotXYZ(lmsToRgb[1], ldt2, mdt2, sdt2);
+		const ug = g1 / (g1 * g1 - .5 * g_ * g2);
+		let tg = -g_ * ug;
+		const b_ = dotXYZ(lmsToRgb[2], l, m, s) - 1;
+		const b1 = dotXYZ(lmsToRgb[2], ldt, mdt, sdt);
+		const b2 = dotXYZ(lmsToRgb[2], ldt2, mdt2, sdt2);
+		const ub = b1 / (b1 * b1 - .5 * b_ * b2);
+		let tb = -b_ * ub;
+		tr = ur >= 0 ? tr : floatMax;
+		tg = ug >= 0 ? tg : floatMax;
+		tb = ub >= 0 ? tb : floatMax;
+		t += Math.min(tr, Math.min(tg, tb));
+	}
+	return t;
+};
+const computeSt = (cusp) => [cusp[1] / cusp[0], cusp[1] / (1 - cusp[0])];
+const computeStMid = (a, b) => [.11516993 + 1 / (7.4477897 + 4.1590124 * b + a * (-2.19557347 + 1.75198401 * b + a * (-2.13704948 - 10.02301043 * b + a * (-4.24894561 + 5.38770819 * b + 4.69891013 * a)))), .11239642 + 1 / (1.6132032 - .68124379 * b + a * (.40370612 + .90148123 * b + a * (-.27087943 + .6122399 * b + a * (.00299215 - .45399568 * b - .14661872 * a))))];
+const getCs = (L, a, b, cusp) => {
+	const cMax = findGamutIntersectionOKLCH(a, b, L, 1, L, cusp);
+	const stMax = computeSt(cusp);
+	const k = cMax / Math.min(L * stMax[0], (1 - L) * stMax[1]);
+	const stMid = computeStMid(a, b);
+	let ca = L * stMid[0];
+	let cb = (1 - L) * stMid[1];
+	const cMid = .9 * k * Math.sqrt(Math.sqrt(1 / (1 / ca ** 4 + 1 / cb ** 4)));
+	ca = L * .4;
+	cb = (1 - L) * .8;
+	return [
+		Math.sqrt(1 / (1 / ca ** 2 + 1 / cb ** 2)),
+		cMid,
+		cMax
+	];
+};
+/**
+* Convert OKHSL (h: 0–360, s: 0–1, l: 0–1) to OKLab [L, a, b].
+*/
+function okhslToOklab(h, s, l) {
+	const L = toeInv(l);
+	let a = 0;
+	let b = 0;
+	const hNorm = constrainAngle(h) / 360;
+	if (L !== 0 && L !== 1 && s !== 0) {
+		const a_ = Math.cos(TAU * hNorm);
+		const b_ = Math.sin(TAU * hNorm);
+		const [c0, cMid, cMax] = getCs(L, a_, b_, findCuspOKLCH(a_, b_));
+		const mid = .8;
+		const midInv = 1.25;
+		let t, k0, k1, k2;
+		if (s < mid) {
+			t = midInv * s;
+			k0 = 0;
+			k1 = mid * c0;
+			k2 = 1 - k1 / cMid;
+		} else {
+			t = 5 * (s - .8);
+			k0 = cMid;
+			k1 = .2 * cMid ** 2 * 1.25 ** 2 / c0;
+			k2 = 1 - k1 / (cMax - cMid);
+		}
+		const c = k0 + t * k1 / (1 - k2 * t);
+		a = c * a_;
+		b = c * b_;
+	}
+	return [
+		L,
+		a,
+		b
+	];
+}
+/**
+* Convert OKHSL (h: 0–360, s: 0–1, l: 0–1) to linear sRGB.
+* Channels may exceed [0, 1] near gamut boundaries — caller must clamp if needed.
+*/
+function okhslToLinearSrgb(h, s, l) {
+	return OKLabToLinearSRGB(okhslToOklab(h, s, l));
+}
+/**
+* Compute relative luminance Y from linear sRGB channels.
+* Per WCAG 2: Y = 0.2126·R + 0.7152·G + 0.0722·B
+*/
+function relativeLuminanceFromLinearRgb(rgb) {
+	return .2126 * rgb[0] + .7152 * rgb[1] + .0722 * rgb[2];
+}
+/**
+* WCAG 2 contrast ratio from two luminance values.
+*/
+function contrastRatioFromLuminance(yA, yB) {
+	const lighter = Math.max(yA, yB);
+	const darker = Math.min(yA, yB);
+	return (lighter + .05) / (darker + .05);
+}
+const sRGBLinearToGamma = (val) => {
+	const sign = val < 0 ? -1 : 1;
+	const abs = Math.abs(val);
+	return abs > .0031308 ? sign * (1.055 * Math.pow(abs, 1 / 2.4) - .055) : 12.92 * val;
+};
+const sRGBGammaToLinear = (val) => {
+	const sign = val < 0 ? -1 : 1;
+	const abs = Math.abs(val);
+	return abs <= .04045 ? val / 12.92 : sign * Math.pow((abs + .055) / 1.055, 2.4);
+};
+/**
+* Convert OKHSL to gamma-encoded sRGB (clamped to 0–1).
+*/
+function okhslToSrgb(h, s, l) {
+	const lin = okhslToLinearSrgb(h, s, l);
+	return [
+		Math.max(0, Math.min(1, sRGBLinearToGamma(lin[0]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(lin[1]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(lin[2])))
+	];
+}
+/**
+* Compute WCAG 2 relative luminance from linear sRGB, matching the browser
+* rendering pipeline: gamma-encode, clamp to sRGB gamut [0,1], then linearize.
+* This avoids over/under-estimating luminance for out-of-gamut OKHSL colors.
+*/
+function gamutClampedLuminance(linearRgb) {
+	const r = sRGBGammaToLinear(Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[0]))));
+	const g = sRGBGammaToLinear(Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[1]))));
+	const b = sRGBGammaToLinear(Math.max(0, Math.min(1, sRGBLinearToGamma(linearRgb[2]))));
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+const linearSrgbToOklab = (rgb) => {
+	return transform(cbrt3(transform(rgb, linear_sRGB_to_LMS_M)), LMS_to_OKLab_M);
+};
+const oklabToOkhsl = (lab) => {
+	const L = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	const C = Math.sqrt(a * a + b * b);
+	if (C < EPSILON) return [
+		0,
+		0,
+		toe(L)
+	];
+	const a_ = a / C;
+	const b_ = b / C;
+	let h = Math.atan2(b, a) * (180 / Math.PI);
+	h = constrainAngle(h);
+	const [c0, cMid, cMax] = getCs(L, a_, b_, findCuspOKLCH(a_, b_));
+	const mid = .8;
+	const midInv = 1.25;
+	let s;
+	if (C < cMid) {
+		const k1 = mid * c0;
+		s = C / (k1 + C * (1 - k1 / cMid)) / midInv;
+	} else {
+		const k0 = cMid;
+		const k1 = .2 * cMid ** 2 * 1.25 ** 2 / c0;
+		const k2 = 1 - k1 / (cMax - cMid);
+		const cDiff = C - k0;
+		s = mid + cDiff / (k1 + cDiff * k2) / 5;
+	}
+	const l = toe(L);
+	return [
+		h,
+		clampVal(s, 0, 1),
+		clampVal(l, 0, 1)
+	];
+};
+/**
+* Convert gamma-encoded sRGB (0–1 per channel) to OKHSL.
+* Returns [h, s, l] where h: 0–360, s: 0–1, l: 0–1.
+*/
+function srgbToOkhsl(rgb) {
+	return oklabToOkhsl(linearSrgbToOklab([
+		sRGBGammaToLinear(rgb[0]),
+		sRGBGammaToLinear(rgb[1]),
+		sRGBGammaToLinear(rgb[2])
+	]));
+}
+/**
+* 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.
+*/
+function parseHex(hex) {
+	const h = hex.startsWith("#") ? hex.slice(1) : hex;
+	if (h.length === 3) {
+		const r = parseInt(h[0] + h[0], 16);
+		const g = parseInt(h[1] + h[1], 16);
+		const b = parseInt(h[2] + h[2], 16);
+		if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+		return [
+			r / 255,
+			g / 255,
+			b / 255
+		];
+	}
+	if (h.length === 6) {
+		const r = parseInt(h.slice(0, 2), 16);
+		const g = parseInt(h.slice(2, 4), 16);
+		const b = parseInt(h.slice(4, 6), 16);
+		if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+		return [
+			r / 255,
+			g / 255,
+			b / 255
+		];
+	}
+	return null;
+}
+function fmt$1(value, decimals) {
+	return parseFloat(value.toFixed(decimals)).toString();
+}
+/**
+* Format OKHSL values as a CSS `okhsl(H S% L%)` string.
+* h: 0–360, s: 0–100, l: 0–100 (percentage scale for s and l).
+*/
+function formatOkhsl(h, s, l) {
+	return `okhsl(${fmt$1(h, 2)} ${fmt$1(s, 2)}% ${fmt$1(l, 2)}%)`;
+}
+/**
+* Format OKHSL values as a CSS `rgb(R G B)` string.
+* Uses 2 decimal places to avoid 8-bit quantization contrast loss.
+* h: 0–360, s: 0–100, l: 0–100 (percentage scale for s and l).
+*/
+function formatRgb(h, s, l) {
+	const [r, g, b] = okhslToSrgb(h, s / 100, l / 100);
+	return `rgb(${parseFloat((r * 255).toFixed(2))} ${parseFloat((g * 255).toFixed(2))} ${parseFloat((b * 255).toFixed(2))})`;
+}
+/**
+* Format OKHSL values as a CSS `hsl(H S% L%)` string.
+* h: 0–360, s: 0–100, l: 0–100 (percentage scale for s and l).
+*/
+function formatHsl(h, s, l) {
+	const [r, g, b] = okhslToSrgb(h, s / 100, l / 100);
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const delta = max - min;
+	let hh = 0;
+	let ss = 0;
+	const ll = (max + min) / 2;
+	if (delta > 0) {
+		ss = ll > .5 ? delta / (2 - max - min) : delta / (max + min);
+		if (max === r) hh = ((g - b) / delta + (g < b ? 6 : 0)) * 60;
+		else if (max === g) hh = ((b - r) / delta + 2) * 60;
+		else hh = ((r - g) / delta + 4) * 60;
+	}
+	return `hsl(${fmt$1(hh, 2)} ${fmt$1(ss * 100, 2)}% ${fmt$1(ll * 100, 2)}%)`;
+}
+/**
+* Format OKHSL values as a CSS `oklch(L C H)` string.
+* h: 0–360, s: 0–100, l: 0–100 (percentage scale for s and l).
+*/
+function formatOklch(h, s, l) {
+	const [L, a, b] = okhslToOklab(h, s / 100, l / 100);
+	const C = Math.sqrt(a * a + b * b);
+	let hh = Math.atan2(b, a) * (180 / Math.PI);
+	hh = constrainAngle(hh);
+	return `oklch(${fmt$1(L, 4)} ${fmt$1(C, 4)} ${fmt$1(hh, 2)})`;
+}
+
+//#endregion
+//#region src/contrast-solver.ts
+/**
+* OKHSL Contrast Solver
+*
+* Finds the closest OKHSL lightness that satisfies a WCAG 2 contrast target
+* against a base color. Used by glaze when resolving dependent colors
+* with `contrast`.
+*/
+const CONTRAST_PRESETS = {
+	AA: 4.5,
+	AAA: 7,
+	"AA-large": 3,
+	"AAA-large": 4.5
+};
+function resolveMinContrast(value) {
+	if (typeof value === "number") return Math.max(1, value);
+	return CONTRAST_PRESETS[value];
+}
+const CACHE_SIZE = 512;
+const luminanceCache = /* @__PURE__ */ new Map();
+const cacheOrder = [];
+function cachedLuminance(h, s, l) {
+	const lRounded = Math.round(l * 1e4) / 1e4;
+	const key = `${h}|${s}|${lRounded}`;
+	const cached = luminanceCache.get(key);
+	if (cached !== void 0) return cached;
+	const y = gamutClampedLuminance(okhslToLinearSrgb(h, s, lRounded));
+	if (luminanceCache.size >= CACHE_SIZE) {
+		const evict = cacheOrder.shift();
+		luminanceCache.delete(evict);
+	}
+	luminanceCache.set(key, y);
+	cacheOrder.push(key);
+	return y;
+}
+/**
+* Binary search one branch [lo, hi] for the nearest passing lightness to `preferred`.
+*/
+function searchBranch(h, s, lo, hi, yBase, target, epsilon, maxIter, preferred) {
+	const yLo = cachedLuminance(h, s, lo);
+	const yHi = cachedLuminance(h, s, hi);
+	const crLo = contrastRatioFromLuminance(yLo, yBase);
+	const crHi = contrastRatioFromLuminance(yHi, yBase);
+	if (crLo < target && crHi < target) {
+		if (crLo >= crHi) return {
+			lightness: lo,
+			contrast: crLo,
+			met: false
+		};
+		return {
+			lightness: hi,
+			contrast: crHi,
+			met: false
+		};
+	}
+	let low = lo;
+	let high = hi;
+	for (let i = 0; i < maxIter; i++) {
+		if (high - low < epsilon) break;
+		const mid = (low + high) / 2;
+		if (contrastRatioFromLuminance(cachedLuminance(h, s, mid), yBase) >= target) if (mid < preferred) low = mid;
+		else high = mid;
+		else if (mid < preferred) high = mid;
+		else low = mid;
+	}
+	const yLow = cachedLuminance(h, s, low);
+	const yHigh = cachedLuminance(h, s, high);
+	const crLow = contrastRatioFromLuminance(yLow, yBase);
+	const crHigh = contrastRatioFromLuminance(yHigh, yBase);
+	const lowPasses = crLow >= target;
+	const highPasses = crHigh >= target;
+	if (lowPasses && highPasses) {
+		if (Math.abs(low - preferred) <= Math.abs(high - preferred)) return {
+			lightness: low,
+			contrast: crLow,
+			met: true
+		};
+		return {
+			lightness: high,
+			contrast: crHigh,
+			met: true
+		};
+	}
+	if (lowPasses) return {
+		lightness: low,
+		contrast: crLow,
+		met: true
+	};
+	if (highPasses) return {
+		lightness: high,
+		contrast: crHigh,
+		met: true
+	};
+	return coarseScan(h, s, lo, hi, yBase, target, epsilon, maxIter);
+}
+/**
+* Fallback coarse scan when binary search is unstable near gamut edges.
+*/
+function coarseScan(h, s, lo, hi, yBase, target, epsilon, maxIter) {
+	const STEPS = 64;
+	const step = (hi - lo) / STEPS;
+	let bestL = lo;
+	let bestCr = 0;
+	let bestMet = false;
+	for (let i = 0; i <= STEPS; i++) {
+		const l = lo + step * i;
+		const cr = contrastRatioFromLuminance(cachedLuminance(h, s, l), yBase);
+		if (cr >= target && !bestMet) {
+			bestL = l;
+			bestCr = cr;
+			bestMet = true;
+		} else if (cr >= target && bestMet) {
+			bestL = l;
+			bestCr = cr;
+		} else if (!bestMet && cr > bestCr) {
+			bestL = l;
+			bestCr = cr;
+		}
+	}
+	if (bestMet && bestL > lo + step) {
+		let rLo = bestL - step;
+		let rHi = bestL;
+		for (let i = 0; i < maxIter; i++) {
+			if (rHi - rLo < epsilon) break;
+			const mid = (rLo + rHi) / 2;
+			const cr = contrastRatioFromLuminance(cachedLuminance(h, s, mid), yBase);
+			if (cr >= target) {
+				rHi = mid;
+				bestL = mid;
+				bestCr = cr;
+			} else rLo = mid;
+		}
+	}
+	return {
+		lightness: bestL,
+		contrast: bestCr,
+		met: bestMet
+	};
+}
+/**
+* Find the OKHSL lightness that satisfies a WCAG 2 contrast target
+* against a base color, staying as close to `preferredLightness` as possible.
+*/
+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 yBase = gamutClampedLuminance(baseLinearRgb);
+	const crPref = contrastRatioFromLuminance(cachedLuminance(hue, saturation, preferredLightness), yBase);
+	if (crPref >= searchTarget) return {
+		lightness: preferredLightness,
+		contrast: crPref,
+		met: true,
+		branch: "preferred"
+	};
+	const [minL, maxL] = lightnessRange;
+	const darkerResult = preferredLightness > minL ? searchBranch(hue, saturation, minL, preferredLightness, yBase, searchTarget, epsilon, maxIterations, preferredLightness) : null;
+	const lighterResult = preferredLightness < maxL ? searchBranch(hue, saturation, preferredLightness, maxL, yBase, searchTarget, epsilon, maxIterations, preferredLightness) : null;
+	if (darkerResult) darkerResult.met = darkerResult.contrast >= target;
+	if (lighterResult) lighterResult.met = lighterResult.contrast >= target;
+	const darkerPasses = darkerResult?.met ?? false;
+	const lighterPasses = lighterResult?.met ?? false;
+	if (darkerPasses && lighterPasses) {
+		if (Math.abs(darkerResult.lightness - preferredLightness) <= Math.abs(lighterResult.lightness - preferredLightness)) return {
+			...darkerResult,
+			branch: "darker"
+		};
+		return {
+			...lighterResult,
+			branch: "lighter"
+		};
+	}
+	if (darkerPasses) return {
+		...darkerResult,
+		branch: "darker"
+	};
+	if (lighterPasses) return {
+		...lighterResult,
+		branch: "lighter"
+	};
+	const candidates = [];
+	if (darkerResult) candidates.push({
+		...darkerResult,
+		branch: "darker"
+	});
+	if (lighterResult) candidates.push({
+		...lighterResult,
+		branch: "lighter"
+	});
+	if (candidates.length === 0) return {
+		lightness: preferredLightness,
+		contrast: crPref,
+		met: false,
+		branch: "preferred"
+	};
+	candidates.sort((a, b) => b.contrast - a.contrast);
+	return candidates[0];
+}
+/**
+* Binary-search one branch [lo, hi] for the nearest passing mix value
+* to `preferred`.
+*/
+function searchMixBranch(lo, hi, yBase, target, epsilon, maxIter, preferred, luminanceAt) {
+	const crLo = contrastRatioFromLuminance(luminanceAt(lo), yBase);
+	const crHi = contrastRatioFromLuminance(luminanceAt(hi), yBase);
+	if (crLo < target && crHi < target) {
+		if (crLo >= crHi) return {
+			lightness: lo,
+			contrast: crLo,
+			met: false
+		};
+		return {
+			lightness: hi,
+			contrast: crHi,
+			met: false
+		};
+	}
+	let low = lo;
+	let high = hi;
+	for (let i = 0; i < maxIter; i++) {
+		if (high - low < epsilon) break;
+		const mid = (low + high) / 2;
+		if (contrastRatioFromLuminance(luminanceAt(mid), yBase) >= target) if (mid < preferred) low = mid;
+		else high = mid;
+		else if (mid < preferred) high = mid;
+		else low = mid;
+	}
+	const crLow = contrastRatioFromLuminance(luminanceAt(low), yBase);
+	const crHigh = contrastRatioFromLuminance(luminanceAt(high), yBase);
+	const lowPasses = crLow >= target;
+	const highPasses = crHigh >= target;
+	if (lowPasses && highPasses) {
+		if (Math.abs(low - preferred) <= Math.abs(high - preferred)) return {
+			lightness: low,
+			contrast: crLow,
+			met: true
+		};
+		return {
+			lightness: high,
+			contrast: crHigh,
+			met: true
+		};
+	}
+	if (lowPasses) return {
+		lightness: low,
+		contrast: crLow,
+		met: true
+	};
+	if (highPasses) return {
+		lightness: high,
+		contrast: crHigh,
+		met: true
+	};
+	return crLow >= crHigh ? {
+		lightness: low,
+		contrast: crLow,
+		met: false
+	} : {
+		lightness: high,
+		contrast: crHigh,
+		met: false
+	};
+}
+/**
+* Find the mix parameter (ratio or opacity) that satisfies a WCAG 2 contrast
+* target against a base color, staying as close to `preferredValue` as possible.
+*/
+function findValueForMixContrast(options) {
+	const { preferredValue, baseLinearRgb, contrast: contrastInput, luminanceAtValue, epsilon = 1e-4, maxIterations = 20 } = options;
+	const target = resolveMinContrast(contrastInput);
+	const searchTarget = target * 1.01;
+	const yBase = gamutClampedLuminance(baseLinearRgb);
+	const crPref = contrastRatioFromLuminance(luminanceAtValue(preferredValue), yBase);
+	if (crPref >= searchTarget) return {
+		value: preferredValue,
+		contrast: crPref,
+		met: true
+	};
+	const darkerResult = preferredValue > 0 ? searchMixBranch(0, preferredValue, yBase, searchTarget, epsilon, maxIterations, preferredValue, luminanceAtValue) : null;
+	const lighterResult = preferredValue < 1 ? searchMixBranch(preferredValue, 1, yBase, searchTarget, epsilon, maxIterations, preferredValue, luminanceAtValue) : null;
+	if (darkerResult) darkerResult.met = darkerResult.contrast >= target;
+	if (lighterResult) lighterResult.met = lighterResult.contrast >= target;
+	const darkerPasses = darkerResult?.met ?? false;
+	const lighterPasses = lighterResult?.met ?? false;
+	if (darkerPasses && lighterPasses) {
+		if (Math.abs(darkerResult.lightness - preferredValue) <= Math.abs(lighterResult.lightness - preferredValue)) return {
+			value: darkerResult.lightness,
+			contrast: darkerResult.contrast,
+			met: true
+		};
+		return {
+			value: lighterResult.lightness,
+			contrast: lighterResult.contrast,
+			met: true
+		};
+	}
+	if (darkerPasses) return {
+		value: darkerResult.lightness,
+		contrast: darkerResult.contrast,
+		met: true
+	};
+	if (lighterPasses) return {
+		value: lighterResult.lightness,
+		contrast: lighterResult.contrast,
+		met: true
+	};
+	const candidates = [];
+	if (darkerResult) candidates.push({
+		...darkerResult,
+		branch: "lower"
+	});
+	if (lighterResult) candidates.push({
+		...lighterResult,
+		branch: "upper"
+	});
+	if (candidates.length === 0) return {
+		value: preferredValue,
+		contrast: crPref,
+		met: false
+	};
+	candidates.sort((a, b) => b.contrast - a.contrast);
+	return {
+		value: candidates[0].lightness,
+		contrast: candidates[0].contrast,
+		met: candidates[0].met
+	};
+}
+
+//#endregion
+//#region src/glaze.ts
+/**
+* Glaze — OKHSL-based color theme generator.
+*
+* Generates robust light, dark, and high-contrast colors from a hue/saturation
+* seed, preserving contrast for UI pairs via explicit dependencies.
+*/
+let globalConfig = {
+	lightLightness: [10, 100],
+	darkLightness: [15, 95],
+	darkDesaturation: .1,
+	darkCurve: .5,
+	states: {
+		dark: "@dark",
+		highContrast: "@high-contrast"
+	},
+	modes: {
+		dark: true,
+		highContrast: false
+	}
+};
+function pairNormal(p) {
+	return Array.isArray(p) ? p[0] : p;
+}
+function pairHC(p) {
+	return Array.isArray(p) ? p[1] : p;
+}
+function isShadowDef(def) {
+	return def.type === "shadow";
+}
+function isMixDef(def) {
+	return def.type === "mix";
+}
+const DEFAULT_SHADOW_TUNING = {
+	saturationFactor: .18,
+	maxSaturation: .25,
+	lightnessFactor: .25,
+	lightnessBounds: [.05, .2],
+	minGapTarget: .05,
+	alphaMax: 1,
+	bgHueBlend: .2
+};
+function resolveShadowTuning(perColor) {
+	return {
+		...DEFAULT_SHADOW_TUNING,
+		...globalConfig.shadowTuning,
+		...perColor,
+		lightnessBounds: perColor?.lightnessBounds ?? globalConfig.shadowTuning?.lightnessBounds ?? DEFAULT_SHADOW_TUNING.lightnessBounds
+	};
+}
+function circularLerp(a, b, t) {
+	let diff = b - a;
+	if (diff > 180) diff -= 360;
+	else if (diff < -180) diff += 360;
+	return ((a + diff * t) % 360 + 360) % 360;
+}
+/**
+* Compute the canonical max-contrast reference t value for normalization.
+* Uses bg.l=1, fg.l=0, intensity=100 — the theoretical maximum.
+* This is a fixed constant per tuning configuration, ensuring uniform
+* scaling across all bg/fg pairs at low intensities.
+*/
+function computeRefT(tuning) {
+	const EPSILON = 1e-6;
+	let lShRef = clamp(tuning.lightnessFactor, tuning.lightnessBounds[0], tuning.lightnessBounds[1]);
+	lShRef = Math.max(Math.min(lShRef, 1 - tuning.minGapTarget), 0);
+	return 1 / Math.max(1 - lShRef, EPSILON);
+}
+function computeShadow(bg, fg, intensity, tuning) {
+	const EPSILON = 1e-6;
+	const clampedIntensity = clamp(intensity, 0, 100);
+	const contrastWeight = fg ? Math.abs(bg.l - fg.l) : 1;
+	const deltaL = clampedIntensity / 100 * contrastWeight;
+	const h = fg ? circularLerp(fg.h, bg.h, tuning.bgHueBlend) : bg.h;
+	const s = fg ? Math.min(fg.s * tuning.saturationFactor, tuning.maxSaturation) : 0;
+	let lSh = clamp(bg.l * tuning.lightnessFactor, tuning.lightnessBounds[0], tuning.lightnessBounds[1]);
+	lSh = Math.max(Math.min(lSh, bg.l - tuning.minGapTarget), 0);
+	const t = deltaL / Math.max(bg.l - lSh, EPSILON);
+	const tRef = computeRefT(tuning);
+	const norm = Math.tanh(tRef / tuning.alphaMax);
+	const alpha = Math.min(tuning.alphaMax * Math.tanh(t / tuning.alphaMax) / norm, tuning.alphaMax);
+	return {
+		h,
+		s,
+		l: lSh,
+		alpha
+	};
+}
+function validateColorDefs(defs) {
+	const names = new Set(Object.keys(defs));
+	for (const [name, def] of Object.entries(defs)) {
+		if (isShadowDef(def)) {
+			if (!names.has(def.bg)) throw new Error(`glaze: shadow "${name}" references non-existent bg "${def.bg}".`);
+			if (isShadowDef(defs[def.bg])) throw new Error(`glaze: shadow "${name}" bg "${def.bg}" references another shadow color.`);
+			if (def.fg !== void 0) {
+				if (!names.has(def.fg)) throw new Error(`glaze: shadow "${name}" references non-existent fg "${def.fg}".`);
+				if (isShadowDef(defs[def.fg])) throw new Error(`glaze: shadow "${name}" fg "${def.fg}" references another shadow color.`);
+			}
+			continue;
+		}
+		if (isMixDef(def)) {
+			if (!names.has(def.base)) throw new Error(`glaze: mix "${name}" references non-existent base "${def.base}".`);
+			if (!names.has(def.target)) throw new Error(`glaze: mix "${name}" references non-existent target "${def.target}".`);
+			if (isShadowDef(defs[def.base])) throw new Error(`glaze: mix "${name}" base "${def.base}" references a shadow color.`);
+			if (isShadowDef(defs[def.target])) throw new Error(`glaze: mix "${name}" target "${def.target}" references a shadow color.`);
+			continue;
+		}
+		const regDef = def;
+		if (regDef.contrast !== void 0 && !regDef.base) throw new Error(`glaze: color "${name}" has "contrast" without "base".`);
+		if (regDef.lightness !== void 0 && !isAbsoluteLightness(regDef.lightness) && !regDef.base) throw new Error(`glaze: color "${name}" has relative "lightness" without "base".`);
+		if (regDef.base && !names.has(regDef.base)) throw new Error(`glaze: color "${name}" references non-existent base "${regDef.base}".`);
+		if (regDef.base && isShadowDef(defs[regDef.base])) throw new Error(`glaze: color "${name}" base "${regDef.base}" references a shadow color.`);
+		if (!isAbsoluteLightness(regDef.lightness) && regDef.base === void 0) throw new Error(`glaze: color "${name}" must have either absolute "lightness" (root) or "base" (dependent).`);
+		if (regDef.contrast !== void 0 && regDef.opacity !== void 0) console.warn(`glaze: color "${name}" has both "contrast" and "opacity". Opacity makes perceived lightness unpredictable.`);
+	}
+	const visited = /* @__PURE__ */ new Set();
+	const inStack = /* @__PURE__ */ new Set();
+	function dfs(name) {
+		if (inStack.has(name)) throw new Error(`glaze: circular base reference detected involving "${name}".`);
+		if (visited.has(name)) return;
+		inStack.add(name);
+		const def = defs[name];
+		if (isShadowDef(def)) {
+			dfs(def.bg);
+			if (def.fg) dfs(def.fg);
+		} else if (isMixDef(def)) {
+			dfs(def.base);
+			dfs(def.target);
+		} else {
+			const regDef = def;
+			if (regDef.base) dfs(regDef.base);
+		}
+		inStack.delete(name);
+		visited.add(name);
+	}
+	for (const name of names) dfs(name);
+}
+function topoSort(defs) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	function visit(name) {
+		if (visited.has(name)) return;
+		visited.add(name);
+		const def = defs[name];
+		if (isShadowDef(def)) {
+			visit(def.bg);
+			if (def.fg) visit(def.fg);
+		} else if (isMixDef(def)) {
+			visit(def.base);
+			visit(def.target);
+		} else {
+			const regDef = def;
+			if (regDef.base) visit(regDef.base);
+		}
+		result.push(name);
+	}
+	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") 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;
+	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") return [0, 1];
+	const [lo, hi] = lightnessWindow(isHighContrast, isDark ? "dark" : "light");
+	return [lo / 100, hi / 100];
+}
+function clamp(v, min, max) {
+	return Math.max(min, Math.min(max, v));
+}
+/**
+* Parse a value that can be absolute (number) or relative (signed string).
+* Returns the numeric value and whether it's relative.
+*/
+function parseRelativeOrAbsolute(value) {
+	if (typeof value === "number") return {
+		value,
+		relative: false
+	};
+	return {
+		value: parseFloat(value),
+		relative: true
+	};
+}
+/**
+* Compute the effective hue for a color, given the theme seed hue
+* and an optional per-color hue override.
+*/
+function resolveEffectiveHue(seedHue, defHue) {
+	if (defHue === void 0) return seedHue;
+	const parsed = parseRelativeOrAbsolute(defHue);
+	if (parsed.relative) return ((seedHue + parsed.value) % 360 + 360) % 360;
+	return (parsed.value % 360 + 360) % 360;
+}
+/**
+* Check whether a lightness value represents an absolute root definition
+* (i.e. a number, not a relative string).
+*/
+function isAbsoluteLightness(lightness) {
+	if (lightness === void 0) return false;
+	return typeof (Array.isArray(lightness) ? lightness[0] : lightness) === "number";
+}
+function resolveRootColor(_name, def, _ctx, isHighContrast) {
+	const rawL = def.lightness;
+	return {
+		lightL: clamp(parseRelativeOrAbsolute(isHighContrast ? pairHC(rawL) : pairNormal(rawL)).value, 0, 100),
+		satFactor: clamp(def.saturation ?? 1, 0, 1)
+	};
+}
+function resolveDependentColor(name, def, ctx, isHighContrast, isDark, effectiveHue) {
+	const baseName = def.base;
+	const baseResolved = ctx.resolved.get(baseName);
+	if (!baseResolved) throw new Error(`glaze: base "${baseName}" not yet resolved for "${name}".`);
+	const mode = def.mode ?? "auto";
+	const satFactor = clamp(def.saturation ?? 1, 0, 1);
+	const baseVariant = getSchemeVariant(baseResolved, isDark, isHighContrast);
+	const baseL = baseVariant.l * 100;
+	let preferredL;
+	const rawLightness = def.lightness;
+	if (rawLightness === void 0) preferredL = baseL;
+	else {
+		const parsed = parseRelativeOrAbsolute(isHighContrast ? pairHC(rawLightness) : pairNormal(rawLightness));
+		if (parsed.relative) {
+			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);
+	}
+	const rawContrast = def.contrast;
+	if (rawContrast !== void 0) {
+		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 windowRange = schemeLightnessRange(isDark, mode, isHighContrast);
+		return {
+			l: findLightnessForContrast({
+				hue: effectiveHue,
+				saturation: effectiveSat,
+				preferredLightness: clamp(preferredL / 100, windowRange[0], windowRange[1]),
+				baseLinearRgb,
+				contrast: minCr,
+				lightnessRange: [0, 1]
+			}).lightness * 100,
+			satFactor
+		};
+	}
+	return {
+		l: clamp(preferredL, 0, 100),
+		satFactor
+	};
+}
+function getSchemeVariant(color, isDark, isHighContrast) {
+	if (isDark && isHighContrast) return color.darkContrast;
+	if (isDark) return color.dark;
+	if (isHighContrast) return color.lightContrast;
+	return color.light;
+}
+function resolveColorForScheme(name, def, ctx, isDark, isHighContrast) {
+	if (isShadowDef(def)) return resolveShadowForScheme(def, ctx, isDark, isHighContrast);
+	if (isMixDef(def)) return resolveMixForScheme(def, ctx, isDark, isHighContrast);
+	const regDef = def;
+	const mode = regDef.mode ?? "auto";
+	const isRoot = isAbsoluteLightness(regDef.lightness) && !regDef.base;
+	const effectiveHue = resolveEffectiveHue(ctx.hue, regDef.hue);
+	let lightL;
+	let satFactor;
+	if (isRoot) {
+		const root = resolveRootColor(name, regDef, ctx, isHighContrast);
+		lightL = root.lightL;
+		satFactor = root.satFactor;
+	} else {
+		const dep = resolveDependentColor(name, regDef, ctx, isHighContrast, isDark, effectiveHue);
+		lightL = dep.l;
+		satFactor = dep.satFactor;
+	}
+	let finalL;
+	let finalSat;
+	if (isDark && isRoot) {
+		finalL = mapLightnessDark(lightL, mode, isHighContrast);
+		finalSat = mapSaturationDark(satFactor * ctx.saturation / 100, mode);
+	} else if (isDark && !isRoot) {
+		finalL = lightL;
+		finalSat = mapSaturationDark(satFactor * ctx.saturation / 100, mode);
+	} else if (isRoot) {
+		finalL = mapLightnessLight(lightL, mode, isHighContrast);
+		finalSat = satFactor * ctx.saturation / 100;
+	} else {
+		finalL = lightL;
+		finalSat = satFactor * ctx.saturation / 100;
+	}
+	return {
+		h: effectiveHue,
+		s: clamp(finalSat, 0, 1),
+		l: clamp(finalL / 100, 0, 1),
+		alpha: regDef.opacity ?? 1
+	};
+}
+function resolveShadowForScheme(def, ctx, isDark, isHighContrast) {
+	const bgVariant = getSchemeVariant(ctx.resolved.get(def.bg), isDark, isHighContrast);
+	let fgVariant;
+	if (def.fg) fgVariant = getSchemeVariant(ctx.resolved.get(def.fg), isDark, isHighContrast);
+	const intensity = isHighContrast ? pairHC(def.intensity) : pairNormal(def.intensity);
+	const tuning = resolveShadowTuning(def.tuning);
+	return computeShadow(bgVariant, fgVariant, intensity, tuning);
+}
+function variantToLinearRgb(v) {
+	return okhslToLinearSrgb(v.h, v.s, v.l);
+}
+/**
+* Resolve hue for OKHSL mixing, handling achromatic colors.
+* When one color has no saturation, its hue is meaningless —
+* use the hue from the color that has saturation (matches CSS
+* color-mix "missing component" behavior).
+*/
+function mixHue(base, target, t) {
+	const SAT_EPSILON = 1e-6;
+	const baseHasSat = base.s > SAT_EPSILON;
+	const targetHasSat = target.s > SAT_EPSILON;
+	if (baseHasSat && targetHasSat) return circularLerp(base.h, target.h, t);
+	if (targetHasSat) return target.h;
+	return base.h;
+}
+function linearSrgbLerp(base, target, t) {
+	return [
+		base[0] + (target[0] - base[0]) * t,
+		base[1] + (target[1] - base[1]) * t,
+		base[2] + (target[2] - base[2]) * t
+	];
+}
+function linearRgbToVariant(rgb) {
+	const [h, s, l] = srgbToOkhsl([
+		Math.max(0, Math.min(1, sRGBLinearToGamma(rgb[0]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(rgb[1]))),
+		Math.max(0, Math.min(1, sRGBLinearToGamma(rgb[2])))
+	]);
+	return {
+		h,
+		s,
+		l,
+		alpha: 1
+	};
+}
+function resolveMixForScheme(def, ctx, isDark, isHighContrast) {
+	const baseResolved = ctx.resolved.get(def.base);
+	const targetResolved = ctx.resolved.get(def.target);
+	const baseVariant = getSchemeVariant(baseResolved, isDark, isHighContrast);
+	const targetVariant = getSchemeVariant(targetResolved, isDark, isHighContrast);
+	let t = clamp(isHighContrast ? pairHC(def.value) : pairNormal(def.value), 0, 100) / 100;
+	const blend = def.blend ?? "opaque";
+	const space = def.space ?? "okhsl";
+	const baseLinear = variantToLinearRgb(baseVariant);
+	const targetLinear = variantToLinearRgb(targetVariant);
+	if (def.contrast !== void 0) {
+		const minCr = isHighContrast ? pairHC(def.contrast) : pairNormal(def.contrast);
+		let luminanceAt;
+		if (blend === "transparent") luminanceAt = (v) => gamutClampedLuminance(linearSrgbLerp(baseLinear, targetLinear, v));
+		else if (space === "srgb") luminanceAt = (v) => gamutClampedLuminance(linearSrgbLerp(baseLinear, targetLinear, v));
+		else luminanceAt = (v) => {
+			return gamutClampedLuminance(okhslToLinearSrgb(mixHue(baseVariant, targetVariant, v), baseVariant.s + (targetVariant.s - baseVariant.s) * v, baseVariant.l + (targetVariant.l - baseVariant.l) * v));
+		};
+		t = findValueForMixContrast({
+			preferredValue: t,
+			baseLinearRgb: baseLinear,
+			targetLinearRgb: targetLinear,
+			contrast: minCr,
+			luminanceAtValue: luminanceAt
+		}).value;
+	}
+	if (blend === "transparent") return {
+		h: targetVariant.h,
+		s: targetVariant.s,
+		l: targetVariant.l,
+		alpha: clamp(t, 0, 1)
+	};
+	if (space === "srgb") return linearRgbToVariant(linearSrgbLerp(baseLinear, targetLinear, t));
+	return {
+		h: mixHue(baseVariant, targetVariant, t),
+		s: clamp(baseVariant.s + (targetVariant.s - baseVariant.s) * t, 0, 1),
+		l: clamp(baseVariant.l + (targetVariant.l - baseVariant.l) * t, 0, 1),
+		alpha: 1
+	};
+}
+function resolveAllColors(hue, saturation, defs) {
+	validateColorDefs(defs);
+	const order = topoSort(defs);
+	const ctx = {
+		hue,
+		saturation,
+		defs,
+		resolved: /* @__PURE__ */ new Map()
+	};
+	function defMode(def) {
+		if (isShadowDef(def) || isMixDef(def)) return void 0;
+		return def.mode ?? "auto";
+	}
+	const lightMap = /* @__PURE__ */ new Map();
+	for (const name of order) {
+		const variant = resolveColorForScheme(name, defs[name], ctx, false, false);
+		lightMap.set(name, variant);
+		ctx.resolved.set(name, {
+			name,
+			light: variant,
+			dark: variant,
+			lightContrast: variant,
+			darkContrast: variant,
+			mode: defMode(defs[name])
+		});
+	}
+	const lightHCMap = /* @__PURE__ */ new Map();
+	for (const name of order) ctx.resolved.set(name, {
+		...ctx.resolved.get(name),
+		lightContrast: lightMap.get(name)
+	});
+	for (const name of order) {
+		const variant = resolveColorForScheme(name, defs[name], ctx, false, true);
+		lightHCMap.set(name, variant);
+		ctx.resolved.set(name, {
+			...ctx.resolved.get(name),
+			lightContrast: variant
+		});
+	}
+	const darkMap = /* @__PURE__ */ new Map();
+	for (const name of order) ctx.resolved.set(name, {
+		name,
+		light: lightMap.get(name),
+		dark: lightMap.get(name),
+		lightContrast: lightHCMap.get(name),
+		darkContrast: lightHCMap.get(name),
+		mode: defMode(defs[name])
+	});
+	for (const name of order) {
+		const variant = resolveColorForScheme(name, defs[name], ctx, true, false);
+		darkMap.set(name, variant);
+		ctx.resolved.set(name, {
+			...ctx.resolved.get(name),
+			dark: variant
+		});
+	}
+	const darkHCMap = /* @__PURE__ */ new Map();
+	for (const name of order) ctx.resolved.set(name, {
+		...ctx.resolved.get(name),
+		darkContrast: darkMap.get(name)
+	});
+	for (const name of order) {
+		const variant = resolveColorForScheme(name, defs[name], ctx, true, true);
+		darkHCMap.set(name, variant);
+		ctx.resolved.set(name, {
+			...ctx.resolved.get(name),
+			darkContrast: variant
+		});
+	}
+	const result = /* @__PURE__ */ new Map();
+	for (const name of order) result.set(name, {
+		name,
+		light: lightMap.get(name),
+		dark: darkMap.get(name),
+		lightContrast: lightHCMap.get(name),
+		darkContrast: darkHCMap.get(name),
+		mode: defMode(defs[name])
+	});
+	return result;
+}
+const formatters = {
+	okhsl: formatOkhsl,
+	rgb: formatRgb,
+	hsl: formatHsl,
+	oklch: formatOklch
+};
+function fmt(value, decimals) {
+	return parseFloat(value.toFixed(decimals)).toString();
+}
+function formatVariant(v, format = "okhsl") {
+	const base = formatters[format](v.h, v.s * 100, v.l * 100);
+	if (v.alpha >= 1) return base;
+	const closing = base.lastIndexOf(")");
+	return `${base.slice(0, closing)} / ${fmt(v.alpha, 4)})`;
+}
+function resolveModes(override) {
+	return {
+		dark: override?.dark ?? globalConfig.modes.dark,
+		highContrast: override?.highContrast ?? globalConfig.modes.highContrast
+	};
+}
+function buildTokenMap(resolved, prefix, states, modes, format = "okhsl") {
+	const tokens = {};
+	for (const [name, color] of resolved) {
+		const key = `#${prefix}${name}`;
+		const entry = { "": formatVariant(color.light, format) };
+		if (modes.dark) entry[states.dark] = formatVariant(color.dark, format);
+		if (modes.highContrast) entry[states.highContrast] = formatVariant(color.lightContrast, format);
+		if (modes.dark && modes.highContrast) entry[`${states.dark} & ${states.highContrast}`] = formatVariant(color.darkContrast, format);
+		tokens[key] = entry;
+	}
+	return tokens;
+}
+function buildFlatTokenMap(resolved, prefix, modes, format = "okhsl") {
+	const result = { light: {} };
+	if (modes.dark) result.dark = {};
+	if (modes.highContrast) result.lightContrast = {};
+	if (modes.dark && modes.highContrast) result.darkContrast = {};
+	for (const [name, color] of resolved) {
+		const key = `${prefix}${name}`;
+		result.light[key] = formatVariant(color.light, format);
+		if (modes.dark) result.dark[key] = formatVariant(color.dark, format);
+		if (modes.highContrast) result.lightContrast[key] = formatVariant(color.lightContrast, format);
+		if (modes.dark && modes.highContrast) result.darkContrast[key] = formatVariant(color.darkContrast, format);
+	}
+	return result;
+}
+function buildJsonMap(resolved, modes, format = "okhsl") {
+	const result = {};
+	for (const [name, color] of resolved) {
+		const entry = { light: formatVariant(color.light, format) };
+		if (modes.dark) entry.dark = formatVariant(color.dark, format);
+		if (modes.highContrast) entry.lightContrast = formatVariant(color.lightContrast, format);
+		if (modes.dark && modes.highContrast) entry.darkContrast = formatVariant(color.darkContrast, format);
+		result[name] = entry;
+	}
+	return result;
+}
+function buildCssMap(resolved, prefix, suffix, format) {
+	const lines = {
+		light: [],
+		dark: [],
+		lightContrast: [],
+		darkContrast: []
+	};
+	for (const [name, color] of resolved) {
+		const prop = `--${prefix}${name}${suffix}`;
+		lines.light.push(`${prop}: ${formatVariant(color.light, format)};`);
+		lines.dark.push(`${prop}: ${formatVariant(color.dark, format)};`);
+		lines.lightContrast.push(`${prop}: ${formatVariant(color.lightContrast, format)};`);
+		lines.darkContrast.push(`${prop}: ${formatVariant(color.darkContrast, format)};`);
+	}
+	return {
+		light: lines.light.join("\n"),
+		dark: lines.dark.join("\n"),
+		lightContrast: lines.lightContrast.join("\n"),
+		darkContrast: lines.darkContrast.join("\n")
+	};
+}
+function createTheme(hue, saturation, initialColors) {
+	let colorDefs = initialColors ? { ...initialColors } : {};
+	return {
+		get hue() {
+			return hue;
+		},
+		get saturation() {
+			return saturation;
+		},
+		colors(defs) {
+			colorDefs = {
+				...colorDefs,
+				...defs
+			};
+		},
+		color(name, def) {
+			if (def === void 0) return colorDefs[name];
+			colorDefs[name] = def;
+		},
+		remove(names) {
+			const list = Array.isArray(names) ? names : [names];
+			for (const name of list) delete colorDefs[name];
+		},
+		has(name) {
+			return name in colorDefs;
+		},
+		list() {
+			return Object.keys(colorDefs);
+		},
+		reset() {
+			colorDefs = {};
+		},
+		export() {
+			return {
+				hue,
+				saturation,
+				colors: { ...colorDefs }
+			};
+		},
+		extend(options) {
+			return createTheme(options.hue ?? hue, options.saturation ?? saturation, options.colors ? {
+				...colorDefs,
+				...options.colors
+			} : { ...colorDefs });
+		},
+		resolve() {
+			return resolveAllColors(hue, saturation, colorDefs);
+		},
+		tokens(options) {
+			return buildFlatTokenMap(resolveAllColors(hue, saturation, colorDefs), "", resolveModes(options?.modes), options?.format);
+		},
+		tasty(options) {
+			return buildTokenMap(resolveAllColors(hue, saturation, colorDefs), "", {
+				dark: options?.states?.dark ?? globalConfig.states.dark,
+				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
+			}, resolveModes(options?.modes), options?.format);
+		},
+		json(options) {
+			return buildJsonMap(resolveAllColors(hue, saturation, colorDefs), resolveModes(options?.modes), options?.format);
+		},
+		css(options) {
+			return buildCssMap(resolveAllColors(hue, saturation, colorDefs), "", options?.suffix ?? "-color", options?.format ?? "rgb");
+		}
+	};
+}
+function resolvePrefix(options, themeName, defaultPrefix = false) {
+	const prefix = options?.prefix ?? defaultPrefix;
+	if (prefix === true) return `${themeName}-`;
+	if (typeof prefix === "object" && prefix !== null) return prefix[themeName] ?? `${themeName}-`;
+	return "";
+}
+function validatePrimaryTheme(primary, themes) {
+	if (primary !== void 0 && !(primary in themes)) {
+		const available = Object.keys(themes).join(", ");
+		throw new Error(`glaze: primary theme "${primary}" not found in palette. Available: ${available}.`);
+	}
+}
+function createPalette(themes) {
+	return {
+		tokens(options) {
+			validatePrimaryTheme(options?.primary, themes);
+			const modes = resolveModes(options?.modes);
+			const allTokens = {};
+			for (const [themeName, theme] of Object.entries(themes)) {
+				const resolved = theme.resolve();
+				const tokens = buildFlatTokenMap(resolved, resolvePrefix(options, themeName, true), 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);
+					for (const variant of Object.keys(unprefixed)) Object.assign(allTokens[variant], unprefixed[variant]);
+				}
+			}
+			return allTokens;
+		},
+		tasty(options) {
+			validatePrimaryTheme(options?.primary, themes);
+			const states = {
+				dark: options?.states?.dark ?? globalConfig.states.dark,
+				highContrast: options?.states?.highContrast ?? globalConfig.states.highContrast
+			};
+			const modes = resolveModes(options?.modes);
+			const allTokens = {};
+			for (const [themeName, theme] of Object.entries(themes)) {
+				const resolved = theme.resolve();
+				const tokens = buildTokenMap(resolved, resolvePrefix(options, themeName, true), states, modes, options?.format);
+				Object.assign(allTokens, tokens);
+				if (themeName === options?.primary) {
+					const unprefixed = buildTokenMap(resolved, "", states, modes, options?.format);
+					Object.assign(allTokens, unprefixed);
+				}
+			}
+			return allTokens;
+		},
+		json(options) {
+			const modes = resolveModes(options?.modes);
+			const result = {};
+			for (const [themeName, theme] of Object.entries(themes)) result[themeName] = buildJsonMap(theme.resolve(), modes, options?.format);
+			return result;
+		},
+		css(options) {
+			validatePrimaryTheme(options?.primary, themes);
+			const suffix = options?.suffix ?? "-color";
+			const format = options?.format ?? "rgb";
+			const allLines = {
+				light: [],
+				dark: [],
+				lightContrast: [],
+				darkContrast: []
+			};
+			for (const [themeName, theme] of Object.entries(themes)) {
+				const resolved = theme.resolve();
+				const css = buildCssMap(resolved, resolvePrefix(options, themeName, true), 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);
+					for (const key of [
+						"light",
+						"dark",
+						"lightContrast",
+						"darkContrast"
+					]) if (unprefixed[key]) allLines[key].push(unprefixed[key]);
+				}
+			}
+			return {
+				light: allLines.light.join("\n"),
+				dark: allLines.dark.join("\n"),
+				lightContrast: allLines.lightContrast.join("\n"),
+				darkContrast: allLines.darkContrast.join("\n")
+			};
+		}
+	};
+}
+function createColorToken(input) {
+	const defs = { __color__: {
+		lightness: input.lightness,
+		saturation: input.saturationFactor,
+		mode: input.mode
+	} };
+	return {
+		resolve() {
+			return resolveAllColors(input.hue, input.saturation, defs).get("__color__");
+		},
+		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__"];
+		},
+		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__"];
+		},
+		json(options) {
+			return buildJsonMap(resolveAllColors(input.hue, input.saturation, defs), resolveModes(options?.modes), options?.format)["__color__"];
+		}
+	};
+}
+/**
+* Create a single-hue glaze theme.
+*
+* @example
+* ```ts
+* const primary = glaze({ hue: 280, saturation: 80 });
+* // or shorthand:
+* const primary = glaze(280, 80);
+* ```
+*/
+function glaze(hueOrOptions, saturation) {
+	if (typeof hueOrOptions === "number") return createTheme(hueOrOptions, saturation ?? 100);
+	return createTheme(hueOrOptions.hue, hueOrOptions.saturation);
+}
+/**
+* Configure global glaze settings.
+*/
+glaze.configure = function configure(config) {
+	globalConfig = {
+		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
+		},
+		modes: {
+			dark: config.modes?.dark ?? globalConfig.modes.dark,
+			highContrast: config.modes?.highContrast ?? globalConfig.modes.highContrast
+		},
+		shadowTuning: config.shadowTuning ?? globalConfig.shadowTuning
+	};
+};
+/**
+* Compose multiple themes into a palette.
+*/
+glaze.palette = function palette(themes) {
+	return createPalette(themes);
+};
+/**
+* Create a theme from a serialized export.
+*/
+glaze.from = function from(data) {
+	return createTheme(data.hue, data.saturation, data.colors);
+};
+/**
+* Create a standalone single-color token.
+*/
+glaze.color = function color(input) {
+	return createColorToken(input);
+};
+/**
+* Compute a shadow color from a bg/fg pair and intensity.
+*/
+glaze.shadow = function shadow(input) {
+	const bg = parseOkhslInput(input.bg);
+	const fg = input.fg ? parseOkhslInput(input.fg) : void 0;
+	const tuning = resolveShadowTuning(input.tuning);
+	return computeShadow({
+		...bg,
+		alpha: 1
+	}, fg ? {
+		...fg,
+		alpha: 1
+	} : void 0, input.intensity, tuning);
+};
+/**
+* Format a resolved color variant as a CSS string.
+*/
+glaze.format = function format(variant, colorFormat) {
+	return formatVariant(variant, colorFormat);
+};
+function parseOkhslInput(input) {
+	if (typeof input === "string") {
+		const rgb = parseHex(input);
+		if (!rgb) throw new Error(`glaze: invalid hex color "${input}".`);
+		const [h, s, l] = srgbToOkhsl(rgb);
+		return {
+			h,
+			s,
+			l
+		};
+	}
+	return input;
+}
+/**
+* Create a theme from a hex color string.
+* Extracts hue and saturation from the color.
+*/
+glaze.fromHex = function fromHex(hex) {
+	const rgb = parseHex(hex);
+	if (!rgb) throw new Error(`glaze: invalid hex color "${hex}".`);
+	const [h, s] = srgbToOkhsl(rgb);
+	return createTheme(h, s * 100);
+};
+/**
+* Create a theme from RGB values (0–255).
+* Extracts hue and saturation from the color.
+*/
+glaze.fromRgb = function fromRgb(r, g, b) {
+	const [h, s] = srgbToOkhsl([
+		r / 255,
+		g / 255,
+		b / 255
+	]);
+	return createTheme(h, s * 100);
+};
+/**
+* Get the current global configuration (for testing/debugging).
+*/
+glaze.getConfig = function getConfig() {
+	return { ...globalConfig };
+};
+/**
+* Reset global configuration to defaults.
+*/
+glaze.resetConfig = function resetConfig() {
+	globalConfig = {
+		lightLightness: [10, 100],
+		darkLightness: [15, 95],
+		darkDesaturation: .1,
+		darkCurve: .5,
+		states: {
+			dark: "@dark",
+			highContrast: "@high-contrast"
+		},
+		modes: {
+			dark: true,
+			highContrast: false
+		}
+	};
+};
+
+//#endregion
+exports.contrastRatioFromLuminance = contrastRatioFromLuminance;
+exports.findLightnessForContrast = findLightnessForContrast;
+exports.findValueForMixContrast = findValueForMixContrast;
+exports.formatHsl = formatHsl;
+exports.formatOkhsl = formatOkhsl;
+exports.formatOklch = formatOklch;
+exports.formatRgb = formatRgb;
+exports.gamutClampedLuminance = gamutClampedLuminance;
+exports.glaze = glaze;
+exports.okhslToLinearSrgb = okhslToLinearSrgb;
+exports.okhslToOklab = okhslToOklab;
+exports.okhslToSrgb = okhslToSrgb;
+exports.parseHex = parseHex;
+exports.relativeLuminanceFromLinearRgb = relativeLuminanceFromLinearRgb;
+exports.resolveMinContrast = resolveMinContrast;
+exports.srgbToOkhsl = srgbToOkhsl;
+//# sourceMappingURL=index.cjs.map