cssints 0.0.0-stage → 0.2.0

package/dist/derived.mjs

@@ -0,0 +1,391 @@
+//#region src/derived.ts
+/** The custom property of :root that carries the data (derived-data.ts writes it). */
+const KEY = "--_derived";
+const mul = (m, v) => [
+	0,
+	3,
+	6
+].map((r) => v.reduce((s, x, k) => s + m[r + k] * x, 0));
+const lin = (c) => {
+	const a = Math.abs(c);
+	return (a <= .04045 ? a / 12.92 : ((a + .055) / 1.055) ** 2.4) * Math.sign(c);
+};
+const gam = (c) => {
+	const a = Math.abs(c);
+	return (a <= .0031308 ? a * 12.92 : 1.055 * a ** (1 / 2.4) - .055) * Math.sign(c);
+};
+const rad = Math.PI / 180;
+const rect = ([l, c, h]) => [
+	l,
+	c * Math.cos(h * rad),
+	c * Math.sin(h * rad)
+];
+const polar = ([l, a, b]) => {
+	const h = Math.atan2(b, a) / rad;
+	return [
+		l,
+		Math.hypot(a, b),
+		h < 0 ? h + 360 : h
+	];
+};
+const LMS = [
+	.4122214708,
+	.5363325363,
+	.0514459929,
+	.2119034982,
+	.6806995451,
+	.1073969566,
+	.0883024619,
+	.2817188376,
+	.6299787005
+];
+const OK = [
+	.2104542553,
+	.793617785,
+	-.0040720468,
+	1.9779984951,
+	-2.428592205,
+	.4505937099,
+	.0259040371,
+	.7827717662,
+	-.808675766
+];
+const LMS_I = [
+	4.0767416621,
+	-3.3077115913,
+	.2309699292,
+	-1.2684380046,
+	2.6097574011,
+	-.3413193965,
+	-.0041960863,
+	-.7034186147,
+	1.707614701
+];
+const OK_I = [
+	1,
+	.3963377774,
+	.2158037573,
+	1,
+	-.1055613458,
+	-.0638541728,
+	1,
+	-.0894841775,
+	-1.291485548
+];
+const XYZ = [
+	.436065743,
+	.385151469,
+	.143078454,
+	.222493192,
+	.716887054,
+	.0606197905,
+	.0139239045,
+	.0970812857,
+	.714099358
+];
+const XYZ_I = [
+	3.13413576,
+	-1.61738568,
+	-.49066242,
+	-.978795456,
+	1.91625419,
+	.0334429841,
+	.071955413,
+	-.228976675,
+	1.40538601
+];
+const D50 = [
+	.9642956764295677,
+	1,
+	.8251046025104602
+];
+const E = 216 / 24389;
+const K = 24389 / 27;
+const to = {
+	"srgb-linear": (c) => c,
+	srgb: (c) => c.map(lin),
+	oklab: (c) => mul(LMS_I, mul(OK_I, c).map((v) => v ** 3)),
+	oklch: (c) => to.oklab(rect(c)),
+	lab: ([l, a, b]) => {
+		const y = (l + 16) / 116;
+		const f = [
+			a / 500 + y,
+			y,
+			y - b / 200
+		];
+		return mul(XYZ_I, f.map((v, i) => D50[i] * (v ** 3 > E ? v ** 3 : (116 * v - 16) / K)));
+	}
+};
+const from = {
+	"srgb-linear": (c) => c,
+	srgb: (c) => c.map(gam),
+	oklab: (c) => mul(OK, mul(LMS, c).map(Math.cbrt)),
+	oklch: (c) => polar(from.oklab(c)),
+	lab: (c) => {
+		const f = mul(XYZ, c).map((v, i) => {
+			const x = v / D50[i];
+			return x > E ? Math.cbrt(x) : (K * x + 16) / 116;
+		});
+		return [
+			116 * f[1] - 16,
+			500 * (f[0] - f[1]),
+			200 * (f[1] - f[2])
+		];
+	}
+};
+const conv = (c, s) => c.s === s ? c : {
+	s,
+	c: from[s](to[c.s](c.c)),
+	a: c.a
+};
+const SPEC = {
+	srgb: ["rgb", [
+		1,
+		1,
+		1
+	]],
+	"srgb-linear": ["rgb", [
+		1,
+		1,
+		1
+	]],
+	oklab: ["lab", [
+		1,
+		.4,
+		.4
+	]],
+	oklch: ["lch", [
+		1,
+		.4,
+		360
+	]],
+	lab: ["lab", [
+		100,
+		125,
+		125
+	]]
+};
+const NAMED = {
+	black: "#000",
+	white: "#fff",
+	transparent: "#0000"
+};
+const TOKEN = /[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?(?:%|deg)?|#\w+|(?:--|-?)[a-z_][\w-]*|[^\s]/gi;
+const fail = (x) => {
+	throw new Error(x);
+};
+const hex = (x) => {
+	const h = x.slice(1);
+	if (![
+		3,
+		4,
+		6,
+		8
+	].includes(h.length) || /[^\da-f]/i.test(h)) return fail(x);
+	const n = h.length < 5 ? h.replace(/./g, "$&$&") : h;
+	const byte = (i) => parseInt(n.slice(i, i + 2), 16) / 255;
+	return {
+		s: "srgb",
+		c: [
+			byte(0),
+			byte(2),
+			byte(4)
+		],
+		a: n.length > 6 ? byte(6) : 1
+	};
+};
+const evaluate = (text, get = (n) => fail(n)) => {
+	const t = text.match(TOKEN) ?? [];
+	let i = 0;
+	let pct = 1;
+	let env = {};
+	const next = () => t[i++] ?? fail(t[i - 2]);
+	const want = (s) => {
+		if (next() !== s) fail(t[i - 1]);
+	};
+	const input = () => {
+		want("(");
+		const v = get(next());
+		want(")");
+		return v;
+	};
+	const list = () => {
+		want("(");
+		const out = [sum()];
+		while (t[i] === ",") {
+			i++;
+			out.push(sum());
+		}
+		want(")");
+		return out;
+	};
+	const atom = () => {
+		const x = next();
+		if (/^[+-]?[\d.]/.test(x)) return parseFloat(x) * (x.endsWith("%") ? pct / 100 : 1);
+		if (x === "(") {
+			const v = sum();
+			want(")");
+			return v;
+		}
+		if (x === "calc") return atom();
+		if (x === "-") return -atom();
+		if (x === "clamp") {
+			const [lo, v, hi] = list();
+			return Math.max(lo, Math.min(v, hi));
+		}
+		if (x === "min") return Math.min(...list());
+		if (x === "max") return Math.max(...list());
+		if (x === "var") {
+			const v = input();
+			return typeof v === "string" && v ? Number(v) : fail(x);
+		}
+		if (x === "none") return 0;
+		return Object.hasOwn(env, x) ? env[x] : fail(x);
+	};
+	const prod = () => {
+		let v = atom();
+		for (let o = t[i]; o === "*" || o === "/"; o = t[i]) {
+			i++;
+			v = o === "*" ? v * atom() : v / atom();
+		}
+		return v;
+	};
+	const sum = () => {
+		let v = prod();
+		for (let o = t[i]; o === "+" || o === "-"; o = t[i]) {
+			i++;
+			v += o === "+" ? prod() : -prod();
+		}
+		return v;
+	};
+	const fn = (f) => {
+		want("(");
+		const origin = t[i] === "from" ? (i++, col()) : void 0;
+		const space = f === "color" ? next() : f === "rgb" || f === "rgba" ? "srgb" : f;
+		if (!Object.hasOwn(SPEC, space)) return fail(f === "color" ? space : f);
+		const [names, base] = SPEC[space];
+		const k = f[0] === "r" ? 255 : 1;
+		const src = origin && conv(origin, space);
+		env = src ? {
+			alpha: src.a,
+			...Object.fromEntries([...names].map((n, j) => [n, src.c[j] * k]))
+		} : {};
+		const c = base.map((b, j) => {
+			if (j && t[i] === ",") i++;
+			pct = b * k;
+			return atom() / k;
+		});
+		let a = 1;
+		if (t[i] === "/" || t[i] === ",") {
+			i++;
+			pct = 1;
+			a = Math.min(1, Math.max(0, atom()));
+		}
+		want(")");
+		return {
+			s: space,
+			c,
+			a
+		};
+	};
+	const mix = () => {
+		want("(");
+		want("in");
+		const s = next();
+		if (s === "oklch" || !Object.hasOwn(SPEC, s)) return fail(s);
+		want(",");
+		const one = () => {
+			return [conv(col(), s), t[i]?.endsWith("%") ? parseFloat(next()) : void 0];
+		};
+		const [a, p] = one();
+		want(",");
+		const [b, q] = one();
+		want(")");
+		const x = p ?? 100 - (q ?? 50);
+		const y = q ?? 100 - x;
+		if (x + y !== 100) return fail("color-mix");
+		const al = (a.a * x + b.a * y) / 100;
+		return {
+			s,
+			c: a.c.map((v, j) => al ? (v * a.a * x + b.c[j] * b.a * y) / 100 / al : 0),
+			a: al
+		};
+	};
+	const col = () => {
+		const x = next();
+		if (x.startsWith("#")) return hex(x);
+		if (NAMED[x]) return hex(NAMED[x]);
+		if (x === "var") {
+			const v = input();
+			return typeof v === "string" ? evaluate(v, get) : v;
+		}
+		return x === "color-mix" ? mix() : fn(x);
+	};
+	const out = col();
+	if (i < t.length) fail(t[i]);
+	return out;
+};
+const css = (c) => {
+	const [r, g, b] = conv(c, "srgb").c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255));
+	return `rgb(${r} ${g} ${b}${c.a < 1 ? ` / ${+c.a.toFixed(3)}` : ""})`;
+};
+var derived_default = () => {
+	if (typeof document === "undefined") return;
+	const root = document.documentElement;
+	const cs = getComputedStyle(root);
+	const written = /* @__PURE__ */ new Map();
+	let observer;
+	let raw = "";
+	let data;
+	let names;
+	const read = () => {
+		const v = cs.getPropertyValue(KEY).trim();
+		if (!v || v === raw) return !!v;
+		raw = v;
+		data = JSON.parse(v.slice(1, -1).replace(/\\(.)/g, "$1"));
+		names = [.../* @__PURE__ */ new Set([...Object.keys(data.b), ...data.t.flatMap(([, x]) => Object.keys(x))])];
+		return true;
+	};
+	const update = () => {
+		read();
+		const tpl = new Map(Object.entries(data.b));
+		for (const [cond, v] of data.t) if (cond.startsWith("@") ? matchMedia(cond.slice(6)).matches : root.matches(cond)) for (const n in v) if (v[n]) tpl.set(n, v[n]);
+		else tpl.delete(n);
+		for (const n of names) if (!tpl.has(n) && written.delete(n)) root.style.removeProperty(n);
+		const done = /* @__PURE__ */ new Map();
+		const get = (n) => {
+			let v = done.get(n);
+			if (v === void 0) {
+				const t = tpl.get(n);
+				done.set(n, v = t === void 0 ? cs.getPropertyValue(n).trim() || fail(n) : evaluate(t, get));
+			}
+			return v;
+		};
+		const next = [...tpl.keys()].map((n) => {
+			try {
+				return [n, css(get(n))];
+			} catch {
+				return [n, void 0];
+			}
+		});
+		for (const [n, v] of next) if (v === void 0) {
+			if (written.delete(n)) root.style.removeProperty(n);
+		} else if (written.get(n) !== v) {
+			written.set(n, v);
+			root.style.setProperty(n, v);
+		}
+		observer.takeRecords();
+	};
+	const go = () => {
+		if (!read()) return false;
+		if (data.p.every((p) => CSS.supports("color", p))) return true;
+		observer = new MutationObserver(update);
+		observer.observe(root, { attributes: true });
+		for (const [cond] of data.t) if (cond.startsWith("@")) matchMedia(cond.slice(6)).addEventListener("change", update);
+		update();
+		return true;
+	};
+	if (!go()) addEventListener("load", go, { once: true });
+};
+//#endregion
+export { KEY, css, derived_default as default, evaluate };

package/dist/errors-D4ZbcwRo.d.mts

@@ -0,0 +1,32 @@
+//#region src/errors.d.ts
+declare const MacroError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "MacroError";
+} & Readonly<A>;
+/** A css.* call, cv(), or a value in it is wrong. `file`, `site` (index) and `offset` name the call site, when known. */
+declare class MacroError extends MacroError_base<{
+  readonly message: string;
+  readonly file?: string;
+  readonly site?: number;
+  readonly offset?: number;
+  readonly cause?: unknown;
+}> {}
+declare const ImportError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ImportError";
+} & Readonly<A>;
+/** `import ... from "cssints"` without the attribute names something that only exists at build time. */
+declare class ImportError extends ImportError_base<{
+  readonly message: string;
+  readonly file: string;
+  readonly offset: number;
+}> {}
+declare const ContrastError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ContrastError";
+} & Readonly<A>;
+/** cssints/check `contrast`: a colour that has no contrast (one it cannot read, or a translucent one). */
+declare class ContrastError extends ContrastError_base<{
+  readonly message: string;
+  /** The colour as given. */
+  readonly colour: string;
+}> {}
+//#endregion
+export { ImportError as n, MacroError as r, ContrastError as t };

package/dist/frame-BoBKjgBB.mjs

@@ -0,0 +1,92 @@
+import { scope } from "cssints/plugin";
+//#region src/frame.ts
+const registered = (names) => names.map((n) => `@property --_${n} { syntax: "<length>"; inherits: false; initial-value: 0px; }`).join("\n");
+const inner = "max(var(--_x) - var(--_p) - var(--_b), 0px)";
+const outer = (parent) => `max(var(${parent}, calc(var(--_r) + var(--_m))) - var(--_m), 0px)`;
+const css = `
+& {
+  padding: var(--_p);
+  margin: var(--_m);
+  border: var(--_b) solid;
+  border-radius: var(--_x);
+}
+@container (style(--_c: e)) or (not style(--_c)) {
+  & { --_c: o; --_x: ${outer("--_e")}; --_o: ${inner}; }
+}
+@container style(--_c: o) {
+  & { --_c: e; --_x: ${outer("--_o")}; --_e: ${inner}; }
+}`;
+const fallback = `
+:root[data-cssints-poly] & {
+  --_u: calc(var(--_r) + var(--_m));
+  --_i: max(max(var(--_u) - var(--_m), 0px) - var(--_p) - var(--_b), 0px);
+  --_t: var(--_i);
+  border-radius: max(var(--_u) - var(--_m), 0px);
+  transition: --_t 1ms;
+}`;
+const length = "<length [0,∞]>";
+/**
+* `frame().radius(t.radius.lg).padding(4).border("1px").margin(2)`: a box whose radius follows from the frames around it
+* (`radius` is the radius of the outermost frame; inside, it is the parent's inner radius less the margin). `padding` and
+* `margin` take a step of the spacing scale; each method once. It stands for `padding`, `margin`, `border-radius` and the
+* border widths and styles, so mixing it with them in one `cn()` is a build error (border colours are fine).
+*/
+const frameScope = scope("frame", {
+	core: {
+		css,
+		atProperty: registered([
+			"r",
+			"p",
+			"b",
+			"m",
+			"u",
+			"i",
+			"t"
+		]),
+		requires: ["css.at-rules.property", "css.types.max"]
+	},
+	fallback: {
+		polyfills: ["css.at-rules.container.style_queries_for_custom_properties"],
+		parentVars: [{
+			marker: "&",
+			read: "--_i",
+			write: "--_u",
+			watch: "--_t"
+		}],
+		css: fallback
+	},
+	noBox: {
+		props: [/^(padding|margin)(-|$)/, /^border(?!.*color)/],
+		message: "frame() sets padding, margin, border-radius and the border: use its methods"
+	},
+	frame: {
+		uses: [
+			"core",
+			"fallback",
+			"noBox"
+		],
+		chain: {
+			radius: {
+				args: length,
+				emit: (v) => [["--_r", v]]
+			},
+			padding: {
+				args: length,
+				spacing: true,
+				emit: (v) => [["--_p", v]]
+			},
+			border: {
+				args: length,
+				emit: (v) => [["--_b", v]]
+			},
+			margin: {
+				args: "<length>",
+				spacing: true,
+				emit: (v) => [["--_m", v]]
+			}
+		}
+	}
+});
+const { frame } = frameScope.export();
+//#endregion
+export { frameScope as n, frame as t };

package/dist/frame.d.mts

@@ -0,0 +1,72 @@
+//#region src/frame.d.ts
+/**
+ * `frame().radius(t.radius.lg).padding(4).border("1px").margin(2)`: a box whose radius follows from the frames around it
+ * (`radius` is the radius of the outermost frame; inside, it is the parent's inner radius less the margin). `padding` and
+ * `margin` take a step of the spacing scale; each method once. It stands for `padding`, `margin`, `border-radius` and the
+ * border widths and styles, so mixing it with them in one `cn()` is a build error (border colours are fine).
+ */
+export declare const frameScope: import("cssints/plugin").Scope<"frame", {
+  readonly core: {
+    readonly css: string;
+    readonly atProperty: string;
+    readonly requires: ["css.at-rules.property", "css.types.max"];
+  };
+  readonly fallback: {
+    readonly polyfills: ["css.at-rules.container.style_queries_for_custom_properties"];
+    readonly parentVars: [{
+      readonly marker: "&";
+      readonly read: "--_i";
+      readonly write: "--_u";
+      readonly watch: "--_t";
+    }];
+    readonly css: "\n:root[data-cssints-poly] & {\n  --_u: calc(var(--_r) + var(--_m));\n  --_i: max(max(var(--_u) - var(--_m), 0px) - var(--_p) - var(--_b), 0px);\n  --_t: var(--_i);\n  border-radius: max(var(--_u) - var(--_m), 0px);\n  transition: --_t 1ms;\n}";
+  };
+  readonly noBox: {
+    readonly props: [RegExp, RegExp];
+    readonly message: "frame() sets padding, margin, border-radius and the border: use its methods";
+  };
+  readonly frame: {
+    readonly uses: readonly ["core", "fallback", "noBox"];
+    readonly chain: {
+      readonly radius: {
+        readonly args: "<length [0,∞]>";
+        readonly emit: (v: string) => [string, string][];
+      };
+      readonly padding: {
+        readonly args: "<length [0,∞]>";
+        readonly spacing: true;
+        readonly emit: (v: string) => [string, string][];
+      };
+      readonly border: {
+        readonly args: "<length [0,∞]>";
+        readonly emit: (v: string) => [string, string][];
+      };
+      readonly margin: {
+        readonly args: "<length>";
+        readonly spacing: true;
+        readonly emit: (v: string) => [string, string][];
+      };
+    };
+  };
+}>;
+export declare const frame: () => import("cssints/plugin").Chain<"frame", {
+  readonly radius: {
+    readonly args: "<length [0,∞]>";
+    readonly emit: (v: string) => [string, string][];
+  };
+  readonly padding: {
+    readonly args: "<length [0,∞]>";
+    readonly spacing: true;
+    readonly emit: (v: string) => [string, string][];
+  };
+  readonly border: {
+    readonly args: "<length [0,∞]>";
+    readonly emit: (v: string) => [string, string][];
+  };
+  readonly margin: {
+    readonly args: "<length>";
+    readonly spacing: true;
+    readonly emit: (v: string) => [string, string][];
+  };
+}, {}>;
+//#endregion

package/dist/frame.mjs

@@ -0,0 +1,2 @@
+import { n as frameScope, t as frame } from "./frame-BoBKjgBB.mjs";
+export { frame, frameScope };

package/dist/group-common-9zpBxfUF.d.mts

@@ -0,0 +1 @@
+import "./theme-types-Bqv0Ggz_.mjs";

package/dist/group-types-9ttphdku.d.mts

@@ -0,0 +1,55 @@
+import { $p as Fn, Qp as CheckMath, Xp as Arg, Zp as CheckFn, am as Fallback, cm as Text, em as Result, om as Part, rm as Check, sm as Style, tm as Text$1 } from "./theme-types-Bqv0Ggz_.mjs";
+import { properties } from "@cssints/css-grammar/mdn";
+import { CSSStyleValue } from "@cssints/css-grammar/values";
+import { QueryKind, ValidQuery } from "@cssints/css-grammar/query";
+//#region src/group-types.d.ts
+/**
+ * What a group bans. `kw`: by property, its keywords, and `name(` for a function only that property has; `fn`: functions
+ * (anywhere); `unit`; `media`, `container`, `supports`: the words of a query (`scroll-state(`).
+ */
+interface Ban {
+  id: string;
+  kw: Record<string, string>;
+  fn: string;
+  unit: string;
+  media: string;
+  container: string;
+  supports: string;
+}
+type Sep = " " | "," | ")" | "/" | ":" | ";" | '"' | "'" | "<" | ">" | "=" | "+" | "*" | "[" | "]" | "{" | "}" | "!" | "#" | "%" | "." | "⟨" | "⟩" | "&" | "|" | "\n" | "\t";
+type Words<S extends string, W extends string = "", Acc extends string = never> = S extends `${infer C}${infer R}` ? C extends "(" ? Words<R, "", Acc | (W extends "" ? never : `${W}(`)> : C extends Sep ? Words<R, "", Acc | W> : Words<R, `${W}${C}`, Acc> : Acc | W;
+type Banned<B extends Ban, K extends string> = K | `${B["fn"]}(` | `${number}${B["unit"]}`;
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type Seen<B extends Ban, K extends string> = K | `${B["fn"]}(` | `${Digit}${B["unit"]}`;
+type Hit<B extends Ban, K extends string, S extends string> = S extends `${string}${Seen<B, K>}${string}` ? Extract<Words<S>, Banned<B, K>> : never;
+type Said<T extends string> = T extends `${infer N}(` ? `${N}()` : T;
+type Msg<B extends Ban, L extends string, T extends string> = `${L}: "${Said<T>}" is not in cssints/${B["id"]}`;
+type KwOf<B extends Ban, P extends string> = P extends keyof B["kw"] ? B["kw"][P] : never;
+type Same<A, C> = [A] extends [C] ? ([C] extends [A] ? true : false) : false;
+type PartText<P> = P extends Fallback<infer V> ? Text<V[number]> : Text<P>;
+type Scan<B extends Ban, K extends string, L extends string, A extends readonly Part[]> = { [I in keyof A]: Hit<B, K, PartText<A[I]>> extends (infer T extends string) ? [T] extends [never] ? A[I] : Msg<B, L, T> : never; };
+type Narrow<B extends Ban, P extends string, A extends readonly Part[], C> = Same<A, C> extends true ? Scan<B, KwOf<B, P>, P, A> : C;
+/** A property of a group: `Prop` of types.ts, with the group's banned words refused. */
+type GProp<B extends Ban, P extends keyof typeof properties, R = Style> = <const A extends readonly Part[]>(...parts: Narrow<B, P, A, Check<P, A>>) => R;
+/** `flex` and `grid` of a group: `M` holds the chain methods whose property the group has. */
+interface GLayout<B extends Ban, P extends "flex" | "grid", M extends Record<string, keyof typeof properties>> {
+  (): GChain<B, M>;
+  <const A extends readonly Part[]>(...parts: Narrow<B, P, A, Check<P, A>>): Style;
+}
+type GChain<B extends Ban, M extends Record<string, keyof typeof properties>> = Style & { readonly [K in keyof M]: GProp<B, M[K], GChain<B, M>>; };
+type ScanArgs<B extends Ban, L extends string, A extends readonly Arg[]> = { [I in keyof A]: Hit<B, never, Text$1<A[I]>> extends (infer T extends string) ? [T] extends [never] ? A[I] : Msg<B, L, T> : never; };
+type NarrowFn<B extends Ban, L extends string, A extends readonly Arg[], C> = Same<A, C> extends true ? ScanArgs<B, L, A> : C;
+/** A css function of a group (`oklch`, `linearGradient`): `Fn` of function-types.ts, its arguments read for banned words. */
+type GFn<B extends Ban, N extends string, Sep extends string> = <const A extends readonly Arg[]>(...parts: NarrowFn<B, `${N}()`, A, CheckFn<N, Sep, A>>) => ReturnType<Fn<N, Sep>>;
+/** A math function of a group (`calc`, `min`). */
+type GMath<B extends Ban, C extends "same" | "number" | "angle"> = <const A extends readonly Arg[]>(...parts: NarrowFn<B, "calc()", A, CheckMath<A>>) => CSSStyleValue<Result<C, A>>;
+type Query<B extends Ban, K extends QueryKind> = K extends "media" ? B["media"] : K extends "container" ? B["container"] : B["supports"];
+type GQ<B extends Ban, K extends QueryKind, Q extends string> = ValidQuery<K, Q> extends (infer V) ? [V] extends [Q] ? Hit<B, Query<B, K>, Q> extends (infer T extends string) ? [T] extends [never] ? Q : Msg<B, `@${K}`, T> : never : V : never;
+/** `media`, `container` and `supports` of a group: `Condition` of css-grammar's query.ts, the media features it bans refused. */
+interface GCondition<B extends Ban, K extends QueryKind, R> {
+  <const O extends Record<string, string>>(queries: { [P in keyof O]: GQ<B, K, O[P]>; }): { [P in keyof O]: R; };
+  <const Q extends readonly [string, string, ...string[]]>(...queries: { [I in keyof Q]: GQ<B, K, Q[I]>; }): { [I in keyof Q]: R; };
+  <const Q extends string>(query: GQ<B, K, Q>): R;
+}
+//#endregion
+export { GProp as a, GMath as i, GFn as n, GLayout as r, GCondition as t };

package/dist/groups/compositing-2.d.mts

@@ -0,0 +1,20 @@
+import { A as Wrap, C as Keyframes, D as QueryWrap, F as cv, H as style, I as firstThatWorks, K as within, L as global, M as cn, O as StateWrap, R as group, S as CvValue, T as PositionTry, W as token, _ as CSSStyleValue, a as DtcgUnit, am as Fallback, b as CvConfig, c as Tokens, d as createTokens, f as layers, g as CSSImageValue, h as CSSColorValue, i as DtcgShadow, j as attr, k as Steps, l as check, m as CSS, n as DtcgColor, o as DtcgValue, om as Part, p as AttrOp, q as ClassValue, r as DtcgCubicBezier, s as Overrides, sm as Style, t as CheckOverrides, u as createGlobalTheme, v as CSSUnitValue, x as CvProps } from "../theme-types-Bqv0Ggz_.mjs";
+import { a as GProp } from "../group-types-9ttphdku.mjs";
+import "../group-common-9zpBxfUF.mjs";
+import { properties } from "@cssints/css-grammar/mdn";
+//#region src/groups/compositing-2.d.ts
+type B = {
+  id: "compositing-2";
+  kw: Record<never, never>;
+  fn: never;
+  unit: never;
+  media: never;
+  container: never;
+  supports: never;
+};
+type P<K extends keyof typeof properties> = GProp<B, K>;
+export declare const backgroundBlendMode: P<"background-blend-mode">;
+export declare const isolation: P<"isolation">;
+export declare const mixBlendMode: P<"mix-blend-mode">;
+//#endregion
+export { type AttrOp, type CSS, type CSSColorValue, type CSSImageValue, type CSSStyleValue, type CSSUnitValue, CheckOverrides, type ClassValue, type CvConfig, type CvProps, type CvValue, DtcgColor, DtcgCubicBezier, DtcgShadow, DtcgUnit, DtcgValue, type Fallback, type Keyframes, Overrides, type Part, type PositionTry, type QueryWrap, type StateWrap, type Steps, type Style, Tokens, type Wrap, attr, check, cn, createGlobalTheme, createTokens, cv, firstThatWorks, global, group, layers, style, token, within };