@tbela99/css-parser 0.1.0 → 0.3.0

package/dist/lib/ast/expand.js

@@ -7,12 +7,12 @@ import { walkValues } from './walk.js';
 
 function expand(ast) {
     //
-    if (![4 /* NodeType.RuleNodeType */, 2 /* NodeType.StyleSheetNodeType */, 3 /* NodeType.AtRuleNodeType */].includes(ast.typ)) {
+    if (![EnumToken.RuleNodeType, EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType].includes(ast.typ)) {
         return ast;
     }
-    if (4 /* NodeType.RuleNodeType */ == ast.typ) {
+    if (EnumToken.RuleNodeType == ast.typ) {
         return {
-            typ: 2 /* NodeType.StyleSheetNodeType */,
+            typ: EnumToken.StyleSheetNodeType,
             chi: expandRule(ast)
         };
     }
@@ -24,16 +24,16 @@ function expand(ast) {
     for (let i = 0; i < ast.chi.length; i++) {
         // @ts-ignore
         const node = ast.chi[i];
-        if (node.typ == 4 /* NodeType.RuleNodeType */) {
+        if (node.typ == EnumToken.RuleNodeType) {
             // @ts-ignore
             result.chi.push(...expandRule(node));
             // i += expanded.length - 1;
         }
-        else if (node.typ == 3 /* NodeType.AtRuleNodeType */ && 'chi' in node) {
+        else if (node.typ == EnumToken.AtRuleNodeType && 'chi' in node) {
             let hasRule = false;
             let j = node.chi.length;
             while (j--) {
-                if (node.chi[j].typ == 4 /* NodeType.RuleNodeType */ || node.chi[j].typ == 3 /* NodeType.AtRuleNodeType */) {
+                if (node.chi[j].typ == EnumToken.RuleNodeType || node.chi[j].typ == EnumToken.AtRuleNodeType) {
                     hasRule = true;
                     break;
                 }
@@ -51,10 +51,10 @@ function expand(ast) {
 function expandRule(node) {
     const ast = { ...node, chi: node.chi.slice() };
     const result = [];
-    if (ast.typ == 4 /* NodeType.RuleNodeType */) {
+    if (ast.typ == EnumToken.RuleNodeType) {
         let i = 0;
         for (; i < ast.chi.length; i++) {
-            if (ast.chi[i].typ == 4 /* NodeType.RuleNodeType */) {
+            if (ast.chi[i].typ == EnumToken.RuleNodeType) {
                 const rule = ast.chi[i];
                 if (!rule.sel.includes('&')) {
                     const selRule = splitRule(rule.sel);
@@ -70,7 +70,7 @@ function expandRule(node) {
                 ast.chi.splice(i--, 1);
                 result.push(...expandRule(rule));
             }
-            else if (ast.chi[i].typ == 3 /* NodeType.AtRuleNodeType */) {
+            else if (ast.chi[i].typ == EnumToken.AtRuleNodeType) {
                 let astAtRule = ast.chi[i];
                 const values = [];
                 if (astAtRule.nam == 'scope') {
@@ -85,7 +85,7 @@ function expandRule(node) {
                     // @ts-ignore
                     astAtRule.chi.length = 0;
                     for (const r of expandRule(clone)) {
-                        if (r.typ == 3 /* NodeType.AtRuleNodeType */ && 'chi' in r) {
+                        if (r.typ == EnumToken.AtRuleNodeType && 'chi' in r) {
                             if (astAtRule.val !== '' && r.val !== '') {
                                 if (astAtRule.nam == 'media' && r.nam == 'media') {
                                     r.val = astAtRule.val + ' and ' + r.val;
@@ -97,7 +97,7 @@ function expandRule(node) {
                             // @ts-ignore
                             values.push(r);
                         }
-                        else if (r.typ == 4 /* NodeType.RuleNodeType */) {
+                        else if (r.typ == EnumToken.RuleNodeType) {
                             // @ts-ignore
                             astAtRule.chi.push(...expandRule(r));
                         }

package/dist/lib/ast/features/calc.js

@@ -1,21 +1,22 @@
 import { EnumToken } from '../types.js';
-import { reduceNumber, renderToken } from '../../renderer/render.js';
 import { walkValues } from '../walk.js';
-import { MinifyFeature } from '../utiles/minifyfeature.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
+import { IterableWeakSet } from '../../iterable/weakset.js';
+import { evaluate } from '../math/expression.js';
 
-class ComputeCalcExpression extends MinifyFeature {
+class ComputeCalcExpressionFeature extends MinifyFeature {
     static get ordering() {
         return 1;
     }
     static register(options) {
         if (options.computeCalcExpression) {
             for (const feature of options.features) {
-                if (feature instanceof ComputeCalcExpression) {
+                if (feature instanceof ComputeCalcExpressionFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new ComputeCalcExpression());
+            options.features.push(new ComputeCalcExpressionFeature());
         }
     }
     run(ast) {
@@ -24,15 +25,35 @@ class ComputeCalcExpression extends MinifyFeature {
         }
         // @ts-ignore
         for (const node of ast.chi) {
-            if (node.typ != 5 /* NodeType.DeclarationNodeType */) {
+            if (node.typ != EnumToken.DeclarationNodeType) {
                 continue;
             }
-            const set = new Set;
-            for (const { parent } of walkValues(node.val)) {
-                if (parent != null && parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') {
+            const set = new IterableWeakSet;
+            for (const { value, parent } of walkValues(node.val)) {
+                if (value != null && value.typ == EnumToken.FunctionTokenType && value.val == 'calc') {
                     if (!set.has(parent)) {
-                        set.add(parent);
-                        parent.chi = evaluate(parent.chi);
+                        set.add(value);
+                        value.chi = evaluate(value.chi);
+                        if (value.chi.length == 1 && value.chi[0].typ != EnumToken.BinaryExpressionTokenType) {
+                            if (parent != null) {
+                                if (parent.typ == EnumToken.BinaryExpressionTokenType) {
+                                    if (parent.l == value) {
+                                        parent.l = value.chi[0];
+                                    }
+                                    else {
+                                        parent.r = value.chi[0];
+                                    }
+                                }
+                                else {
+                                    for (let i = 0; i < parent.chi.length; i++) {
+                                        if (parent.chi[i] == value) {
+                                            parent.chi.splice(i, 1, value.chi[0]);
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -40,217 +61,5 @@ class ComputeCalcExpression extends MinifyFeature {
         return ast;
     }
 }
-/**
- * evaluate arithmetic operation
- * @param l
- * @param r
- * @param op
- */
-function doEvaluate(l, r, op) {
-    const defaultReturn = {
-        typ: EnumToken.BinaryExpressionTokenType,
-        op,
-        l,
-        r
-    };
-    if (!isScalarToken(l) || !isScalarToken(r)) {
-        return defaultReturn;
-    }
-    if ((op == EnumToken.Add || op == EnumToken.Sub)) {
-        // @ts-ignore
-        if (l.typ != r.typ || Number.isNaN(+l.val) || Number.isNaN(r.val)) {
-            return defaultReturn;
-        }
-        // @ts-ignore
-        return { ...l, val: reduceNumber(+l.val + (op == EnumToken.Add ? +r.val : -1 * r.val)) };
-    }
-    else {
-        // @ts-ignore
-        let val;
-        if (op == EnumToken.Div) {
-            if (r.typ != EnumToken.NumberTokenType || r.val == '0') {
-                return defaultReturn;
-            }
-            // @ts-ignore
-            val = reduceNumber(l.val / r.val);
-        }
-        else {
-            // @ts-ignore
-            val = reduceNumber(r.val * l.val);
-        }
-        let result;
-        if (r.typ == EnumToken.NumberTokenType || op == EnumToken.Div) {
-            result = { ...l, val };
-        }
-        else {
-            // @ts-ignore
-            result = { ...r, val };
-        }
-        if (renderToken(result).length <= renderToken(defaultReturn).length) {
-            return result;
-        }
-    }
-    return defaultReturn;
-}
-/**
- * evaluate an array of tokens
- * @param tokens
- */
-function evaluate(tokens) {
-    const nodes = inlineExpression(evaluateExpression(buildExpression(tokens)));
-    if (nodes.length <= 1) {
-        return nodes;
-    }
-    const map = new Map;
-    let token;
-    let i;
-    for (i = 0; i < nodes.length; i++) {
-        token = nodes[i];
-        if (token.typ == EnumToken.Add) {
-            continue;
-        }
-        if (token.typ == EnumToken.Sub) {
-            if (!isScalarToken(nodes[i + 1])) {
-                token = { typ: EnumToken.ListToken, chi: [nodes[i], nodes[i + 1]] };
-            }
-            else {
-                token = doEvaluate(nodes[i + 1], { typ: EnumToken.NumberTokenType, val: '-1' }, EnumToken.Mul);
-            }
-            i++;
-        }
-        if (!map.has(token.typ)) {
-            map.set(token.typ, [token]);
-        }
-        else {
-            map.get(token.typ).push(token);
-        }
-    }
-    return [...map].reduce((acc, curr) => {
-        const token = curr[1].reduce((acc, curr) => doEvaluate(acc, curr, EnumToken.Add));
-        if (token.typ != EnumToken.BinaryExpressionTokenType) {
-            if ('val' in token && +token.val < 0) {
-                acc.push({ typ: EnumToken.Sub }, { ...token, val: String(-token.val) });
-                return acc;
-            }
-        }
-        if (acc.length > 0 && curr[0] != EnumToken.ListToken) {
-            acc.push({ typ: EnumToken.Add });
-        }
-        acc.push(token);
-        return acc;
-    }, []);
-}
-/**
- * convert BinaryExpression into an array
- * @param token
- */
-function inlineExpression(token) {
-    const result = [];
-    if (token.typ == EnumToken.BinaryExpressionTokenType) {
-        if ([EnumToken.Mul, EnumToken.Div].includes(token.op)) {
-            result.push(token);
-        }
-        else {
-            result.push(...inlineExpression(token.l), { typ: token.op }, ...inlineExpression(token.r));
-        }
-    }
-    else {
-        result.push(token);
-    }
-    return result;
-}
-/**
- * evaluate expression
- * @param token
- */
-function evaluateExpression(token) {
-    if (token.typ != EnumToken.BinaryExpressionTokenType) {
-        return token;
-    }
-    if (token.r.typ == EnumToken.BinaryExpressionTokenType) {
-        token.r = evaluateExpression(token.r);
-    }
-    if (token.l.typ == EnumToken.BinaryExpressionTokenType) {
-        token.l = evaluateExpression(token.l);
-    }
-    const result = doEvaluate(token.l, token.r, token.op);
-    if (result.typ == EnumToken.BinaryExpressionTokenType &&
-        [EnumToken.Mul, EnumToken.Div].includes(result.op)) {
-        // wrap expression
-        if (result.l.typ == EnumToken.BinaryExpressionTokenType && [EnumToken.Sub, EnumToken.Add].includes(result.l.op)) {
-            result.l = { typ: EnumToken.ParensTokenType, chi: [result.l] };
-        }
-        else if (result.r.typ == EnumToken.BinaryExpressionTokenType && [EnumToken.Sub, EnumToken.Add].includes(result.r.op)) {
-            result.r = { typ: EnumToken.ParensTokenType, chi: [result.r] };
-        }
-    }
-    return result;
-}
-function isScalarToken(token) {
-    return token.typ != EnumToken.BinaryExpressionTokenType && token.typ != EnumToken.ParensTokenType && token.typ != EnumToken.FunctionTokenType;
-}
-/**
- *
- * generate binary expression tree
- * @param tokens
- */
-function buildExpression(tokens) {
-    return factor(factor(tokens.filter(t => t.typ != EnumToken.WhitespaceTokenType), ['/', '*']), ['+', '-'])[0];
-}
-function getArithmeticOperation(op) {
-    if (op == '+') {
-        return EnumToken.Add;
-    }
-    if (op == '-') {
-        return EnumToken.Sub;
-    }
-    if (op == '/') {
-        return EnumToken.Div;
-    }
-    return EnumToken.Mul;
-}
-/**
- *
- * generate binary expression tree
- * @param token
- */
-function factorToken(token) {
-    if (token.typ == EnumToken.ParensTokenType || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc')) {
-        if (token.typ == EnumToken.FunctionTokenType && token.val == 'calc') {
-            token = { ...token, typ: EnumToken.ParensTokenType };
-            // @ts-ignore
-            delete token.val;
-        }
-        return buildExpression(token.chi);
-    }
-    return token;
-}
-/**
- * generate binary expression tree
- * @param tokens
- * @param ops
- */
-function factor(tokens, ops) {
-    let isOp;
-    const opList = [EnumToken.Add, EnumToken.Sub, EnumToken.Div, EnumToken.Mul];
-    if (tokens.length == 1) {
-        return [factorToken(tokens[0])];
-    }
-    for (let i = 0; i < tokens.length; i++) {
-        isOp = opList.includes(tokens[i].typ);
-        if (isOp ||
-            // @ts-ignore
-            (tokens[i].typ == EnumToken.LiteralTokenType && ops.includes(tokens[i].val))) {
-            tokens.splice(i - 1, 3, {
-                typ: EnumToken.BinaryExpressionTokenType,
-                op: isOp ? tokens[i].typ : getArithmeticOperation(tokens[i].val),
-                l: factorToken(tokens[i - 1]),
-                r: factorToken(tokens[i + 1])
-            });
-            i--;
-        }
-    }
-    return tokens;
-}
 
-export { ComputeCalcExpression };
+export { ComputeCalcExpressionFeature };

package/dist/lib/ast/features/index.js

@@ -1,3 +1,3 @@
-export { InlineCssVariables } from './inlinecssvariables.js';
-export { ComputeShorthand } from './shorthand.js';
-export { ComputeCalcExpression } from './calc.js';
+export { InlineCssVariablesFeature } from './inlinecssvariables.js';
+export { ComputeShorthandFeature } from './shorthand.js';
+export { ComputeCalcExpressionFeature } from './calc.js';

package/dist/lib/ast/features/inlinecssvariables.js

@@ -1,34 +1,58 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
-import { MinifyFeature } from '../utiles/minifyfeature.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
+import { IterableWeakSet } from '../../iterable/weakset.js';
 
-class InlineCssVariables extends MinifyFeature {
+function replace(node, variableScope) {
+    for (const { value, parent: parentValue } of walkValues(node.val)) {
+        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+            if (value.chi.length == 1 && value.chi[0].typ == EnumToken.DashedIdenTokenType) {
+                const info = variableScope.get(value.chi[0].val);
+                if (info?.replaceable) {
+                    if (parentValue != null) {
+                        let i = 0;
+                        for (; i < parentValue.chi.length; i++) {
+                            if (parentValue.chi[i] == value) {
+                                parentValue.chi.splice(i, 1, ...info.node.val);
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        node.val = info.node.val.slice();
+                    }
+                }
+            }
+        }
+    }
+}
+class InlineCssVariablesFeature extends MinifyFeature {
     static get ordering() {
         return 0;
     }
     static register(options) {
         if (options.inlineCssVariables) {
             for (const feature of options.features) {
-                if (feature instanceof InlineCssVariables) {
+                if (feature instanceof InlineCssVariablesFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new InlineCssVariables());
+            options.features.push(new InlineCssVariablesFeature());
         }
     }
     run(ast, options = {}, parent, context) {
         if (!('variableScope' in context)) {
             context.variableScope = new Map;
         }
-        const isRoot = parent.typ == 2 /* NodeType.StyleSheetNodeType */ && ast.typ == 4 /* NodeType.RuleNodeType */ && ast.sel == ':root';
+        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && ast.sel == ':root';
         const variableScope = context.variableScope;
         // @ts-ignore
         for (const node of ast.chi) {
-            if (node.typ == 1 /* NodeType.CDOCOMMNodeType */ || node.typ == 0 /* NodeType.CommentNodeType */) {
+            if (node.typ == EnumToken.CDOCOMMNodeType || node.typ == EnumToken.CommentNodeType) {
                 continue;
             }
-            if (node.typ != 5 /* NodeType.DeclarationNodeType */) {
+            if (node.typ != EnumToken.DeclarationNodeType) {
                 break;
             }
             // css variable
@@ -37,13 +61,23 @@ class InlineCssVariables extends MinifyFeature {
                     const info = {
                         globalScope: isRoot,
                         // @ts-ignore
-                        parent: new Set(),
+                        parent: new IterableWeakSet(),
                         declarationCount: 1,
                         replaceable: isRoot,
                         node: node
                     };
                     info.parent.add(ast);
                     variableScope.set(node.nam, info);
+                    let recursive = false;
+                    for (const { value, parent: parentValue } of walkValues(node.val)) {
+                        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+                            recursive = true;
+                            break;
+                        }
+                    }
+                    if (recursive) {
+                        replace(node, variableScope);
+                    }
                 }
                 else {
                     const info = variableScope.get(node.nam);
@@ -59,27 +93,7 @@ class InlineCssVariables extends MinifyFeature {
                 }
             }
             else {
-                for (const { value, parent: parentValue } of walkValues(node.val)) {
-                    if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
-                        if (value.chi.length == 1 && value.chi[0].typ == EnumToken.IdenTokenType) {
-                            const info = variableScope.get(value.chi[0].val);
-                            if (info?.replaceable) {
-                                if (parentValue != null) {
-                                    let i = 0;
-                                    for (; i < parentValue.chi.length; i++) {
-                                        if (parentValue.chi[i] == value) {
-                                            parentValue.chi.splice(i, 1, ...info.node.val);
-                                            break;
-                                        }
-                                    }
-                                }
-                                else {
-                                    node.val = info.node.val.slice();
-                                }
-                            }
-                        }
-                    }
-                }
+                replace(node, variableScope);
             }
         }
     }
@@ -88,10 +102,11 @@ class InlineCssVariables extends MinifyFeature {
         for (const info of variableScope.values()) {
             if (info.replaceable) {
                 let i;
+                // drop declarations from :root{}
                 for (const parent of info.parent) {
                     i = parent.chi?.length ?? 0;
                     while (i--) {
-                        if (parent.chi[i].typ == 5 /* NodeType.DeclarationNodeType */ && parent.chi[i].nam == info.node.nam) {
+                        if (parent.chi[i].typ == EnumToken.DeclarationNodeType && parent.chi[i].nam == info.node.nam) {
                             parent.chi.splice(i, 1);
                         }
                     }
@@ -112,4 +127,4 @@ class InlineCssVariables extends MinifyFeature {
     }
 }
 
-export { InlineCssVariables };
+export { InlineCssVariablesFeature };

package/dist/lib/ast/features/shorthand.js

@@ -1,24 +1,24 @@
 import { PropertyList } from '../../parser/declaration/list.js';
 import '../../renderer/utils/color.js';
-import '../types.js';
+import { EnumToken } from '../types.js';
 import '../minify.js';
 import '../../parser/parse.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import { MinifyFeature } from '../utiles/minifyfeature.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
 
-class ComputeShorthand extends MinifyFeature {
+class ComputeShorthandFeature extends MinifyFeature {
     static get ordering() {
         return 2;
     }
     static register(options) {
         if (options.computeShorthand) {
             for (const feature of options.features) {
-                if (feature instanceof ComputeShorthand) {
+                if (feature instanceof ComputeShorthandFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new ComputeShorthand());
+            options.features.push(new ComputeShorthandFeature());
         }
     }
     run(ast, options = {}, parent, context) {
@@ -30,7 +30,7 @@ class ComputeShorthand extends MinifyFeature {
         for (; k < j; k++) {
             // @ts-ignore
             const node = ast.chi[k];
-            if (node.typ == 0 /* NodeType.CommentNodeType */ || node.typ == 5 /* NodeType.DeclarationNodeType */) {
+            if (node.typ == EnumToken.CommentNodeType || node.typ == EnumToken.DeclarationNodeType) {
                 properties.add(node);
                 continue;
             }
@@ -42,4 +42,4 @@ class ComputeShorthand extends MinifyFeature {
     }
 }
 
-export { ComputeShorthand };
+export { ComputeShorthandFeature };

package/dist/lib/ast/features/utils/math.js

@@ -0,0 +1,95 @@
+import { EnumToken } from '../../types.js';
+import { reduceNumber } from '../../../renderer/render.js';
+
+const gcd = (x, y) => {
+    x = Math.abs(x);
+    y = Math.abs(y);
+    let t;
+    if (x == 0 || y == 0) {
+        return 1;
+    }
+    while (y) {
+        t = y;
+        y = x % y;
+        x = t;
+    }
+    return x;
+};
+function compute(a, b, op) {
+    if (typeof a == 'number' && typeof b == 'number') {
+        switch (op) {
+            case EnumToken.Add:
+                return a + b;
+            case EnumToken.Sub:
+                return a - b;
+            case EnumToken.Mul:
+                return a * b;
+            case EnumToken.Div:
+                const r = simplify(a, b);
+                if (r[1] == 1) {
+                    return r[0];
+                }
+                const result = a / b;
+                const r2 = reduceNumber(r[0]) + '/' + reduceNumber(r[1]);
+                return reduceNumber(result).length <= r2.length ? result : {
+                    typ: EnumToken.FractionTokenType,
+                    l: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[0]) },
+                    r: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[1]) }
+                };
+        }
+    }
+    let l1 = typeof a == 'number' ? {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a) },
+        r: { typ: EnumToken.NumberTokenType, val: '1' }
+    } : a;
+    let r1 = typeof b == 'number' ? {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(b) },
+        r: { typ: EnumToken.NumberTokenType, val: '1' }
+    } : b;
+    let l2;
+    let r2;
+    switch (op) {
+        case EnumToken.Add:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val + l1.r.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Sub:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val - l1.r.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Mul:
+            // @ts-ignore
+            l2 = l1.l.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Div:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.l.val;
+            break;
+    }
+    const a2 = simplify(l2, r2);
+    if (a2[1] == 1) {
+        return a2[0];
+    }
+    const result = a2[0] / a2[1];
+    return reduceNumber(result).length <= reduceNumber(a2[0]).length + 1 + reduceNumber(a2[1]).length ? result : {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[0]) },
+        r: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[1]) }
+    };
+}
+function simplify(a, b) {
+    const g = gcd(a, b);
+    return g > 1 ? [a / g, b / g] : [a, b];
+}
+
+export { compute, gcd, simplify };