@craft-ts/style 0.7.0-beta.15

package/src/lib/tokens/palette.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The palette.
+ *
+ * A token carries **both** of its values and its role. `palette.surface.raised`
+ * is a value, not a string, and dark mode is not a second file to keep in sync
+ * by hand — the emitter reads the `dark` side off the same token.
+ *
+ * The role is what later makes `defineAxis(..., { writes: onlyVarsOfKind(color) })`
+ * meaningful, and what lets the graph answer "which surfaces does this token
+ * paint?" without parsing CSS.
+ */
+import type { ColorValue } from './units.ts';
+export interface PaletteEntry {
+    readonly light: string;
+    readonly dark: string;
+}
+export type PaletteSpec = Readonly<Record<string, Readonly<Record<string, PaletteEntry>>>>;
+export type Palette<Spec extends PaletteSpec> = {
+    readonly [Group in keyof Spec]: {
+        readonly [Token in keyof Spec[Group]]: ColorValue;
+    };
+};
+export declare function definePalette<const Spec extends PaletteSpec>(spec: Spec): Palette<Spec>;
+/**
+ * The dark side of a token, as a value.
+ *
+ * A token carries both of its values; this is how a sheet reaches the other
+ * one. Written once, at the theme level — `when(scheme.dark, [set(theme.ink,
+ * darkOf(palette.text.strong))])` — rather than at every use site, which is
+ * what keeps dark mode from becoming a second design system to maintain.
+ *
+ * The role travels with it: the dark side of a surface is still a surface.
+ */
+export declare const darkOf: (token: ColorValue) => ColorValue;
+export declare const palette: Palette<{
+    readonly surface: {
+        readonly page: {
+            readonly light: "#ffffff";
+            readonly dark: "#0b0d11";
+        };
+        readonly raised: {
+            readonly light: "#f6f7f9";
+            readonly dark: "#151922";
+        };
+        readonly sunken: {
+            readonly light: "#eceef2";
+            readonly dark: "#0f131a";
+        };
+    };
+    readonly text: {
+        readonly strong: {
+            readonly light: "#111318";
+            readonly dark: "#f2f4f8";
+        };
+        readonly muted: {
+            readonly light: "#5b6472";
+            readonly dark: "#98a2b3";
+        };
+        readonly inverted: {
+            readonly light: "#ffffff";
+            readonly dark: "#0b0d11";
+        };
+    };
+    readonly border: {
+        readonly subtle: {
+            readonly light: "#e3e6ea";
+            readonly dark: "#232936";
+        };
+        readonly strong: {
+            readonly light: "#c3c9d2";
+            readonly dark: "#39414f";
+        };
+    };
+    readonly accent: {
+        readonly info: {
+            readonly light: "#1b5fa1";
+            readonly dark: "#6fb2f0";
+        };
+        readonly success: {
+            readonly light: "#0f7b4f";
+            readonly dark: "#3ddc97";
+        };
+        readonly warning: {
+            readonly light: "#8a5a00";
+            readonly dark: "#f5b544";
+        };
+        readonly danger: {
+            readonly light: "#a11b1b";
+            readonly dark: "#ff6b6b";
+        };
+        readonly neutral: {
+            readonly light: "#4a5568";
+            readonly dark: "#a6b0c0";
+        };
+    };
+}>;
+//# sourceMappingURL=palette.d.ts.map

package/src/lib/tokens/palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../../../../../libs/style/src/lib/tokens/palette.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAa,UAAU,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAKD,MAAM,MAAM,WAAW,GAAG,QAAQ,CAChC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CACvD,CAAC;AAEF,MAAM,MAAM,OAAO,CAAC,IAAI,SAAS,WAAW,IAAI;IAC9C,QAAQ,EAAE,KAAK,IAAI,MAAM,IAAI,GAAG;QAC9B,QAAQ,EAAE,KAAK,IAAI,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,UAAU;KAClD;CACF,CAAC;AAcF,wBAAgB,aAAa,CAAC,KAAK,CAAC,IAAI,SAAS,WAAW,EAC1D,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,UAAU,KAAG,UAMzB,CAAC;AAEnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBlB,CAAC"}

package/src/lib/tokens/palette.js

@@ -0,0 +1,61 @@
+const swatch = (light, dark, role) => ({ css: light, dark, role, unproven: '' });
+/**
+ * Roles are derived from the group name rather than repeated on every entry:
+ * a token in `surface` paints a surface. A group the map does not know gets
+ * `'none'`, which is honest — it says the role is unknown instead of guessing.
+ */
+const ROLE_OF_GROUP = {
+    surface: 'surface',
+    text: 'text',
+    border: 'border',
+    accent: 'accent',
+};
+export function definePalette(spec) {
+    return Object.fromEntries(Object.entries(spec).map(([group, tokens]) => [
+        group,
+        Object.fromEntries(Object.entries(tokens).map(([name, pair]) => [
+            name,
+            swatch(pair.light, pair.dark, ROLE_OF_GROUP[group] ?? 'none'),
+        ])),
+    ]));
+}
+/**
+ * The dark side of a token, as a value.
+ *
+ * A token carries both of its values; this is how a sheet reaches the other
+ * one. Written once, at the theme level — `when(scheme.dark, [set(theme.ink,
+ * darkOf(palette.text.strong))])` — rather than at every use site, which is
+ * what keeps dark mode from becoming a second design system to maintain.
+ *
+ * The role travels with it: the dark side of a surface is still a surface.
+ */
+export const darkOf = (token) => ({
+    css: token.dark,
+    dark: token.dark,
+    role: token.role,
+    unproven: token.unproven,
+});
+export const palette = definePalette({
+    surface: {
+        page: { light: '#ffffff', dark: '#0b0d11' },
+        raised: { light: '#f6f7f9', dark: '#151922' },
+        sunken: { light: '#eceef2', dark: '#0f131a' },
+    },
+    text: {
+        strong: { light: '#111318', dark: '#f2f4f8' },
+        muted: { light: '#5b6472', dark: '#98a2b3' },
+        inverted: { light: '#ffffff', dark: '#0b0d11' },
+    },
+    border: {
+        subtle: { light: '#e3e6ea', dark: '#232936' },
+        strong: { light: '#c3c9d2', dark: '#39414f' },
+    },
+    accent: {
+        info: { light: '#1b5fa1', dark: '#6fb2f0' },
+        success: { light: '#0f7b4f', dark: '#3ddc97' },
+        warning: { light: '#8a5a00', dark: '#f5b544' },
+        danger: { light: '#a11b1b', dark: '#ff6b6b' },
+        neutral: { light: '#4a5568', dark: '#a6b0c0' },
+    },
+});
+//# sourceMappingURL=palette.js.map

package/src/lib/tokens/palette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.js","sourceRoot":"","sources":["../../../../../../libs/style/src/lib/tokens/palette.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,GAAG,CAAC,KAAa,EAAE,IAAY,EAAE,IAAe,EAAc,EAAE,CAC1E,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAe,CAAC;AAY3D;;;;GAIG;AACH,MAAM,aAAa,GAAwC;IACzD,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;CACjB,CAAC;AAEF,MAAM,UAAU,aAAa,CAC3B,IAAU;IAEV,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QAC5C,KAAK;QACL,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC;YAC3C,IAAI;YACJ,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC;SAC9D,CAAC,CACH;KACF,CAAC,CACc,CAAC;AACrB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAiB,EAAc,EAAE,CACtD,CAAC;IACC,GAAG,EAAE,KAAK,CAAC,IAAI;IACf,IAAI,EAAE,KAAK,CAAC,IAAI;IAChB,IAAI,EAAE,KAAK,CAAC,IAAI;IAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;CACzB,CAAe,CAAC;AAEnB,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC;IACnC,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC3C,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC7C,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;KAC9C;IACD,IAAI,EAAE;QACJ,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC7C,KAAK,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC5C,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;KAChD;IACD,MAAM,EAAE;QACN,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC7C,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;KAC9C;IACD,MAAM,EAAE;QACN,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC3C,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC9C,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC9C,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QAC7C,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;KAC/C;CACF,CAAC,CAAC","sourcesContent":["/**\n * The palette.\n *\n * A token carries **both** of its values and its role. `palette.surface.raised`\n * is a value, not a string, and dark mode is not a second file to keep in sync\n * by hand — the emitter reads the `dark` side off the same token.\n *\n * The role is what later makes `defineAxis(..., { writes: onlyVarsOfKind(color) })`\n * meaningful, and what lets the graph answer \"which surfaces does this token\n * paint?\" without parsing CSS.\n */\nimport type { ColorRole, ColorValue } from './units.ts';\n\nexport interface PaletteEntry {\n  readonly light: string;\n  readonly dark: string;\n}\n\nconst swatch = (light: string, dark: string, role: ColorRole): ColorValue =>\n  ({ css: light, dark, role, unproven: '' }) as ColorValue;\n\nexport type PaletteSpec = Readonly<\n  Record<string, Readonly<Record<string, PaletteEntry>>>\n>;\n\nexport type Palette<Spec extends PaletteSpec> = {\n  readonly [Group in keyof Spec]: {\n    readonly [Token in keyof Spec[Group]]: ColorValue;\n  };\n};\n\n/**\n * Roles are derived from the group name rather than repeated on every entry:\n * a token in `surface` paints a surface. A group the map does not know gets\n * `'none'`, which is honest — it says the role is unknown instead of guessing.\n */\nconst ROLE_OF_GROUP: Readonly<Record<string, ColorRole>> = {\n  surface: 'surface',\n  text: 'text',\n  border: 'border',\n  accent: 'accent',\n};\n\nexport function definePalette<const Spec extends PaletteSpec>(\n  spec: Spec,\n): Palette<Spec> {\n  return Object.fromEntries(\n    Object.entries(spec).map(([group, tokens]) => [\n      group,\n      Object.fromEntries(\n        Object.entries(tokens).map(([name, pair]) => [\n          name,\n          swatch(pair.light, pair.dark, ROLE_OF_GROUP[group] ?? 'none'),\n        ]),\n      ),\n    ]),\n  ) as Palette<Spec>;\n}\n\n/**\n * The dark side of a token, as a value.\n *\n * A token carries both of its values; this is how a sheet reaches the other\n * one. Written once, at the theme level — `when(scheme.dark, [set(theme.ink,\n * darkOf(palette.text.strong))])` — rather than at every use site, which is\n * what keeps dark mode from becoming a second design system to maintain.\n *\n * The role travels with it: the dark side of a surface is still a surface.\n */\nexport const darkOf = (token: ColorValue): ColorValue =>\n  ({\n    css: token.dark,\n    dark: token.dark,\n    role: token.role,\n    unproven: token.unproven,\n  }) as ColorValue;\n\nexport const palette = definePalette({\n  surface: {\n    page: { light: '#ffffff', dark: '#0b0d11' },\n    raised: { light: '#f6f7f9', dark: '#151922' },\n    sunken: { light: '#eceef2', dark: '#0f131a' },\n  },\n  text: {\n    strong: { light: '#111318', dark: '#f2f4f8' },\n    muted: { light: '#5b6472', dark: '#98a2b3' },\n    inverted: { light: '#ffffff', dark: '#0b0d11' },\n  },\n  border: {\n    subtle: { light: '#e3e6ea', dark: '#232936' },\n    strong: { light: '#c3c9d2', dark: '#39414f' },\n  },\n  accent: {\n    info: { light: '#1b5fa1', dark: '#6fb2f0' },\n    success: { light: '#0f7b4f', dark: '#3ddc97' },\n    warning: { light: '#8a5a00', dark: '#f5b544' },\n    danger: { light: '#a11b1b', dark: '#ff6b6b' },\n    neutral: { light: '#4a5568', dark: '#a6b0c0' },\n  },\n});\n"]}

package/src/lib/tokens/scales.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The closed scales.
+ *
+ * `space(4.5)` does not compile: the step is a union of literals, not a
+ * `number`. When a step is missing, it is added here — that is the whole point
+ * of a scale, and the reason `unsafeLength` exists as the marked alternative
+ * rather than an arbitrary-value syntax.
+ */
+import { type LengthValue } from './units.ts';
+export type SpaceStep = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24;
+export declare const space: (step: SpaceStep) => LengthValue;
+export declare const radii: {
+    readonly none: LengthValue;
+    readonly sm: LengthValue;
+    readonly md: LengthValue;
+    readonly lg: LengthValue;
+    readonly xl: LengthValue;
+    readonly full: LengthValue;
+};
+/**
+ * Named `lineWidth` rather than `borderWidth`: the generated table already
+ * exports a `borderWidth` **helper**, and one name for two concepts in the same
+ * import is the collision this package spends its effort avoiding.
+ */
+export declare const lineWidth: {
+    readonly hairline: LengthValue;
+    readonly thick: LengthValue;
+};
+/**
+ * A type scale entry **is** a length, and carries its line height alongside.
+ *
+ * Being a length is what lets it flow into the generated `font-size` helper
+ * without a conversion; carrying the line height is what lets `font(text.sm)`
+ * emit both declarations, which is the only shape in which the pair cannot
+ * drift apart.
+ */
+export interface FontSizeToken extends LengthValue {
+    readonly lineHeight: string;
+}
+export declare const text: {
+    readonly xs: FontSizeToken;
+    readonly sm: FontSizeToken;
+    readonly base: FontSizeToken;
+    readonly lg: FontSizeToken;
+    readonly xl: FontSizeToken;
+};
+//# sourceMappingURL=scales.d.ts.map

package/src/lib/tokens/scales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scales.d.ts","sourceRoot":"","sources":["../../../../../../libs/style/src/lib/tokens/scales.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzD,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAkB/E,eAAO,MAAM,KAAK,GAAI,MAAM,SAAS,KAAG,WACJ,CAAC;AAErC,eAAO,MAAM,KAAK;;;;;;;CAOR,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,WAAW,aAAc,SAAQ,WAAW;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAKD,eAAO,MAAM,IAAI;;;;;;CAMP,CAAC"}

package/src/lib/tokens/scales.js

@@ -0,0 +1,51 @@
+/**
+ * The closed scales.
+ *
+ * `space(4.5)` does not compile: the step is a union of literals, not a
+ * `number`. When a step is missing, it is added here — that is the whole point
+ * of a scale, and the reason `unsafeLength` exists as the marked alternative
+ * rather than an arbitrary-value syntax.
+ */
+import { rawLength } from "./units.js";
+const SPACE_REM = {
+    0: 0,
+    1: 0.25,
+    2: 0.5,
+    3: 0.75,
+    4: 1,
+    5: 1.25,
+    6: 1.5,
+    8: 2,
+    10: 2.5,
+    12: 3,
+    16: 4,
+    20: 5,
+    24: 6,
+};
+export const space = (step) => rawLength(`${SPACE_REM[step]}rem`);
+export const radii = {
+    none: rawLength('0'),
+    sm: rawLength('0.25rem'),
+    md: rawLength('0.375rem'),
+    lg: rawLength('0.5rem'),
+    xl: rawLength('0.75rem'),
+    full: rawLength('9999px'),
+};
+/**
+ * Named `lineWidth` rather than `borderWidth`: the generated table already
+ * exports a `borderWidth` **helper**, and one name for two concepts in the same
+ * import is the collision this package spends its effort avoiding.
+ */
+export const lineWidth = {
+    hairline: rawLength('1px'),
+    thick: rawLength('2px'),
+};
+const size = (css, lineHeight) => ({ ...rawLength(css), lineHeight });
+export const text = {
+    xs: size('0.75rem', '1rem'),
+    sm: size('0.875rem', '1.25rem'),
+    base: size('1rem', '1.5rem'),
+    lg: size('1.125rem', '1.75rem'),
+    xl: size('1.375rem', '1.875rem'),
+};
+//# sourceMappingURL=scales.js.map

package/src/lib/tokens/scales.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scales.js","sourceRoot":"","sources":["../../../../../../libs/style/src/lib/tokens/scales.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,SAAS,EAAoB,MAAM,YAAY,CAAC;AAIzD,MAAM,SAAS,GAAwC;IACrD,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,CAAC;IACJ,EAAE,EAAE,GAAG;IACP,EAAE,EAAE,CAAC;IACL,EAAE,EAAE,CAAC;IACL,EAAE,EAAE,CAAC;IACL,EAAE,EAAE,CAAC;CACN,CAAC;AAEF,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,IAAe,EAAe,EAAE,CACpD,SAAS,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAErC,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,SAAS,CAAC,GAAG,CAAC;IACpB,EAAE,EAAE,SAAS,CAAC,SAAS,CAAC;IACxB,EAAE,EAAE,SAAS,CAAC,UAAU,CAAC;IACzB,EAAE,EAAE,SAAS,CAAC,QAAQ,CAAC;IACvB,EAAE,EAAE,SAAS,CAAC,SAAS,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC,QAAQ,CAAC;CACjB,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,QAAQ,EAAE,SAAS,CAAC,KAAK,CAAC;IAC1B,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC;CACf,CAAC;AAcX,MAAM,IAAI,GAAG,CAAC,GAAW,EAAE,UAAkB,EAAiB,EAAE,CAC9D,CAAC,EAAE,GAAG,SAAS,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAkB,CAAC;AAEvD,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,EAAE,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,EAAE,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC5B,EAAE,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,EAAE,EAAE,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC","sourcesContent":["/**\n * The closed scales.\n *\n * `space(4.5)` does not compile: the step is a union of literals, not a\n * `number`. When a step is missing, it is added here — that is the whole point\n * of a scale, and the reason `unsafeLength` exists as the marked alternative\n * rather than an arbitrary-value syntax.\n */\nimport { rawLength, type LengthValue } from './units.ts';\n\nexport type SpaceStep = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24;\n\nconst SPACE_REM: Readonly<Record<SpaceStep, number>> = {\n  0: 0,\n  1: 0.25,\n  2: 0.5,\n  3: 0.75,\n  4: 1,\n  5: 1.25,\n  6: 1.5,\n  8: 2,\n  10: 2.5,\n  12: 3,\n  16: 4,\n  20: 5,\n  24: 6,\n};\n\nexport const space = (step: SpaceStep): LengthValue =>\n  rawLength(`${SPACE_REM[step]}rem`);\n\nexport const radii = {\n  none: rawLength('0'),\n  sm: rawLength('0.25rem'),\n  md: rawLength('0.375rem'),\n  lg: rawLength('0.5rem'),\n  xl: rawLength('0.75rem'),\n  full: rawLength('9999px'),\n} as const;\n\n/**\n * Named `lineWidth` rather than `borderWidth`: the generated table already\n * exports a `borderWidth` **helper**, and one name for two concepts in the same\n * import is the collision this package spends its effort avoiding.\n */\nexport const lineWidth = {\n  hairline: rawLength('1px'),\n  thick: rawLength('2px'),\n} as const;\n\n/**\n * A type scale entry **is** a length, and carries its line height alongside.\n *\n * Being a length is what lets it flow into the generated `font-size` helper\n * without a conversion; carrying the line height is what lets `font(text.sm)`\n * emit both declarations, which is the only shape in which the pair cannot\n * drift apart.\n */\nexport interface FontSizeToken extends LengthValue {\n  readonly lineHeight: string;\n}\n\nconst size = (css: string, lineHeight: string): FontSizeToken =>\n  ({ ...rawLength(css), lineHeight }) as FontSizeToken;\n\nexport const text = {\n  xs: size('0.75rem', '1rem'),\n  sm: size('0.875rem', '1.25rem'),\n  base: size('1rem', '1.5rem'),\n  lg: size('1.125rem', '1.75rem'),\n  xl: size('1.375rem', '1.875rem'),\n} as const;\n"]}

package/src/lib/tokens/units.d.ts

@@ -0,0 +1,114 @@
+/**
+ * The branded value types every helper in the design system speaks.
+ *
+ * Each value is a **nominal object** — `{ readonly [LENGTH]: true }` with
+ * `LENGTH` a `unique symbol` — never a `string & { __length?: true }`. An
+ * optional phantom on a primitive base brands nothing: `'blabla'` stays
+ * assignable and the whole guarantee collapses in silence, with every test
+ * still green. That failure mode is the most expensive one this package can
+ * have, which is why the shape is an object and why `tokens.spec.ts` measures
+ * the brand itself rather than a handful of hand-picked cases.
+ *
+ * The assignability lattice is carried by the brands, not by a separate table:
+ * an integer *is* a number (it carries both brands), a length *is* a
+ * length-percentage (the target is a union). See `kinds.ts`.
+ */
+declare const LENGTH: unique symbol;
+declare const PERCENT: unique symbol;
+declare const NUMBER: unique symbol;
+declare const INTEGER: unique symbol;
+declare const ANGLE: unique symbol;
+declare const TIME: unique symbol;
+declare const COLOR: unique symbol;
+declare const IDENT: unique symbol;
+declare const CSS_STRING: unique symbol;
+declare const URL_VALUE: unique symbol;
+/** Shared by every value: the CSS text, and the debt it carries. */
+export interface StyleValue {
+    readonly css: string;
+    /**
+     * Non-empty when the value could not be proven — see `unsafeLength`. It
+     * travels with the declaration all the way to the graph, which is what makes
+     * the debt countable instead of invisible.
+     */
+    readonly unproven: string;
+}
+export interface LengthValue extends StyleValue {
+    readonly [LENGTH]: true;
+}
+export interface PercentValue extends StyleValue {
+    readonly [PERCENT]: true;
+}
+export interface NumberValue extends StyleValue {
+    readonly [NUMBER]: true;
+}
+/** An integer carries the number brand too: `<integer>` is a `<number>`. */
+export interface IntegerValue extends NumberValue {
+    readonly [INTEGER]: true;
+}
+export interface AngleValue extends StyleValue {
+    readonly [ANGLE]: true;
+}
+export interface TimeValue extends StyleValue {
+    readonly [TIME]: true;
+}
+export type ColorRole = 'surface' | 'text' | 'border' | 'accent' | 'none';
+export interface ColorValue extends StyleValue {
+    readonly [COLOR]: true;
+    /** The dark counterpart. A palette token carries both of its values. */
+    readonly dark: string;
+    readonly role: ColorRole;
+}
+/** `<custom-ident>` — a name, never a free string. */
+export interface IdentValue extends StyleValue {
+    readonly [IDENT]: true;
+}
+/** `<string>` — quoted at construction, so it cannot break out of the rule. */
+export interface CssStringValue extends StyleValue {
+    readonly [CSS_STRING]: true;
+}
+/** `<url>` — wrapped at construction for the same reason. */
+export interface UrlValue extends StyleValue {
+    readonly [URL_VALUE]: true;
+}
+/** `<length-percentage>`, spelled as the union the grammar actually means. */
+export type LengthPercentageValue = LengthValue | PercentValue;
+export declare const rawLength: (css: string, unproven?: string) => LengthValue;
+/**
+ * Raw units live under a namespace rather than at the top level for a dull but
+ * real reason: `px` is already taken by `padding-inline` on the property side.
+ * Two short names for two different concepts in the same import is a guaranteed
+ * collision — better settled here, once.
+ */
+export declare const unit: {
+    readonly rem: (amount: number) => LengthValue;
+    readonly px: (amount: number) => LengthValue;
+    readonly em: (amount: number) => LengthValue;
+    readonly ch: (amount: number) => LengthValue;
+    readonly vw: (amount: number) => LengthValue;
+    readonly vh: (amount: number) => LengthValue;
+    readonly pct: (amount: number) => PercentValue;
+    readonly deg: (amount: number) => AngleValue;
+    readonly ms: (amount: number) => TimeValue;
+    readonly s: (amount: number) => TimeValue;
+};
+export declare const num: (amount: number) => NumberValue;
+export declare const int: (amount: number) => IntegerValue;
+/**
+ * The three types the generator cannot close, each behind its own constructor
+ * so that no generated signature ever has to accept a bare `string`.
+ */
+export declare const ident: (name: string) => IdentValue;
+export declare const cssString: (text: string) => CssStringValue;
+export declare const url: (href: string) => UrlValue;
+/**
+ * The only way out of the scales, and it leaves a trace.
+ *
+ * Without this door a blocked agent bypasses the design system entirely; with
+ * it unmarked, the bypass is silent. `unproven` bubbles up to the graph, so the
+ * debt is countable. There is no `[17px]` arbitrary-value syntax: if a value is
+ * missing from a scale, it is added to the scale.
+ */
+export declare const unsafeLength: <Reason extends string>(css: string, reason: Reason) => LengthValue;
+export {};
+//# sourceMappingURL=units.d.ts.map

package/src/lib/tokens/units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../../../../../../libs/style/src/lib/tokens/units.ts"],"names":[],"mappings":"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"}

package/src/lib/tokens/units.js

@@ -0,0 +1,54 @@
+/**
+ * The branded value types every helper in the design system speaks.
+ *
+ * Each value is a **nominal object** — `{ readonly [LENGTH]: true }` with
+ * `LENGTH` a `unique symbol` — never a `string & { __length?: true }`. An
+ * optional phantom on a primitive base brands nothing: `'blabla'` stays
+ * assignable and the whole guarantee collapses in silence, with every test
+ * still green. That failure mode is the most expensive one this package can
+ * have, which is why the shape is an object and why `tokens.spec.ts` measures
+ * the brand itself rather than a handful of hand-picked cases.
+ *
+ * The assignability lattice is carried by the brands, not by a separate table:
+ * an integer *is* a number (it carries both brands), a length *is* a
+ * length-percentage (the target is a union). See `kinds.ts`.
+ */
+const value = (css, unproven = '') => ({ css, unproven });
+export const rawLength = (css, unproven = '') => value(css, unproven);
+/**
+ * Raw units live under a namespace rather than at the top level for a dull but
+ * real reason: `px` is already taken by `padding-inline` on the property side.
+ * Two short names for two different concepts in the same import is a guaranteed
+ * collision — better settled here, once.
+ */
+export const unit = {
+    rem: (amount) => rawLength(`${amount}rem`),
+    px: (amount) => rawLength(`${amount}px`),
+    em: (amount) => rawLength(`${amount}em`),
+    ch: (amount) => rawLength(`${amount}ch`),
+    vw: (amount) => rawLength(`${amount}vw`),
+    vh: (amount) => rawLength(`${amount}vh`),
+    pct: (amount) => value(`${amount}%`),
+    deg: (amount) => value(`${amount}deg`),
+    ms: (amount) => value(`${amount}ms`),
+    s: (amount) => value(`${amount}s`),
+};
+export const num = (amount) => value(String(amount));
+export const int = (amount) => value(String(Math.trunc(amount)));
+/**
+ * The three types the generator cannot close, each behind its own constructor
+ * so that no generated signature ever has to accept a bare `string`.
+ */
+export const ident = (name) => value(name.replace(/[^A-Za-z0-9_-]/g, ''));
+export const cssString = (text) => value(JSON.stringify(text));
+export const url = (href) => value(`url(${JSON.stringify(href)})`);
+/**
+ * The only way out of the scales, and it leaves a trace.
+ *
+ * Without this door a blocked agent bypasses the design system entirely; with
+ * it unmarked, the bypass is silent. `unproven` bubbles up to the graph, so the
+ * debt is countable. There is no `[17px]` arbitrary-value syntax: if a value is
+ * missing from a scale, it is added to the scale.
+ */
+export const unsafeLength = (css, reason) => rawLength(css, reason);
+//# sourceMappingURL=units.js.map

package/src/lib/tokens/units.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.js","sourceRoot":"","sources":["../../../../../../libs/style/src/lib/tokens/units.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA4EH,MAAM,KAAK,GAAG,CAAQ,GAAW,EAAE,QAAQ,GAAG,EAAE,EAAS,EAAE,CACzD,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAU,CAAC;AAE/B,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,GAAW,EAAE,QAAQ,GAAG,EAAE,EAAe,EAAE,CACnE,KAAK,CAAc,GAAG,EAAE,QAAQ,CAAC,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,GAAG,EAAE,CAAC,MAAc,EAAe,EAAE,CAAC,SAAS,CAAC,GAAG,MAAM,KAAK,CAAC;IAC/D,EAAE,EAAE,CAAC,MAAc,EAAe,EAAE,CAAC,SAAS,CAAC,GAAG,MAAM,IAAI,CAAC;IAC7D,EAAE,EAAE,CAAC,MAAc,EAAe,EAAE,CAAC,SAAS,CAAC,GAAG,MAAM,IAAI,CAAC;IAC7D,EAAE,EAAE,CAAC,MAAc,EAAe,EAAE,CAAC,SAAS,CAAC,GAAG,MAAM,IAAI,CAAC;IAC7D,EAAE,EAAE,CAAC,MAAc,EAAe,EAAE,CAAC,SAAS,CAAC,GAAG,MAAM,IAAI,CAAC;IAC7D,EAAE,EAAE,CAAC,MAAc,EAAe,EAAE,CAAC,SAAS,CAAC,GAAG,MAAM,IAAI,CAAC;IAC7D,GAAG,EAAE,CAAC,MAAc,EAAgB,EAAE,CAAC,KAAK,CAAe,GAAG,MAAM,GAAG,CAAC;IACxE,GAAG,EAAE,CAAC,MAAc,EAAc,EAAE,CAAC,KAAK,CAAa,GAAG,MAAM,KAAK,CAAC;IACtE,EAAE,EAAE,CAAC,MAAc,EAAa,EAAE,CAAC,KAAK,CAAY,GAAG,MAAM,IAAI,CAAC;IAClE,CAAC,EAAE,CAAC,MAAc,EAAa,EAAE,CAAC,KAAK,CAAY,GAAG,MAAM,GAAG,CAAC;CACxD,CAAC;AAEX,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,MAAc,EAAe,EAAE,CACjD,KAAK,CAAc,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAErC,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,MAAc,EAAgB,EAAE,CAClD,KAAK,CAAe,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAElD;;;GAGG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,IAAY,EAAc,EAAE,CAChD,KAAK,CAAa,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC,CAAC;AAEzD,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,IAAY,EAAkB,EAAE,CACxD,KAAK,CAAiB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;AAE9C,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,IAAY,EAAY,EAAE,CAC5C,KAAK,CAAW,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,GAAW,EACX,MAAc,EACD,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC","sourcesContent":["/**\n * The branded value types every helper in the design system speaks.\n *\n * Each value is a **nominal object** — `{ readonly [LENGTH]: true }` with\n * `LENGTH` a `unique symbol` — never a `string & { __length?: true }`. An\n * optional phantom on a primitive base brands nothing: `'blabla'` stays\n * assignable and the whole guarantee collapses in silence, with every test\n * still green. That failure mode is the most expensive one this package can\n * have, which is why the shape is an object and why `tokens.spec.ts` measures\n * the brand itself rather than a handful of hand-picked cases.\n *\n * The assignability lattice is carried by the brands, not by a separate table:\n * an integer *is* a number (it carries both brands), a length *is* a\n * length-percentage (the target is a union). See `kinds.ts`.\n */\n\ndeclare const LENGTH: unique symbol;\ndeclare const PERCENT: unique symbol;\ndeclare const NUMBER: unique symbol;\ndeclare const INTEGER: unique symbol;\ndeclare const ANGLE: unique symbol;\ndeclare const TIME: unique symbol;\ndeclare const COLOR: unique symbol;\ndeclare const IDENT: unique symbol;\ndeclare const CSS_STRING: unique symbol;\ndeclare const URL_VALUE: unique symbol;\n\n/** Shared by every value: the CSS text, and the debt it carries. */\nexport interface StyleValue {\n  readonly css: string;\n  /**\n   * Non-empty when the value could not be proven — see `unsafeLength`. It\n   * travels with the declaration all the way to the graph, which is what makes\n   * the debt countable instead of invisible.\n   */\n  readonly unproven: string;\n}\n\nexport interface LengthValue extends StyleValue {\n  readonly [LENGTH]: true;\n}\n\nexport interface PercentValue extends StyleValue {\n  readonly [PERCENT]: true;\n}\n\nexport interface NumberValue extends StyleValue {\n  readonly [NUMBER]: true;\n}\n\n/** An integer carries the number brand too: `<integer>` is a `<number>`. */\nexport interface IntegerValue extends NumberValue {\n  readonly [INTEGER]: true;\n}\n\nexport interface AngleValue extends StyleValue {\n  readonly [ANGLE]: true;\n}\n\nexport interface TimeValue extends StyleValue {\n  readonly [TIME]: true;\n}\n\nexport type ColorRole = 'surface' | 'text' | 'border' | 'accent' | 'none';\n\nexport interface ColorValue extends StyleValue {\n  readonly [COLOR]: true;\n  /** The dark counterpart. A palette token carries both of its values. */\n  readonly dark: string;\n  readonly role: ColorRole;\n}\n\n/** `<custom-ident>` — a name, never a free string. */\nexport interface IdentValue extends StyleValue {\n  readonly [IDENT]: true;\n}\n\n/** `<string>` — quoted at construction, so it cannot break out of the rule. */\nexport interface CssStringValue extends StyleValue {\n  readonly [CSS_STRING]: true;\n}\n\n/** `<url>` — wrapped at construction for the same reason. */\nexport interface UrlValue extends StyleValue {\n  readonly [URL_VALUE]: true;\n}\n\n/** `<length-percentage>`, spelled as the union the grammar actually means. */\nexport type LengthPercentageValue = LengthValue | PercentValue;\n\nconst value = <Brand>(css: string, unproven = ''): Brand =>\n  ({ css, unproven }) as Brand;\n\nexport const rawLength = (css: string, unproven = ''): LengthValue =>\n  value<LengthValue>(css, unproven);\n\n/**\n * Raw units live under a namespace rather than at the top level for a dull but\n * real reason: `px` is already taken by `padding-inline` on the property side.\n * Two short names for two different concepts in the same import is a guaranteed\n * collision — better settled here, once.\n */\nexport const unit = {\n  rem: (amount: number): LengthValue => rawLength(`${amount}rem`),\n  px: (amount: number): LengthValue => rawLength(`${amount}px`),\n  em: (amount: number): LengthValue => rawLength(`${amount}em`),\n  ch: (amount: number): LengthValue => rawLength(`${amount}ch`),\n  vw: (amount: number): LengthValue => rawLength(`${amount}vw`),\n  vh: (amount: number): LengthValue => rawLength(`${amount}vh`),\n  pct: (amount: number): PercentValue => value<PercentValue>(`${amount}%`),\n  deg: (amount: number): AngleValue => value<AngleValue>(`${amount}deg`),\n  ms: (amount: number): TimeValue => value<TimeValue>(`${amount}ms`),\n  s: (amount: number): TimeValue => value<TimeValue>(`${amount}s`),\n} as const;\n\nexport const num = (amount: number): NumberValue =>\n  value<NumberValue>(String(amount));\n\nexport const int = (amount: number): IntegerValue =>\n  value<IntegerValue>(String(Math.trunc(amount)));\n\n/**\n * The three types the generator cannot close, each behind its own constructor\n * so that no generated signature ever has to accept a bare `string`.\n */\nexport const ident = (name: string): IdentValue =>\n  value<IdentValue>(name.replace(/[^A-Za-z0-9_-]/g, ''));\n\nexport const cssString = (text: string): CssStringValue =>\n  value<CssStringValue>(JSON.stringify(text));\n\nexport const url = (href: string): UrlValue =>\n  value<UrlValue>(`url(${JSON.stringify(href)})`);\n\n/**\n * The only way out of the scales, and it leaves a trace.\n *\n * Without this door a blocked agent bypasses the design system entirely; with\n * it unmarked, the bypass is silent. `unproven` bubbles up to the graph, so the\n * debt is countable. There is no `[17px]` arbitrary-value syntax: if a value is\n * missing from a scale, it is added to the scale.\n */\nexport const unsafeLength = <Reason extends string>(\n  css: string,\n  reason: Reason,\n): LengthValue => rawLength(css, reason);\n"]}

package/src/plugin/emit.d.ts

@@ -0,0 +1,64 @@
+import type { AtomicRule, RegisteredClass } from '../lib/styles.ts';
+import type { CssVarDeclaration } from '../lib/css-vars.ts';
+/** The layer order is fixed here so that no import order can change it. */
+export declare const LAYERS: readonly ["reset", "tokens", "components", "variants", "overrides"];
+/**
+ * Properties the vocabulary owns.
+ *
+ * The generated table, plus the ones only an obligation can write. `overflow`
+ * is in the second set and not the first on purpose: it is reachable through
+ * `provides(scrollPort.block)` and through nothing else.
+ */
+export declare const knownProperties: () => ReadonlySet<string>;
+export declare class UnknownCssError extends Error {
+    readonly property: string;
+    readonly source: string;
+    constructor(property: string, source: string);
+}
+/**
+ * The last net under the escape hatches.
+ *
+ * A keyword or property that slipped past the types would otherwise become CSS
+ * the browser silently drops — the exact failure the package exists to prevent,
+ * arriving at the last possible moment.
+ */
+export declare function validateAtoms(atoms: readonly AtomicRule[], source?: string): void;
+/**
+ * The stylesheet.
+ *
+ * Unconditional atoms land in `components`, conditional ones in `variants`, so
+ * a variant always wins over the base without anyone counting selector
+ * specificity. Ordering is by class name rather than by registration order:
+ * the output must not depend on which module the bundler happened to load
+ * first, or two identical builds would produce two different files.
+ */
+export declare function renderCss(atoms: readonly AtomicRule[], vars: readonly CssVarDeclaration[]): string;
+export interface StyleDump {
+    readonly classes: readonly {
+        readonly key: string;
+        readonly className: string;
+        readonly axes: Readonly<Record<string, readonly string[]>>;
+        readonly atoms: readonly string[];
+        readonly unproven: readonly string[];
+        readonly requires: readonly string[];
+        readonly provides: readonly string[];
+        readonly violates: readonly string[];
+    }[];
+    readonly atoms: readonly {
+        readonly className: string;
+        readonly property: string;
+        readonly value: string;
+        readonly conditions: readonly string[];
+        readonly unproven: string;
+    }[];
+    readonly vars: readonly CssVarDeclaration[];
+}
+/**
+ * What the dependency graph consumes.
+ *
+ * Emitted by the plugin rather than re-derived by an AST pass: there is one
+ * graph and two producers, and a second, approximate evaluation of the DSL
+ * would disagree with this one sooner or later.
+ */
+export declare function styleDump(classes: readonly RegisteredClass[], atoms: readonly AtomicRule[], vars: readonly CssVarDeclaration[]): StyleDump;
+//# sourceMappingURL=emit.d.ts.map

package/src/plugin/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../../../libs/style/src/plugin/emit.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAU5D,2EAA2E;AAC3E,eAAO,MAAM,MAAM,qEAMT,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,QAAO,WAAW,CAAC,MAAM,CAYpD,CAAC;AAEF,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAO7C;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,MAAM,SAAuB,GAC5B,IAAI,CAUN;AAwBD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,IAAI,EAAE,SAAS,iBAAiB,EAAE,GACjC,MAAM,CAqBR;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS;QACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;QAC3D,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;QAClC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;QACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;QACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;QACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;KACtC,EAAE,CAAC;IACJ,QAAQ,CAAC,KAAK,EAAE,SAAS;QACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;QACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,EAAE,CAAC;IACJ,QAAQ,CAAC,IAAI,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,IAAI,EAAE,SAAS,iBAAiB,EAAE,GACjC,SAAS,CAyBX"}