@master/css 2.0.0-rc.61 → 2.0.0-rc.62

package/dist/utils/compare-rule-priority.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// ✅ Pseudo-class priority (lower = weaker)
+const selectorPriority = {
+    hover: 1,
+    focus: 2,
+    active: 3,
+    disabled: 4
+};
+function extractSelectorPriority(nodes = []) {
+    let priority = 0;
+    for (const node of nodes){
+        if ('value' in node && typeof node.value === 'string') {
+            priority += selectorPriority[node.value] ?? 0;
+        }
+        if ('children' in node && Array.isArray(node.children)) {
+            priority += extractSelectorPriority(node.children);
+        }
+    }
+    return priority;
+}
+const NOT_COMPARISON_OPERATORS = {
+    '>=': '<',
+    '<=': '>',
+    '>': '<=',
+    '<': '>='
+};
+function getAtRuleEntries(nestNodes) {
+    const featureMap = new Map();
+    const walk = (list, isOutsideNot = false)=>{
+        (list ?? []).forEach((node, i, arr)=>{
+            const prev = arr[i - 1];
+            if ('operator' in node) {
+                const entry = featureMap.get(node.name) ?? {};
+                let operator = node.operator;
+                if (isOutsideNot) operator = NOT_COMPARISON_OPERATORS[operator];
+                if (prev?.type === 'logical' && prev.value === 'not') operator = NOT_COMPARISON_OPERATORS[operator];
+                switch(operator){
+                    case '>':
+                        entry.min = node.value + 0.02;
+                        break;
+                    case '>=':
+                        entry.min = node.value;
+                        break;
+                    case '<':
+                        entry.max = node.value - 0.02;
+                        break;
+                    case '<=':
+                        entry.max = node.value;
+                        break;
+                }
+                featureMap.set(node.name, entry);
+            }
+            if ('children' in node && Array.isArray(node.children)) {
+                walk(node.children, prev?.type === 'logical' && prev.value === 'not');
+            }
+        });
+    };
+    walk(nestNodes);
+    return featureMap;
+}
+// ✅ Calculate RulePriority from AST
+function calcRulePriority(rule) {
+    const features = [];
+    const extractFeatures = (nodes)=>{
+        const featureMap = getAtRuleEntries(nodes);
+        for (const [name, entry] of featureMap.entries()){
+            const max = entry.max ?? Number.MAX_SAFE_INTEGER;
+            const min = entry.min ?? 0;
+            features.push([
+                name,
+                min,
+                max
+            ]);
+        }
+    };
+    if (rule.atRules?.media) extractFeatures(rule.atRules.media);
+    if (rule.atRules?.container) extractFeatures(rule.atRules.container);
+    features.sort(([a], [b])=>a.localeCompare(b, undefined, {
+            numeric: true
+        }));
+    const selector = extractSelectorPriority(rule.selectorNodes ?? []);
+    return {
+        features,
+        selector
+    };
+}
+function compareFeatureTuples(a, b) {
+    const len = Math.max(a.length, b.length);
+    for(let i = 0; i < len; i++){
+        const aa = a[i];
+        const bb = b[i];
+        if (!aa) return -1;
+        if (!bb) return 1;
+        const [nameA, minA, maxA] = aa;
+        const [nameB, minB, maxB] = bb;
+        const nameCmp = nameA.localeCompare(nameB, undefined, {
+            numeric: true
+        });
+        if (nameCmp !== 0) return nameCmp;
+        const rangeA = maxA - minA;
+        const rangeB = maxB - minB;
+        if (rangeA !== rangeB) return rangeB - rangeA;
+        if (minA !== minB) return minB - minA;
+        if (maxA !== maxB) return maxB - maxA;
+    }
+    return 0;
+}
+// ✅ Compare function
+function compareRulePriority(a, b) {
+    const getTier = (rule)=>{
+        const hasSelector = rule.selectorNodes?.length;
+        const hasAtRules = !!rule.atRules;
+        const hasMode = !!rule.mode;
+        if (hasAtRules) return 3;
+        if (hasMode) return 2;
+        if (hasSelector) return 1;
+        return 0;
+    };
+    const aTier = getTier(a);
+    const bTier = getTier(b);
+    if (aTier !== bTier) return aTier - bTier;
+    // 1. features
+    const fa = a.priority.features || [];
+    const fb = b.priority.features || [];
+    const featureCmp = compareFeatureTuples(fa, fb);
+    if (featureCmp !== 0) return featureCmp;
+    // 2. selector
+    const selectorCmp = a.priority.selector - b.priority.selector;
+    if (selectorCmp !== 0) return selectorCmp;
+    // 3. rule.type
+    const typeCmp = a.type - b.type;
+    if (typeCmp !== 0) return typeCmp;
+    // 4. fallback: name
+    return a.key.localeCompare(b.key, undefined, {
+        numeric: true
+    });
+}
+
+exports.calcRulePriority = calcRulePriority;
+exports.default = compareRulePriority;

package/dist/utils/compare-rule-priority.d.ts

@@ -0,0 +1,7 @@
+import { SyntaxRule } from '../syntax-rule';
+export type RulePriority = {
+    features?: [string, number, number][];
+    selector: number;
+};
+export declare function calcRulePriority(rule: SyntaxRule): RulePriority;
+export default function compareRulePriority(a: SyntaxRule, b: SyntaxRule): number;

package/dist/utils/compare-rule-priority.mjs

@@ -0,0 +1,138 @@
+// ✅ Pseudo-class priority (lower = weaker)
+const selectorPriority = {
+    hover: 1,
+    focus: 2,
+    active: 3,
+    disabled: 4
+};
+function extractSelectorPriority(nodes = []) {
+    let priority = 0;
+    for (const node of nodes){
+        if ('value' in node && typeof node.value === 'string') {
+            priority += selectorPriority[node.value] ?? 0;
+        }
+        if ('children' in node && Array.isArray(node.children)) {
+            priority += extractSelectorPriority(node.children);
+        }
+    }
+    return priority;
+}
+const NOT_COMPARISON_OPERATORS = {
+    '>=': '<',
+    '<=': '>',
+    '>': '<=',
+    '<': '>='
+};
+function getAtRuleEntries(nestNodes) {
+    const featureMap = new Map();
+    const walk = (list, isOutsideNot = false)=>{
+        (list ?? []).forEach((node, i, arr)=>{
+            const prev = arr[i - 1];
+            if ('operator' in node) {
+                const entry = featureMap.get(node.name) ?? {};
+                let operator = node.operator;
+                if (isOutsideNot) operator = NOT_COMPARISON_OPERATORS[operator];
+                if (prev?.type === 'logical' && prev.value === 'not') operator = NOT_COMPARISON_OPERATORS[operator];
+                switch(operator){
+                    case '>':
+                        entry.min = node.value + 0.02;
+                        break;
+                    case '>=':
+                        entry.min = node.value;
+                        break;
+                    case '<':
+                        entry.max = node.value - 0.02;
+                        break;
+                    case '<=':
+                        entry.max = node.value;
+                        break;
+                }
+                featureMap.set(node.name, entry);
+            }
+            if ('children' in node && Array.isArray(node.children)) {
+                walk(node.children, prev?.type === 'logical' && prev.value === 'not');
+            }
+        });
+    };
+    walk(nestNodes);
+    return featureMap;
+}
+// ✅ Calculate RulePriority from AST
+function calcRulePriority(rule) {
+    const features = [];
+    const extractFeatures = (nodes)=>{
+        const featureMap = getAtRuleEntries(nodes);
+        for (const [name, entry] of featureMap.entries()){
+            const max = entry.max ?? Number.MAX_SAFE_INTEGER;
+            const min = entry.min ?? 0;
+            features.push([
+                name,
+                min,
+                max
+            ]);
+        }
+    };
+    if (rule.atRules?.media) extractFeatures(rule.atRules.media);
+    if (rule.atRules?.container) extractFeatures(rule.atRules.container);
+    features.sort(([a], [b])=>a.localeCompare(b, undefined, {
+            numeric: true
+        }));
+    const selector = extractSelectorPriority(rule.selectorNodes ?? []);
+    return {
+        features,
+        selector
+    };
+}
+function compareFeatureTuples(a, b) {
+    const len = Math.max(a.length, b.length);
+    for(let i = 0; i < len; i++){
+        const aa = a[i];
+        const bb = b[i];
+        if (!aa) return -1;
+        if (!bb) return 1;
+        const [nameA, minA, maxA] = aa;
+        const [nameB, minB, maxB] = bb;
+        const nameCmp = nameA.localeCompare(nameB, undefined, {
+            numeric: true
+        });
+        if (nameCmp !== 0) return nameCmp;
+        const rangeA = maxA - minA;
+        const rangeB = maxB - minB;
+        if (rangeA !== rangeB) return rangeB - rangeA;
+        if (minA !== minB) return minB - minA;
+        if (maxA !== maxB) return maxB - maxA;
+    }
+    return 0;
+}
+// ✅ Compare function
+function compareRulePriority(a, b) {
+    const getTier = (rule)=>{
+        const hasSelector = rule.selectorNodes?.length;
+        const hasAtRules = !!rule.atRules;
+        const hasMode = !!rule.mode;
+        if (hasAtRules) return 3;
+        if (hasMode) return 2;
+        if (hasSelector) return 1;
+        return 0;
+    };
+    const aTier = getTier(a);
+    const bTier = getTier(b);
+    if (aTier !== bTier) return aTier - bTier;
+    // 1. features
+    const fa = a.priority.features || [];
+    const fb = b.priority.features || [];
+    const featureCmp = compareFeatureTuples(fa, fb);
+    if (featureCmp !== 0) return featureCmp;
+    // 2. selector
+    const selectorCmp = a.priority.selector - b.priority.selector;
+    if (selectorCmp !== 0) return selectorCmp;
+    // 3. rule.type
+    const typeCmp = a.type - b.type;
+    if (typeCmp !== 0) return typeCmp;
+    // 4. fallback: name
+    return a.key.localeCompare(b.key, undefined, {
+        numeric: true
+    });
+}
+
+export { calcRulePriority, compareRulePriority as default };

package/dist/utils/equal-at-rules.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var common = require('../common.cjs');
+
+function areNodesEqual(a, b) {
+    return a.type === b.type && a.value === b.value && a.unit === b.unit && a.name === b.name && a.operator === b.operator && areNodeArraysEqual(a.children ?? [], b.children ?? []);
+}
+function areNodeArraysEqual(aNodes, bNodes) {
+    if (aNodes.length !== bNodes.length) return false;
+    const matched = new Array(bNodes.length).fill(false);
+    for (const aNode of aNodes){
+        const index = bNodes.findIndex((bNode, i)=>!matched[i] && areNodesEqual(aNode, bNode));
+        if (index === -1) return false;
+        matched[index] = true;
+    }
+    return true;
+}
+function equalAtRules(a, b) {
+    return common.AT_IDENTIFIERS.every((key)=>areNodeArraysEqual(a?.[key] ?? [], b?.[key] ?? []));
+}
+
+module.exports = equalAtRules;

package/dist/utils/equal-at-rules.d.ts

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function equalAtRules(a: SyntaxRule['atRules'], b: SyntaxRule['atRules']): boolean;

package/dist/utils/equal-at-rules.mjs

@@ -0,0 +1,20 @@
+import { AT_IDENTIFIERS } from '../common.mjs';
+
+function areNodesEqual(a, b) {
+    return a.type === b.type && a.value === b.value && a.unit === b.unit && a.name === b.name && a.operator === b.operator && areNodeArraysEqual(a.children ?? [], b.children ?? []);
+}
+function areNodeArraysEqual(aNodes, bNodes) {
+    if (aNodes.length !== bNodes.length) return false;
+    const matched = new Array(bNodes.length).fill(false);
+    for (const aNode of aNodes){
+        const index = bNodes.findIndex((bNode, i)=>!matched[i] && areNodesEqual(aNode, bNode));
+        if (index === -1) return false;
+        matched[index] = true;
+    }
+    return true;
+}
+function equalAtRules(a, b) {
+    return AT_IDENTIFIERS.every((key)=>areNodeArraysEqual(a?.[key] ?? [], b?.[key] ?? []));
+}
+
+export { equalAtRules as default };

package/dist/utils/equal-declarations.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+function equalDeclarations(a = {}, b = {}) {
+    if (Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+    }
+    return Object.keys(a).every((key)=>key in b);
+}
+
+module.exports = equalDeclarations;

package/dist/utils/equal-declarations.d.ts

@@ -0,0 +1,2 @@
+import { SyntaxRule } from '../syntax-rule';
+export default function equalDeclarations(a?: SyntaxRule['declarations'], b?: SyntaxRule['declarations']): boolean;

package/dist/utils/equal-declarations.mjs

@@ -0,0 +1,8 @@
+function equalDeclarations(a = {}, b = {}) {
+    if (Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+    }
+    return Object.keys(a).every((key)=>key in b);
+}
+
+export { equalDeclarations as default };

package/dist/utils/equal-selectors.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+function isCombinator(node) {
+    return node.type === 'combinator';
+}
+function areSelectorNodesEqual(a, b) {
+    if (a.type !== b.type) return false;
+    if (a.value !== b.value) return false;
+    const aChildren = a.children ?? [];
+    const bChildren = b.children ?? [];
+    if (aChildren.length !== bChildren.length) return false;
+    return equalUnorderedSelectorNodes(aChildren, bChildren);
+}
+function equalUnorderedSelectorNodes(a, b) {
+    if (a.length !== b.length) return false;
+    const unmatchedB = new Set(b);
+    for (const nodeA of a){
+        let matched = false;
+        for (const nodeB of unmatchedB){
+            if (areSelectorNodesEqual(nodeA, nodeB)) {
+                unmatchedB.delete(nodeB);
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) return false;
+    }
+    return true;
+}
+function splitByCombinators(nodes) {
+    const parts = [];
+    let buffer = [];
+    for (const node of nodes){
+        if (isCombinator(node)) {
+            if (buffer.length > 0) {
+                parts.push(buffer);
+                buffer = [];
+            }
+            parts.push(node) // push combinator as-is
+            ;
+        } else {
+            buffer.push(node);
+        }
+    }
+    if (buffer.length > 0) {
+        parts.push(buffer);
+    }
+    return parts;
+}
+function equalSelectors(a = [], b = []) {
+    const aParts = splitByCombinators(a);
+    const bParts = splitByCombinators(b);
+    if (aParts.length !== bParts.length) return false;
+    for(let i = 0; i < aParts.length; i++){
+        const partA = aParts[i];
+        const partB = bParts[i];
+        if (Array.isArray(partA) && Array.isArray(partB)) {
+            if (!equalUnorderedSelectorNodes(partA, partB)) return false;
+        } else if (!Array.isArray(partA) && !Array.isArray(partB)) {
+            // both are combinators
+            if (!areSelectorNodesEqual(partA, partB)) return false;
+        } else {
+            return false // mismatch between combinator vs non-combinator
+            ;
+        }
+    }
+    return true;
+}
+
+module.exports = equalSelectors;

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

@@ -0,0 +1,2 @@
+import type { SelectorNode } from './parse-selector';
+export default function equalSelectors(a?: SelectorNode[], b?: SelectorNode[]): boolean;

package/dist/utils/equal-selectors.mjs

@@ -0,0 +1,68 @@
+function isCombinator(node) {
+    return node.type === 'combinator';
+}
+function areSelectorNodesEqual(a, b) {
+    if (a.type !== b.type) return false;
+    if (a.value !== b.value) return false;
+    const aChildren = a.children ?? [];
+    const bChildren = b.children ?? [];
+    if (aChildren.length !== bChildren.length) return false;
+    return equalUnorderedSelectorNodes(aChildren, bChildren);
+}
+function equalUnorderedSelectorNodes(a, b) {
+    if (a.length !== b.length) return false;
+    const unmatchedB = new Set(b);
+    for (const nodeA of a){
+        let matched = false;
+        for (const nodeB of unmatchedB){
+            if (areSelectorNodesEqual(nodeA, nodeB)) {
+                unmatchedB.delete(nodeB);
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) return false;
+    }
+    return true;
+}
+function splitByCombinators(nodes) {
+    const parts = [];
+    let buffer = [];
+    for (const node of nodes){
+        if (isCombinator(node)) {
+            if (buffer.length > 0) {
+                parts.push(buffer);
+                buffer = [];
+            }
+            parts.push(node) // push combinator as-is
+            ;
+        } else {
+            buffer.push(node);
+        }
+    }
+    if (buffer.length > 0) {
+        parts.push(buffer);
+    }
+    return parts;
+}
+function equalSelectors(a = [], b = []) {
+    const aParts = splitByCombinators(a);
+    const bParts = splitByCombinators(b);
+    if (aParts.length !== bParts.length) return false;
+    for(let i = 0; i < aParts.length; i++){
+        const partA = aParts[i];
+        const partB = bParts[i];
+        if (Array.isArray(partA) && Array.isArray(partB)) {
+            if (!equalUnorderedSelectorNodes(partA, partB)) return false;
+        } else if (!Array.isArray(partA) && !Array.isArray(partB)) {
+            // both are combinators
+            if (!areSelectorNodesEqual(partA, partB)) return false;
+        } else {
+            return false // mismatch between combinator vs non-combinator
+            ;
+        }
+    }
+    return true;
+}
+
+export { equalSelectors as default };

package/dist/utils/equal-variants.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var equalSelectors = require('./equal-selectors.cjs');
+var equalAtRules = require('./equal-at-rules.cjs');
+
+function equalVariants(a, b) {
+    return a.mode === b.mode && equalSelectors(a.selectorNodes, b.selectorNodes) && equalAtRules(a.atRules, b.atRules);
+}
+
+module.exports = equalVariants;

package/dist/utils/equal-variants.d.ts

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function equalVariants(a: SyntaxRule, b: SyntaxRule): boolean;

package/dist/utils/equal-variants.mjs

@@ -0,0 +1,8 @@
+import equalSelectors from './equal-selectors.mjs';
+import equalAtRules from './equal-at-rules.mjs';
+
+function equalVariants(a, b) {
+    return a.mode === b.mode && equalSelectors(a.selectorNodes, b.selectorNodes) && equalAtRules(a.atRules, b.atRules);
+}
+
+export { equalVariants as default };

package/dist/utils/extend-config.cjs

@@ -19,7 +19,6 @@ function extendConfig(...configs) {
         };
         [
             'components',
-            'at',
             'variables'
         ].forEach((key)=>{
             if (clonedConfig[key]) {

package/dist/utils/extend-config.mjs

@@ -17,7 +17,6 @@ function extendConfig(...configs) {
         };
         [
             'components',
-            'at',
             'variables'
         ].forEach((key)=>{
             if (clonedConfig[key]) {

package/dist/utils/generate-at.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+function generateAt(atRule) {
+    const generate = (nodes)=>{
+        let text = nodes.map((comp)=>{
+            let current = '';
+            if ('children' in comp) {
+                const body = generate(comp.children);
+                current = comp.type === 'group' ? '(' + body + ')' : body;
+            } else {
+                const value = comp.type === 'number' ? String(comp.value) + (comp.unit || '') : comp.value;
+                if ('name' in comp) {
+                    if ('operator' in comp) {
+                        current = '(' + `${comp.name}${comp.operator}${value}` + ')';
+                    } else {
+                        current = '(' + `${comp.name}:${value}` + ')';
+                    }
+                } else {
+                    current = value;
+                }
+            }
+            return current;
+        }).filter(Boolean).join(atRule.id === 'layer' ? '.' : ' ');
+        return text;
+    };
+    const result = generate(atRule.nodes);
+    return '@' + atRule.id + (result ? ' ' + result : '');
+}
+
+module.exports = generateAt;

package/dist/utils/generate-at.d.ts

@@ -0,0 +1,2 @@
+import { AtRule } from './parse-at';
+export default function generateAt(atRule: AtRule): string;

package/dist/utils/generate-at.mjs

@@ -0,0 +1,28 @@
+function generateAt(atRule) {
+    const generate = (nodes)=>{
+        let text = nodes.map((comp)=>{
+            let current = '';
+            if ('children' in comp) {
+                const body = generate(comp.children);
+                current = comp.type === 'group' ? '(' + body + ')' : body;
+            } else {
+                const value = comp.type === 'number' ? String(comp.value) + (comp.unit || '') : comp.value;
+                if ('name' in comp) {
+                    if ('operator' in comp) {
+                        current = '(' + `${comp.name}${comp.operator}${value}` + ')';
+                    } else {
+                        current = '(' + `${comp.name}:${value}` + ')';
+                    }
+                } else {
+                    current = value;
+                }
+            }
+            return current;
+        }).filter(Boolean).join(atRule.id === 'layer' ? '.' : ' ');
+        return text;
+    };
+    const result = generate(atRule.nodes);
+    return '@' + atRule.id + (result ? ' ' + result : '');
+}
+
+export { generateAt as default };

package/dist/utils/generate-selector.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var common = require('../common.cjs');
+
+const prefixMap = {
+    'class': '.',
+    'pseudo-class': ':',
+    'pseudo-element': '::',
+    'attribute': '',
+    'combinator': ''
+};
+function generateSelector(nodes, body = '') {
+    const generate = (node)=>{
+        if (node.type === 'attribute') return `[${node.value}]`;
+        if (node.type === 'combinator') return node.value;
+        const prefix = node.type && prefixMap[node.type] || '';
+        const base = node.value ? prefix + node.value : '';
+        if ('children' in node && node.children?.length) {
+            const childrenText = node.children.map(generate).join('');
+            return node.value ? base + `(${childrenText})` : base + childrenText;
+        }
+        return base;
+    };
+    let pre = '';
+    let current = '';
+    const groups = [];
+    const flatNodes = nodes.flatMap((node)=>!('value' in node) && 'children' in node && node.children?.length ? node.children : node);
+    flatNodes.forEach((node)=>{
+        if (node.value === ',') {
+            groups.push(current);
+            current = '';
+        } else if (node.value === 'of' && 'children' in node) {
+            pre += node.children.map(generate).join('');
+        } else {
+            current += generate(node);
+        }
+    });
+    if (current) groups.push(current);
+    if (pre) {
+        const lastChar = pre.charAt(pre.length - 1);
+        if (!common.SELECTOR_COMBINATORS.includes(lastChar) && lastChar !== ' ') {
+            pre += ' ';
+        }
+    }
+    const result = groups.length ? groups.map((text)=>pre + body + text).join(',') : pre + body;
+    return result;
+}
+
+module.exports = generateSelector;

package/dist/utils/generate-selector.d.ts

@@ -0,0 +1,2 @@
+import { SelectorNode } from './parse-selector';
+export default function generateSelector(nodes: SelectorNode[], body?: string): string;