@tenphi/tasty 3.7.0 → 3.9.0

package/dist/chunks/dsl-C5yuAn41.js

@@ -0,0 +1,1373 @@
+import { a as warnOnceDev, o as isDevEnv } from "./shared-utils-DWA4LjIa.js";
+//#region src/parser/const.ts
+const VALUE_KEYWORDS = new Set([
+	"auto",
+	"max-content",
+	"min-content",
+	"fit-content",
+	"stretch",
+	"initial",
+	"inherit",
+	"revert",
+	"unset",
+	"revert-layer"
+]);
+const CSS_WIDE_KEYWORDS = new Set([
+	"initial",
+	"inherit",
+	"revert",
+	"unset",
+	"revert-layer"
+]);
+const DERIVED_COLOR_FUNCS_LIST = [
+	"color-mix",
+	"color-contrast",
+	"contrast-color",
+	"light-dark"
+];
+const DERIVED_COLOR_FUNCS = new Set(DERIVED_COLOR_FUNCS_LIST);
+const COLOR_FUNCS = new Set([
+	"rgb",
+	"rgba",
+	"hsl",
+	"hsla",
+	"hwb",
+	"lab",
+	"lch",
+	"oklab",
+	"oklch",
+	"color",
+	"device-cmyk",
+	"gray",
+	...DERIVED_COLOR_FUNCS_LIST
+]);
+const RE_FUNC_CALL = /^([a-z][a-z0-9-]*)\((.+)\)$/i;
+const RE_UNIT_NUM = /^[+-]?(?:\d*\.\d+|\d+)([a-z][a-z0-9]*)$/;
+const RE_NUMBER = /^[+-]?(?:\d*\.\d+|\d+)$/;
+const RE_HEX = /^(?:[0-9a-f]{3,4}|[0-9a-f]{6}(?:[0-9a-f]{2})?)$/;
+const RE_RAW_UNIT = /^([+-]?(?:\d*\.\d+|\d+))([a-z%]+)$/;
+const CANONICAL_FUNC_CASE = new Map([
+	["translatex", "translateX"],
+	["translatey", "translateY"],
+	["translatez", "translateZ"],
+	["scalex", "scaleX"],
+	["scaley", "scaleY"],
+	["scalez", "scaleZ"],
+	["rotatex", "rotateX"],
+	["rotatey", "rotateY"],
+	["rotatez", "rotateZ"],
+	["skewx", "skewX"],
+	["skewy", "skewY"]
+]);
+function canonicalFuncName(lowered) {
+	return CANONICAL_FUNC_CASE.get(lowered) ?? lowered;
+}
+//#endregion
+//#region src/utils/string.ts
+function toSnakeCase(str) {
+	return str.replace(/[A-Z]/g, (s) => `-${s.toLowerCase()}`);
+}
+function normalizeDslName(name) {
+	if (!name) return name;
+	const first = name[0];
+	const lower = first.toLowerCase();
+	return lower === first ? name : lower + name.slice(1);
+}
+const RE_DSL_IDENTIFIER = /(\$\$?|##?)([a-zA-Z_][a-zA-Z0-9_-]*)/g;
+function foldDslCase(src) {
+	const folded = src.toLowerCase();
+	if (folded === src || !src.includes("$") && !src.includes("#")) return folded;
+	RE_DSL_IDENTIFIER.lastIndex = 0;
+	let out = "";
+	let last = 0;
+	let match;
+	while (match = RE_DSL_IDENTIFIER.exec(src)) {
+		const [whole, prefix, body] = match;
+		out += src.slice(last, match.index).toLowerCase();
+		out += prefix + (prefix[0] === "#" && RE_HEX.test(body.toLowerCase()) ? body.toLowerCase() : normalizeDslName(body));
+		last = match.index + whole.length;
+	}
+	return out + src.slice(last).toLowerCase();
+}
+//#endregion
+//#region src/utils/color-math.ts
+const OKLab_to_LMS_ab = [
+	[.3963377773761749, .2158037573099136],
+	[-.1055613458156586, -.0638541728258133],
+	[-.0894841775298119, -1.2914855480194092]
+];
+const LMS_to_linear_sRGB_M = [
+	[
+		4.076741636075959,
+		-3.307711539258062,
+		.2309699031821041
+	],
+	[
+		-1.2684379732850313,
+		2.6097573492876878,
+		-.3413193760026569
+	],
+	[
+		-.004196076138675526,
+		-.703418617935936,
+		1.7076146940746113
+	]
+];
+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 dotXY = (vector, x, y) => vector[0] * x + vector[1] * y;
+const dotXYZ = (matrix, x, y, z) => matrix[0] * x + matrix[1] * y + matrix[2] * z;
+const INV_GAMMA = 1 / 2.4;
+function srgbLinearToGamma(val) {
+	const sign = val < 0 ? -1 : 1;
+	const abs = Math.abs(val);
+	return abs > .0031308 ? sign * (1.055 * abs ** INV_GAMMA - .055) : 12.92 * val;
+}
+const TAU = 2 * Math.PI;
+const K1 = .206;
+const K2 = .03;
+const K3 = 1.206 / 1.03;
+const clamp$1 = (value, min, max) => Math.max(Math.min(value, max), min);
+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 OKHST_REF_EPS = .05;
+function yToL(y) {
+	return toe(Math.cbrt(Math.max(0, y)));
+}
+function yFromTone(t, eps = OKHST_REF_EPS) {
+	const den = Math.log(1 + eps) - Math.log(eps);
+	return Math.exp(t / 100 * den + Math.log(eps)) - eps;
+}
+function fromTone(t, eps = OKHST_REF_EPS) {
+	return yToL(yFromTone(t, eps));
+}
+const oklabToLinearSrgb = (lab) => {
+	const L = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	const l_ = L + .3963377773761749 * a + .2158037573099136 * b;
+	const m_ = L - .1055613458156586 * a - .0638541728258133 * b;
+	const s_ = L - .0894841775298119 * a - 1.2914855480194092 * b;
+	const l = l_ * l_ * l_;
+	const m = m_ * m_ * m_;
+	const s = s_ * s_ * s_;
+	return [
+		4.076741636075959 * l - 3.307711539258062 * m + .2309699031821041 * s,
+		-1.2684379732850313 * l + 2.6097573492876878 * m - .3413193760026569 * s,
+		-.004196076138675526 * l - .703418617935936 * m + 1.7076146940746113 * s
+	];
+};
+const computeMaxSaturationOKLC = (a, b) => {
+	const okCoeff = OKLab_to_linear_sRGB_coefficients;
+	const lmsToRgb = LMS_to_linear_sRGB_M;
+	let chnlCoeff;
+	let chnlLMS;
+	if (dotXY(okCoeff[0][0], a, b) > 1) {
+		chnlCoeff = okCoeff[0][1];
+		chnlLMS = lmsToRgb[0];
+	} else if (dotXY(okCoeff[1][0], a, b) > 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 kl = dotXY(OKLab_to_LMS_ab[0], a, b);
+	const km = dotXY(OKLab_to_LMS_ab[1], a, b);
+	const ks = dotXY(OKLab_to_LMS_ab[2], a, b);
+	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;
+	let t;
+	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 = dotXY(OKLab_to_LMS_ab[0], a, b);
+		const km = dotXY(OKLab_to_LMS_ab[1], a, b);
+		const ks = dotXY(OKLab_to_LMS_ab[2], a, b);
+		const ldt_ = dl + dc * kl;
+		const mdt_ = dl + dc * km;
+		const sdt_ = dl + dc * ks;
+		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 * ldt_ * l_ * l_;
+		const mdt = 3 * mdt_ * m_ * m_;
+		const sdt = 3 * sdt_ * s_ * s_;
+		const ldt2 = 6 * ldt_ * ldt_ * l_;
+		const mdt2 = 6 * mdt_ * mdt_ * m_;
+		const sdt2 = 6 * sdt_ * sdt_ * s_;
+		let correction = Number.MAX_VALUE;
+		for (const matrix of lmsToRgb) {
+			const value = dotXYZ(matrix, l, m, s) - 1;
+			const slope = dotXYZ(matrix, ldt, mdt, sdt);
+			const slope2 = dotXYZ(matrix, ldt2, mdt2, sdt2);
+			const u = slope / (slope * slope - .5 * value * slope2);
+			if (u >= 0) correction = Math.min(correction, -value * u);
+		}
+		t += correction;
+	}
+	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
+	];
+};
+const okhslToOklab = (hsl) => {
+	let h = hsl[0];
+	const s = hsl[1];
+	const l = hsl[2];
+	const L = toeInv(l);
+	let a = 0;
+	let b = 0;
+	h = constrainAngle(h) / 360;
+	if (L !== 0 && L !== 1 && s !== 0) {
+		const a_ = Math.cos(TAU * h);
+		const b_ = Math.sin(TAU * h);
+		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
+	];
+};
+function hslToRgbValues(h, s, l) {
+	const a = s * Math.min(l, 1 - l);
+	const f = (n) => {
+		const k = (n + h / 30) % 12;
+		return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+	};
+	return [
+		f(0) * 255,
+		f(8) * 255,
+		f(4) * 255
+	];
+}
+function okhslToSrgb(h, s, l) {
+	const linearRGB = oklabToLinearSrgb(okhslToOklab([
+		h,
+		s,
+		l
+	]));
+	return [
+		clamp$1(srgbLinearToGamma(linearRGB[0]), 0, 1),
+		clamp$1(srgbLinearToGamma(linearRGB[1]), 0, 1),
+		clamp$1(srgbLinearToGamma(linearRGB[2]), 0, 1)
+	];
+}
+function okhstToSrgb(h, s, t) {
+	return okhslToSrgb(h, clamp$1(s, 0, 1), clamp$1(fromTone(t * 100), 0, 1));
+}
+function oklchToRgbValues(L, C, H) {
+	const hRad = H * Math.PI / 180;
+	const linear = oklabToLinearSrgb([
+		L,
+		C * Math.cos(hRad),
+		C * Math.sin(hRad)
+	]);
+	return [
+		clamp$1(srgbLinearToGamma(linear[0]), 0, 1) * 255,
+		clamp$1(srgbLinearToGamma(linear[1]), 0, 1) * 255,
+		clamp$1(srgbLinearToGamma(linear[2]), 0, 1) * 255
+	];
+}
+let _namedColorHex = null;
+function getNamedColorHex() {
+	if (_namedColorHex) return _namedColorHex;
+	const names = "aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen".split(" ");
+	const hex = "f0f8fffaebd700ffff7fffd4f0fffff5f5dcffe4c4000000ffebcd0000ff8a2be2a52a2adeb8875f9ea07fff00d2691eff7f506495edfff8dcdc143c00ffff00008b008b8bb8860ba9a9a9006400a9a9a9bdb76b8b008b556b2fff8c009932cc8b0000e9967a8fbc8f483d8b2f4f4f2f4f4f00ced19400d3ff149300bfff6969696969691e90ffb22222fffaf0228b22ff00ffdcdcdcf8f8ffffd700daa520808080008000adff2f808080f0fff0ff69b4cd5c5c4b0082fffff0f0e68ce6e6fafff0f57cfc00fffacdadd8e6f08080e0fffffafad2d3d3d390ee90d3d3d3ffb6c1ffa07a20b2aa87cefa778899778899b0c4deffffe000ff0032cd32faf0e6ff00ff80000066cdaa0000cdba55d39370db3cb3717b68ee00fa9a48d1ccc71585191970f5fffaffe4e1ffe4b5ffdead000080fdf5e68080006b8e23ffa500ff4500da70d6eee8aa98fb98afeeeedb7093ffefd5ffdab9cd853fffc0cbdda0ddb0e0e6800080663399ff0000bc8f8f4169e18b4513fa8072f4a4602e8b57fff5eea0522dc0c0c087ceeb6a5acd708090708090fffafa00ff7f4682b4d2b48c008080d8bfd8ff634740e0d0ee82eef5deb3fffffff5f5f5ffff009acd32";
+	const colors = /* @__PURE__ */ new Map();
+	for (let i = 0; i < names.length; i++) colors.set(names[i], `#${hex.slice(i * 6, i * 6 + 6)}`);
+	return _namedColorHex = colors;
+}
+function hexToRgb(hex) {
+	const matched = hex.replace(/^#?([a-f\d])([a-f\d])([a-f\d])$/i, (_m, r, g, b) => "#" + r + r + g + g + b + b).substring(1).match(/.{2}/g);
+	if (!matched) return null;
+	const rgba = matched.map((x, i) => parseInt(x, 16) * (i === 3 ? 1 / 255 : 1));
+	if (rgba.some((v) => Number.isNaN(v))) return null;
+	if (rgba.length >= 3) return `rgb(${rgba.slice(0, 3).join(" ")}${rgba.length > 3 ? ` / ${rgba[3]}` : ""})`;
+	return null;
+}
+function getRgbValuesFromRgbaString(str) {
+	const match = str.match(/rgba?\(([^)]+)\)/i);
+	if (!match) return [];
+	const [colorPart] = match[1].trim().split("/");
+	return colorPart.trim().split(/[,\s]+/).filter(Boolean).slice(0, 3).map((part) => {
+		part = part.trim();
+		if (part.endsWith("%")) return parseFloat(part) / 100 * 255;
+		return parseFloat(part);
+	});
+}
+function strToRgb(color, _ignoreAlpha = false) {
+	if (!color) return void 0;
+	if (color.startsWith("rgb")) return color;
+	if (color.startsWith("#")) return hexToRgb(color);
+	if (color.startsWith("oklch(")) return oklchStringToRgb(color);
+	if (color.startsWith("hsl")) return hslStringToRgb(color);
+	const namedHex = getNamedColorHex().get(color.toLowerCase());
+	if (namedHex) return hexToRgb(namedHex);
+	return null;
+}
+function hslStringToRgb(hslStr) {
+	const match = hslStr.match(/hsla?\(([^)]+)\)/i);
+	if (!match) return null;
+	const [colorPart, slashAlpha] = match[1].trim().split("/");
+	const parts = colorPart.trim().split(/[,\s]+/).filter(Boolean);
+	if (parts.length < 3) return null;
+	const alphaPart = slashAlpha?.trim() || (parts.length >= 4 ? parts[3] : null);
+	let h = parseFloat(parts[0]);
+	const hueStr = parts[0].toLowerCase();
+	if (hueStr.endsWith("turn")) h = parseFloat(hueStr) * 360;
+	else if (hueStr.endsWith("rad")) h = parseFloat(hueStr) * 180 / Math.PI;
+	h = (h % 360 + 360) % 360;
+	const parsePercent = (val) => {
+		const num = parseFloat(val);
+		return val.includes("%") ? num / 100 : num;
+	};
+	const s = Math.max(0, Math.min(1, parsePercent(parts[1])));
+	const l = Math.max(0, Math.min(1, parsePercent(parts[2])));
+	const [r, g, b] = hslToRgbValues(h, s, l);
+	if (alphaPart) {
+		const alpha = parseFloat(alphaPart.trim());
+		return `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${alpha})`;
+	}
+	return `rgb(${Math.round(r)} ${Math.round(g)} ${Math.round(b)})`;
+}
+function oklchStringToRgb(oklchStr) {
+	const match = oklchStr.match(/oklch\(([^)]+)\)/i);
+	if (!match) return null;
+	const [colorPart, alphaPart] = match[1].trim().split("/");
+	const parts = colorPart.trim().split(/[,\s]+/).filter(Boolean);
+	if (parts.length < 3) return null;
+	const parsePercent = (val) => {
+		const num = parseFloat(val);
+		return val.includes("%") ? num / 100 : num;
+	};
+	const L = Math.max(0, Math.min(1, parsePercent(parts[0])));
+	const C = Math.max(0, parseFloat(parts[1]));
+	let H = parseFloat(parts[2]);
+	const hueStr = parts[2].toLowerCase();
+	if (hueStr.endsWith("turn")) H = parseFloat(hueStr) * 360;
+	else if (hueStr.endsWith("rad")) H = parseFloat(hueStr) * 180 / Math.PI;
+	else if (hueStr.endsWith("deg")) H = parseFloat(hueStr);
+	const [r, g, b] = oklchToRgbValues(L, C, H);
+	if (alphaPart) {
+		const alpha = parseFloat(alphaPart.trim());
+		return `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${alpha})`;
+	}
+	return `rgb(${Math.round(r)} ${Math.round(g)} ${Math.round(b)})`;
+}
+//#endregion
+//#region src/utils/color-space.ts
+function overrideColorAlpha(color, alpha) {
+	return `oklch(from ${color} l c h / ${alpha})`;
+}
+function mixColorAlpha(color, percentage) {
+	return `color-mix(in oklab, ${color} ${percentage}, transparent)`;
+}
+const RE_ALPHA_OVERRIDE = /^oklch\(from (.+) l c h \/ (.+)\)$/;
+function parseAlphaOverride(value) {
+	const match = value.match(RE_ALPHA_OVERRIDE);
+	return match ? {
+		color: match[1],
+		alpha: match[2]
+	} : null;
+}
+//#endregion
+//#region src/parser/types.ts
+const makeEmptyPart = () => ({
+	mods: [],
+	values: [],
+	colors: [],
+	all: [],
+	output: ""
+});
+const makeEmptyDetails = () => ({
+	input: "",
+	output: "",
+	mods: [],
+	values: [],
+	colors: [],
+	all: [],
+	parts: []
+});
+//#endregion
+//#region src/parser/classify.ts
+function alphaSuffixToAlpha(rawAlpha) {
+	if (rawAlpha.startsWith("$")) return `var(--${rawAlpha.slice(1)})`;
+	if (rawAlpha === "0") return "0";
+	return `.${rawAlpha}`;
+}
+function fadeColor(color, rawAlpha) {
+	return overrideColorAlpha(color, alphaSuffixToAlpha(rawAlpha));
+}
+function alphaSuffixToPercentage(rawAlpha) {
+	if (rawAlpha.startsWith("$")) return `calc(var(--${rawAlpha.slice(1)}) * 100%)`;
+	if (rawAlpha === "0") return "0%";
+	const digits = rawAlpha.length === 1 ? `${rawAlpha}0` : rawAlpha;
+	const whole = String(Number(digits.slice(0, 2)));
+	const fraction = digits.slice(2);
+	return `${fraction ? `${whole}.${fraction}` : whole}%`;
+}
+function fadeCurrentColor(rawAlpha) {
+	return mixColorAlpha("currentcolor", alphaSuffixToPercentage(rawAlpha));
+}
+function hasColorArgs(parsed) {
+	const namedColors = getNamedColorHex();
+	return parsed.groups.some((group) => group.colors.length > 0 || group.mods.some((mod) => namedColors.has(mod)));
+}
+function resolveUntilStable(value, opts, recurse, maxIterations = 10) {
+	let current = value;
+	for (let i = 0; i < maxIterations; i++) {
+		const unitMatch = current.match(RE_UNIT_NUM);
+		if (!unitMatch) break;
+		const unitName = unitMatch[1];
+		if (!opts.units || !(unitName in opts.units)) break;
+		const result = recurse(current);
+		if (result.output === current) break;
+		current = result.output;
+	}
+	return current;
+}
+function classify(raw, opts, recurse) {
+	const token = raw.trim();
+	if (!token) return {
+		bucket: 2,
+		processed: ""
+	};
+	if (token.includes("(")) {
+		let depth = 0;
+		let inQuote = 0;
+		for (let i = 0; i < token.length; i++) {
+			const ch = token[i];
+			if (inQuote) {
+				if (ch === inQuote && token[i - 1] !== "\\") inQuote = 0;
+				continue;
+			}
+			if (ch === "\"" || ch === "'") {
+				inQuote = ch;
+				continue;
+			}
+			if (ch === "(") depth++;
+			else if (ch === ")" && depth) depth--;
+		}
+		if (depth !== 0) {
+			console.warn("[Tasty] skipped invalid function token with unmatched parentheses:", token);
+			return {
+				bucket: 2,
+				processed: ""
+			};
+		}
+	}
+	if (token.startsWith("\"") && token.endsWith("\"") || token.startsWith("'") && token.endsWith("'")) return {
+		bucket: 1,
+		processed: token
+	};
+	if (token.startsWith("$$")) {
+		const rest = token.slice(2);
+		const openIdx = rest.indexOf("(");
+		if (openIdx > 0 && rest.endsWith(")")) {
+			const fname = rest.slice(0, openIdx);
+			if (/^[a-z_][a-z0-9-_]*$/i.test(fname)) {
+				const inner = rest.slice(openIdx + 1, -1).trim();
+				const cssName = `--${fname}`;
+				if (opts.functions && cssName in opts.functions) {
+					const groups = inner ? new StyleParser(opts).process(inner).groups : [];
+					const funcResult = opts.functions[cssName](groups);
+					if (funcResult !== "") return classify(funcResult, {
+						...opts,
+						functions: void 0
+					}, recurse);
+				}
+				return {
+					bucket: 1,
+					processed: `--${fname}(${inner ? recurse(inner).output : ""})`
+				};
+			}
+		}
+		if (/^[a-z_][a-z0-9-_]*$/i.test(rest)) return {
+			bucket: 1,
+			processed: `--${rest}`
+		};
+	}
+	if (token.startsWith("##")) {
+		const rest = token.slice(2);
+		const openIdx = rest.indexOf("(");
+		if (openIdx > 0 && rest.endsWith(")")) {
+			const fname = rest.slice(0, openIdx);
+			if (/^[a-z_][a-z0-9-_]*$/i.test(fname)) {
+				const inner = rest.slice(openIdx + 1, -1).trim();
+				return {
+					bucket: 1,
+					processed: `--${fname}-color(${inner ? recurse(inner).output : ""})`
+				};
+			}
+		}
+		if (/^[a-z_][a-z0-9-_]*$/i.test(rest)) return {
+			bucket: 1,
+			processed: `--${rest}-color`
+		};
+	}
+	if (token === "#current") return {
+		bucket: 0,
+		processed: "currentcolor"
+	};
+	const currentAlphaMatch = token.match(/^#current\.(\$[a-z_][a-z0-9-_]*|[0-9]+)$/i);
+	if (currentAlphaMatch) return {
+		bucket: 0,
+		processed: fadeCurrentColor(currentAlphaMatch[1])
+	};
+	if (token[0] === "$" || token[0] === "#") {
+		const predefinedTokens = getGlobalPredefinedTokens();
+		if (predefinedTokens) {
+			const lookupKey = token.toLowerCase();
+			if (lookupKey in predefinedTokens) {
+				const tokenValue = predefinedTokens[lookupKey];
+				return classify(foldDslCase(tokenValue), opts, recurse);
+			}
+			if (token[0] === "#") {
+				const alphaMatch = token.match(/^(#[a-z0-9-]+)\.(\$[a-z_][a-z0-9-_]*|[0-9]+)$/i);
+				if (alphaMatch) {
+					const [, baseToken, rawAlpha] = alphaMatch;
+					const baseKey = baseToken.toLowerCase();
+					if (baseKey in predefinedTokens) {
+						const resolvedValue = predefinedTokens[baseKey];
+						if (resolvedValue.startsWith("#")) return classify(`${foldDslCase(resolvedValue)}.${rawAlpha}`, opts, recurse);
+						const funcMatch = resolvedValue.match(RE_FUNC_CALL);
+						if (funcMatch) {
+							const [, funcName, args] = funcMatch;
+							const lowerFunc = funcName.toLowerCase();
+							if (DERIVED_COLOR_FUNCS.has(lowerFunc)) return {
+								bucket: 0,
+								processed: fadeColor(classify(foldDslCase(resolvedValue), opts, recurse).processed, rawAlpha)
+							};
+							const isCustomFunc = !!(opts.functions && lowerFunc in opts.functions && !COLOR_FUNCS.has(lowerFunc) && !COLOR_FUNCS.has(funcName.replace(/a$/i, "").toLowerCase()));
+							const normalizedFunc = isCustomFunc ? lowerFunc : funcName.replace(/a$/i, "").toLowerCase();
+							if (!(COLOR_FUNCS.has(normalizedFunc) || COLOR_FUNCS.has(lowerFunc) || isCustomFunc)) return classify(`${resolvedValue}.${rawAlpha}`, opts, recurse);
+							let alpha;
+							if (rawAlpha.startsWith("$")) alpha = `var(--${rawAlpha.slice(1)})`;
+							else alpha = rawAlpha === "0" ? "0" : `.${rawAlpha}`;
+							const normalizeArgs = (a) => {
+								let result = "";
+								let depth = 0;
+								for (let i = 0; i < a.length; i++) {
+									const c = a[i];
+									if (c === "(") {
+										depth++;
+										result += c;
+									} else if (c === ")") {
+										depth = Math.max(0, depth - 1);
+										result += c;
+									} else if (c === "," && depth === 0) {
+										while (i + 1 < a.length && /\s/.test(a[i + 1])) i++;
+										result += " ";
+									} else result += c;
+								}
+								return result;
+							};
+							const findLastTopLevel = (str, ch) => {
+								let depth = 0;
+								for (let i = str.length - 1; i >= 0; i--) {
+									const c = str[i];
+									if (c === ")") depth++;
+									else if (c === "(") depth = Math.max(0, depth - 1);
+									else if (c === ch && depth === 0) return i;
+								}
+								return -1;
+							};
+							const slashIdx = findLastTopLevel(args, "/");
+							const hasModernAlpha = slashIdx !== -1;
+							let topLevelCommaCount = 0;
+							let lastTopLevelComma = -1;
+							{
+								let depth = 0;
+								for (let i = 0; i < args.length; i++) {
+									const c = args[i];
+									if (c === "(") depth++;
+									else if (c === ")") depth = Math.max(0, depth - 1);
+									else if (c === "," && depth === 0) {
+										topLevelCommaCount++;
+										lastTopLevelComma = i;
+									}
+								}
+							}
+							const hasLegacyAlpha = !hasModernAlpha && /a$/i.test(funcName) && topLevelCommaCount === 3;
+							const constructed = `${normalizedFunc}(${hasModernAlpha || hasLegacyAlpha ? normalizeArgs(hasModernAlpha ? args.slice(0, slashIdx).trim() : args.slice(0, lastTopLevelComma).trim()) : normalizeArgs(args)} / ${alpha})`;
+							if (!COLOR_FUNCS.has(normalizedFunc) && opts.functions && normalizedFunc in opts.functions) return classify(constructed, opts, recurse);
+							return {
+								bucket: 0,
+								processed: constructed
+							};
+						}
+						return classify(`${resolvedValue}.${rawAlpha}`, opts, recurse);
+					}
+				}
+			}
+		}
+	}
+	if (token.match(/^var\(--([a-zA-Z0-9-]+)-color\)$/)) return {
+		bucket: 0,
+		processed: token
+	};
+	if (token.startsWith("url(")) return {
+		bucket: 1,
+		processed: token
+	};
+	if (token[0] === "$") {
+		const identMatch = token.match(/^\$([a-z_][a-zA-Z0-9-_]*)$/);
+		if (identMatch) {
+			const name = identMatch[1];
+			const processed = `var(--${name})`;
+			return {
+				bucket: name.endsWith("-color") ? 3 : 1,
+				processed
+			};
+		}
+	}
+	if (token[0] === "#" && token.length > 1) {
+		const alphaMatch = token.match(/^#([a-z0-9-]+)\.(\$[a-z_][a-z0-9-_]*|[0-9]+)$/i);
+		if (alphaMatch) {
+			const [, base, rawAlpha] = alphaMatch;
+			return {
+				bucket: 0,
+				processed: fadeColor(`var(--${base}-color)`, rawAlpha)
+			};
+		}
+		const name = token.slice(1);
+		if (RE_HEX.test(name)) return {
+			bucket: 0,
+			processed: `var(--${name}-color, #${name})`
+		};
+		return {
+			bucket: 0,
+			processed: `var(--${name}-color)`
+		};
+	}
+	const openIdx = token.indexOf("(");
+	if (openIdx > 0 && token.endsWith(")")) {
+		const fname = token.slice(0, openIdx);
+		const inner = token.slice(openIdx + 1, -1);
+		if (COLOR_FUNCS.has(fname)) {
+			const parsedInner = recurse(inner);
+			const argProcessed = parsedInner.output.replace(/,\s+/g, ",");
+			const processed = `${canonicalFuncName(fname)}(${argProcessed})`;
+			return {
+				bucket: fname === "light-dark" && !hasColorArgs(parsedInner) ? 1 : 0,
+				processed
+			};
+		}
+		if (opts.functions && fname in opts.functions) {
+			const tmp = new StyleParser(opts).process(inner);
+			return classify(opts.functions[fname](tmp.groups), {
+				...opts,
+				functions: void 0
+			}, recurse);
+		}
+		const argProcessed = recurse(inner).output;
+		return {
+			bucket: 1,
+			processed: `${canonicalFuncName(fname)}(${argProcessed})`
+		};
+	}
+	if (token.startsWith("(") && token.endsWith(")")) {
+		const colorMatch = token.slice(1, -1).match(/^#([a-z0-9-]+)\s*,\s*(.*)$/i);
+		if (colorMatch) {
+			const [, name, fallback] = colorMatch;
+			return {
+				bucket: 0,
+				processed: `var(--${name}-color, ${recurse(fallback).output})`
+			};
+		}
+	}
+	if (token.startsWith("(") && token.endsWith(")")) {
+		const match = token.slice(1, -1).match(/^\$([a-z_][a-zA-Z0-9-_]*)\s*,\s*(.*)$/);
+		if (match) {
+			const [, name, fallback] = match;
+			const processedFallback = recurse(fallback).output;
+			return {
+				bucket: name.endsWith("-color") ? 3 : 1,
+				processed: `var(--${name}, ${processedFallback})`
+			};
+		}
+	}
+	if (token[0] === "(" && token[token.length - 1] === ")") return {
+		bucket: 1,
+		processed: `calc(${recurse(token.slice(1, -1)).output})`
+	};
+	const um = token.match(RE_UNIT_NUM);
+	if (um) {
+		const unit = um[1];
+		const numericPart = parseFloat(token.slice(0, -unit.length));
+		const handler = opts.units && opts.units[unit];
+		if (handler) if (typeof handler === "string") {
+			const rawMatch = handler.match(RE_RAW_UNIT);
+			if (rawMatch) {
+				const [, baseNum, cssUnit] = rawMatch;
+				return {
+					bucket: 1,
+					processed: resolveUntilStable(`${numericPart * parseFloat(baseNum)}${cssUnit}`, opts, recurse)
+				};
+			}
+			const base = handler;
+			if (numericPart === 1) return {
+				bucket: 1,
+				processed: base
+			};
+			return {
+				bucket: 1,
+				processed: `calc(${numericPart} * ${base})`
+			};
+		} else return {
+			bucket: 1,
+			processed: handler(numericPart)
+		};
+	}
+	if (/^[+-]?(?:\d*\.\d+|\d+)[a-z%]+$/.test(token)) return {
+		bucket: 1,
+		processed: token
+	};
+	if (RE_NUMBER.test(token)) return {
+		bucket: 1,
+		processed: token
+	};
+	if (VALUE_KEYWORDS.has(token)) return {
+		bucket: 1,
+		processed: token
+	};
+	if (token === "transparent" || token === "currentcolor") return {
+		bucket: 0,
+		processed: token
+	};
+	return {
+		bucket: 2,
+		processed: token
+	};
+}
+//#endregion
+//#region src/parser/lru.ts
+var Lru = class {
+	limit;
+	map = /* @__PURE__ */ new Map();
+	head = null;
+	tail = null;
+	onEvict;
+	constructor(limit = 1e3, onEvict) {
+		this.limit = limit;
+		let normalized = Number.isFinite(this.limit) ? Math.floor(this.limit) : 1e3;
+		if (normalized <= 0) normalized = 1e3;
+		this.limit = normalized;
+		this.onEvict = onEvict;
+	}
+	setOnEvict(fn) {
+		this.onEvict = fn;
+	}
+	get(key) {
+		const node = this.map.get(key);
+		if (node === void 0) return void 0;
+		if (this.head !== node) this.moveToHead(node);
+		return node.value;
+	}
+	set(key, value) {
+		const existing = this.map.get(key);
+		if (existing !== void 0) {
+			existing.value = value;
+			if (this.head !== existing) this.moveToHead(existing);
+			return;
+		}
+		const node = {
+			key,
+			prev: null,
+			next: this.head,
+			value
+		};
+		if (this.head) this.head.prev = node;
+		this.head = node;
+		if (!this.tail) this.tail = node;
+		this.map.set(key, node);
+		if (this.map.size > this.limit) this.evict();
+	}
+	delete(key) {
+		const node = this.map.get(key);
+		if (node === void 0) return;
+		this.detach(node);
+		this.map.delete(key);
+	}
+	keys() {
+		return this.map.keys();
+	}
+	detach(node) {
+		if (node.prev) node.prev.next = node.next;
+		if (node.next) node.next.prev = node.prev;
+		if (this.head === node) this.head = node.next;
+		if (this.tail === node) this.tail = node.prev;
+		node.prev = null;
+		node.next = null;
+	}
+	moveToHead(node) {
+		this.detach(node);
+		node.next = this.head;
+		if (this.head) this.head.prev = node;
+		this.head = node;
+		if (!this.tail) this.tail = node;
+	}
+	evict() {
+		const node = this.tail;
+		if (!node) return;
+		this.detach(node);
+		this.map.delete(node.key);
+		if (this.onEvict) try {
+			this.onEvict(node.key, node.value);
+		} catch {}
+	}
+	clear() {
+		this.map.clear();
+		this.head = this.tail = null;
+	}
+};
+//#endregion
+//#region src/parser/tokenizer.ts
+const isWhitespace = (ch) => ch === " " || ch === "\n" || ch === "	" || ch === "\r" || ch === "\f";
+function scan(src, cb) {
+	let depth = 0;
+	let inQuote = 0;
+	let start = 0;
+	let i = 0;
+	let pendingSlash = false;
+	const flush = (isComma, isSlash) => {
+		const actualSlash = isSlash || pendingSlash;
+		pendingSlash = false;
+		if (start < i) cb(src.slice(start, i), isComma, actualSlash);
+		else if (isComma) cb("", true, false);
+		else if (actualSlash) cb("", false, true);
+		start = i + 1;
+	};
+	for (; i < src.length; i++) {
+		const ch = src[i];
+		if (inQuote) {
+			if (ch === inQuote && src[i - 1] !== "\\") inQuote = 0;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			inQuote = ch;
+			continue;
+		}
+		if (ch === "(") {
+			depth++;
+			continue;
+		}
+		if (ch === ")") {
+			if (depth) depth--;
+			continue;
+		}
+		if (!depth) {
+			if (ch === ",") {
+				flush(true, false);
+				continue;
+			}
+			if (ch === "/") {
+				const prevIsWhitespace = isWhitespace(src[i - 1]);
+				const nextIsWhitespace = isWhitespace(src[i + 1]);
+				if (prevIsWhitespace && nextIsWhitespace) {
+					pendingSlash = true;
+					start = i + 1;
+					continue;
+				}
+				continue;
+			}
+			if (isWhitespace(ch)) {
+				flush(false, false);
+				continue;
+			}
+		}
+	}
+	flush(false, false);
+}
+//#endregion
+//#region src/parser/parser.ts
+var StyleParser = class {
+	opts;
+	cache;
+	constructor(opts = {}) {
+		this.opts = opts;
+		this.cache = new Lru(this.opts.cacheSize ?? 1e3);
+	}
+	process(src) {
+		const key = String(src);
+		const hit = this.cache.get(key);
+		if (hit) return hit;
+		const stripped = foldDslCase(src.replace(/\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g, ""));
+		const groups = [];
+		let currentGroup = makeEmptyDetails();
+		let currentPart = makeEmptyPart();
+		let parts = [];
+		const pushToken = (bucket, processed) => {
+			if (!processed) return;
+			if (currentPart.values.length > 0 && currentPart.values[currentPart.values.length - 1].startsWith("url(")) {
+				currentPart.values[currentPart.values.length - 1] += ` ${processed}`;
+				currentPart.all[currentPart.all.length - 1] += ` ${processed}`;
+				return;
+			}
+			switch (bucket) {
+				case 0:
+					currentPart.colors.push(processed);
+					break;
+				case 1:
+					currentPart.values.push(processed);
+					break;
+				case 2:
+					currentPart.mods.push(processed);
+					break;
+				case 3:
+					currentPart.colors.push(processed);
+					currentPart.values.push(processed);
+					break;
+			}
+			currentPart.all.push(processed);
+		};
+		const endPart = (reset = true) => {
+			if (currentPart.all.length > 0) {
+				currentPart.output = currentPart.all.join(" ");
+				parts.push(currentPart);
+			}
+			if (reset) currentPart = makeEmptyPart();
+		};
+		const endGroup = (reset = true) => {
+			endPart(reset);
+			if (parts.length === 0) parts.push(makeEmptyPart());
+			currentGroup.parts = parts;
+			for (const part of parts) {
+				currentGroup.mods.push(...part.mods);
+				currentGroup.values.push(...part.values);
+				currentGroup.colors.push(...part.colors);
+				currentGroup.all.push(...part.all);
+			}
+			currentGroup.output = parts.length === 1 ? parts[0].output : parts.map((part) => part.output).join(" / ");
+			groups.push(currentGroup);
+			if (reset) {
+				currentGroup = makeEmptyDetails();
+				parts = [];
+			}
+		};
+		scan(stripped, (tok, isComma, isSlash) => {
+			if (tok) {
+				if (currentGroup.input) currentGroup.input += ` ${tok}`;
+				else currentGroup.input = tok;
+				const { bucket, processed } = classify(tok, this.opts, (sub) => this.process(sub));
+				pushToken(bucket, processed);
+			}
+			if (isSlash) endPart();
+			if (isComma) endGroup();
+		});
+		if (currentPart.all.length || parts.length || !groups.length) endGroup(false);
+		const result = {
+			output: groups.length === 1 ? groups[0].output : groups.map((group) => group.output).join(", "),
+			groups
+		};
+		Object.freeze(result);
+		this.cache.set(key, result);
+		return result;
+	}
+	setFunctions(functions) {
+		this.opts.functions = functions;
+		this.cache.clear();
+	}
+	setUnits(units) {
+		this.opts.units = units;
+		this.cache.clear();
+	}
+	updateOptions(patch) {
+		Object.assign(this.opts, patch);
+		if (patch.cacheSize) this.cache = new Lru(patch.cacheSize);
+		else this.cache.clear();
+	}
+	clearCache() {
+		this.cache.clear();
+	}
+	getUnits() {
+		return this.opts.units;
+	}
+};
+//#endregion
+//#region src/plugins/color-func.ts
+const clamp = (value, min, max) => Math.max(Math.min(value, max), min);
+const parseAngle = (value) => {
+	const match = value.match(/^([+-]?\d*\.?\d+)(deg|turn|rad)?$/);
+	if (!match) return 0;
+	const num = parseFloat(match[1]);
+	switch (match[2]) {
+		case "turn": return num * 360;
+		case "rad": return num * 180 / Math.PI;
+		default: return num;
+	}
+};
+const parsePercentage = (value) => {
+	const match = value.match(/^([+-]?\d*\.?\d+)%?$/);
+	if (!match) return 0;
+	const num = parseFloat(match[1]);
+	return value.includes("%") ? num / 100 : num;
+};
+function createColorFunc(name, convert, label) {
+	const conversionCache = new Lru(500);
+	const expected = label ? ` (${label})` : "";
+	return (groups) => {
+		if (groups.length === 0 || groups[0].all.length < 3) {
+			if (isDevEnv()) console.warn(`[Tasty] ${name}(): expected 3 values${expected}, got:`, groups);
+			return "rgb(0% 0% 0%)";
+		}
+		const group = groups[0];
+		const tokens = group.all;
+		const alpha = group.parts.length > 1 && group.parts[1].all.length > 0 ? group.parts[1].output : void 0;
+		const cacheKey = tokens.slice(0, 3).join(" ") + (alpha ? ` / ${alpha}` : "");
+		const cached = conversionCache.get(cacheKey);
+		if (cached) return cached;
+		const h = parseAngle(tokens[0]);
+		const c2 = parsePercentage(tokens[1]);
+		const c3 = parsePercentage(tokens[2]);
+		const misscaled = [tokens[1], tokens[2]].filter((raw, i) => !raw.includes("%") && (i === 0 ? c2 : c3) > 1);
+		if (misscaled.length) warnOnceDev(`${name}:percent-scale`, `${name}(): channels are factors (0-1) or percentages, so ${misscaled.map((v) => `"${v}"`).join(" and ")} ${misscaled.length > 1 ? "clamp" : "clamps"} to 1 — add the missing '%', or write the value as a 0-1 number.`);
+		const [r, g, b] = convert(h, clamp(c2, 0, 1), clamp(c3, 0, 1));
+		const format = (n) => {
+			const pct = n * 100;
+			return parseFloat(pct.toFixed(1)).toString() + "%";
+		};
+		const result = alpha ? `rgb(${format(r)} ${format(g)} ${format(b)} / ${alpha})` : `rgb(${format(r)} ${format(g)} ${format(b)})`;
+		conversionCache.set(cacheKey, result);
+		return result;
+	};
+}
+//#endregion
+//#region src/plugins/okhsl-plugin.ts
+const okhslFunction = createColorFunc("okhsl", okhslToSrgb, "H S L");
+const okhslPlugin = () => ({
+	name: "okhsl",
+	functions: { okhsl: okhslFunction }
+});
+//#endregion
+//#region src/plugins/okhst-plugin.ts
+const okhstFunction = createColorFunc("okhst", okhstToSrgb, "H S T");
+const okhstPlugin = () => ({
+	name: "okhst",
+	functions: { okhst: okhstFunction }
+});
+//#endregion
+//#region src/plugins/defaults.ts
+function registerDefaultFunctions() {
+	customFunction("okhsl", okhslFunction);
+	customFunction("okhst", okhstFunction);
+}
+//#endregion
+//#region src/utils/styles.ts
+function normalizeColorTokenValue(value) {
+	if (value === true) return "transparent";
+	if (value === false) return null;
+	return value;
+}
+const COLOR_VAR_PATTERN = /^var\(--([a-z0-9-]+)-color[,)]/;
+const RGB_ALPHA_PATTERN = /\/\s*([0-9.]+)\)/;
+const RE_HEX_COLOR = /^#[0-9a-fA-F]{3,8}$/;
+const RE_VAR_COLOR = /^var\(--[a-z0-9-]+-color/;
+function isSimpleColorFast(val) {
+	switch (val.charCodeAt(0)) {
+		case 35: return RE_HEX_COLOR.test(val);
+		case 114:
+			if (val.charCodeAt(1) === 103 && val.charCodeAt(2) === 98) return true;
+			break;
+		case 104:
+			if (val.charCodeAt(1) === 115 && val.charCodeAt(2) === 108) return true;
+			break;
+		case 108:
+			if (val.charCodeAt(1) === 99 && val.charCodeAt(2) === 104) return true;
+			break;
+		case 111:
+			if (val.startsWith("oklch(")) return true;
+			break;
+		case 118:
+			if (RE_VAR_COLOR.test(val)) return true;
+			break;
+		case 99:
+			if (val === "currentColor" || val === "currentcolor") return true;
+			break;
+		case 116:
+			if (val === "transparent") return true;
+			break;
+	}
+	return getNamedColorHex().has(val.toLowerCase());
+}
+let colorWarningCount = 0;
+const MAX_COLOR_WARNINGS = 10;
+const CUSTOM_UNITS = {
+	r: "6px",
+	cr: "10px",
+	bw: "1px",
+	ow: "3px",
+	x: "8px",
+	sf: function sf(num) {
+		return `minmax(0, ${num}fr)`;
+	}
+};
+const DIRECTIONS = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+let __tastyParser = null;
+function getOrCreateParser() {
+	if (!__tastyParser) {
+		__tastyParser = new StyleParser({ units: CUSTOM_UNITS });
+		__tastyParser.setFunctions(__tastyParseFunctions);
+		registerDefaultFunctions();
+	}
+	return __tastyParser;
+}
+const __tastyParseFunctions = {};
+function customFunction(name, fn) {
+	__tastyParseFunctions[name] = fn;
+	getOrCreateParser().setFunctions(__tastyParseFunctions);
+}
+function resetGlobalParseFunctions() {
+	for (const key of Object.keys(__tastyParseFunctions)) delete __tastyParseFunctions[key];
+	registerDefaultFunctions();
+	getOrCreateParser().setFunctions(__tastyParseFunctions);
+}
+function getGlobalParser() {
+	return getOrCreateParser();
+}
+function getGlobalParseFunctions() {
+	return __tastyParseFunctions;
+}
+let __globalPredefinedTokens = null;
+function setGlobalPredefinedTokens(tokens) {
+	const normalizedTokens = {};
+	for (const [key, value] of Object.entries(tokens)) {
+		const lowerKey = key.toLowerCase();
+		const lowerValue = value.toLowerCase();
+		if (lowerKey.startsWith("#") && lowerValue === "#current") {
+			console.warn(`[Tasty] Using #current to define color token "${key}" is not supported. The #current token represents currentcolor which cannot be used as a base for other tokens.`);
+			continue;
+		}
+		normalizedTokens[lowerKey] = value;
+	}
+	__globalPredefinedTokens = __globalPredefinedTokens ? {
+		...__globalPredefinedTokens,
+		...normalizedTokens
+	} : normalizedTokens;
+	getOrCreateParser().clearCache();
+}
+function getGlobalPredefinedTokens() {
+	return __globalPredefinedTokens;
+}
+function resetGlobalPredefinedTokens() {
+	__globalPredefinedTokens = null;
+	getOrCreateParser().clearCache();
+}
+function parseStyle(value) {
+	let str;
+	if (typeof value === "string") str = value;
+	else if (typeof value === "number") str = String(value);
+	else str = "";
+	return getOrCreateParser().process(str);
+}
+const RE_CUSTOM_PROPERTY_REF = /\$[a-zA-Z_$]/;
+function resolveCustomProperties(value) {
+	if (!RE_CUSTOM_PROPERTY_REF.test(value)) return value;
+	return parseStyle(value).output || value;
+}
+function parseColor(val, ignoreError = false) {
+	if (typeof val !== "string") val = String(val ?? "");
+	val = val.trim();
+	if (!val) return {};
+	const isSimpleColor = isSimpleColorFast(val);
+	let firstColor;
+	if (isSimpleColor) firstColor = val;
+	else {
+		const extractedColor = parseStyle(val).groups.find((g) => g.colors.length)?.colors[0];
+		if (!extractedColor) {
+			if (!ignoreError && colorWarningCount < MAX_COLOR_WARNINGS) {
+				console.warn("[Tasty] unable to parse color:", val);
+				colorWarningCount++;
+				if (colorWarningCount === MAX_COLOR_WARNINGS) console.warn("[Tasty] color parsing warnings will be suppressed from now on");
+			}
+			return {};
+		}
+		firstColor = extractedColor;
+	}
+	const faded = parseAlphaOverride(firstColor);
+	const baseColor = faded ? faded.color : firstColor;
+	const nameMatch = baseColor.match(COLOR_VAR_PATTERN);
+	let opacity;
+	if (faded) {
+		const { alpha } = faded;
+		const v = parseFloat(alpha);
+		if (!isNaN(v)) opacity = alpha.endsWith("%") ? v : v * 100;
+	} else if (baseColor.startsWith("rgb") || baseColor.startsWith("hsl") || baseColor.startsWith("lch") || baseColor.startsWith("oklch")) {
+		const alphaMatch = baseColor.match(RGB_ALPHA_PATTERN);
+		if (alphaMatch) {
+			const v = parseFloat(alphaMatch[1]);
+			if (!isNaN(v)) opacity = v * 100;
+		}
+	}
+	return {
+		color: firstColor,
+		name: nameMatch ? nameMatch[1] : void 0,
+		opacity
+	};
+}
+function filterMods(mods, allowedMods) {
+	const filtered = [];
+	for (const mod of mods) if (allowedMods.includes(mod)) filtered.push(mod);
+	return filtered;
+}
+const _innerCache = /* @__PURE__ */ new WeakMap();
+const _topLevelCache = /* @__PURE__ */ new WeakMap();
+function stringifyStyles(styles) {
+	if (styles == null || typeof styles !== "object") return "";
+	const cached = _topLevelCache.get(styles);
+	if (cached !== void 0) return cached;
+	const obj = styles;
+	const keys = Object.keys(obj).sort();
+	const parts = [];
+	for (const k of keys) {
+		const v = obj[k];
+		if (v === void 0 || typeof v === "function" || typeof v === "symbol") continue;
+		const c0 = k.charCodeAt(0);
+		const needsInnerSort = (c0 >= 65 && c0 <= 90 || c0 === 38) && v && typeof v === "object" && !Array.isArray(v);
+		let sv;
+		if (needsInnerSort) {
+			sv = _innerCache.get(v);
+			if (sv === void 0) {
+				const innerObj = v;
+				const innerKeys = Object.keys(innerObj).sort();
+				const innerParts = [];
+				for (const ik of innerKeys) {
+					const ivs = JSON.stringify(innerObj[ik]);
+					if (ivs !== void 0) innerParts.push(JSON.stringify(ik) + ":" + ivs);
+				}
+				sv = "{" + innerParts.join(",") + "}";
+				_innerCache.set(v, sv);
+			}
+		} else sv = JSON.stringify(v);
+		parts.push(JSON.stringify(k) + ":" + sv);
+	}
+	const result = "{" + parts.join(",") + "}";
+	_topLevelCache.set(styles, result);
+	return result;
+}
+//#endregion
+//#region src/utils/function-color.ts
+const RE_FUNC_NAME = /^([a-z][a-z0-9-]*)\s*\(/i;
+const RE_COLOR_OUT = /^(?:rgb|hsl|hwb|lab|lch|oklab|oklch|color)\(|^#|^var\(--/i;
+function resolveFunctionColor(str) {
+	const m = RE_FUNC_NAME.exec(str);
+	if (!m) return null;
+	const name = m[1].toLowerCase();
+	getGlobalParser();
+	if (!(name in getGlobalParseFunctions())) return null;
+	const out = getGlobalParser().process(str).output;
+	if (!out || !RE_COLOR_OUT.test(out)) return null;
+	return out;
+}
+//#endregion
+//#region src/utils/colors.ts
+function color(name, opacity = 1) {
+	if (opacity !== 1) return overrideColorAlpha(`var(--${name}-color)`, String(opacity));
+	return `var(--${name}-color)`;
+}
+//#endregion
+export { strToRgb as A, StyleParser as C, getRgbValuesFromRgbaString as D, getNamedColorHex as E, RE_RAW_UNIT as F, toSnakeCase as M, CSS_WIDE_KEYWORDS as N, hexToRgb as O, RE_NUMBER as P, createColorFunc as S, makeEmptyDetails as T, stringifyStyles as _, customFunction as a, okhslFunction as b, getGlobalParser as c, parseColor as d, parseStyle as f, setGlobalPredefinedTokens as g, resolveCustomProperties as h, DIRECTIONS as i, normalizeDslName as j, hslToRgbValues as k, getGlobalPredefinedTokens as l, resetGlobalPredefinedTokens as m, resolveFunctionColor as n, filterMods as o, resetGlobalParseFunctions as p, CUSTOM_UNITS as r, getGlobalParseFunctions as s, color as t, normalizeColorTokenValue as u, okhstFunction as v, Lru as w, okhslPlugin as x, okhstPlugin as y };
+
+//# sourceMappingURL=dsl-C5yuAn41.js.map