@master/css-engine 2.0.0-rc.70

package/dist/compile-manifest.mjs

@@ -0,0 +1,451 @@
+import { isNativeCSSShorthandProperty } from '@master/css-schema/native-css-shorthand';
+import { flattenMasterCSSManifestVariables } from '@master/css-schema/manifest';
+import UtilityType from '@master/css-schema/utility-type';
+import { MATCH_NAME_BOUNDARY } from './common.mjs';
+import { builtinKeyAliases as keyAliases } from './key-aliases.mjs';
+import { builtinNativeValueNamespaces as nativeValueNamespaces } from './native-value-namespaces.mjs';
+
+const DEFAULT_SETTINGS = {
+    rootSize: 16,
+    baseUnit: 4,
+    defaultMode: 'light',
+    modeTrigger: 'media',
+    modes: [
+        'light',
+        'dark'
+    ]
+};
+// Manifests are compiled by object identity. Mutating a manifest after first use is unsupported.
+const compiledManifestCache = new WeakMap();
+function assertMasterCSSManifest(manifest) {
+    if (!manifest || manifest.version !== 1) {
+        throw new TypeError('Unsupported MasterCSSManifest version. Expected version 1.');
+    }
+    if (Array.isArray(manifest.variables)) {
+        throw new TypeError('Unsupported MasterCSSManifest variables format. Expected namespace-grouped variables.');
+    }
+    if ('utilityBuckets' in manifest) {
+        throw new TypeError('Unsupported MasterCSSManifest utilityBuckets field. Matcher indexes are engine-derived.');
+    }
+}
+function pushUnique(target, values) {
+    for (const value of values){
+        if (!target.includes(value)) target.push(value);
+    }
+}
+function deriveUtilityMetadata(utility) {
+    const keys = utility.keys ? [
+        ...utility.keys
+    ] : [];
+    const aliasGroups = utility.aliasGroups ? [
+        ...utility.aliasGroups
+    ] : [];
+    for (const matcher of utility.matchers){
+        if (matcher.type === 'key') {
+            pushUnique(keys, matcher.keys);
+        } else if (matcher.type === 'variable' || matcher.type === 'value') {
+            pushUnique(aliasGroups, matcher.keys);
+        }
+    }
+    if (keys.length && !utility.keys) utility.keys = keys;
+    if (aliasGroups.length && !utility.aliasGroups) utility.aliasGroups = aliasGroups;
+    if (!utility.key) utility.key = keys[0] || aliasGroups[0];
+}
+function isPureNativeDeclarationUtilityDefinition(utility) {
+    return utility.emit.type === 'property' && utility.id === utility.emit.property && utility.name === utility.emit.property && !utility.variableAliasRefs?.length && !utility.variableAliases?.length && !utility.kind && !utility.atRules?.length;
+}
+function getVariableKeyByNamespace(variableName, namespace) {
+    const negative = variableName.startsWith('-');
+    const positiveName = negative ? variableName.slice(1) : variableName;
+    if (positiveName !== namespace && !positiveName.startsWith(namespace + '-')) return;
+    const key = positiveName === namespace ? '' : positiveName.slice(namespace.length + 1);
+    return negative ? '-' + key : key;
+}
+function isIndexableMatchName(name) {
+    for(let index = 0; index < name.length; index++){
+        if (MATCH_NAME_BOUNDARY.has(name[index])) return false;
+    }
+    return true;
+}
+function pushIndexedUtility(index, key, utility) {
+    const utilities = index.get(key);
+    if (utilities) {
+        if (!utilities.includes(utility)) utilities.push(utility);
+    } else {
+        index.set(key, [
+            utility
+        ]);
+    }
+}
+function createKeyedMatcherIndex(utilities, matcherType) {
+    const index = new Map();
+    for (const utility of utilities){
+        for (const matcher of utility.matchers){
+            if (matcher.type !== matcherType) continue;
+            for (const key of matcher.keys){
+                pushIndexedUtility(index, key, utility);
+            }
+        }
+    }
+    return index;
+}
+function createPatternMatcherIndex(utilities) {
+    const index = new Map();
+    for (const utility of utilities){
+        for (const matcher of utility.matchers){
+            if (matcher.type !== 'pattern') continue;
+            for (const value of matcher.values){
+                const name = matcher.prefix + value;
+                if (isIndexableMatchName(name)) {
+                    pushIndexedUtility(index, name, utility);
+                }
+            }
+        }
+    }
+    return index;
+}
+function canIndexPatternUtilities(utilities) {
+    return utilities.every((utility)=>utility.matchers.every((matcher)=>matcher.type !== 'pattern' || matcher.values.every((value)=>isIndexableMatchName(matcher.prefix + value))));
+}
+function createStaticMatcherIndex(utilities) {
+    const index = new Map();
+    for (const utility of utilities){
+        for (const matcher of utility.matchers){
+            if (matcher.type === 'static' && isIndexableMatchName(matcher.name)) {
+                pushIndexedUtility(index, matcher.name, utility);
+            }
+        }
+    }
+    return index;
+}
+function canIndexStaticOnlyUtilities(utilities) {
+    return utilities.every((utility)=>utility.matchers.length && utility.matchers.every((matcher)=>matcher.type === 'static' && isIndexableMatchName(matcher.name)));
+}
+function createCompiledSettings(manifest) {
+    return {
+        ...DEFAULT_SETTINGS,
+        ...manifest.settings || {},
+        modes: manifest.settings?.modes ? [
+            ...manifest.settings.modes
+        ] : [
+            ...DEFAULT_SETTINGS.modes
+        ]
+    };
+}
+function cloneCompiledSettings(settings) {
+    return {
+        ...settings,
+        modes: [
+            ...settings.modes
+        ]
+    };
+}
+function compileKeyAliases() {
+    const keyAliases$1 = new Map();
+    for (const [key, property] of Object.entries(keyAliases)){
+        if (key && property && key !== property) {
+            keyAliases$1.set(key, property);
+        }
+    }
+    return keyAliases$1;
+}
+function compileVariables(manifest) {
+    const variables = new Map();
+    for (const definition of flattenMasterCSSManifestVariables(manifest.variables)){
+        if (!definition.name || !definition.type || definition.value === false) continue;
+        variables.set(definition.name, {
+            name: definition.name,
+            key: definition.key,
+            type: definition.type,
+            ...definition.namespace ? {
+                namespace: definition.namespace
+            } : {},
+            ...definition.value !== undefined ? {
+                value: Array.isArray(definition.value) ? definition.value.join(',') : definition.value
+            } : {},
+            ...definition.numeric ? {
+                numeric: {
+                    ...definition.numeric
+                }
+            } : {},
+            ...definition.modes ? {
+                modes: {
+                    ...definition.modes
+                }
+            } : {},
+            ...definition.dependencies?.length ? {
+                dependencies: new Set(definition.dependencies)
+            } : {},
+            ...definition.inline ? {
+                inline: true
+            } : {},
+            ...definition.static ? {
+                static: true
+            } : {}
+        });
+    }
+    return variables;
+}
+function compileAnimations(manifest) {
+    const animations = new Map();
+    if (!manifest.animations) return animations;
+    for(const animationName in manifest.animations){
+        const eachAnimation = {};
+        animations.set(animationName, eachAnimation);
+        const eachKeyframes = manifest.animations[animationName];
+        for(const eachKeyframeValue in eachKeyframes){
+            const newValueByPropertyName = eachAnimation[eachKeyframeValue] = {};
+            const eachKeyframeDeclarations = eachKeyframes[eachKeyframeValue];
+            for(const propertyName in eachKeyframeDeclarations){
+                newValueByPropertyName[propertyName] = eachKeyframeDeclarations[propertyName];
+            }
+        }
+    }
+    return animations;
+}
+function compileAtRuleMap(atRules) {
+    const target = new Map();
+    if (!atRules) return target;
+    for (const [name, atRule] of Object.entries(atRules)){
+        target.set(name, {
+            id: atRule.id,
+            nodes: atRule.nodes
+        });
+    }
+    return target;
+}
+function compileVariantAliases(manifest) {
+    const selectors = new Map();
+    if (manifest.selectors) {
+        for (const [name, nodes] of Object.entries(manifest.selectors)){
+            selectors.set(name, nodes);
+        }
+    }
+    const variants = new Map();
+    for (const variant of manifest.variants || []){
+        variants.set(variant.token, variant.branches.map((branch)=>({
+                ...branch,
+                ...branch.selectorNodes?.length ? {
+                    selectorNodes: branch.selectorNodes
+                } : {},
+                ...branch.atRules?.length ? {
+                    atRules: [
+                        ...branch.atRules
+                    ]
+                } : {},
+                ...branch.atRuleNodes?.length ? {
+                    atRuleNodes: branch.atRuleNodes.map((atRule)=>({
+                            id: atRule.id,
+                            nodes: atRule.nodes
+                        }))
+                } : {}
+            })));
+    }
+    return {
+        selectors,
+        variants
+    };
+}
+function createVariableAliasRefResolver(variables) {
+    const aliasRefCache = new Map();
+    return (ref)=>{
+        const cached = aliasRefCache.get(ref);
+        if (cached) return cached;
+        const namespace = ref[0] === '=' || ref[0] === '~' ? ref.slice(1) : '';
+        const aliases = [];
+        const usedKeys = new Set();
+        if (namespace) {
+            for (const variable of variables.values()){
+                const key = getVariableKeyByNamespace(variable.name, namespace);
+                if (key === undefined || usedKeys.has(key)) continue;
+                usedKeys.add(key);
+                aliases.push([
+                    key,
+                    variable.name
+                ]);
+            }
+        }
+        aliasRefCache.set(ref, aliases);
+        return aliases;
+    };
+}
+function compileUtilityDefinition(utility, variables, resolveAliasRef, index = 0, count = 1) {
+    const definedUtility = {
+        ...utility,
+        name: utility.name || utility.id,
+        order: utility.order ?? count - index - 1,
+        layer: utility.layer || 'utilities',
+        matchers: utility.matchers.map((matcher)=>({
+                ...matcher
+            }))
+    };
+    const variableAliases = [
+        ...utility.variableAliases || [],
+        ...(utility.variableAliasRefs || []).flatMap(resolveAliasRef)
+    ];
+    if (variableAliases.length) {
+        definedUtility.variables = new Map();
+        for (const [variableKey, variableName] of variableAliases){
+            if (definedUtility.variables.has(variableKey)) continue;
+            const variable = variables.get(variableName);
+            if (variable) definedUtility.variables.set(variableKey, variable);
+        }
+    }
+    deriveUtilityMetadata(definedUtility);
+    return definedUtility;
+}
+function createNativeValueNamespaceUtility(property, namespace) {
+    return {
+        id: property,
+        name: property,
+        type: isNativeCSSShorthandProperty(property) ? UtilityType.Shorthand : UtilityType.Normal,
+        order: 0,
+        variableAliasRefs: [
+            ...namespace.variableAliasRefs
+        ],
+        emit: {
+            type: 'property',
+            property
+        },
+        matchers: [
+            {
+                type: 'key',
+                keys: [
+                    property
+                ]
+            }
+        ]
+    };
+}
+function compileNativeValueNamespaces(variables, resolveAliasRef) {
+    const nativeValueNamespaceUtilities = new Map();
+    for (const namespace of nativeValueNamespaces){
+        if (!namespace.properties?.length || !namespace.variableAliasRefs?.length) continue;
+        for (const property of namespace.properties){
+            if (!property || nativeValueNamespaceUtilities.has(property)) continue;
+            const utility = compileUtilityDefinition(createNativeValueNamespaceUtility(property, namespace), variables, resolveAliasRef);
+            nativeValueNamespaceUtilities.set(property, utility);
+        }
+    }
+    return nativeValueNamespaceUtilities;
+}
+function registerNativeDeclarationFastPathPolicy(target, utility) {
+    const isPureNativeDeclaration = isPureNativeDeclarationUtilityDefinition(utility);
+    for (const matcher of utility.matchers){
+        if (matcher.type !== 'key' && matcher.type !== 'value' && matcher.type !== 'variable') continue;
+        for (const key of matcher.keys){
+            if (isPureNativeDeclaration && key === utility.emit.property) continue;
+            target.add(key);
+        }
+    }
+}
+function pushBucketUtility(target, utility) {
+    if (!target.includes(utility)) target.push(utility);
+}
+function registerUtilityMatcherBuckets(utility, buckets) {
+    for (const matcher of utility.matchers){
+        switch(matcher.type){
+            case 'variable':
+                if (utility.variableAliases?.length || utility.variableAliasRefs?.length) {
+                    pushBucketUtility(buckets.variableMatcherUtilities, utility);
+                }
+                break;
+            case 'value':
+                if (utility.kind) pushBucketUtility(buckets.valueMatcherUtilities, utility);
+                break;
+            case 'key':
+                pushBucketUtility(buckets.keyMatcherUtilities, utility);
+                break;
+            case 'pattern':
+                pushBucketUtility(buckets.patternMatcherUtilities, utility);
+                break;
+            default:
+                pushBucketUtility(buckets.arbitraryMatcherUtilities, utility);
+                break;
+        }
+    }
+}
+function compileUtilities(manifest, variables, resolveAliasRef) {
+    const definedUtilities = [];
+    const variableMatcherUtilities = [];
+    const valueMatcherUtilities = [];
+    const keyMatcherUtilities = [];
+    const patternMatcherUtilities = [];
+    const arbitraryMatcherUtilities = [];
+    const nativeDeclarationFastPathBlockedProperties = new Set();
+    const manifestUtilities = manifest.utilities || [];
+    for(let index = 0; index < manifestUtilities.length; index++){
+        const utility = manifestUtilities[index];
+        const definedUtility = compileUtilityDefinition(utility, variables, resolveAliasRef, index, manifestUtilities.length);
+        registerNativeDeclarationFastPathPolicy(nativeDeclarationFastPathBlockedProperties, definedUtility);
+        definedUtilities.push(definedUtility);
+        registerUtilityMatcherBuckets(definedUtility, {
+            variableMatcherUtilities,
+            valueMatcherUtilities,
+            keyMatcherUtilities,
+            patternMatcherUtilities,
+            arbitraryMatcherUtilities
+        });
+    }
+    return {
+        definedUtilities,
+        variableMatcherUtilities,
+        valueMatcherUtilities,
+        keyMatcherUtilities,
+        patternMatcherUtilities,
+        arbitraryMatcherUtilities,
+        variableMatcherIndex: createKeyedMatcherIndex(variableMatcherUtilities, 'variable'),
+        valueMatcherIndex: createKeyedMatcherIndex(valueMatcherUtilities, 'value'),
+        keyMatcherIndex: createKeyedMatcherIndex(keyMatcherUtilities, 'key'),
+        patternMatcherIndex: canIndexPatternUtilities(patternMatcherUtilities) ? createPatternMatcherIndex(patternMatcherUtilities) : undefined,
+        arbitraryStaticMatcherIndex: canIndexStaticOnlyUtilities(arbitraryMatcherUtilities) ? createStaticMatcherIndex(arbitraryMatcherUtilities) : undefined,
+        nativeDeclarationFastPathBlockedProperties
+    };
+}
+function compileManifest(manifest) {
+    assertMasterCSSManifest(manifest);
+    const settings = createCompiledSettings(manifest);
+    const variables = compileVariables(manifest);
+    const animations = compileAnimations(manifest);
+    const { selectors, variants } = compileVariantAliases(manifest);
+    const resolveAliasRef = createVariableAliasRefResolver(variables);
+    const nativeValueNamespaceUtilities = compileNativeValueNamespaces(variables, resolveAliasRef);
+    const utilities = compileUtilities(manifest, variables, resolveAliasRef);
+    return {
+        manifest,
+        settings,
+        definedUtilities: utilities.definedUtilities,
+        variableMatcherUtilities: utilities.variableMatcherUtilities,
+        valueMatcherUtilities: utilities.valueMatcherUtilities,
+        keyMatcherUtilities: utilities.keyMatcherUtilities,
+        patternMatcherUtilities: utilities.patternMatcherUtilities,
+        arbitraryMatcherUtilities: utilities.arbitraryMatcherUtilities,
+        variableMatcherIndex: utilities.variableMatcherIndex,
+        valueMatcherIndex: utilities.valueMatcherIndex,
+        keyMatcherIndex: utilities.keyMatcherIndex,
+        patternMatcherIndex: utilities.patternMatcherIndex,
+        arbitraryStaticMatcherIndex: utilities.arbitraryStaticMatcherIndex,
+        selectors,
+        variables,
+        modes: [
+            ...settings.modes
+        ],
+        atRules: compileAtRuleMap(manifest.atRules),
+        variants,
+        breakpointAtRules: compileAtRuleMap(manifest.breakpointAtRules),
+        containerAtRules: compileAtRuleMap(manifest.containerAtRules),
+        animations,
+        nativeDeclarationFastPathBlockedProperties: utilities.nativeDeclarationFastPathBlockedProperties,
+        nativeValueNamespaceUtilities,
+        keyAliases: compileKeyAliases()
+    };
+}
+function getCompiledManifest(manifest) {
+    const cached = compiledManifestCache.get(manifest);
+    if (cached) return cached;
+    const compiledManifest = compileManifest(manifest);
+    compiledManifestCache.set(manifest, compiledManifest);
+    return compiledManifest;
+}
+
+export { cloneCompiledSettings, compileManifest, getCompiledManifest, isPureNativeDeclarationUtilityDefinition };

package/dist/compiler.d.ts

@@ -0,0 +1,32 @@
+import MasterCSS from './core';
+import parseAt from './utils/parse-at';
+import generateAt from './utils/generate-at';
+import parseSelector from './utils/parse-selector';
+import generateSelector from './utils/generate-selector';
+import compareRulePriority from './utils/compare-rule-priority';
+import type { Utility } from './utility';
+import type { MasterCSSManifest } from '@master/css-schema/manifest';
+import type { MasterCSSEmittedGlobals } from './emitted-globals';
+import type { MasterCSSOptions } from './core';
+export { MasterCSS, compareRulePriority, generateAt, generateSelector, parseAt, parseSelector };
+export type { Utility as GeneratedRule };
+export type * from '@master/css-schema/manifest';
+export declare function createCompilerCSS(manifest: MasterCSSManifest, emittedGlobals?: MasterCSSEmittedGlobals, options?: MasterCSSOptions): MasterCSS;
+export declare function expandClassName(manifest: MasterCSSManifest, className: string, mode?: string): Utility[];
+export declare function inspectGeneratedRule(rule: Utility): {
+    className: string;
+    key: string;
+    layer: import("@master/css-schema/manifest").MasterCSSManifestUtilityLayerName;
+    explicitLayer: import("@master/css-schema/manifest").MasterCSSManifestUtilityLayerName | undefined;
+    selector: string;
+    declarations: import("csstype").PropertiesHyphen<0 | (string & {}), string & {}> | undefined;
+    declarationRules: {
+        declarations: import("csstype").PropertiesHyphen;
+        atRules?: string[];
+        selector?: string;
+    }[] | undefined;
+    atRules: Partial<Record<import("@master/css-schema/manifest").MasterCSSManifestAtIdentifier, import("./utils/parse-at").AtRuleNode[]>> | undefined;
+    priority: import("./utils/compare-rule-priority").RulePriority;
+    variableNames: string[];
+    animationNames: string[];
+};

package/dist/compiler.mjs

@@ -0,0 +1,38 @@
+import MasterCSS from './core.mjs';
+export { default as parseAt } from './utils/parse-at.mjs';
+export { default as generateAt } from './utils/generate-at.mjs';
+export { default as parseSelector } from './utils/parse-selector.mjs';
+export { default as generateSelector } from './utils/generate-selector.mjs';
+export { default as compareRulePriority } from './utils/compare-rule-priority.mjs';
+
+function createCompilerCSS(manifest, emittedGlobals, options) {
+    return MasterCSS.create({
+        manifest,
+        emittedGlobals,
+        ...options
+    });
+}
+function expandClassName(manifest, className, mode) {
+    return createCompilerCSS(manifest).createRules(className, undefined, mode);
+}
+function inspectGeneratedRule(rule) {
+    return {
+        className: rule.name,
+        key: rule.key,
+        layer: rule.layerName,
+        explicitLayer: rule.explicitLayerName,
+        selector: rule.selectorText,
+        declarations: rule.declarations,
+        declarationRules: rule.declarationRules,
+        atRules: rule.atRules,
+        priority: rule.priority,
+        variableNames: rule.variableNames ? [
+            ...rule.variableNames
+        ] : [],
+        animationNames: rule.animationNames ? [
+            ...rule.animationNames
+        ] : []
+    };
+}
+
+export { MasterCSS, createCompilerCSS, expandClassName, inspectGeneratedRule };

package/dist/core.d.ts

@@ -0,0 +1,141 @@
+import { Utility } from './utility';
+import type { Rule } from './rule';
+import Layer from './layer';
+import ThemeLayer from './theme-layer';
+import UtilityLayer from './utility-layer';
+import NonLayer from './non-layer';
+import type { Variable } from '@master/css-schema/css-syntax';
+import type { AtRule } from './utils/parse-at';
+import type { SelectorNode } from './utils/parse-selector';
+import type { MasterCSSEmittedGlobals } from './emitted-globals';
+import type { MasterCSSManifest, MasterCSSManifestUtilityLayerName, MasterCSSManifestVariantBranch, MasterCSSManifestVariantToken } from '@master/css-schema/manifest';
+import { type CompiledUtility, type EngineSettings } from './compile-manifest';
+export type { CompiledUtility } from './compile-manifest';
+export interface NativeCSSDeclaration {
+    property: string;
+    value: string;
+}
+export type NativeCSSDeclarationMatcher = (declaration: NativeCSSDeclaration) => boolean;
+export interface MasterCSSOptions {
+    nativeDeclarationMatcher?: NativeCSSDeclarationMatcher;
+}
+export interface MasterCSSCreateOptions extends MasterCSSOptions {
+    manifest: MasterCSSManifest;
+    emittedGlobals?: MasterCSSEmittedGlobals;
+}
+export default class MasterCSS {
+    protected readonly options: MasterCSSOptions;
+    definedUtilities: CompiledUtility[];
+    protected variableMatcherUtilities: CompiledUtility[];
+    protected valueMatcherUtilities: CompiledUtility[];
+    protected keyMatcherUtilities: CompiledUtility[];
+    protected patternMatcherUtilities: CompiledUtility[];
+    protected arbitraryMatcherUtilities: CompiledUtility[];
+    protected variableMatcherIndex: Map<string, CompiledUtility[]>;
+    protected valueMatcherIndex: Map<string, CompiledUtility[]>;
+    protected keyMatcherIndex: Map<string, CompiledUtility[]>;
+    protected patternMatcherIndex?: Map<string, CompiledUtility[]>;
+    protected arbitraryStaticMatcherIndex?: Map<string, CompiledUtility[]>;
+    settings: EngineSettings;
+    readonly rules: (Layer | Rule)[];
+    readonly classUtilities: Map<string, Utility[]>;
+    readonly animationsNonLayer: NonLayer;
+    readonly baseLayer: UtilityLayer;
+    readonly themeLayer: ThemeLayer;
+    readonly defaultsLayer: UtilityLayer;
+    readonly componentsLayer: UtilityLayer;
+    readonly utilitiesLayer: UtilityLayer;
+    selectors: Map<string, SelectorNode[]>;
+    variables: Map<string, Variable>;
+    modes: string[];
+    atRules: Map<string, AtRule>;
+    variants: Map<MasterCSSManifestVariantToken, MasterCSSManifestVariantBranch[]>;
+    breakpointAtRules: Map<string, AtRule>;
+    containerAtRules: Map<string, AtRule>;
+    animations: Map<string, import("@master/css-schema/manifest").MasterCSSManifestKeyframes<import("@master/css-schema/manifest").MasterCSSManifestCSSDeclarations>>;
+    protected readonly staticVariableTokens: Set<string>;
+    protected readonly staticAnimationTokens: Set<string>;
+    readonly emittedGlobals: Required<MasterCSSEmittedGlobals>;
+    protected nativeDeclarationFastPathBlockedProperties: Set<string>;
+    protected readonly nativeDeclarationMatches: Map<string, boolean>;
+    protected readonly nativeDeclarationUtilities: Map<string, CompiledUtility>;
+    protected nativeValueNamespaceUtilities: Map<string, CompiledUtility>;
+    protected keyAliases: Map<string, string>;
+    manifest: MasterCSSManifest;
+    static create(options: MasterCSSCreateOptions): MasterCSS;
+    protected constructor(manifest: MasterCSSManifest, emittedGlobals?: MasterCSSEmittedGlobals, options?: MasterCSSOptions);
+    get text(): string;
+    getUtilityLayer(layerName?: MasterCSSManifestUtilityLayerName): UtilityLayer;
+    getUtilityLayers(): UtilityLayer[];
+    loadManifest(manifest: MasterCSSManifest): void;
+    protected applyEmittedGlobalsCounts(emittedGlobals: MasterCSSEmittedGlobals): void;
+    registerEmittedGlobals(emittedGlobals?: MasterCSSEmittedGlobals): void;
+    isEmittedGlobalsVariable(name: string): boolean;
+    isEmittedGlobalsAnimation(name: string): boolean;
+    protected insertStaticVariable(name: string, visited?: Set<string>): void;
+    protected insertStaticAnimation(name: string): void;
+    insertStaticResources(): this;
+    resolveVariant(token: MasterCSSManifestVariantToken): MasterCSSManifestVariantBranch[] | undefined;
+    parseValue(token: string | number, unit?: string): import("@master/css-schema/css-syntax").StringValueComponent | import("@master/css-schema/css-syntax").NumberValueComponent;
+    /**
+     * Match check if Master CSS utility
+     * @param className
+     * @returns css text
+     */
+    private matchesMatcher;
+    private matchesUtility;
+    private matchesExactUtilityDefinition;
+    private hasClassKey;
+    private isGroupClassName;
+    private getClassKeyAlias;
+    private canonicalizeClassName;
+    private matchResolvedClassName;
+    private createGroupUtility;
+    private createAllGroupUtilities;
+    private matchRawManagedClassName;
+    match(className: string): CompiledUtility | undefined;
+    private matchAllResolvedClassName;
+    private matchAllRawManagedClassName;
+    matchAll(className: string): CompiledUtility[];
+    private parseNativeDeclarationProperty;
+    private getNativeDeclarationUtility;
+    private matchNativeDeclaration;
+    private isNativeDeclarationUtility;
+    private shouldValidateNativeDeclarationUtility;
+    private createNativeDeclarationFallback;
+    private createNativeValueNamespaceFallback;
+    private createNativeValueNamespaceFastPath;
+    private createNativeDeclarationFastPath;
+    /**
+     * Generate utilities from class name
+     * @param className
+     * @returns Utility[]
+     */
+    generate(className: string, mode?: string): Utility[];
+    /**
+     * Create utility from given class name
+     * @param className
+     * @returns Utility
+     */
+    createRule(className: string, fixedClass?: string, mode?: string): Utility | undefined;
+    createRules(className: string, fixedClass?: string, mode?: string): Utility[];
+    protected createRuleWithDefinition(className: string, registeredUtility: CompiledUtility, fixedClass?: string, mode?: string, branchIndex?: number): Utility | undefined;
+    /**
+     * Create utility from given selector text
+     * @param selectorText
+     */
+    createRulesFromSelectorText(selectorText: string, layerName?: MasterCSSManifestUtilityLayerName): Utility[] | undefined;
+    /**
+     * 根據蒐集到的所有 DOM class 重新 create
+     */
+    refresh(manifest?: MasterCSSManifest): this;
+    reset(): this;
+    destroy(): this;
+    add(...classNames: string[]): this;
+    remove(...classNames: string[]): void;
+    getModeSelector(modeName: string): string | undefined;
+}
+export default interface MasterCSS {
+    style: HTMLStyleElement | null;
+    Native: typeof CSS;
+}