@master/css 2.0.0-rc.47 → 2.0.0-rc.49

package/dist/types/config.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types/config.d.ts

@@ -0,0 +1,70 @@
+import type { PropertiesHyphen } from 'csstype';
+import type SyntaxRuleType from '../syntax-rule-type';
+import type { SyntaxRule } from '../syntax-rule';
+import type { ValueComponent } from './syntax';
+import type { rules, utilities } from '../config';
+export interface SyntaxRuleDefinition {
+    type?: SyntaxRuleType;
+    matcher?: RegExp;
+    sign?: string;
+    key?: string;
+    subkey?: string;
+    ambiguousKeys?: string[];
+    ambiguousValues?: (RegExp | string)[];
+    variables?: string[];
+    separators?: string[];
+    unit?: any;
+    declarations?: PropertiesHyphen;
+    includeAnimations?: boolean;
+    analyze?: (this: SyntaxRule, className: string) => [valueToken: string, prefixToken?: string];
+    transformValue?(this: SyntaxRule, value: string): string;
+    transformValueComponents?(this: SyntaxRule, valueComponents: ValueComponent[]): ValueComponent[];
+    declare?(this: SyntaxRule, value: string, valueComponents: ValueComponent[]): PropertiesHyphen;
+    delete?(this: SyntaxRule, className: string): void;
+    create?(this: SyntaxRule, className: string): void;
+    insert?(this: SyntaxRule): void;
+}
+export type VariableValue = number | string | false | (number | string)[];
+export type VariableDefinition = {
+    [key in '' | `@${string}` | string]?: VariableValue | VariableDefinition;
+} | VariableValue;
+export type CSSKeyframes = Record<'from' | 'to' | string, PropertiesHyphen>;
+export type AnimationDefinitions = Record<string, CSSKeyframes>;
+export type SelectorDefinitions = Record<string, string | string[]>;
+export interface AtDefinitions {
+    [key: string]: number | string | AtDefinitions;
+}
+export interface StyleDefinitions {
+    [key: string]: string | StyleDefinitions;
+}
+export type SyntaxRuleDefinitions = Partial<Record<keyof typeof rules | string, SyntaxRuleDefinition>>;
+export type VariableDefinitions = {
+    [key in keyof typeof rules]?: VariableDefinition;
+} & Record<string, VariableDefinition>;
+export type UtilityDefinitions = {
+    [key in keyof typeof utilities]?: PropertiesHyphen;
+} & Record<string, PropertiesHyphen>;
+export type ModeDefinitions = Record<string, 'class' | 'media' | 'host' | false>;
+export interface FunctionDefinition {
+    unit?: string;
+    transform?(this: SyntaxRule, value: string, bypassVariableNames: string[]): string | ValueComponent[];
+}
+export type FunctionDefinitions = Record<string, FunctionDefinition>;
+export interface Config {
+    extends?: (Config | any)[];
+    components?: StyleDefinitions;
+    at?: AtDefinitions;
+    selectors?: SelectorDefinitions;
+    utilities?: UtilityDefinitions;
+    variables?: VariableDefinitions;
+    rules?: SyntaxRuleDefinitions;
+    rootSize?: number;
+    baseUnit?: number;
+    defaultMode?: 'light' | 'dark' | string | false;
+    scope?: string;
+    important?: boolean;
+    override?: boolean;
+    functions?: FunctionDefinitions;
+    animations?: AnimationDefinitions;
+    modes?: ModeDefinitions;
+}

package/dist/types/config.mjs

@@ -0,0 +1 @@
+

package/dist/types/syntax.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types/syntax.d.ts

@@ -0,0 +1,106 @@
+import { SyntaxRuleDefinition } from './config';
+export type AtComponent = AtArbitraryComponent | AtFeatureComponent | AtOperatorComponent;
+export interface AtArbitraryComponent {
+    type: 'arbitrary';
+    token?: string;
+    value: string;
+}
+export interface AtFeatureComponent {
+    type: 'feature';
+    token?: string;
+    name: string;
+    valueType: 'number' | 'string';
+    value: string | number;
+    unit?: string;
+}
+export interface AtOperatorComponent {
+    type: 'operator';
+    token: '&';
+    value: 'and';
+}
+export type ValueComponent = StringValueComponent | NumericValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;
+export interface StringValueComponent {
+    text?: string;
+    token: string;
+    type: 'string';
+    value: string;
+}
+export interface NumericValueComponent {
+    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?: string;
+    fallback?: string;
+    variable?: Variable;
+}
+export interface SeparatorValueComponent {
+    text?: string;
+    token: string;
+    type: 'separator';
+    value: string;
+}
+export interface DefinedRule {
+    id: string;
+    key?: string;
+    keys: string[];
+    matchers: {
+        key?: RegExp;
+        variable?: RegExp;
+        value?: RegExp;
+        arbitrary?: RegExp;
+    };
+    variables: Record<string, Variable>;
+    order: number;
+    definition: SyntaxRuleDefinition;
+}
+export type MediaFeatureComponent = {
+    type: string;
+    tokenType?: string;
+    operator?: string;
+    value: number;
+    unit: string;
+};
+export interface MediaQuery {
+    token: string;
+    features: Record<string, MediaFeatureComponent>;
+    type?: string;
+}
+type VariableCommon = {
+    group?: string;
+    name: string;
+    key: string;
+    modes?: Record<string, TypeVariable>;
+};
+export interface StringVariable {
+    type: 'string';
+    value: string;
+}
+export interface NumberVariable {
+    type: 'number';
+    value: number;
+}
+export interface ColorVariable {
+    type: 'color';
+    value: string;
+    space: 'rgb' | 'hsl';
+}
+export type TypeVariable = StringVariable | NumberVariable | ColorVariable;
+export type Variable = TypeVariable & VariableCommon;
+export {};

package/dist/types/syntax.mjs

@@ -0,0 +1 @@
+

package/dist/utils/are-rule-at-equal.cjs

@@ -1,17 +1,17 @@
 'use strict';
 
-function areRuleAtEqual(aRule, bRule) {
-    const aQueryTypes = Object.keys(aRule.at);
-    const bQueryTypes = Object.keys(bRule.at);
+function areRuleAtEqual(aSyntaxRule, bSyntaxRule) {
+    const aQueryTypes = Object.keys(aSyntaxRule.at);
+    const bQueryTypes = Object.keys(bSyntaxRule.at);
     if (aQueryTypes.length !== bQueryTypes.length) {
         return false;
     }
     for (const aQueryType of aQueryTypes){
-        const aAtComponents = aRule.at[aQueryType];
-        const bAtComponents = bRule.at[aQueryType];
+        const aAtComponents = aSyntaxRule.at[aQueryType];
+        const bAtComponents = bSyntaxRule.at[aQueryType];
         for (const aAtComponent of aAtComponents){
-            const aAtComponentToken = aRule.resolveAtComponent(aAtComponent);
-            if (!bAtComponents.find((bAtComponent)=>bRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
+            const aAtComponentToken = aSyntaxRule.resolveAtComponent(aAtComponent);
+            if (!bAtComponents.find((bAtComponent)=>bSyntaxRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
                 return false;
             }
         }

package/dist/utils/are-rule-at-equal.d.ts

@@ -1,2 +1,2 @@
-import type { Rule } from '../rule';
-export default function areRuleAtEqual(aRule: Rule, bRule: Rule): boolean;
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleAtEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-at-equal.mjs

@@ -1,15 +1,15 @@
-function areRuleAtEqual(aRule, bRule) {
-    const aQueryTypes = Object.keys(aRule.at);
-    const bQueryTypes = Object.keys(bRule.at);
+function areRuleAtEqual(aSyntaxRule, bSyntaxRule) {
+    const aQueryTypes = Object.keys(aSyntaxRule.at);
+    const bQueryTypes = Object.keys(bSyntaxRule.at);
     if (aQueryTypes.length !== bQueryTypes.length) {
         return false;
     }
     for (const aQueryType of aQueryTypes){
-        const aAtComponents = aRule.at[aQueryType];
-        const bAtComponents = bRule.at[aQueryType];
+        const aAtComponents = aSyntaxRule.at[aQueryType];
+        const bAtComponents = bSyntaxRule.at[aQueryType];
         for (const aAtComponent of aAtComponents){
-            const aAtComponentToken = aRule.resolveAtComponent(aAtComponent);
-            if (!bAtComponents.find((bAtComponent)=>bRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
+            const aAtComponentToken = aSyntaxRule.resolveAtComponent(aAtComponent);
+            if (!bAtComponents.find((bAtComponent)=>bSyntaxRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
                 return false;
             }
         }

package/dist/utils/are-rule-modes-equal.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-function areRuleModesEqual(aRule, bRule) {
-    return aRule.mode === bRule.mode;
+function areRuleModesEqual(aSyntaxRule, bSyntaxRule) {
+    return aSyntaxRule.mode === bSyntaxRule.mode;
 }
 
 module.exports = areRuleModesEqual;

package/dist/utils/are-rule-modes-equal.d.ts

@@ -1,2 +1,2 @@
-import type { Rule } from '../rule';
-export default function areRuleModesEqual(aRule: Rule, bRule: Rule): boolean;
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleModesEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-modes-equal.mjs

@@ -1,5 +1,5 @@
-function areRuleModesEqual(aRule, bRule) {
-    return aRule.mode === bRule.mode;
+function areRuleModesEqual(aSyntaxRule, bSyntaxRule) {
+    return aSyntaxRule.mode === bSyntaxRule.mode;
 }
 
 export { areRuleModesEqual as default };

package/dist/utils/are-rule-selectors-equal.cjs

@@ -1,25 +1,25 @@
 'use strict';
 
-function areRuleSelectorsEqual(aRule, bRule) {
+function areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) {
     // suffix
-    const aVendorSuffixSelectorKeys = Object.keys(aRule.vendorSuffixSelectors);
-    const bVendorSuffixSelectorKeys = Object.keys(bRule.vendorSuffixSelectors);
+    const aVendorSuffixSelectorKeys = Object.keys(aSyntaxRule.vendorSuffixSelectors);
+    const bVendorSuffixSelectorKeys = Object.keys(bSyntaxRule.vendorSuffixSelectors);
     if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
     const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
-        if (!Object.prototype.hasOwnProperty.call(bRule.vendorSuffixSelectors, eachAKey)) return false;
-        const aValues = aRule.vendorSuffixSelectors[eachAKey];
-        const bValues = bRule.vendorSuffixSelectors[eachAKey];
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorSuffixSelectors[eachAKey];
         return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
     });
     if (!isSameVendorSuffixSelectors) return false;
     // prefix
-    const aVendorPrefixSelectorKeys = Object.keys(aRule.vendorPrefixSelectors);
-    const bVendorPrefixSelectorKeys = Object.keys(bRule.vendorPrefixSelectors);
+    const aVendorPrefixSelectorKeys = Object.keys(aSyntaxRule.vendorPrefixSelectors);
+    const bVendorPrefixSelectorKeys = Object.keys(bSyntaxRule.vendorPrefixSelectors);
     if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
     const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
-        if (!Object.prototype.hasOwnProperty.call(bRule.vendorPrefixSelectors, eachAKey)) return false;
-        const aValues = aRule.vendorPrefixSelectors[eachAKey];
-        const bValues = bRule.vendorPrefixSelectors[eachAKey];
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorPrefixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorPrefixSelectors[eachAKey];
         return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
     });
     if (!isSameVendorPrefixSelectors) return false;

package/dist/utils/are-rule-selectors-equal.d.ts

@@ -1,2 +1,2 @@
-import type { Rule } from '../rule';
-export default function areRuleSelectorsEqual(aRule: Rule, bRule: Rule): boolean;
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleSelectorsEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-selectors-equal.mjs

@@ -1,23 +1,23 @@
-function areRuleSelectorsEqual(aRule, bRule) {
+function areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) {
     // suffix
-    const aVendorSuffixSelectorKeys = Object.keys(aRule.vendorSuffixSelectors);
-    const bVendorSuffixSelectorKeys = Object.keys(bRule.vendorSuffixSelectors);
+    const aVendorSuffixSelectorKeys = Object.keys(aSyntaxRule.vendorSuffixSelectors);
+    const bVendorSuffixSelectorKeys = Object.keys(bSyntaxRule.vendorSuffixSelectors);
     if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
     const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
-        if (!Object.prototype.hasOwnProperty.call(bRule.vendorSuffixSelectors, eachAKey)) return false;
-        const aValues = aRule.vendorSuffixSelectors[eachAKey];
-        const bValues = bRule.vendorSuffixSelectors[eachAKey];
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorSuffixSelectors[eachAKey];
         return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
     });
     if (!isSameVendorSuffixSelectors) return false;
     // prefix
-    const aVendorPrefixSelectorKeys = Object.keys(aRule.vendorPrefixSelectors);
-    const bVendorPrefixSelectorKeys = Object.keys(bRule.vendorPrefixSelectors);
+    const aVendorPrefixSelectorKeys = Object.keys(aSyntaxRule.vendorPrefixSelectors);
+    const bVendorPrefixSelectorKeys = Object.keys(bSyntaxRule.vendorPrefixSelectors);
     if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
     const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
-        if (!Object.prototype.hasOwnProperty.call(bRule.vendorPrefixSelectors, eachAKey)) return false;
-        const aValues = aRule.vendorPrefixSelectors[eachAKey];
-        const bValues = bRule.vendorPrefixSelectors[eachAKey];
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorPrefixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorPrefixSelectors[eachAKey];
         return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
     });
     if (!isSameVendorPrefixSelectors) return false;

package/dist/utils/are-rule-states-equal.cjs

@@ -4,8 +4,8 @@ var areRuleSelectorsEqual = require('./are-rule-selectors-equal.cjs');
 var areRuleModesEqual = require('./are-rule-modes-equal.cjs');
 var areRuleAtEqual = require('./are-rule-at-equal.cjs');
 
-function areRuleStatesEqual(aRule, bRule) {
-    return areRuleSelectorsEqual(aRule, bRule) && areRuleModesEqual(aRule, bRule) && areRuleAtEqual(aRule, bRule);
+function areRuleStatesEqual(aSyntaxRule, bSyntaxRule) {
+    return areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) && areRuleModesEqual(aSyntaxRule, bSyntaxRule) && areRuleAtEqual(aSyntaxRule, bSyntaxRule);
 }
 
 module.exports = areRuleStatesEqual;

package/dist/utils/are-rule-states-equal.d.ts

@@ -1,2 +1,2 @@
-import type { Rule } from '../rule';
-export default function areRuleStatesEqual(aRule: Rule, bRule: Rule): boolean;
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleStatesEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-states-equal.mjs

@@ -2,8 +2,8 @@ import areRuleSelectorsEqual from './are-rule-selectors-equal.mjs';
 import areRuleModesEqual from './are-rule-modes-equal.mjs';
 import areRuleAtEqual from './are-rule-at-equal.mjs';
 
-function areRuleStatesEqual(aRule, bRule) {
-    return areRuleSelectorsEqual(aRule, bRule) && areRuleModesEqual(aRule, bRule) && areRuleAtEqual(aRule, bRule);
+function areRuleStatesEqual(aSyntaxRule, bSyntaxRule) {
+    return areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) && areRuleModesEqual(aSyntaxRule, bSyntaxRule) && areRuleAtEqual(aSyntaxRule, bSyntaxRule);
 }
 
 export { areRuleStatesEqual as default };

package/dist/utils/are-rules-duplicated.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function areRulesDuplicated(aSyntaxRule, bSyntaxRule) {
+    const aKeys = Object.keys(aSyntaxRule.declarations || {});
+    const bKeys = Object.keys(bSyntaxRule.declarations || {});
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.declarations, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+module.exports = areRulesDuplicated;

package/dist/utils/are-rules-duplicated.d.ts

@@ -0,0 +1,2 @@
+import { SyntaxRule } from '../syntax-rule';
+export default function areRulesDuplicated(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rules-duplicated.mjs

@@ -0,0 +1,15 @@
+function areRulesDuplicated(aSyntaxRule, bSyntaxRule) {
+    const aKeys = Object.keys(aSyntaxRule.declarations || {});
+    const bKeys = Object.keys(bSyntaxRule.declarations || {});
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.declarations, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { areRulesDuplicated as default };

package/dist/utils/autofill-solid-style.d.ts

@@ -1,3 +1,3 @@
-import { SyntaxDefinition } from '../rule';
-declare const autofillSolidStyle: SyntaxDefinition['transformValueComponents'];
+import { SyntaxRuleDefinition } from '../types/config';
+declare const autofillSolidStyle: SyntaxRuleDefinition['transformValueComponents'];
 export default autofillSolidStyle;

package/dist/utils/extend-config.cjs

@@ -18,8 +18,8 @@ function extendConfig(...configs) {
                 }
             }
         };
-        if (clonedConfig.styles) {
-            formatDeeply(clonedConfig.styles);
+        if (clonedConfig.components) {
+            formatDeeply(clonedConfig.components);
         }
         if (clonedConfig.at) {
             formatDeeply(clonedConfig.at);
@@ -43,7 +43,7 @@ function extendConfig(...configs) {
     }
     let extendedConfig = {
         animations: {},
-        styles: {},
+        components: {},
         at: {},
         variables: {}
     };
@@ -62,8 +62,8 @@ function extendConfig(...configs) {
                         });
                     }
             }
-        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.styles, key)) {
-        //     Object.assign(extendedConfig.styles[key], currentFormattedConfig.styles[key])
+        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.components, key)) {
+        //     Object.assign(extendedConfig.components[key], currentFormattedConfig.components[key])
         // }
         }
     }

package/dist/utils/extend-config.d.ts

@@ -1,2 +1,2 @@
-import type { Config } from '../config';
+import type { Config } from '../types/config';
 export default function extendConfig(...configs: (Config | undefined)[]): Config;

package/dist/utils/extend-config.mjs

@@ -16,8 +16,8 @@ function extendConfig(...configs) {
                 }
             }
         };
-        if (clonedConfig.styles) {
-            formatDeeply(clonedConfig.styles);
+        if (clonedConfig.components) {
+            formatDeeply(clonedConfig.components);
         }
         if (clonedConfig.at) {
             formatDeeply(clonedConfig.at);
@@ -41,7 +41,7 @@ function extendConfig(...configs) {
     }
     let extendedConfig = {
         animations: {},
-        styles: {},
+        components: {},
         at: {},
         variables: {}
     };
@@ -60,8 +60,8 @@ function extendConfig(...configs) {
                         });
                     }
             }
-        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.styles, key)) {
-        //     Object.assign(extendedConfig.styles[key], currentFormattedConfig.styles[key])
+        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.components, key)) {
+        //     Object.assign(extendedConfig.components[key], currentFormattedConfig.components[key])
         // }
         }
     }

package/dist/utils/generate-css.cjs

@@ -6,7 +6,7 @@ function generateCSS(classes, css = new core.default()) {
     let text = '';
     css.add(...classes);
     text = css.text;
-    css.delete(...classes);
+    css.remove(...classes);
     return text;
 }
 

package/dist/utils/generate-css.mjs

@@ -4,7 +4,7 @@ function generateCSS(classes, css = new MasterCSS()) {
     let text = '';
     css.add(...classes);
     text = css.text;
-    css.delete(...classes);
+    css.remove(...classes);
     return text;
 }
 

package/dist/utils/is-core-rule.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var syntaxes = require('../config/syntaxes.cjs');
+var rules = require('../config/rules.cjs');
 
 function isCoreRule(id) {
-    return Object.hasOwnProperty.call(syntaxes, id);
+    return Object.hasOwnProperty.call(rules, id);
 }
 
 module.exports = isCoreRule;

package/dist/utils/is-core-rule.mjs

@@ -1,7 +1,7 @@
-import syntaxes from '../config/syntaxes.mjs';
+import rules from '../config/rules.mjs';
 
 function isCoreRule(id) {
-    return Object.hasOwnProperty.call(syntaxes, id);
+    return Object.hasOwnProperty.call(rules, id);
 }
 
 export { isCoreRule as default };

package/dist/utils/reorder-for-readable-classes.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var layer = require('../layer.cjs');
+var syntaxRuleType = require('../syntax-rule-type.cjs');
 var core = require('../core.cjs');
 
 /**
@@ -10,16 +10,16 @@ var core = require('../core.cjs');
  * @returns consistent classes
  */ function reorderForReadableClasses(classes, css = new core.default()) {
     css.add(...classes);
-    const orderedClasses = css.syntaxes// 只保留樣式語法相關的 syntaxes, 排除 keyframes 與 variables 在外
-    .filter((eachRule)=>eachRule.layer).sort((a, b)=>{
-        if (a.layer === layer.Utility && b.layer !== layer.Utility) {
-            // 如果 a 是 Layer.Utility 而 b 不是，则 a 应该排在 b 前面
+    const orderedClasses = css.generalLayer.rules// 只保留樣式語法相關的 rules, 排除 keyframes 與 variables 在外
+    .filter((eachRule)=>eachRule.type).sort((a, b)=>{
+        if (a.type === syntaxRuleType.Utility && b.type !== syntaxRuleType.Utility) {
+            // 如果 a 是 SyntaxRuleType.Utility 而 b 不是，则 a 应该排在 b 前面
             return -1;
-        } else if (a.layer !== layer.Utility && b.layer === layer.Utility) {
-            // 如果 b 是 Layer.Utility 而 a 不是，则 b 应该排在 a 前面
+        } else if (a.type !== syntaxRuleType.Utility && b.type === syntaxRuleType.Utility) {
+            // 如果 b 是 SyntaxRuleType.Utility 而 a 不是，则 b 应该排在 a 前面
             return 1;
         } else if (a.id !== b.id) {
-            return a.className.localeCompare(b.className);
+            return a.name.localeCompare(b.name);
         } else {
             // 檢查 vendorSuffixSelectors 是否存在
             const aHasVendorSuffix = a.vendorSuffixSelectors?.['']?.[0];
@@ -49,13 +49,13 @@ var core = require('../core.cjs');
             }
             // 如果 a 和 b 的 id 相同，則按照以下規則排序
             if (a.id === b.id && a.stateToken === b.stateToken) {
-                return a.className.localeCompare(b.className);
+                return a.name.localeCompare(b.name);
             }
             // 再按照 rule.order 本身來升序排列
             return a.order - b.order;
         }
-    }).map((eachRule)=>eachRule.className);
-    css.delete(...classes);
+    }).map((eachRule)=>eachRule.name);
+    css.remove(...classes);
     return orderedClasses;
 }
 

package/dist/utils/reorder-for-readable-classes.mjs

@@ -1,4 +1,4 @@
-import Layer from '../layer.mjs';
+import SyntaxRuleType from '../syntax-rule-type.mjs';
 import MasterCSS from '../core.mjs';
 
 /**
@@ -8,16 +8,16 @@ import MasterCSS from '../core.mjs';
  * @returns consistent classes
  */ function reorderForReadableClasses(classes, css = new MasterCSS()) {
     css.add(...classes);
-    const orderedClasses = css.syntaxes// 只保留樣式語法相關的 syntaxes, 排除 keyframes 與 variables 在外
-    .filter((eachRule)=>eachRule.layer).sort((a, b)=>{
-        if (a.layer === Layer.Utility && b.layer !== Layer.Utility) {
-            // 如果 a 是 Layer.Utility 而 b 不是，则 a 应该排在 b 前面
+    const orderedClasses = css.generalLayer.rules// 只保留樣式語法相關的 rules, 排除 keyframes 與 variables 在外
+    .filter((eachRule)=>eachRule.type).sort((a, b)=>{
+        if (a.type === SyntaxRuleType.Utility && b.type !== SyntaxRuleType.Utility) {
+            // 如果 a 是 SyntaxRuleType.Utility 而 b 不是，则 a 应该排在 b 前面
             return -1;
-        } else if (a.layer !== Layer.Utility && b.layer === Layer.Utility) {
-            // 如果 b 是 Layer.Utility 而 a 不是，则 b 应该排在 a 前面
+        } else if (a.type !== SyntaxRuleType.Utility && b.type === SyntaxRuleType.Utility) {
+            // 如果 b 是 SyntaxRuleType.Utility 而 a 不是，则 b 应该排在 a 前面
             return 1;
         } else if (a.id !== b.id) {
-            return a.className.localeCompare(b.className);
+            return a.name.localeCompare(b.name);
         } else {
             // 檢查 vendorSuffixSelectors 是否存在
             const aHasVendorSuffix = a.vendorSuffixSelectors?.['']?.[0];
@@ -47,13 +47,13 @@ import MasterCSS from '../core.mjs';
             }
             // 如果 a 和 b 的 id 相同，則按照以下規則排序
             if (a.id === b.id && a.stateToken === b.stateToken) {
-                return a.className.localeCompare(b.className);
+                return a.name.localeCompare(b.name);
             }
             // 再按照 rule.order 本身來升序排列
             return a.order - b.order;
         }
-    }).map((eachRule)=>eachRule.className);
-    css.delete(...classes);
+    }).map((eachRule)=>eachRule.name);
+    css.remove(...classes);
     return orderedClasses;
 }