@master/css-engine 2.0.0-rc.70

package/dist/utils/collect-animation-names.d.ts

@@ -0,0 +1,10 @@
+import type { PropertiesHyphen } from 'csstype';
+import type { Variable } from '@master/css-schema/css-syntax';
+export interface CollectAnimationNamesOptions {
+    animationNames: Iterable<string>;
+    variables?: Map<string, Variable>;
+    variableNames?: Iterable<string>;
+}
+export declare function collectAnimationNamesFromValue(value: string | number | undefined, animationNames: Iterable<string>): Set<string>;
+export declare function collectAnimationNamesFromDeclaration(propertyName: string, value: string | number | undefined, options: CollectAnimationNamesOptions): Set<string>;
+export default function collectAnimationNames(declarations: PropertiesHyphen, options: CollectAnimationNamesOptions): Set<string> | undefined;

package/dist/utils/collect-animation-names.mjs

@@ -0,0 +1,61 @@
+import { normalizeVariableValue } from './css-variables.mjs';
+
+function isAnimationDeclaration(propertyName) {
+    return propertyName === 'animation' || propertyName === 'animation-name';
+}
+function addAnimationName(references, animationNames, animationName) {
+    if (animationNames.has(animationName)) {
+        references.add(animationName);
+    }
+}
+function collectAnimationNamesFromValue(value, animationNames) {
+    const references = new Set();
+    if (value === undefined) return references;
+    const names = new Set(animationNames);
+    if (!names.size) return references;
+    const normalizedValue = normalizeVariableValue(value).value;
+    for (const rawValue of normalizedValue.split(/[\s,]+/)){
+        addAnimationName(references, names, rawValue);
+    }
+    return references;
+}
+function collectAnimationNamesFromVariable(references, variable, animationNames, variables, visited = new Set()) {
+    if (!variable || visited.has(variable.name)) return;
+    visited.add(variable.name);
+    for (const animationName of collectAnimationNamesFromValue(variable.value, animationNames)){
+        references.add(animationName);
+    }
+    for (const modeVariable of Object.values(variable.modes || {})){
+        for (const animationName of collectAnimationNamesFromValue(modeVariable.value, animationNames)){
+            references.add(animationName);
+        }
+    }
+    variable.dependencies?.forEach((dependency)=>{
+        collectAnimationNamesFromVariable(references, variables?.get(dependency), animationNames, variables, visited);
+    });
+}
+function collectAnimationNamesFromDeclaration(propertyName, value, options) {
+    const references = new Set();
+    if (!isAnimationDeclaration(propertyName)) return references;
+    const animationNames = new Set(options.animationNames);
+    if (!animationNames.size) return references;
+    for (const animationName of collectAnimationNamesFromValue(value, animationNames)){
+        references.add(animationName);
+    }
+    for (const variableName of options.variableNames || []){
+        collectAnimationNamesFromVariable(references, options.variables?.get(variableName), animationNames, options.variables);
+    }
+    return references;
+}
+function collectAnimationNames(declarations, options) {
+    const references = new Set();
+    for(const propertyName in declarations){
+        const propertyValue = declarations[propertyName];
+        for (const animationName of collectAnimationNamesFromDeclaration(propertyName, propertyValue, options)){
+            references.add(animationName);
+        }
+    }
+    return references.size ? references : undefined;
+}
+
+export { collectAnimationNamesFromDeclaration, collectAnimationNamesFromValue, collectAnimationNames as default };

package/dist/utils/collect-variable-names.d.ts

@@ -0,0 +1,3 @@
+import type { PropertiesHyphen } from 'csstype';
+import type { Variable } from '@master/css-schema/css-syntax';
+export default function collectVariableNames(declarations: PropertiesHyphen, variables: Map<string, Variable>): Set<string> | undefined;

package/dist/utils/collect-variable-names.mjs

@@ -0,0 +1,18 @@
+import { CSS_VARIABLE_REFERENCE } from './css-variables.mjs';
+
+function collectVariableNames(declarations, variables) {
+    const variableNames = new Set();
+    for(const propertyName in declarations){
+        const propertyValue = declarations[propertyName];
+        if (!propertyValue) continue;
+        for (const match of String(propertyValue).matchAll(CSS_VARIABLE_REFERENCE)){
+            const variable = variables.get(match[1]);
+            if (variable && !variable.inline) {
+                variableNames.add(match[1]);
+            }
+        }
+    }
+    return variableNames.size ? variableNames : undefined;
+}
+
+export { collectVariableNames as default };

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

@@ -0,0 +1,14 @@
+import { Utility } from '../utility';
+export type RulePriority = {
+    features?: [string, number, number][];
+    selector: number;
+};
+type ComparableRule = Pick<Utility, 'priority' | 'type' | 'key'> & Partial<Pick<Utility, 'atRules' | 'mode' | 'selectorNodes'>> & {
+    sortTier?: number;
+};
+export declare function calcRulePriority(rule: Utility): RulePriority;
+export declare function getRuleSortTier(rule: Partial<Pick<Utility, 'atRules' | 'mode' | 'selectorNodes'>> & {
+    sortTier?: number;
+}): number;
+export default function compareRulePriority(a: ComparableRule, b: ComparableRule): number;
+export {};

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

@@ -0,0 +1,136 @@
+import naturalCompare from './natural-compare.mjs';
+
+// ✅ Pseudo-class priority (lower = weaker)
+const selectorPriority = {
+    hover: 1,
+    focus: 2,
+    'focus-visible': 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])=>naturalCompare(a, b));
+    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 = naturalCompare(nameA, nameB);
+        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;
+}
+function getRuleSortTier(rule) {
+    if (typeof rule.sortTier === 'number') return rule.sortTier;
+    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;
+}
+// ✅ Compare function
+function compareRulePriority(a, b) {
+    const aTier = getRuleSortTier(a);
+    const bTier = getRuleSortTier(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 naturalCompare(a.key, b.key);
+}
+
+export { calcRulePriority, compareRulePriority as default, getRuleSortTier };

package/dist/utils/css-variables.d.ts

@@ -0,0 +1,12 @@
+import type { Variable } from '@master/css-schema/css-syntax';
+export declare const CSS_VARIABLE_REFERENCE: RegExp;
+export declare function createCSSVariableReference(name: string, alpha?: number, fallback?: string): string;
+export declare function createAlphaColorValue(value: string, alpha: number): string;
+export declare function createNumberVariableReference(variable: Variable, unit: string, rootSize?: number): string;
+export declare function createNegativeNumberVariableReference(variable: Variable, unit: string, rootSize?: number): string;
+export declare function collectCSSVariableReferences(value: string): Set<string>;
+export declare function replaceCSSVariableReferences(value: string, replacer: (name: string, text: string) => string | undefined): string;
+export declare function normalizeVariableValue(value: string | number): {
+    value: string;
+    dependencies: Set<string>;
+};

package/dist/utils/css-variables.mjs

@@ -0,0 +1,197 @@
+const CSS_VARIABLE_REFERENCE = /var\(\s*--([_a-zA-Z0-9-]+)\b/g;
+function createCSSVariableReference(name, alpha, fallback) {
+    const reference = `var(--${name}${fallback ? ',' + fallback : ''})`;
+    return alpha !== undefined ? createAlphaColorValue(reference, alpha) : reference;
+}
+function createAlphaColorValue(value, alpha) {
+    return `color-mix(in oklab,${value} ${Number(alpha) * 100}%,transparent)`;
+}
+function createNumberVariableReference(variable, unit, rootSize = 16) {
+    return createCSSVariableReference(variable.name);
+}
+function createNegativeNumberVariableReference(variable, unit, rootSize = 16) {
+    const reference = createCSSVariableReference(variable.name);
+    return `calc(${reference} * -1)`;
+}
+function collectCSSVariableReferences(value) {
+    const references = new Set();
+    for (const match of value.matchAll(CSS_VARIABLE_REFERENCE)){
+        references.add(match[1]);
+    }
+    return references;
+}
+function replaceCSSVariableReferences(value, replacer) {
+    let result = '';
+    let quote = '';
+    for(let i = 0; i < value.length;){
+        const char = value[i];
+        if (quote) {
+            result += char;
+            if (char === '\\') {
+                result += value[i + 1] || '';
+                i += 2;
+                continue;
+            }
+            if (char === quote) quote = '';
+            i++;
+            continue;
+        }
+        if (char === '"' || char === '\'') {
+            quote = char;
+            result += char;
+            i++;
+            continue;
+        }
+        if (value.startsWith('var(', i)) {
+            let cursor = i + 4;
+            while(value[cursor] === ' ')cursor++;
+            if (value.slice(cursor, cursor + 2) !== '--') {
+                result += char;
+                i++;
+                continue;
+            }
+            cursor += 2;
+            const nameStart = cursor;
+            while(/[_a-zA-Z0-9-]/.test(value[cursor] || ''))cursor++;
+            const name = value.slice(nameStart, cursor);
+            if (!name) {
+                result += char;
+                i++;
+                continue;
+            }
+            let depth = 1;
+            let innerQuote = '';
+            let closeIndex = -1;
+            for(let j = cursor; j < value.length; j++){
+                const nextChar = value[j];
+                if (innerQuote) {
+                    if (nextChar === '\\') {
+                        j++;
+                        continue;
+                    }
+                    if (nextChar === innerQuote) innerQuote = '';
+                    continue;
+                }
+                if (nextChar === '"' || nextChar === '\'') {
+                    innerQuote = nextChar;
+                    continue;
+                }
+                if (nextChar === '(') {
+                    depth++;
+                    continue;
+                }
+                if (nextChar === ')') {
+                    depth--;
+                    if (depth === 0) {
+                        closeIndex = j;
+                        break;
+                    }
+                }
+            }
+            if (closeIndex === -1) {
+                result += value.slice(i);
+                break;
+            }
+            const text = value.slice(i, closeIndex + 1);
+            result += replacer(name, text) ?? text;
+            i = closeIndex + 1;
+            continue;
+        }
+        result += char;
+        i++;
+    }
+    return result;
+}
+function readAliasName(value, start) {
+    if (value[start + 1] === '(') {
+        let i = start + 2;
+        let name = '';
+        for(; i < value.length; i++){
+            if (value[i] === ')') break;
+            name += value[i];
+        }
+        return name ? {
+            name,
+            end: i + 1
+        } : undefined;
+    }
+    let i = start + 1;
+    let name = '';
+    for(; i < value.length; i++){
+        const char = value[i];
+        if (!/[a-zA-Z0-9-]/.test(char)) break;
+        name += char;
+    }
+    return name ? {
+        name,
+        end: i
+    } : undefined;
+}
+function readAliasAlpha(value, start) {
+    let i = start;
+    while(value[i] === ' ')i++;
+    if (value[i] !== '/') return;
+    i++;
+    while(value[i] === ' ')i++;
+    const alphaStart = i;
+    for(; i < value.length; i++){
+        if (/[\s,);|]/.test(value[i])) break;
+    }
+    const alpha = value.slice(alphaStart, i);
+    return alpha ? {
+        alpha: Number(alpha),
+        end: i
+    } : undefined;
+}
+function normalizeVariableValue(value) {
+    if (typeof value === 'number') {
+        return {
+            value: String(value),
+            dependencies: new Set()
+        };
+    }
+    let result = '';
+    let inSingle = false;
+    let inDouble = false;
+    const dependencies = new Set();
+    for(let i = 0; i < value.length; i++){
+        const char = value[i];
+        const previous = value[i - 1];
+        if (char === '\'' && previous !== '\\' && !inDouble) {
+            inSingle = !inSingle;
+            result += char;
+            continue;
+        }
+        if (char === '"' && previous !== '\\' && !inSingle) {
+            inDouble = !inDouble;
+            result += char;
+            continue;
+        }
+        if (!inSingle && !inDouble) {
+            if (char === '|') {
+                result += ' ';
+                continue;
+            }
+            if (char === '$') {
+                const alias = readAliasName(value, i);
+                if (alias) {
+                    const alpha = readAliasAlpha(value, alias.end);
+                    dependencies.add(alias.name);
+                    result += createCSSVariableReference(alias.name, alpha?.alpha);
+                    i = (alpha?.end ?? alias.end) - 1;
+                    continue;
+                }
+            }
+        }
+        result += char;
+    }
+    for (const reference of collectCSSVariableReferences(result)){
+        dependencies.add(reference);
+    }
+    return {
+        value: result,
+        dependencies
+    };
+}
+
+export { CSS_VARIABLE_REFERENCE, collectCSSVariableReferences, createAlphaColorValue, createCSSVariableReference, createNegativeNumberVariableReference, createNumberVariableReference, normalizeVariableValue, replaceCSSVariableReferences };

package/dist/utils/find-native-css-rule-index.d.ts

@@ -0,0 +1 @@
+export default function findNativeCSSRuleIndex(cssRules: CSSRuleList, nativeRule: CSSRule): number;

package/dist/utils/find-native-css-rule-index.mjs

@@ -0,0 +1,10 @@
+function findNativeCSSRuleIndex(cssRules, nativeRule) {
+    for(let i = 0; i < cssRules.length; i++){
+        if (cssRules[i] === nativeRule) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+export { findNativeCSSRuleIndex as default };

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,32 @@
+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 {
+                if (comp.type === 'boolean') {
+                    current = `(${comp.name})`;
+                    return current;
+                }
+                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.d.ts

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

package/dist/utils/generate-selector.mjs

@@ -0,0 +1,48 @@
+import { SELECTOR_COMBINATORS } from '../common.mjs';
+
+const prefixMap = {
+    'class': '.',
+    'pseudo-class': ':',
+    'pseudo-element': '::',
+    'attribute': '',
+    'combinator': '',
+    'id': '#'
+};
+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 (!SELECTOR_COMBINATORS.includes(lastChar) && lastChar !== ' ') {
+            pre += ' ';
+        }
+    }
+    const result = groups.length ? groups.map((text)=>pre + body + text).join(',') : pre + body;
+    return result;
+}
+
+export { generateSelector as default };

package/dist/utils/natural-compare.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (x: string, y: string) => number;
+export default _default;

package/dist/utils/natural-compare.mjs

@@ -0,0 +1,6 @@
+const naturalCollator = new Intl.Collator(undefined, {
+    numeric: true
+});
+var naturalCompare = naturalCollator.compare;
+
+export { naturalCompare as default };

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

@@ -0,0 +1,44 @@
+import type MasterCSS from '../core';
+import type { MasterCSSManifestAtIdentifier } from '@master/css-schema/manifest';
+export type AtRule = {
+    id: MasterCSSManifestAtIdentifier;
+    nodes: AtRuleNode[];
+};
+export declare type AtRuleBooleanNode = {
+    raw?: string;
+    name: string;
+    type: 'boolean';
+};
+export declare type AtRuleNumberNode = {
+    raw?: string;
+    name: string;
+    type: 'number';
+    value: number;
+    unit?: string;
+    operator?: string;
+};
+export declare type AtRuleStringNode = {
+    raw?: string;
+    name: string;
+    type: 'string';
+    value: string;
+};
+export declare type AtRuleValueNode = AtRuleNumberNode | AtRuleStringNode;
+export interface AtRuleComparisonOperatorNode {
+    type: 'comparison';
+    raw?: string;
+    value: string;
+}
+export interface AtRuleLogicalOperatorNode {
+    type: 'logical';
+    raw?: string;
+    value: string;
+}
+export type AtRuleOperatorNode = AtRuleComparisonOperatorNode | AtRuleLogicalOperatorNode;
+export interface AtRuleGroupNode {
+    type?: 'group';
+    raw?: string;
+    children: AtRuleNode[];
+}
+export type AtRuleNode = AtRuleBooleanNode | AtRuleValueNode | AtRuleComparisonOperatorNode | AtRuleLogicalOperatorNode | AtRuleGroupNode;
+export default function parseAt(token: string, css: MasterCSS, isRaw?: boolean): AtRule;