@barocss/kit 0.9.0 → 0.10.0

package/dist/index.js

@@ -1082,7 +1082,13 @@ function parseUtility(value, ctx) {
 //#region src/core/astToCss.ts
 var isSafePrelude = (text) => {
 	const t = String(text ?? "");
-	return !hasCommentDelimiter(t) && !hasHtmlEndTagOpener(t) && isBalancedPrelude(t);
+	return !hasCommentDelimiter(t) && !hasHtmlEndTagOpener(t) && isBalancedPrelude(t) && !/url\s*\(/i.test(t);
+};
+var uniqueDescriptors = (node) => {
+	if (node.type !== "at-rule") return [];
+	if (node.name !== "property") return node.nodes;
+	const seen = /* @__PURE__ */ new Set();
+	return node.nodes.filter((c) => c.type !== "decl" || !seen.has(c.prop) && !!seen.add(c.prop));
 };
 var isSafeDecl = (prop, value) => isStructureSafeValue(String(prop)) && isStructureSafeValue(String(value ?? "")) && !hasHtmlEndTagOpener(String(prop)) && !hasHtmlEndTagOpener(String(value ?? ""));
 var importantPrefix = "!important";
@@ -1178,10 +1184,10 @@ function rootToCss(nodes, opts) {
 			if (isSafeDecl(node.prop, node.value)) list.push(minify ? `${node.prop}:${node.value};` : `${node.prop}: ${node.value};`);
 		} else if (node.type === "at-rule" && isSafePrelude(node.name) && isSafePrelude(node.params)) {
 			if (minify) {
-				const body = node.nodes.filter((child) => child.type === "decl" && isSafeDecl(child.prop, child.value)).map((child) => child.type === "decl" ? `${child.prop}:${child.value};` : "").join("");
+				const body = uniqueDescriptors(node).filter((child) => child.type === "decl" && isSafeDecl(child.prop, child.value)).map((child) => child.type === "decl" ? `${child.prop}:${child.value};` : "").join("");
 				list.push(`@${node.name} ${node.params}{${body}}`);
 			} else list.push(`@${node.name} ${node.params} {
-${node.nodes.map((node) => {
+${uniqueDescriptors(node).map((node) => {
 				if (node.type === "decl" && isSafeDecl(node.prop, node.value)) return `\t${node.prop}: ${node.value};`;
 			}).join("\n")}
 }`);
@@ -1736,6 +1742,11 @@ function parseClassToAst(fullClassName, ctx) {
 				variantChain: modifiers,
 				index: i
 			});
+			if (result == null) {
+				debugWarn(`[BAROCSS] Unknown variant: "${variant.type}" in "${fullClassName}"`);
+				failures.add(fullClassName);
+				return [];
+			}
 			if (plugin.wrap && (result === "&" || typeof result === "object" && !Array.isArray(result) && result.selector === "&" || Array.isArray(result) && result.length === 1 && result[0].selector === "&")) continue;
 			if (typeof result === "string" && result.includes("&")) wrappers.push({
 				type: "rule",
@@ -1822,10 +1833,11 @@ function getAstCacheStats(ctx) {
 * @example
 *   const css = generateCss('sm:dark:hover:bg-red-500 sm:focus:bg-blue-500', ctx);
 */
+var CLASS_SEPARATOR = /[ \t\n\f\r]+/;
 function generateCss(classList, ctx, opts) {
 	const seen = /* @__PURE__ */ new Set();
 	const allAtRootNodes = [];
-	const results = classList.split(/\s+/).filter((cls) => {
+	const results = classList.split(CLASS_SEPARATOR).filter((cls) => {
 		if (!cls) return false;
 		if (opts?.dedup) {
 			if (seen.has(cls)) return false;
@@ -1885,7 +1897,7 @@ function generateCss(classList, ctx, opts) {
 */
 function generateCssRules(classList, ctx, opts) {
 	const seen = /* @__PURE__ */ new Set();
-	return classList.split(/\s+/).filter((cls) => {
+	return classList.split(CLASS_SEPARATOR).filter((cls) => {
 		if (!cls) return false;
 		if (opts?.dedup) {
 			if (seen.has(cls)) return false;
@@ -3124,6 +3136,7 @@ function jsonToAst(input, ctx) {
 					variantChain: [],
 					index: i
 				});
+				if (result == null) continue;
 				if (plugin.wrap && (result === "&" || typeof result === "object" && !Array.isArray(result) && result.selector === "&" || Array.isArray(result) && result.length === 1 && result[0].selector === "&")) {} else if (typeof result === "string" && result.includes("&")) wrappers.push({
 					type: "rule",
 					selector: result
@@ -7609,19 +7622,14 @@ staticModifier("after", ["&::after"], {
 	source: "pseudo",
 	astHandler: withPseudoContent
 });
-staticModifier("placeholder", [
-	"&::placeholder",
-	"&::-webkit-input-placeholder",
-	"&::-moz-placeholder",
-	"&:-ms-input-placeholder"
-], { source: "pseudo" });
-staticModifier("selection", ["&::selection", "&::-moz-selection"], { source: "pseudo" });
-staticModifier("file", ["&::file-selector-button", "&::-webkit-file-upload-button"], { source: "pseudo" });
+staticModifier("placeholder", ["&::placeholder"], { source: "pseudo" });
+staticModifier("selection", ["& *::selection", "&::selection"], { source: "pseudo" });
+staticModifier("file", ["&::file-selector-button"], { source: "pseudo" });
 staticModifier("marker", [
+	"& *::marker",
 	"&::marker",
-	"&::-webkit-details-marker",
-	"&::-moz-list-bullet",
-	"&::-moz-list-number"
+	"& *::-webkit-details-marker",
+	"&::-webkit-details-marker"
 ], { source: "pseudo" });
 staticModifier("details-content", ["&::details-content"], { source: "pseudo" });
 staticModifier("first-line", ["&::first-line"], { source: "pseudo" });
@@ -7679,7 +7687,9 @@ function attributeVariantSelector(variant) {
 		return `[${kind}-${key}=${/^(["']).*\1$/.test(raw) ? raw : `"${decodeArbitrarySelector(raw)}"`}]`;
 	}
 	const bare = /^data-([a-zA-Z0-9_-]+)$/.exec(variant);
-	return bare ? `[data-${bare[1]}]` : void 0;
+	if (bare) return `[data-${bare[1]}]`;
+	const aria = /^aria-([a-zA-Z0-9_-]+)$/.exec(variant);
+	return aria ? `[aria-${aria[1]}="true"]` : void 0;
 }
 /**
 * The argument of a `:has()`/`:not()` built from an arbitrary value: a selector list is wrapped as `*:is(…)`
@@ -7700,6 +7710,80 @@ function hasTopLevelComma(value) {
 	}
 	return false;
 }
+/**
+* #335: the pseudo-class selector (`:hover`, `:first-child`, `:nth-child(odd)`) of a registered static
+* variant, for compounding in not-/group-/peer-/has- forms, or null when the variant is unknown or is not a
+* single pseudo-class (pseudo-elements, at-rules, multi-selector variants). Tailwind 4.3.3 emits nothing
+* for a compound variant whose inner variant it cannot compound (`not-foo`, `group-before`, `peer-has-foo`).
+*/
+function pseudoClassOf(name, ctx) {
+	const plugin = getModifier(ctx).find((p) => p.name === name && p.match(name, ctx));
+	if (!plugin?.modifySelector) return null;
+	const r = plugin.modifySelector({
+		selector: "&",
+		fullClassName: "",
+		mod: { type: name },
+		context: ctx
+	});
+	const list = Array.isArray(r) ? r : r && typeof r === "object" ? [r] : typeof r === "string" ? [{ selector: r }] : [];
+	if (list.length !== 1) return null;
+	const m = /^&(:(?!:)[a-zA-Z-]+(?:\(.*\))?)$/.exec(list[0].selector);
+	return m ? m[1] : null;
+}
+/**
+* #352: the selector `not-<v>` / `group-not-<v>` negates: an attribute variant (`data-*`, `aria-*`), a
+* pseudo-class (#335), or a wrap-free `has-*` variant (`has-[…]`, `has-aria-*`), as Tailwind 4.3.3 compounds
+* them. Null when `<v>` is unknown or is not a single compound on `&`.
+*/
+function negatableSelectorOf(name, ctx) {
+	const attr = attributeVariantSelector(name);
+	if (attr) return attr;
+	const pc = pseudoClassOf(name, ctx);
+	if (pc || !name.startsWith("has-")) return pc;
+	const plugin = getModifier(ctx).find((p) => p.match(name, ctx));
+	if (!plugin?.modifySelector || plugin.wrap || plugin.astHandler) return null;
+	const r = plugin.modifySelector({
+		selector: "&",
+		fullClassName: "",
+		mod: { type: name },
+		context: ctx
+	});
+	const list = Array.isArray(r) ? r : r && typeof r === "object" ? [r] : typeof r === "string" ? [{ selector: r }] : [];
+	if (list.length !== 1) return null;
+	const m = /^&(:has\(.+\))$/.exec(list[0].selector);
+	return m && !m[1].includes("&") ? m[1] : null;
+}
+/**
+* #352: `not-<v>` for a wrap-only at-rule variant (`md`, `max-md`, `min-[…]`, `print`, `motion-safe`,
+* `supports-[…]`, `dark` in media mode): the same at-rule with its condition negated (`@media not (…)`,
+* `@supports not (…)`), as Tailwind 4.3.3 emits it. Null for anything else, and for a prelude that is a list
+* or already combines conditions, where a leading `not` would not negate the whole query.
+*/
+function negatedAtRuleOf(name, ctx) {
+	if (name.startsWith("not-")) return null;
+	const plugin = getModifier(ctx).find((p) => p.match(name, ctx));
+	if (!plugin?.wrap || plugin.astHandler) return null;
+	if (plugin.modifySelector) {
+		const r = plugin.modifySelector({
+			selector: "&",
+			fullClassName: "",
+			mod: { type: name },
+			context: ctx
+		});
+		if ((typeof r === "string" ? r : Array.isArray(r) ? r.length === 1 ? r[0].selector : null : r?.selector) !== "&") return null;
+	}
+	const items = plugin.wrap({ type: name }, ctx);
+	if (items.length !== 1) return null;
+	const node = items[0];
+	if (node.type !== "at-rule" || node.name !== "media" && node.name !== "supports" || node.nodes?.length) return null;
+	const params = (node.params ?? "").trim();
+	if (!params || /^not\b|,|\s(and|or)\s/i.test(params)) return null;
+	return {
+		...node,
+		params: `not ${params}`,
+		nodes: []
+	};
+}
 //#endregion
 //#region src/presets/variants/responsive.ts
 functionalModifier((mod, context) => {
@@ -7850,6 +7934,7 @@ function innerCompound(variant, ctx) {
 		mod: { type: variant },
 		context: ctx
 	});
+	if (out == null) return void 0;
 	const list = typeof out === "string" ? [{ selector: out }] : Array.isArray(out) ? out : [out];
 	if (list.length !== 1) return void 0;
 	const sel = list[0].selector;
@@ -7944,6 +8029,10 @@ functionalModifier((mod, ctx) => {
 }, groupHasSelector);
 //#endregion
 //#region src/presets/variants/negation-variants.ts
+functionalModifier((mod, context) => /^not-(?!@)/.test(mod) && !!negatedAtRuleOf(mod.slice(4), context), () => "&", (mod, context) => {
+	const node = negatedAtRuleOf(mod.type.slice(4), context);
+	return node ? [node] : [];
+});
 functionalModifier((mod) => /^not-\[.*\]$/.test(mod), ({ selector, mod }) => {
 	const m = /^not-\[(.+)\]$/.exec(mod.type);
 	if (m) {
@@ -7965,10 +8054,12 @@ functionalModifier((mod) => /^not-\[.*\]$/.test(mod), ({ selector, mod }) => {
 		source: "attribute"
 	};
 });
-functionalModifier((mod) => /^not-/.test(mod) && !mod.startsWith("not-@"), ({ selector, mod }) => {
+functionalModifier((mod) => /^not-/.test(mod) && !mod.startsWith("not-@"), ({ selector, mod, context }) => {
 	const m = /^not-(.+)$/.exec(mod.type);
+	const inner = m ? negatableSelectorOf(m[1], context) : null;
+	if (m && !inner) return null;
 	return {
-		selector: m ? `&:not(:${m[1]})` : selector,
+		selector: inner ? `&:not(${inner})` : selector,
 		flatten: false,
 		wrappingType: "rule",
 		source: "attribute"
@@ -8028,7 +8119,7 @@ functionalModifier((mod) => /^aria-/.test(mod), ({ selector, mod }) => {
 		source: "aria"
 	};
 }, void 0);
-functionalModifier((mod) => mod.startsWith("not-") && !mod.startsWith("not-@"), ({ selector, mod }) => {
+functionalModifier((mod) => mod.startsWith("not-") && !mod.startsWith("not-@"), ({ selector, mod, context }) => {
 	const pseudo = mod.type.replace("not-", "");
 	if (pseudo.startsWith("[")) {
 		const inner = pseudo.slice(1, -1);
@@ -8040,10 +8131,14 @@ functionalModifier((mod) => mod.startsWith("not-") && !mod.startsWith("not-@"),
 			selector: `&:not(${functionalArgument(inner)})`,
 			source: "attribute"
 		};
-	} else return {
-		selector: `&:not(:${pseudo})`,
-		source: "attribute"
-	};
+	} else {
+		const inner = negatableSelectorOf(pseudo, context);
+		if (!inner) return null;
+		return {
+			selector: `&:not(${inner})`,
+			source: "attribute"
+		};
+	}
 }, void 0);
 functionalModifier((mod) => /^data-/.test(mod), ({ selector, mod }) => {
 	const bracket = /^data-\[([a-zA-Z0-9_-]+)(?:=([^\]]+))?\]$/.exec(mod.type);
@@ -8156,11 +8251,13 @@ functionalModifier((mod) => /^(group|peer)-hover(\/[a-zA-Z0-9_-]+)?$/.test(mod),
 		source: kind
 	};
 }, () => [atRule("media", "(hover: hover)", [])]);
-function negated(value) {
+function negated(value, ctx) {
 	const v = value.slice(4);
-	return v.startsWith("[") && v.endsWith("]") ? `:not(*:is(${decodeArbitrarySelector(v.slice(1, -1))}))` : `:not(:${v})`;
+	if (v.startsWith("[") && v.endsWith("]")) return `:not(*:is(${decodeArbitrarySelector(v.slice(1, -1))}))`;
+	const inner = negatableSelectorOf(v, ctx);
+	return inner ? `:not(${inner})` : null;
 }
-functionalModifier((mod) => /^group-(.+)$/.test(mod) && !atRuleHas(mod), ({ selector, mod }) => {
+functionalModifier((mod) => /^group-(.+)$/.test(mod) && !atRuleHas(mod), ({ selector, mod, context }) => {
 	const raw = /^group-(.+)$/.exec(mod.type);
 	const [variant, base] = splitGroupName("group", raw?.[1] ?? "");
 	const m = raw ? [raw[0], variant] : null;
@@ -8176,11 +8273,14 @@ functionalModifier((mod) => /^group-(.+)$/.test(mod) && !atRuleHas(mod), ({ sele
 		wrappingType: "rule",
 		source: "group"
 	};
-	if (m?.[1]?.startsWith("not-")) return {
-		selector: `&:is(${g}${negated(m[1])} *)`,
-		wrappingType: "rule",
-		source: "group"
-	};
+	if (m?.[1]?.startsWith("not-")) {
+		const neg = negated(m[1], context);
+		return neg ? {
+			selector: `&:is(${g}${neg} *)`,
+			wrappingType: "rule",
+			source: "group"
+		} : null;
+	}
 	if (m?.[1]?.startsWith("has-")) {
 		const pattern = /^has-\[([a-zA-Z0-9_-]+)\]$/.exec(m?.[1]);
 		if (pattern) return {
@@ -8206,8 +8306,10 @@ functionalModifier((mod) => /^group-(.+)$/.test(mod) && !atRuleHas(mod), ({ sele
 			};
 		}
 	}
+	const pc = m ? pseudoClassOf(m[1], context) : null;
+	if (m && !pc) return null;
 	return m ? {
-		selector: `&:is(${g}:${m[1]} *)`,
+		selector: `&:is(${g}${pc} *)`,
 		wrappingType: "rule",
 		source: "group"
 	} : {
@@ -8215,7 +8317,7 @@ functionalModifier((mod) => /^group-(.+)$/.test(mod) && !atRuleHas(mod), ({ sele
 		source: "group"
 	};
 }, void 0);
-functionalModifier((mod) => /^peer-(.+)$/.test(mod) && !atRuleHas(mod), ({ selector, mod }) => {
+functionalModifier((mod) => /^peer-(.+)$/.test(mod) && !atRuleHas(mod), ({ selector, mod, context }) => {
 	const raw = /^peer-(.+)$/.exec(mod.type);
 	const [variant, base] = splitGroupName("peer", raw?.[1] ?? "");
 	const m = raw ? [raw[0], variant] : null;
@@ -8236,14 +8338,22 @@ functionalModifier((mod) => /^peer-(.+)$/.test(mod) && !atRuleHas(mod), ({ selec
 		selector: `&:is(${g}:has(${functionalArgument(value.slice(5, -1))}) ~ *)`,
 		source: "peer"
 	};
-	if (value?.startsWith("has-")) return {
-		selector: `&:is(${g}:has(:${value.slice(4)})~*)`,
-		source: "peer"
-	};
-	if (value?.startsWith("not-")) return {
-		selector: `&:is(${g}${negated(value)} ~ *)`,
-		source: "peer"
-	};
+	if (value?.startsWith("has-")) {
+		const pc = pseudoClassOf(value.slice(4), context);
+		if (!pc) return null;
+		return {
+			selector: `&:is(${g}:has(${pc})~*)`,
+			source: "peer"
+		};
+	}
+	if (value?.startsWith("not-")) {
+		const neg = negated(value, context);
+		if (!neg) return null;
+		return {
+			selector: `&:is(${g}${neg} ~ *)`,
+			source: "peer"
+		};
+	}
 	if (value?.startsWith("aria-")) {
 		let pattern = /^aria-([a-zA-Z0-9_]+)$/.exec(value);
 		if (pattern) return {
@@ -8264,8 +8374,10 @@ functionalModifier((mod) => /^peer-(.+)$/.test(mod) && !atRuleHas(mod), ({ selec
 			};
 		}
 	}
+	const pc = m ? pseudoClassOf(value, context) : null;
+	if (m && !pc) return null;
 	return m ? {
-		selector: `&:is(${g}:${value}~*)`,
+		selector: `&:is(${g}${pc}~*)`,
 		source: "peer"
 	} : {
 		selector,
@@ -8314,6 +8426,7 @@ function toPx(n, unit) {
 }
 function preludeKey(kind, prelude) {
 	const container = kind === "container";
+	if (!container && /^\s*not\b/i.test(prelude)) return [0, 0];
 	const min = MIN_W.exec(prelude);
 	if (min) return [container ? 4 : 2, toPx(min[1], min[2])];
 	const max = MAX_W.exec(prelude);