@master/css-schema 2.0.0-rc.70

package/README.md

@@ -0,0 +1,5 @@
+# @master/css-schema
+
+Public Master CSS schema and wire-format contracts.
+
+This package owns dependency-light types, serializable constants, and pure codec helpers shared by the compiler, engine, runtime, integrations, and tooling.

package/dist/css-common.d.ts

@@ -0,0 +1 @@
+export type Vendors = 'webkit' | 'moz' | 'ms' | 'o';

package/dist/css-common.mjs

@@ -0,0 +1 @@
+

package/dist/css-directives.d.ts

@@ -0,0 +1,138 @@
+import type { MasterCSSManifestDefaultMode, MasterCSSManifestUtilityKind, MasterCSSManifestModeTrigger, MasterCSSManifestUtilityLayerName, MasterCSSManifestVariant } from './manifest.js';
+export type CSSDirectiveVariableValue = number | string | false | (number | string)[];
+export type CSSDirectiveDeclarations = Record<string, string>;
+export type CSSDirectiveLayerName = MasterCSSManifestUtilityLayerName;
+export type CSSDirectiveModeTrigger = MasterCSSManifestModeTrigger;
+export type CSSDirectiveDefaultMode = MasterCSSManifestDefaultMode;
+export type CSSDirectiveVariantDefinitions = Pick<MasterCSSManifestVariant, 'token' | 'branches'>[];
+export interface CSSDirectiveSourceRange {
+    start: number;
+    end: number;
+}
+export interface CSSDirectiveSourceLocation {
+    line: number;
+    column: number;
+}
+export interface CSSDirectiveSourceReference {
+    file?: string;
+    range: CSSDirectiveSourceRange;
+    loc?: {
+        start: CSSDirectiveSourceLocation;
+        end: CSSDirectiveSourceLocation;
+    };
+}
+export interface CSSDirectiveRelatedInformation {
+    message: string;
+    source?: CSSDirectiveSourceReference;
+}
+export declare class CSSDirectiveError extends Error {
+    code: string;
+    source?: CSSDirectiveSourceReference;
+    related?: CSSDirectiveRelatedInformation[];
+    constructor(code: string, message: string, source?: CSSDirectiveSourceReference, related?: CSSDirectiveRelatedInformation[]);
+}
+export declare function createCSSDirectiveSourceReference(file: string | undefined, range: CSSDirectiveSourceRange, source?: string): CSSDirectiveSourceReference;
+export interface CSSDirectiveVariableDefinition {
+    name?: string;
+    value: CSSDirectiveVariableValue;
+    mode?: string;
+    inline?: boolean;
+    static?: boolean;
+    namespace?: string;
+    key?: string;
+}
+export type CSSDirectiveAnimationDefinitions = Record<string, Record<string, CSSDirectiveDeclarations>>;
+export type CSSDirectiveAnimationOptions = Record<string, {
+    static?: boolean;
+}>;
+export interface CSSDirectiveUtilityRuleDefinition {
+    declarations: CSSDirectiveDeclarations;
+    atRules?: string[];
+    selector?: string;
+}
+export interface CSSDirectiveUtilityPatternDefinition {
+    prefix: string;
+    values: string[];
+}
+export interface CSSDirectiveUtilityDynamicDefinition {
+    key: string;
+    variableAliasRefs?: string[];
+    kind?: MasterCSSManifestUtilityKind;
+    values?: string[];
+    arbitrary?: boolean;
+}
+export interface CSSDirectiveUtilityDefinition {
+    name: string;
+    type?: 'static' | 'pattern' | 'dynamic';
+    layer?: CSSDirectiveLayerName;
+    pattern?: CSSDirectiveUtilityPatternDefinition;
+    dynamic?: CSSDirectiveUtilityDynamicDefinition;
+    declarations?: CSSDirectiveDeclarations;
+    atRules?: string[];
+    rules?: CSSDirectiveUtilityRuleDefinition[];
+}
+export interface CSSDirectiveManifestInput {
+    variants?: CSSDirectiveVariantDefinitions;
+    variables?: CSSDirectiveVariableDefinition[];
+    utilities?: CSSDirectiveUtilityDefinition[];
+    rootSize?: number;
+    baseUnit?: number;
+    defaultMode?: CSSDirectiveDefaultMode;
+    scope?: string;
+    important?: boolean;
+    animations?: CSSDirectiveAnimationDefinitions;
+    animationOptions?: CSSDirectiveAnimationOptions;
+    modes?: string[];
+    modeTrigger?: CSSDirectiveModeTrigger;
+}
+export interface CSSDirectiveExtractionPolicy {
+    include: string[];
+    exclude: string[];
+    safelist: string[];
+    blocklist: (string | RegExp)[];
+    preserveNative: boolean;
+}
+export interface CSSDirectiveReference {
+    source: string;
+    file?: string;
+}
+export interface CSSDirectiveStyleComposeDefinition {
+    type: 'compose';
+    order: number;
+    className: string;
+    selector: string;
+    source?: CSSDirectiveSourceReference;
+    directiveSource?: CSSDirectiveSourceReference;
+    selectorSource?: CSSDirectiveSourceReference;
+    atRules?: string[];
+    layer?: CSSDirectiveLayerName;
+    name?: string;
+}
+export interface CSSDirectiveStyleNativeDefinition {
+    type: 'native';
+    order: number;
+    selector: string;
+    declarations: CSSDirectiveDeclarations;
+    source?: CSSDirectiveSourceReference;
+    selectorSource?: CSSDirectiveSourceReference;
+    atRules?: string[];
+    layer?: CSSDirectiveLayerName;
+    name?: string;
+}
+export type CSSDirectiveStyleDefinition = CSSDirectiveStyleComposeDefinition | CSSDirectiveStyleNativeDefinition;
+export interface CSSDirectiveResult {
+    manifestInput: CSSDirectiveManifestInput;
+    extractionPolicy: CSSDirectiveExtractionPolicy;
+    classNames: string[];
+    nativeClassNames: string[];
+    nativeCSS: string;
+    css: string;
+    generatedCSS: string;
+    warnings: string[];
+    dependencies: string[];
+    references?: CSSDirectiveReference[];
+    styleDefinitions?: CSSDirectiveStyleDefinition[];
+}
+export declare const CSS_DIRECTIVE_VARIANT_REFERENCE_PREFIX = "__master_variant__:";
+export declare function createCSSDirectiveVariantReference(token: string): string;
+export declare function readCSSDirectiveVariantReference(atRule: string): string | undefined;

package/dist/css-directives.mjs

@@ -0,0 +1,51 @@
+class CSSDirectiveError extends Error {
+    code;
+    source;
+    related;
+    constructor(code, message, source, related){
+        super(message);
+        this.name = 'CSSDirectiveError';
+        this.code = code;
+        this.source = source;
+        this.related = related;
+    }
+}
+function offsetToLocation(source, offset) {
+    let line = 1;
+    let column = 1;
+    for(let index = 0; index < offset && index < source.length; index++){
+        if (source[index] === '\n') {
+            line++;
+            column = 1;
+        } else {
+            column++;
+        }
+    }
+    return {
+        line,
+        column
+    };
+}
+function createCSSDirectiveSourceReference(file, range, source) {
+    return {
+        ...file ? {
+            file
+        } : {},
+        range,
+        ...source ? {
+            loc: {
+                start: offsetToLocation(source, range.start),
+                end: offsetToLocation(source, range.end)
+            }
+        } : {}
+    };
+}
+const CSS_DIRECTIVE_VARIANT_REFERENCE_PREFIX = '__master_variant__:';
+function createCSSDirectiveVariantReference(token) {
+    return CSS_DIRECTIVE_VARIANT_REFERENCE_PREFIX + token;
+}
+function readCSSDirectiveVariantReference(atRule) {
+    return atRule.startsWith(CSS_DIRECTIVE_VARIANT_REFERENCE_PREFIX) ? atRule.slice(CSS_DIRECTIVE_VARIANT_REFERENCE_PREFIX.length) : undefined;
+}
+
+export { CSSDirectiveError, CSS_DIRECTIVE_VARIANT_REFERENCE_PREFIX, createCSSDirectiveSourceReference, createCSSDirectiveVariantReference, readCSSDirectiveVariantReference };

package/dist/css-syntax.d.ts

@@ -0,0 +1,92 @@
+import type { MasterCSSManifestUtility, MasterCSSManifestUtilityLayerName, MasterCSSManifestVariableNumericValue } from './manifest.js';
+export type ValueComponent = StringValueComponent | NumberValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;
+export interface StringValueComponent {
+    text?: string;
+    token: string;
+    type: 'string';
+    value: string;
+}
+export interface NumberValueComponent {
+    text?: string;
+    token: string;
+    type: 'number';
+    value: number;
+    unit?: string;
+}
+export interface FunctionValueComponent {
+    text?: string;
+    token: string;
+    type: 'function';
+    name: string;
+    symbol: string;
+    children: ValueComponent[];
+    bypassTransform?: boolean;
+}
+export interface VariableValueComponent {
+    text?: string;
+    token: string;
+    type: 'variable';
+    name: string;
+    alpha?: number;
+    fallback?: string;
+    negative?: boolean;
+    variable?: Variable;
+}
+export interface SeparatorValueComponent {
+    text?: string;
+    token: string;
+    type: 'separator';
+    value: string;
+}
+export interface DefinedUtility {
+    id: string;
+    key?: string;
+    keys: string[];
+    matchers: {
+        key?: RegExp;
+        variable?: RegExp;
+        value?: RegExp;
+        arbitrary?: RegExp;
+    };
+    variables?: Map<string, Variable>;
+    order: number;
+    definition: MasterCSSManifestUtility;
+}
+export type ExplicitUtilityLayerName = MasterCSSManifestUtilityLayerName;
+export interface MediaFeatureComponent {
+    type: string;
+    tokenType?: string;
+    operator?: string;
+    value: number;
+    unit: string;
+}
+export interface MediaQuery {
+    token: string;
+    features: Record<string, MediaFeatureComponent>;
+    type?: string;
+}
+interface VariableCommon {
+    namespace?: string;
+    name: string;
+    key: string;
+    inline?: boolean;
+    static?: boolean;
+    modes?: Record<string, ResolvedVariableValue>;
+    dependencies?: Set<string>;
+}
+export interface StringVariable {
+    type: 'string';
+    value: string | number;
+}
+export interface NumberVariable {
+    type: 'number';
+    value: number | string;
+    numeric?: MasterCSSManifestVariableNumericValue;
+}
+export type ResolvedVariableValue = StringVariable | NumberVariable;
+export type Variable = VariableCommon & {
+    type: ResolvedVariableValue['type'];
+    value?: ResolvedVariableValue['value'];
+    numeric?: MasterCSSManifestVariableNumericValue;
+};
+export {};

package/dist/css-syntax.mjs

@@ -0,0 +1 @@
+

package/dist/hydration-manifest.d.ts

@@ -0,0 +1,32 @@
+import type { MasterCSSManifestUtilityLayerName } from './manifest.js';
+import type { UtilityType } from './utility-type.js';
+export declare const MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID = "master-css-hydration-manifest";
+export declare const MASTER_CSS_HYDRATION_MANIFEST_ATTR = "data-master-css-hydration-manifest";
+export declare const MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE = "/_master-css/hydration/";
+export declare const MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME = "master-css-hydration";
+export interface MasterCSSRulePriorityIR {
+    features?: [string, number, number][];
+    selector: number;
+}
+export interface MasterCSSGeneratedRuleNodeIR {
+    text: string;
+}
+export interface MasterCSSGeneratedRuleIR {
+    className: string;
+    key: string;
+    layer: MasterCSSManifestUtilityLayerName;
+    type: UtilityType;
+    sortTier: number;
+    priority: MasterCSSRulePriorityIR;
+    text: string;
+    nodes?: MasterCSSGeneratedRuleNodeIR[];
+    selectorText?: string;
+    variableNames?: string[];
+    animationNames?: string[];
+}
+export interface MasterCSSHydrationManifest {
+    version: 1;
+    rules: MasterCSSGeneratedRuleIR[];
+}
+export declare function serializeMasterCSSHydrationManifest(hydrationManifest: MasterCSSHydrationManifest): string;
+export declare function createMasterCSSHydrationManifestScript(hydrationManifest: MasterCSSHydrationManifest): string;

package/dist/hydration-manifest.mjs

@@ -0,0 +1,12 @@
+const MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID = 'master-css-hydration-manifest';
+const MASTER_CSS_HYDRATION_MANIFEST_ATTR = 'data-master-css-hydration-manifest';
+const MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE = '/_master-css/hydration/';
+const MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME = 'master-css-hydration';
+function serializeMasterCSSHydrationManifest(hydrationManifest) {
+    return JSON.stringify(hydrationManifest).replace(/</g, '\\u003c');
+}
+function createMasterCSSHydrationManifestScript(hydrationManifest) {
+    return `<script type="application/json" id="${MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID}">${serializeMasterCSSHydrationManifest(hydrationManifest)}</script>`;
+}
+
+export { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './manifest';
+export * from './manifest-json';
+export * from './hydration-manifest';
+export * from './css-directives';
+export * from './css-syntax';
+export * from './utility-type';
+export * from './runtime-style';
+export * from './native-css-shorthand';
+export * from './css-common';

package/dist/index.mjs

@@ -0,0 +1,7 @@
+export { flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables } from './manifest.mjs';
+export { normalizeMasterCSSManifestForJSON, stringifyMasterCSSManifestJSON } from './manifest-json.mjs';
+export { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest } from './hydration-manifest.mjs';
+export { CSSDirectiveError, CSS_DIRECTIVE_VARIANT_REFERENCE_PREFIX, createCSSDirectiveSourceReference, createCSSDirectiveVariantReference, readCSSDirectiveVariantReference } from './css-directives.mjs';
+export { UtilityType } from './utility-type.mjs';
+export { MASTER_CSS_RUNTIME_STYLE_ID } from './runtime-style.mjs';
+export { isNativeCSSShorthandProperty } from './native-css-shorthand.mjs';

package/dist/manifest-json.d.ts

@@ -0,0 +1,3 @@
+import type { MasterCSSManifest } from './manifest.js';
+export declare function normalizeMasterCSSManifestForJSON(manifest: MasterCSSManifest): MasterCSSManifest;
+export declare function stringifyMasterCSSManifestJSON(manifest: MasterCSSManifest): string;

package/dist/manifest-json.mjs

@@ -0,0 +1,62 @@
+function getVariableName(namespace, variable) {
+    return variable.name || (namespace ? `${namespace}${variable.key ? '-' + variable.key : ''}` : variable.key);
+}
+function normalizeTemplateDeclarations(declarations) {
+    const normalized = {};
+    for(const propertyName in declarations){
+        const value = declarations[propertyName];
+        normalized[propertyName] = Array.isArray(value) ? value.map((part)=>part === undefined ? null : part) : value === undefined ? null : value;
+    }
+    return normalized;
+}
+function normalizeVariablesForJSON(variables) {
+    if (!variables) return;
+    const normalized = {};
+    for (const [namespace, definitions] of Object.entries(variables)){
+        const nextDefinitions = definitions.map((definition)=>{
+            const normalizedDefinition = {
+                ...definition
+            };
+            if (normalizedDefinition.namespace === namespace || !namespace) delete normalizedDefinition.namespace;
+            if (normalizedDefinition.name === getVariableName(namespace, normalizedDefinition)) {
+                delete normalizedDefinition.name;
+            }
+            if (normalizedDefinition.type === 'string') delete normalizedDefinition.type;
+            return normalizedDefinition;
+        });
+        if (nextDefinitions.length) normalized[namespace] = nextDefinitions;
+    }
+    return Object.keys(normalized).length ? normalized : undefined;
+}
+function normalizeUtilityForJSON(utility) {
+    const normalized = {
+        ...utility
+    };
+    if (normalized.name === normalized.id) delete normalized.name;
+    if (normalized.layer === 'utilities') delete normalized.layer;
+    delete normalized.order;
+    if (normalized.emit.type !== 'template') return normalized;
+    return {
+        ...normalized,
+        emit: {
+            ...normalized.emit,
+            declarations: normalizeTemplateDeclarations(normalized.emit.declarations)
+        }
+    };
+}
+function normalizeMasterCSSManifestForJSON(manifest) {
+    return {
+        ...manifest,
+        ...manifest.variables ? {
+            variables: normalizeVariablesForJSON(manifest.variables)
+        } : {},
+        ...manifest.utilities?.length ? {
+            utilities: manifest.utilities.map(normalizeUtilityForJSON)
+        } : {}
+    };
+}
+function stringifyMasterCSSManifestJSON(manifest) {
+    return JSON.stringify(normalizeMasterCSSManifestForJSON(manifest));
+}
+
+export { normalizeMasterCSSManifestForJSON, stringifyMasterCSSManifestJSON };

package/dist/manifest.d.ts

@@ -0,0 +1,210 @@
+import type { PropertiesHyphen } from 'csstype';
+import type { UtilityType } from './utility-type.js';
+export type MasterCSSManifestAtIdentifier = 'container' | 'starting-style' | 'supports' | 'media' | 'layer';
+export type MasterCSSManifestUtilityLayerName = 'base' | 'defaults' | 'components' | 'utilities';
+export type MasterCSSManifestDefaultMode = 'light' | 'dark' | 'none' | string;
+export type MasterCSSManifestModeTrigger = 'class' | 'media' | 'host';
+export type MasterCSSManifestVariantToken = `:${string}` | `::${string}` | `@${string}`;
+export type MasterCSSManifestUtilityKind = 'number' | 'color' | 'image';
+/** Defaults to single for variable/value matchers; multiple is an explicit opt-in. */
+export type MasterCSSManifestUtilityMatcherValueSegments = 'single' | 'multiple';
+export type MasterCSSManifestCSSDeclarationPrimitive = string | number | null;
+export type MasterCSSManifestCSSDeclarations = PropertiesHyphen | Record<string, MasterCSSManifestCSSDeclarationPrimitive | MasterCSSManifestCSSDeclarationPrimitive[]>;
+export type MasterCSSManifestVariableValue = number | string | false | (number | string)[];
+export type MasterCSSManifestVariableType = 'number' | 'string';
+export interface MasterCSSManifestVariableNumericValue {
+    value: number;
+    unit?: string;
+}
+export interface MasterCSSManifestAtRuleBooleanNode {
+    raw?: string;
+    name: string;
+    type: 'boolean';
+}
+export interface MasterCSSManifestAtRuleNumberNode {
+    raw?: string;
+    name?: string;
+    type: 'number';
+    value: number;
+    unit?: string;
+    operator?: string;
+}
+export interface MasterCSSManifestAtRuleStringNode {
+    raw?: string;
+    name?: string;
+    type: 'string';
+    value: string;
+}
+export type MasterCSSManifestAtRuleValueNode = MasterCSSManifestAtRuleNumberNode | MasterCSSManifestAtRuleStringNode;
+export interface MasterCSSManifestAtRuleComparisonOperatorNode {
+    type: 'comparison';
+    raw?: string;
+    value: string;
+}
+export interface MasterCSSManifestAtRuleLogicalOperatorNode {
+    type: 'logical';
+    raw?: string;
+    value: string;
+}
+export type MasterCSSManifestAtRuleOperatorNode = MasterCSSManifestAtRuleComparisonOperatorNode | MasterCSSManifestAtRuleLogicalOperatorNode;
+export interface MasterCSSManifestAtRuleGroupNode {
+    type?: 'group';
+    raw?: string;
+    children: MasterCSSManifestAtRuleNode[];
+}
+export type MasterCSSManifestAtRuleNode = MasterCSSManifestAtRuleBooleanNode | MasterCSSManifestAtRuleValueNode | MasterCSSManifestAtRuleComparisonOperatorNode | MasterCSSManifestAtRuleLogicalOperatorNode | MasterCSSManifestAtRuleGroupNode;
+export interface MasterCSSManifestAtRule {
+    id: MasterCSSManifestAtIdentifier;
+    nodes: MasterCSSManifestAtRuleNode[];
+}
+export type MasterCSSManifestAtRules = Record<string, MasterCSSManifestAtRule>;
+export interface MasterCSSManifestSelectorLiteralNode {
+    type?: 'attribute' | 'pseudo-class' | 'pseudo-element' | 'class' | 'universal' | 'id';
+    raw?: string;
+    value?: string;
+    children?: MasterCSSManifestSelectorNode[];
+}
+export interface MasterCSSManifestSelectorSeparatorNode {
+    type: 'separator';
+    raw?: string;
+    value: string;
+}
+export interface MasterCSSManifestSelectorCombinatorNode {
+    type: 'combinator';
+    raw?: string;
+    value: string;
+}
+export type MasterCSSManifestSelectorNode = MasterCSSManifestSelectorLiteralNode | MasterCSSManifestSelectorCombinatorNode | MasterCSSManifestSelectorSeparatorNode;
+export type MasterCSSManifestSelectors = Record<string, MasterCSSManifestSelectorNode[]>;
+export interface MasterCSSManifestSettings {
+    rootSize?: number;
+    baseUnit?: number;
+    defaultMode?: MasterCSSManifestDefaultMode;
+    scope?: string;
+    important?: boolean;
+    modeTrigger?: MasterCSSManifestModeTrigger;
+    modes?: string[];
+}
+export interface MasterCSSManifestVariable {
+    name?: string;
+    key: string;
+    namespace?: string;
+    type?: MasterCSSManifestVariableType;
+    value?: MasterCSSManifestVariableValue;
+    numeric?: MasterCSSManifestVariableNumericValue;
+    modes?: Record<string, {
+        type: MasterCSSManifestVariableType;
+        value: number | string;
+        numeric?: MasterCSSManifestVariableNumericValue;
+    }>;
+    dependencies?: string[];
+    mode?: string;
+    inline?: boolean;
+    static?: boolean;
+}
+export type MasterCSSManifestVariables = Record<string, MasterCSSManifestVariable[]>;
+export type MasterCSSManifestVariableEntry = MasterCSSManifestVariable & {
+    name: string;
+    namespace?: string;
+    type: MasterCSSManifestVariableType;
+};
+export type MasterCSSManifestKeyframes<TDeclarations = MasterCSSManifestCSSDeclarations> = Record<'from' | 'to' | string, TDeclarations>;
+export type MasterCSSManifestAnimations<TDeclarations = MasterCSSManifestCSSDeclarations> = Record<string, MasterCSSManifestKeyframes<TDeclarations>>;
+export type MasterCSSManifestAnimationOptions = Record<string, {
+    static?: boolean;
+}>;
+export interface MasterCSSManifestVariantBranch {
+    selector?: string;
+    selectorNodes?: MasterCSSManifestSelectorNode[];
+    atRules?: string[];
+    atRuleNodes?: MasterCSSManifestAtRule[];
+    layer?: MasterCSSManifestUtilityLayerName;
+}
+export interface MasterCSSManifestVariant {
+    token: MasterCSSManifestVariantToken;
+    branches: MasterCSSManifestVariantBranch[];
+}
+export type MasterCSSManifestVariants = MasterCSSManifestVariant[];
+export type MasterCSSManifestUtilityMatcher = {
+    type: 'static';
+    name: string;
+} | {
+    type: 'pattern';
+    prefix: string;
+    values: string[];
+} | {
+    type: 'key';
+    keys: string[];
+} | {
+    type: 'variable';
+    keys: string[];
+    segments?: MasterCSSManifestUtilityMatcherValueSegments;
+} | {
+    type: 'value';
+    keys: string[];
+    segments?: MasterCSSManifestUtilityMatcherValueSegments;
+};
+export type MasterCSSManifestVariableAlias = [key: string, name: string];
+export type MasterCSSManifestVariableAliasSet = MasterCSSManifestVariableAlias[];
+export type MasterCSSManifestUtilityEmit = {
+    type: 'declarations';
+    declarations: string[];
+} | {
+    type: 'template';
+    declarations: MasterCSSManifestCSSDeclarations;
+} | {
+    type: 'property';
+    property: string;
+} | {
+    type: 'static';
+    rules: MasterCSSManifestUtilityRule[];
+};
+export interface MasterCSSManifestUtilityRule<TDeclarations = MasterCSSManifestCSSDeclarations> {
+    declarations: TDeclarations;
+    atRules?: string[];
+    selector?: string;
+}
+export interface MasterCSSManifestUtility {
+    id: string;
+    name?: string;
+    type: UtilityType;
+    order?: number;
+    layer?: MasterCSSManifestUtilityLayerName;
+    key?: string;
+    subkey?: string;
+    keys?: string[];
+    aliasGroups?: string[];
+    kind?: MasterCSSManifestUtilityKind;
+    namespaces?: string[];
+    implicitNamespace?: boolean;
+    separators?: string[];
+    atRules?: string[];
+    variableAliases?: MasterCSSManifestVariableAliasSet;
+    variableAliasRefs?: string[];
+    emit: MasterCSSManifestUtilityEmit;
+    matchers: MasterCSSManifestUtilityMatcher[];
+    debug?: Record<string, unknown>;
+}
+export type MasterCSSManifestUtilities = MasterCSSManifestUtility[];
+export interface MasterCSSManifest {
+    /**
+     * MasterCSSManifest IR schema/codec version.
+     * This is not a legacy Config compatibility marker; engines must reject
+     * unsupported manifest versions instead of migrating authoring APIs at runtime.
+     */
+    version: 1;
+    settings?: MasterCSSManifestSettings;
+    variables?: MasterCSSManifestVariables;
+    animations?: MasterCSSManifestAnimations;
+    animationOptions?: MasterCSSManifestAnimationOptions;
+    variants?: MasterCSSManifestVariants;
+    atRules?: MasterCSSManifestAtRules;
+    breakpointAtRules?: MasterCSSManifestAtRules;
+    containerAtRules?: MasterCSSManifestAtRules;
+    selectors?: MasterCSSManifestSelectors;
+    utilities?: MasterCSSManifestUtilities;
+    debug?: Record<string, unknown>;
+}
+export declare function getMasterCSSManifestVariableName(namespace: string, variable: Pick<MasterCSSManifestVariable, 'key' | 'name'>): string;
+export declare function flattenMasterCSSManifestVariables(variables: MasterCSSManifestVariables | undefined): MasterCSSManifestVariableEntry[];
+export declare function groupMasterCSSManifestVariables(variables: readonly MasterCSSManifestVariable[] | undefined): MasterCSSManifestVariables | undefined;

package/dist/manifest.mjs

@@ -0,0 +1,33 @@
+function getMasterCSSManifestVariableName(namespace, variable) {
+    return variable.name || (namespace ? `${namespace}${variable.key ? '-' + variable.key : ''}` : variable.key);
+}
+function flattenMasterCSSManifestVariables(variables) {
+    const flattened = [];
+    for (const [namespace, definitions] of Object.entries(variables || {})){
+        for (const definition of definitions){
+            const type = definition.type || (typeof definition.value === 'number' ? 'number' : 'string');
+            flattened.push({
+                ...definition,
+                name: getMasterCSSManifestVariableName(namespace, definition),
+                ...namespace ? {
+                    namespace
+                } : {},
+                type
+            });
+        }
+    }
+    return flattened;
+}
+function groupMasterCSSManifestVariables(variables) {
+    if (!variables?.length) return;
+    const grouped = {};
+    for (const variable of variables){
+        const namespace = variable.namespace || '';
+        const group = grouped[namespace] ||= [];
+        const { namespace: _namespace, ...definition } = variable;
+        group.push(definition);
+    }
+    return Object.keys(grouped).length ? grouped : undefined;
+}
+
+export { flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables };

package/dist/native-css-shorthand.d.ts

@@ -0,0 +1,3 @@
+declare const nativeCSSShorthandProperties: Set<string>;
+export declare function isNativeCSSShorthandProperty(property: string): boolean;
+export default nativeCSSShorthandProperties;

package/dist/native-css-shorthand.mjs

@@ -0,0 +1,85 @@
+const nativeCSSShorthandProperties = new Set([
+    'all',
+    'animation',
+    'animation-range',
+    'background',
+    'background-position',
+    'background-repeat',
+    'border',
+    'border-block',
+    'border-block-color',
+    'border-block-end',
+    'border-block-start',
+    'border-block-style',
+    'border-block-width',
+    'border-bottom',
+    'border-color',
+    'border-image',
+    'border-inline',
+    'border-inline-color',
+    'border-inline-end',
+    'border-inline-start',
+    'border-inline-style',
+    'border-inline-width',
+    'border-left',
+    'border-radius',
+    'border-right',
+    'border-style',
+    'border-top',
+    'border-width',
+    'column-rule',
+    'columns',
+    'contain-intrinsic-size',
+    'container',
+    'flex',
+    'flex-flow',
+    'font',
+    'font-synthesis',
+    'font-variant',
+    'gap',
+    'grid',
+    'grid-area',
+    'grid-column',
+    'grid-row',
+    'grid-template',
+    'inset',
+    'inset-block',
+    'inset-inline',
+    'line-clamp',
+    'list-style',
+    'margin',
+    'margin-block',
+    'margin-inline',
+    'mask',
+    'mask-border',
+    'mask-position',
+    'mask-repeat',
+    'offset',
+    'outline',
+    'overflow',
+    'overscroll-behavior',
+    'padding',
+    'padding-block',
+    'padding-inline',
+    'place-content',
+    'place-items',
+    'place-self',
+    'scroll-margin',
+    'scroll-margin-block',
+    'scroll-margin-inline',
+    'scroll-padding',
+    'scroll-padding-block',
+    'scroll-padding-inline',
+    'scroll-timeline',
+    'text-decoration',
+    'text-emphasis',
+    'text-wrap',
+    'transition',
+    'view-timeline',
+    'white-space'
+]);
+function isNativeCSSShorthandProperty(property) {
+    return nativeCSSShorthandProperties.has(property);
+}
+
+export { nativeCSSShorthandProperties as default, isNativeCSSShorthandProperty };

package/dist/runtime-style.d.ts

@@ -0,0 +1 @@
+export declare const MASTER_CSS_RUNTIME_STYLE_ID = "master-css";

package/dist/runtime-style.mjs

@@ -0,0 +1,3 @@
+const MASTER_CSS_RUNTIME_STYLE_ID = 'master-css';
+
+export { MASTER_CSS_RUNTIME_STYLE_ID };

package/dist/utility-type.d.ts

@@ -0,0 +1,19 @@
+export declare const UtilityType: {
+    /**
+     * semantic utility classes
+     * @example block, inline
+     */
+    readonly Semantic: -2;
+    /**
+     * shorthand
+     * @example border, padding, margin
+     */
+    readonly Shorthand: -1;
+    /**
+     * normal
+     * @example grid-cols
+     */
+    readonly Normal: 0;
+};
+export type UtilityType = typeof UtilityType[keyof typeof UtilityType];
+export default UtilityType;

package/dist/utility-type.mjs

@@ -0,0 +1,16 @@
+const UtilityType = {
+    /**
+     * semantic utility classes
+     * @example block, inline
+     */ Semantic: -2,
+    /**
+     * shorthand
+     * @example border, padding, margin
+     */ Shorthand: -1,
+    /**
+     * normal
+     * @example grid-cols
+     */ Normal: 0
+};
+
+export { UtilityType, UtilityType as default };

package/package.json

@@ -0,0 +1 @@
+{"name":"@master/css-schema","type":"module","scripts":{"build":"techor build \"src/**/*.ts\" --formats esm","dev":"pnpm build --watch","lint":"eslint","type-check":"tsc --noEmit","test":"vitest"},"license":"MIT","description":"Public Master CSS schema and wire-format contracts.","author":"Aoyue Design LLC.","funding":"https://rc.css.master.co/sponsor","homepage":"https://css.master.co","bugs":{"url":"https://github.com/master-co/css/issues"},"repository":{"type":"git","url":"https://github.com/master-co/css.git","directory":"packages/schema"},"keywords":["schema","manifest","css","mastercss"],"sideEffects":false,"main":"./dist/index.mjs","jsnext:main":"./dist/index.mjs","esnext":"./dist/index.mjs","module":"./dist/index.mjs","types":"./dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.mjs","default":"./dist/index.mjs"},"./manifest":{"types":"./dist/manifest.d.ts","import":"./dist/manifest.mjs","default":"./dist/manifest.mjs"},"./manifest-json":{"types":"./dist/manifest-json.d.ts","import":"./dist/manifest-json.mjs","default":"./dist/manifest-json.mjs"},"./hydration-manifest":{"types":"./dist/hydration-manifest.d.ts","import":"./dist/hydration-manifest.mjs","default":"./dist/hydration-manifest.mjs"},"./css-directives":{"types":"./dist/css-directives.d.ts","import":"./dist/css-directives.mjs","default":"./dist/css-directives.mjs"},"./css-syntax":{"types":"./dist/css-syntax.d.ts","import":"./dist/css-syntax.mjs","default":"./dist/css-syntax.mjs"},"./utility-type":{"types":"./dist/utility-type.d.ts","import":"./dist/utility-type.mjs","default":"./dist/utility-type.mjs"},"./runtime-style":{"types":"./dist/runtime-style.d.ts","import":"./dist/runtime-style.mjs","default":"./dist/runtime-style.mjs"},"./native-css-shorthand":{"types":"./dist/native-css-shorthand.d.ts","import":"./dist/native-css-shorthand.mjs","default":"./dist/native-css-shorthand.mjs"},"./css-common":{"types":"./dist/css-common.d.ts","import":"./dist/css-common.mjs","default":"./dist/css-common.mjs"}},"files":["dist"],"publishConfig":{"access":"public","provenance":true},"dependencies":{"csstype":"^3.2.3"},"version":"2.0.0-rc.70"}