@tbela99/css-parser 0.1.0 → 0.3.0

package/dist/lib/ast/math/expression.js

@@ -0,0 +1,185 @@
+import { EnumToken } from '../types.js';
+import { compute } from './math.js';
+import { reduceNumber } from '../../renderer/render.js';
+
+/**
+ * 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;
+    }, []);
+}
+/**
+ * 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) {
+            return defaultReturn;
+        }
+    }
+    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : l.typ;
+    // @ts-ignore
+    const val = compute(typeof l.val == 'string' ? +l.val : l.val, typeof r.val == 'string' ? +r.val : r.val, op);
+    return { ...(l.typ == EnumToken.NumberTokenType ? r : l), typ, val: typeof val == 'number' ? reduceNumber(val) : val };
+}
+/**
+ * convert BinaryExpression into an array
+ * @param token
+ */
+function inlineExpression(token) {
+    const result = [];
+    if (token.typ == EnumToken.ParensTokenType && token.chi.length == 1) {
+        result.push(token.chi[0]);
+    }
+    else 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);
+    }
+    return doEvaluate(token.l, token.r, token.op);
+}
+function isScalarToken(token) {
+    return 'unit' in token || [EnumToken.NumberTokenType, EnumToken.FractionTokenType, EnumToken.PercentageTokenType].includes(token.typ);
+}
+/**
+ *
+ * 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 = ops.map(x => getArithmeticOperation(x));
+    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 { evaluate };

package/dist/lib/ast/math/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 };

package/dist/lib/ast/minify.js

@@ -1,5 +1,5 @@
 import { parseString } from '../parser/parse.js';
-import { isIdentStart, isWhiteSpace, isIdent, isFunction } from '../parser/utils/syntax.js';
+import { isWhiteSpace, isIdent, isFunction, isIdentStart } from '../parser/utils/syntax.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { replaceCompound } from './expand.js';
@@ -7,7 +7,7 @@ import { eq } from '../parser/utils/eq.js';
 import { renderToken, doRender } from '../renderer/render.js';
 import * as index from './features/index.js';
 
-const combinators = ['+', '>', '~'];
+const combinators = ['+', '>', '~', '||'];
 const notEndingWith = ['(', '['].concat(combinators);
 const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
 // @ts-ignore
@@ -23,7 +23,12 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
     context.nodes.add(ast);
     if (!('features' in options)) {
         // @ts-ignore
-        options = { removeDuplicateDeclarations: true, computeShorthand: true, computeCalcExpression: true, features: [], ...options };
+        options = {
+            removeDuplicateDeclarations: true,
+            computeShorthand: true,
+            computeCalcExpression: true,
+            features: [], ...options
+        };
         // @ts-ignore
         for (const feature of features) {
             feature.register(options);
@@ -42,7 +47,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 curr.splice(0, 1);
             }
         }
-        else if (ast.typ == 4 /* NodeType.RuleNodeType */ && (isIdent(curr[0]) || isFunction(curr[0]))) {
+        else if (ast.typ == EnumToken.RuleNodeType && (isIdent(curr[0]) || isFunction(curr[0]))) {
             curr.unshift('&', ' ');
         }
         acc.push(curr.join(''));
@@ -51,7 +56,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
     // @ts-ignore
     if ('chi' in ast && ast.chi.length > 0) {
         if (!nestingContent) {
-            nestingContent = options.nestingRules && ast.typ == 4 /* NodeType.RuleNodeType */;
+            nestingContent = options.nestingRules && ast.typ == EnumToken.RuleNodeType;
         }
         let i = 0;
         let previous;
@@ -60,7 +65,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         // @ts-ignore
         for (; i < ast.chi.length; i++) {
             // @ts-ignore
-            if (ast.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
+            if (ast.chi[i].typ == EnumToken.CommentNodeType) {
                 continue;
             }
             // @ts-ignore
@@ -72,10 +77,10 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 i--;
                 continue;
             }
-            if (node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam == 'font-face') {
+            if (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face') {
                 continue;
             }
-            if (node.typ == 3 /* NodeType.AtRuleNodeType */) {
+            if (node.typ == EnumToken.AtRuleNodeType) {
                 if (node.nam == 'media' && node.val == 'all') {
                     // @ts-ignore
                     ast.chi?.splice(i, 1, ...node.chi);
@@ -83,7 +88,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                     continue;
                 }
                 // @ts-ignore
-                if (previous?.typ == 3 /* NodeType.AtRuleNodeType */ &&
+                if (previous?.typ == EnumToken.AtRuleNodeType &&
                     previous.nam == node.nam &&
                     previous.val == node.val) {
                     if ('chi' in node) {
@@ -102,14 +107,14 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 continue;
             }
             // @ts-ignore
-            if (node.typ == 4 /* NodeType.RuleNodeType */) {
+            if (node.typ == EnumToken.RuleNodeType) {
                 reduceRuleSelector(node);
                 let wrapper;
                 let match;
                 // @ts-ignore
                 if (options.nestingRules) {
                     // @ts-ignore
-                    if (previous?.typ == 4 /* NodeType.RuleNodeType */) {
+                    if (previous?.typ == EnumToken.RuleNodeType) {
                         // @ts-ignore
                         reduceRuleSelector(previous);
                         // @ts-ignore
@@ -130,7 +135,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                             // @ts-ignore
                             const nextNode = ast.chi[i];
                             // @ts-ignore
-                            if (nextNode.typ != 4 /* NodeType.RuleNodeType */) {
+                            if (nextNode.typ != EnumToken.RuleNodeType) {
                                 break;
                             }
                             reduceRuleSelector(nextNode);
@@ -184,7 +189,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                 curr.splice(0, 2);
                             }
                             else {
-                                if (ast.typ != 4 /* NodeType.RuleNodeType */ && combinators.includes(curr[1])) {
+                                if (ast.typ != EnumToken.RuleNodeType && combinators.includes(curr[1])) {
                                     wrap = false;
                                 }
                                 else {
@@ -232,18 +237,18 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                         let k = previous.chi.length;
                         while (k-- > 0) {
                             // @ts-ignore
-                            if (previous.chi[k].typ == 0 /* NodeType.CommentNodeType */) {
+                            if (previous.chi[k].typ == EnumToken.CommentNodeType) {
                                 continue;
                             }
                             // @ts-ignore
-                            shouldMerge = previous.chi[k].typ == 5 /* NodeType.DeclarationNodeType */;
+                            shouldMerge = previous.chi[k].typ == EnumToken.DeclarationNodeType;
                             break;
                         }
                         if (shouldMerge) {
                             // @ts-ignore
-                            if ((node.typ == 4 /* NodeType.RuleNodeType */ && node.sel == previous.sel) ||
+                            if ((node.typ == EnumToken.RuleNodeType && node.sel == previous.sel) ||
                                 // @ts-ignore
-                                (node.typ == 3 /* NodeType.AtRuleNodeType */) && node.val != 'font-face' && node.val == previous.val) {
+                                (node.typ == EnumToken.AtRuleNodeType) && node.val != 'font-face' && node.val == previous.val) {
                                 // @ts-ignore
                                 node.chi.unshift(...previous.chi);
                                 // @ts-ignore
@@ -260,7 +265,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                 nodeIndex = i;
                                 continue;
                             }
-                            else if (node.typ == 4 /* NodeType.RuleNodeType */ && previous?.typ == 4 /* NodeType.RuleNodeType */) {
+                            else if (node.typ == EnumToken.RuleNodeType && previous?.typ == EnumToken.RuleNodeType) {
                                 const intersect = diff(previous, node, reducer, options);
                                 if (intersect != null) {
                                     if (intersect.node1.chi.length == 0) {
@@ -317,7 +322,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 // @ts-ignore
                 previous != null &&
                 // previous.optimized != null &&
-                previous.typ == 4 /* NodeType.RuleNodeType */ &&
+                previous.typ == EnumToken.RuleNodeType &&
                 previous.sel.includes('&')) {
                 fixSelector(previous);
             }
@@ -327,9 +332,9 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         // @ts-ignore
         if (recursive && node != null && ('chi' in node)) {
             // @ts-ignore
-            if (!node.chi.some(n => n.typ == 5 /* NodeType.DeclarationNodeType */)) {
+            if (!node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
                 // @ts-ignore
-                if (!(node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam != 'font-face')) {
+                if (!(node.typ == EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
                     minify(node, options, recursive, errors, nestingContent, context);
                 }
             }
@@ -338,12 +343,12 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             // @ts-ignore
             node != null &&
             // previous.optimized != null &&
-            node.typ == 4 /* NodeType.RuleNodeType */ &&
+            node.typ == EnumToken.RuleNodeType &&
             node.sel.includes('&')) {
             fixSelector(node);
         }
     }
-    if (ast.typ == 2 /* NodeType.StyleSheetNodeType */) {
+    if (ast.typ == EnumToken.StyleSheetNodeType) {
         let parent;
         let parents = [ast];
         while (parents.length > 0) {
@@ -352,7 +357,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             for (let k = 0; k < parent.chi.length; k++) {
                 // @ts-ignore
                 const node = parent.chi[k];
-                if (!('chi' in node) || node.typ == 2 /* NodeType.StyleSheetNodeType */ || (node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam == 'font-face')) {
+                if (!('chi' in node) || node.typ == EnumToken.StyleSheetNodeType || (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face')) {
                     continue;
                 }
                 // @ts-ignore
@@ -463,11 +468,11 @@ function hasDeclaration(node) {
     // @ts-ignore
     for (let i = 0; i < node.chi?.length; i++) {
         // @ts-ignore
-        if (node.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
+        if (node.chi[i].typ == EnumToken.CommentNodeType) {
             continue;
         }
         // @ts-ignore
-        return node.chi[i].typ == 5 /* NodeType.DeclarationNodeType */;
+        return node.chi[i].typ == EnumToken.DeclarationNodeType;
     }
     return true;
 }
@@ -613,7 +618,7 @@ function matchSelectors(selector1, selector2, parentType, errors) {
     if (matchFunction != 0 || inAttr != 0) {
         return null;
     }
-    if (parentType != 4 /* NodeType.RuleNodeType */) {
+    if (parentType != EnumToken.RuleNodeType) {
         for (const part of match) {
             if (part.length > 0 && combinators.includes(part[0].charAt(0))) {
                 return null;
@@ -819,7 +824,7 @@ function diff(n1, n2, reducer, options = {}) {
     }
     const intersect = [];
     while (i--) {
-        if (node1.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
+        if (node1.chi[i].typ == EnumToken.CommentNodeType) {
             continue;
         }
         j = node2.chi.length;
@@ -827,7 +832,7 @@ function diff(n1, n2, reducer, options = {}) {
             break;
         }
         while (j--) {
-            if (node2.chi[j].typ == 0 /* NodeType.CommentNodeType */) {
+            if (node2.chi[j].typ == EnumToken.CommentNodeType) {
                 continue;
             }
             if (node1.chi[i].nam == node2.chi[j].nam) {