cssints 0.1.0 → 0.2.0

package/README.md

@@ -2,17 +2,29 @@
 
 <img src="https://cssints.dev/logo.svg" alt="" width="96" height="96">
 
-cssints is compile-time CSS-in-TypeScript. You write calls such as `css.flex().alignItems("center")`. A Vite plugin runs them at build time and replaces each one with atomic, content-hashed class names in `@layer`s. Nothing of the styling code ships to the browser except `cx` and the few lines behind `cv`, which join class names.
+cssints is compile-time CSS-in-TypeScript. You write calls such as `css.flex().alignItems("center")`. A Vite plugin runs them at build time and replaces each one with atomic, content-hashed class names in `@layer`s. Nothing of the styling code ships to the browser except a few lines that join class names: for a `cn()` with runtime arguments and for `cv`.
 
 - Values are checked against the spec grammars (mdn-data) in the types and again at build time. A typo is an error in the editor and in the build.
 - Conditions (`media`, `container`, `supports`, `hover`), variants (`cv`), design tokens and themes (`createTokens`, `createGlobalTheme`, `check.contrast`) are all build-time, and all typed.
 - LightningCSS optimizes the output. Browser support (`@mdn/browser-compat-data` against your browserslist) is reported as warnings, except for what LightningCSS lowers for those targets.
 
-Status: 0.1 is not published yet. Decisions and findings are in [docs/wayfinder.md](docs/wayfinder.md); the API reference is [docs/API.md](docs/API.md). Both are also a site with search and type hovers: [apps/docs](apps/docs) (`cd apps/docs && bun run dev`); deployed to Cloudflare with Alchemy: <https://cssints.dev>.
+> **Alpha.** cssints is on npm at 0.x. The API can still change between minor versions, the plugin packages
+> may move, and some browsers and frameworks are checked less than others (docs/API.md, "Browser support and what 0.1
+> does not have"). Pin the version, and report what breaks.
+
+Decisions and findings are in [docs/wayfinder.md](docs/wayfinder.md); the API reference is [docs/API.md](docs/API.md). Both are also a site with search and type hovers: [apps/docs](apps/docs) (`cd apps/docs && bun run dev`); deployed to Cloudflare with Alchemy: <https://cssints.dev>.
 
 ## Install
 
-Not on npm yet. In this repo `cssints` is a workspace package (`apps/demo` depends on `"cssints": "workspace:*"`). It needs Vite 8 (Vite+ works too) and, for the plugin, Node with type stripping (22.18 or later).
+```bash
+npm install --save-dev cssints vite@8   # or: bun add -d cssints vite@8, pnpm add -D cssints vite@8
+```
+
+cssints needs Vite 8 (Vite+ works too) and Node 22.18 or later (the plugin runs your modules with type stripping). It is a
+dev dependency: nothing of it ships except the few lines behind `cn` with runtime arguments and `cv`. The plugin packages are installed the same
+way, each beside `cssints` (`npm install --save-dev @cssints/fluid`); the list is on the
+[plugin packages](docs/API.md#plugin-packages-cssints-dk1q) page. In this repository `cssints` is a workspace package
+(`"cssints": "workspace:*"`).
 
 ```ts
 // vite.config.ts
@@ -48,10 +60,9 @@ export default {
 };
 ```
 
-`tsconfig.json` is Solid's: `"jsx": "preserve"`, `"jsxImportSource": "@solidjs/web"`, `"types": ["vite/client"]`. Solid's `class` takes a string, an object or an array, so `cx` is not needed: `class={[card, on() && p(4)]}` and `class={badge({ tone: tone() })}` work as in React. A site's arguments are still build-time values, so a signal goes in the condition or in a `cv` variant, not in `p(n())`. Under `vite dev` an edit of a component replaces it and resets its state below it (Solid's refresh); an edit of a style changes the class strings and the sheet with no reload.
+`tsconfig.json` is Solid's: `"jsx": "preserve"`, `"jsxImportSource": "@solidjs/web"`, `"types": ["vite/client"]`. Solid's `class` takes a string, an object or an array, so `cn` is not needed for the join: `class={[card, on() && p(4)]}` and `class={badge({ tone: tone() })}` work as in React. A site's arguments are still build-time values, so a signal goes in the condition or in a `cv` variant, not in `p(n())`. Under `vite dev` an edit of a component replaces it and resets its state below it (Solid's refresh); an edit of a style changes the class strings and the sheet with no reload.
 
 ```tsx
-import { cx } from "cssints";
 import { bg, color, cn, cv, flex, hover, media, p, style, token } from "cssints" with { type: "cssints" };
 
 const md = media("(width >= 40rem)");
@@ -63,13 +74,13 @@ const button = cv({
 });
 
 export const Row = ({ wide, on }: { wide?: boolean; on?: boolean }) => (
-	<div className={cx(flex().alignItems("center").gap(2), on && p(1))} style={style(token.set(accent, "#dc2626"))}>
+	<div className={cn(flex().alignItems("center").gap(2), on && p(1))} style={style(token.set(accent, "#dc2626"))}>
 		<button className={button({ wide })}>Save</button>
 	</div>
 );
 ```
 
-`with { type: "cssints" }` marks what runs at build time. The plugin replaces each call with a class string, so the browser gets `cx("_1s47490 _1ob5z5m _g2iyum", on && "_lqk467")` and `button` is a call of the runtime with `{ base: "_1t8gqy5 ...", ... }`, so it never sees `flex()`. `virtual:cssints.css` is one sheet with every rule once, sorted by layer, then condition, then shorthand before longhand, then class name:
+`with { type: "cssints" }` marks what runs at build time. The plugin replaces each call with a class string, so the browser gets `__cx([], "_1s47490 _1ob5z5m _g2iyum", on && "_lqk467")` and `button` is a call of the runtime with `{ base: "_1t8gqy5 ...", ... }`, so it never sees `flex()`. `virtual:cssints.css` is one sheet with every rule once, sorted by layer, then condition, then shorthand before longhand, then class name:
 
 ```css
 @layer _.k, _.a, _.b, _.c, _.d, _.e;
@@ -95,7 +106,7 @@ export const Row = ({ wide, on }: { wide?: boolean; on?: boolean }) => (
 
 `import * as css from "cssints/tui" with { type: "cssints" }` gives the members a terminal has (cells, colours, borders, flex, states, `cursor`), and the plugin compiles them to prop objects for [OpenTUI](https://opentui.com) renderables instead of classes; `@cssints/tui` applies their states and themes: [packages/tui](packages/tui/README.md), docs/API.md "TUI".
 
-More in [docs/API.md](docs/API.md): property names and short names, `flex()` and `grid()` chains, conditions and layers, tokens and themes, `cx`, `cn` and `cv`, and the errors you can get.
+More in [docs/API.md](docs/API.md): property names and short names, `flex()` and `grid()` chains, conditions and layers, tokens and themes, `cn` and `cv`, and the errors you can get.
 
 ## Debugging
 
@@ -104,7 +115,7 @@ More in [docs/API.md](docs/API.md): property names and short names, `flex()` and
 ## For agents
 
 `cssints` ships two [agent skills](https://agentskills.io) in its package, `skills/cssints` (writing styles: setup,
-`cn`/`cx`/`cv`, conditions, tokens and themes, the plugin packages, build errors) and `skills/cssints-plugin` (writing
+`cn`/`cv`, conditions, tokens and themes, the plugin packages, build errors) and `skills/cssints-plugin` (writing
 a plugin on `scope()`, with its tests). Install them into your agent's skills folder:
 
 ```bash
@@ -112,8 +123,7 @@ npx skills-npm                                # links the skills of every instal
 npx skills add ./node_modules/cssints/skills  # or the skills CLI, for opencode, Claude Code, Codex, Cursor, ...
 ```
 
-Until 0.1 is on npm, point `npx skills add` at `packages/cssints/skills` of this repository. Agents working on this
-repository get `.agents/skills/cssints-contributor` (also `.claude/skills`) with no install.
+Agents working on this repository get `.agents/skills/cssints-contributor` (also `.claude/skills`) with no install.
 
 `@cssints/mcp` is an MCP server with the build's own checks (`check_declaration`, `check_support`, `check_contrast`,
 `compile`, `search_docs`, `list_plugins`), in [packages/mcp](packages/mcp) with the config for opencode, Claude Code

package/dist/check.mjs

@@ -1,5 +1,5 @@
-import { s as ContrastError } from "./registry-n9JCX4pl.mjs";
-import { t as fallbackOf } from "./lowered-CeoXbm0P.mjs";
+import { s as ContrastError } from "./registry-CTumHB8p.mjs";
+import { t as fallbackOf } from "./lowered-D2KusPLp.mjs";
 import { i as shown, r as ratio, t as luminance } from "./color-BYIxVLlS.mjs";
 import { Effect } from "effect";
 //#region src/check.ts

package/dist/{contrast-BUKVao74.mjs → contrast-DhK69Xak.mjs}

@@ -1,5 +1,5 @@
-import { a as registry, d as MacroError, o as warn } from "./registry-n9JCX4pl.mjs";
-import { l as layerStatements } from "./sheet-CO7a-mdA.mjs";
+import { a as registry, d as MacroError, o as warn } from "./registry-CTumHB8p.mjs";
+import { l as layerStatements } from "./sheet-BKsMTa0c.mjs";
 import { Effect } from "effect";
 //#region src/contrast.ts
 const VAR = /var\((--[^\s,)]+)\)/g;

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 };

package/dist/groups/css-align-3.d.mts

@@ -0,0 +1,29 @@
+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/css-align-3.d.ts
+type B = {
+  id: "css-align-3";
+  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 alignContent: P<"align-content">;
+export declare const alignItems: P<"align-items">;
+export declare const alignSelf: P<"align-self">;
+export declare const columnGap: P<"column-gap">;
+export declare const gap: P<"gap">;
+export declare const justifyContent: P<"justify-content">;
+export declare const justifyItems: P<"justify-items">;
+export declare const justifySelf: P<"justify-self">;
+export declare const placeContent: P<"place-content">;
+export declare const placeItems: P<"place-items">;
+export declare const placeSelf: P<"place-self">;
+export declare const rowGap: P<"row-gap">;
+//#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 };

package/dist/groups/css-anchor-position-1.d.mts

@@ -0,0 +1,49 @@
+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, n as GFn } from "../group-types-9ttphdku.mjs";
+import "../group-common-9zpBxfUF.mjs";
+import { properties } from "@cssints/css-grammar/mdn";
+//#region src/groups/css-anchor-position-1.d.ts
+type B = {
+  id: "css-anchor-position-1";
+  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 alignItems: P<"align-items">;
+export declare const alignSelf: P<"align-self">;
+export declare const anchorName: P<"anchor-name">;
+export declare const anchorScope: P<"anchor-scope">;
+export declare const bottom: P<"bottom">;
+export declare const height: P<"height">;
+export declare const justifyItems: P<"justify-items">;
+export declare const justifySelf: P<"justify-self">;
+export declare const left: P<"left">;
+export declare const marginBottom: P<"margin-bottom">;
+export declare const marginLeft: P<"margin-left">;
+export declare const marginRight: P<"margin-right">;
+export declare const marginTop: P<"margin-top">;
+export declare const maxHeight: P<"max-height">;
+export declare const maxWidth: P<"max-width">;
+export declare const mb: P<"margin-bottom">;
+export declare const minHeight: P<"min-height">;
+export declare const minWidth: P<"min-width">;
+export declare const ml: P<"margin-left">;
+export declare const mr: P<"margin-right">;
+export declare const mt: P<"margin-top">;
+export declare const positionAnchor: P<"position-anchor">;
+export declare const positionArea: P<"position-area">;
+export declare const positionTryFallbacks: P<"position-try-fallbacks">;
+export declare const positionTryOrder: P<"position-try-order">;
+export declare const positionVisibility: P<"position-visibility">;
+export declare const right: P<"right">;
+export declare const top: P<"top">;
+export declare const width: P<"width">;
+export declare const anchor: GFn<B, "anchor", ", ">;
+export declare const anchorSize: GFn<B, "anchor-size", ", ">;
+export declare const positionTry: ((style: Style) => PositionTry) & P<"position-try">;
+//#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 };

package/dist/groups/css-anchor-position-2.d.mts

@@ -0,0 +1,50 @@
+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, n as GFn, t as GCondition } from "../group-types-9ttphdku.mjs";
+import "../group-common-9zpBxfUF.mjs";
+import { properties } from "@cssints/css-grammar/mdn";
+//#region src/groups/css-anchor-position-2.d.ts
+type B = {
+  id: "css-anchor-position-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 alignItems: P<"align-items">;
+export declare const alignSelf: P<"align-self">;
+export declare const anchorName: P<"anchor-name">;
+export declare const anchorScope: P<"anchor-scope">;
+export declare const bottom: P<"bottom">;
+export declare const height: P<"height">;
+export declare const justifyItems: P<"justify-items">;
+export declare const justifySelf: P<"justify-self">;
+export declare const left: P<"left">;
+export declare const marginBottom: P<"margin-bottom">;
+export declare const marginLeft: P<"margin-left">;
+export declare const marginRight: P<"margin-right">;
+export declare const marginTop: P<"margin-top">;
+export declare const maxHeight: P<"max-height">;
+export declare const maxWidth: P<"max-width">;
+export declare const mb: P<"margin-bottom">;
+export declare const minHeight: P<"min-height">;
+export declare const minWidth: P<"min-width">;
+export declare const ml: P<"margin-left">;
+export declare const mr: P<"margin-right">;
+export declare const mt: P<"margin-top">;
+export declare const positionAnchor: P<"position-anchor">;
+export declare const positionArea: P<"position-area">;
+export declare const positionTryFallbacks: P<"position-try-fallbacks">;
+export declare const positionTryOrder: P<"position-try-order">;
+export declare const positionVisibility: P<"position-visibility">;
+export declare const right: P<"right">;
+export declare const top: P<"top">;
+export declare const width: P<"width">;
+export declare const anchor: GFn<B, "anchor", ", ">;
+export declare const anchorSize: GFn<B, "anchor-size", ", ">;
+export declare const container: GCondition<B, "container", QueryWrap>;
+export declare const positionTry: ((style: Style) => PositionTry) & P<"position-try">;
+//#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 };

package/dist/groups/css-animations-1.d.mts

@@ -0,0 +1,28 @@
+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, z as keyframes } 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/css-animations-1.d.ts
+type B = {
+  id: "css-animations-1";
+  kw: {
+    "animation-duration": "auto";
+  };
+  fn: never;
+  unit: never;
+  media: never;
+  container: never;
+  supports: never;
+};
+type P<K extends keyof typeof properties> = GProp<B, K>;
+export declare const animation: P<"animation">;
+export declare const animationDelay: P<"animation-delay">;
+export declare const animationDirection: P<"animation-direction">;
+export declare const animationDuration: P<"animation-duration">;
+export declare const animationFillMode: P<"animation-fill-mode">;
+export declare const animationIterationCount: P<"animation-iteration-count">;
+export declare const animationName: P<"animation-name">;
+export declare const animationPlayState: P<"animation-play-state">;
+export declare const animationTimingFunction: P<"animation-timing-function">;
+//#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, keyframes, layers, style, token, within };

package/dist/groups/css-animations-2.d.mts

@@ -0,0 +1,29 @@
+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, z as keyframes } 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/css-animations-2.d.ts
+type B = {
+  id: "css-animations-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 animation: P<"animation">;
+export declare const animationComposition: P<"animation-composition">;
+export declare const animationDelay: P<"animation-delay">;
+export declare const animationDirection: P<"animation-direction">;
+export declare const animationDuration: P<"animation-duration">;
+export declare const animationFillMode: P<"animation-fill-mode">;
+export declare const animationIterationCount: P<"animation-iteration-count">;
+export declare const animationName: P<"animation-name">;
+export declare const animationPlayState: P<"animation-play-state">;
+export declare const animationTimeline: P<"animation-timeline">;
+export declare const animationTimingFunction: P<"animation-timing-function">;
+export declare const animationTrigger: P<"animation-trigger">;
+//#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, keyframes, layers, style, token, within };

package/dist/groups/css-backgrounds-3.d.mts

@@ -0,0 +1,27 @@
+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/css-backgrounds-3.d.ts
+type B = {
+  id: "css-backgrounds-3";
+  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 background: P<"background">;
+export declare const backgroundAttachment: P<"background-attachment">;
+export declare const backgroundClip: P<"background-clip">;
+export declare const backgroundColor: P<"background-color">;
+export declare const backgroundImage: P<"background-image">;
+export declare const backgroundOrigin: P<"background-origin">;
+export declare const backgroundPosition: P<"background-position">;
+export declare const backgroundRepeat: P<"background-repeat">;
+export declare const backgroundSize: P<"background-size">;
+export declare const bg: P<"background-color">;
+//#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 };

package/dist/groups/css-backgrounds-4.d.mts

@@ -0,0 +1,29 @@
+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/css-backgrounds-4.d.ts
+type B = {
+  id: "css-backgrounds-4";
+  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 background: P<"background">;
+export declare const backgroundAttachment: P<"background-attachment">;
+export declare const backgroundClip: P<"background-clip">;
+export declare const backgroundColor: P<"background-color">;
+export declare const backgroundImage: P<"background-image">;
+export declare const backgroundOrigin: P<"background-origin">;
+export declare const backgroundPosition: P<"background-position">;
+export declare const backgroundPositionX: P<"background-position-x">;
+export declare const backgroundPositionY: P<"background-position-y">;
+export declare const backgroundRepeat: P<"background-repeat">;
+export declare const backgroundSize: P<"background-size">;
+export declare const bg: P<"background-color">;
+//#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 };

package/dist/groups/css-borders-4.d.mts

@@ -0,0 +1,95 @@
+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, n as GFn } from "../group-types-9ttphdku.mjs";
+import "../group-common-9zpBxfUF.mjs";
+import { properties } from "@cssints/css-grammar/mdn";
+//#region src/groups/css-borders-4.d.ts
+type B = {
+  id: "css-borders-4";
+  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 border: P<"border">;
+export declare const borderBlock: P<"border-block">;
+export declare const borderBlockColor: P<"border-block-color">;
+export declare const borderBlockEnd: P<"border-block-end">;
+export declare const borderBlockEndColor: P<"border-block-end-color">;
+export declare const borderBlockEndStyle: P<"border-block-end-style">;
+export declare const borderBlockEndWidth: P<"border-block-end-width">;
+export declare const borderBlockStart: P<"border-block-start">;
+export declare const borderBlockStartColor: P<"border-block-start-color">;
+export declare const borderBlockStartStyle: P<"border-block-start-style">;
+export declare const borderBlockStartWidth: P<"border-block-start-width">;
+export declare const borderBlockStyle: P<"border-block-style">;
+export declare const borderBlockWidth: P<"border-block-width">;
+export declare const borderBottom: P<"border-bottom">;
+export declare const borderBottomColor: P<"border-bottom-color">;
+export declare const borderBottomLeftRadius: P<"border-bottom-left-radius">;
+export declare const borderBottomRightRadius: P<"border-bottom-right-radius">;
+export declare const borderBottomStyle: P<"border-bottom-style">;
+export declare const borderBottomWidth: P<"border-bottom-width">;
+export declare const borderColor: P<"border-color">;
+export declare const borderEndEndRadius: P<"border-end-end-radius">;
+export declare const borderEndStartRadius: P<"border-end-start-radius">;
+export declare const borderImage: P<"border-image">;
+export declare const borderImageOutset: P<"border-image-outset">;
+export declare const borderImageRepeat: P<"border-image-repeat">;
+export declare const borderImageSlice: P<"border-image-slice">;
+export declare const borderImageSource: P<"border-image-source">;
+export declare const borderImageWidth: P<"border-image-width">;
+export declare const borderInline: P<"border-inline">;
+export declare const borderInlineColor: P<"border-inline-color">;
+export declare const borderInlineEnd: P<"border-inline-end">;
+export declare const borderInlineEndColor: P<"border-inline-end-color">;
+export declare const borderInlineEndStyle: P<"border-inline-end-style">;
+export declare const borderInlineEndWidth: P<"border-inline-end-width">;
+export declare const borderInlineStart: P<"border-inline-start">;
+export declare const borderInlineStartColor: P<"border-inline-start-color">;
+export declare const borderInlineStartStyle: P<"border-inline-start-style">;
+export declare const borderInlineStartWidth: P<"border-inline-start-width">;
+export declare const borderInlineStyle: P<"border-inline-style">;
+export declare const borderInlineWidth: P<"border-inline-width">;
+export declare const borderLeft: P<"border-left">;
+export declare const borderLeftColor: P<"border-left-color">;
+export declare const borderLeftStyle: P<"border-left-style">;
+export declare const borderLeftWidth: P<"border-left-width">;
+export declare const borderRadius: P<"border-radius">;
+export declare const borderRight: P<"border-right">;
+export declare const borderRightColor: P<"border-right-color">;
+export declare const borderRightStyle: P<"border-right-style">;
+export declare const borderRightWidth: P<"border-right-width">;
+export declare const borderStartEndRadius: P<"border-start-end-radius">;
+export declare const borderStartStartRadius: P<"border-start-start-radius">;
+export declare const borderStyle: P<"border-style">;
+export declare const borderTop: P<"border-top">;
+export declare const borderTopColor: P<"border-top-color">;
+export declare const borderTopLeftRadius: P<"border-top-left-radius">;
+export declare const borderTopRightRadius: P<"border-top-right-radius">;
+export declare const borderTopStyle: P<"border-top-style">;
+export declare const borderTopWidth: P<"border-top-width">;
+export declare const borderWidth: P<"border-width">;
+export declare const boxShadow: P<"box-shadow">;
+export declare const cornerBlockEndShape: P<"corner-block-end-shape">;
+export declare const cornerBlockStartShape: P<"corner-block-start-shape">;
+export declare const cornerBottomLeftShape: P<"corner-bottom-left-shape">;
+export declare const cornerBottomRightShape: P<"corner-bottom-right-shape">;
+export declare const cornerBottomShape: P<"corner-bottom-shape">;
+export declare const cornerEndEndShape: P<"corner-end-end-shape">;
+export declare const cornerEndStartShape: P<"corner-end-start-shape">;
+export declare const cornerInlineEndShape: P<"corner-inline-end-shape">;
+export declare const cornerInlineStartShape: P<"corner-inline-start-shape">;
+export declare const cornerLeftShape: P<"corner-left-shape">;
+export declare const cornerRightShape: P<"corner-right-shape">;
+export declare const cornerShape: P<"corner-shape">;
+export declare const cornerStartEndShape: P<"corner-start-end-shape">;
+export declare const cornerStartStartShape: P<"corner-start-start-shape">;
+export declare const cornerTopLeftShape: P<"corner-top-left-shape">;
+export declare const cornerTopRightShape: P<"corner-top-right-shape">;
+export declare const cornerTopShape: P<"corner-top-shape">;
+export declare const superellipse: GFn<B, "superellipse", " ">;
+//#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 };

package/dist/groups/css-box-4.d.mts

@@ -0,0 +1,38 @@
+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/css-box-4.d.ts
+type B = {
+  id: "css-box-4";
+  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 m: P<"margin">;
+export declare const margin: P<"margin">;
+export declare const marginBottom: P<"margin-bottom">;
+export declare const marginLeft: P<"margin-left">;
+export declare const marginRight: P<"margin-right">;
+export declare const marginTop: P<"margin-top">;
+export declare const marginTrim: P<"margin-trim">;
+export declare const mb: P<"margin-bottom">;
+export declare const ml: P<"margin-left">;
+export declare const mr: P<"margin-right">;
+export declare const mt: P<"margin-top">;
+export declare const p: P<"padding">;
+export declare const padding: P<"padding">;
+export declare const paddingBottom: P<"padding-bottom">;
+export declare const paddingLeft: P<"padding-left">;
+export declare const paddingRight: P<"padding-right">;
+export declare const paddingTop: P<"padding-top">;
+export declare const pb: P<"padding-bottom">;
+export declare const pl: P<"padding-left">;
+export declare const pr: P<"padding-right">;
+export declare const pt: P<"padding-top">;
+//#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 };

package/dist/groups/css-break-4.d.mts

@@ -0,0 +1,23 @@
+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/css-break-4.d.ts
+type B = {
+  id: "css-break-4";
+  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 boxDecorationBreak: P<"box-decoration-break">;
+export declare const breakAfter: P<"break-after">;
+export declare const breakBefore: P<"break-before">;
+export declare const breakInside: P<"break-inside">;
+export declare const orphans: P<"orphans">;
+export declare const widows: P<"widows">;
+//#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 };