@tbela99/css-parser 0.2.0 → 0.4.0

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

@@ -0,0 +1,220 @@
+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;
+        }
+    }
+    else if (op == EnumToken.Mul &&
+        ![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(l.typ) &&
+        ![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(r.typ)) {
+        return defaultReturn;
+    }
+    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : (r.typ == EnumToken.NumberTokenType ? l.typ : (l.typ == EnumToken.PercentageTokenType ? r.typ : l.typ));
+    // @ts-ignore
+    let v1 = typeof l.val == 'string' ? +l.val : l.val;
+    // @ts-ignore
+    let v2 = typeof r.val == 'string' ? +r.val : r.val;
+    if (op == EnumToken.Mul) {
+        if (l.typ != EnumToken.NumberTokenType && r.typ != EnumToken.NumberTokenType) {
+            if (typeof v1 == 'number' && l.typ == EnumToken.PercentageTokenType) {
+                v1 = {
+                    typ: EnumToken.FractionTokenType,
+                    l: { typ: EnumToken.NumberTokenType, val: String(v1) },
+                    r: { typ: EnumToken.NumberTokenType, val: '100' }
+                };
+            }
+            else if (typeof v2 == 'number' && r.typ == EnumToken.PercentageTokenType) {
+                v2 = {
+                    typ: EnumToken.FractionTokenType,
+                    l: { typ: EnumToken.NumberTokenType, val: String(v2) },
+                    r: { typ: EnumToken.NumberTokenType, val: '100' }
+                };
+            }
+        }
+    }
+    // @ts-ignore
+    const val = compute(v1, v2, 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++) {
+        if (tokens[i].typ == EnumToken.ListToken) {
+            // @ts-ignore
+            tokens.splice(i, 1, ...tokens[i].chi);
+        }
+        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/{features/utils → math}/math.js

@@ -1,7 +1,7 @@
-import { EnumToken } from '../../types.js';
-import { reduceNumber } from '../../../renderer/render.js';
+import { EnumToken } from '../types.js';
+import { reduceNumber } from '../../renderer/render.js';
 
-const gcd = (x, y) => {
+function gcd(x, y) {
     x = Math.abs(x);
     y = Math.abs(y);
     let t;
@@ -14,7 +14,7 @@ const gcd = (x, y) => {
         x = t;
     }
     return x;
-};
+}
 function compute(a, b, op) {
     if (typeof a == 'number' && typeof b == 'number') {
         switch (op) {

package/dist/lib/ast/minify.js

@@ -17,7 +17,6 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         context.nodes = new WeakSet;
     }
     if (context.nodes.has(ast)) {
-        // console.error('skipped', ast.typ);
         return ast;
     }
     context.nodes.add(ast);

package/dist/lib/ast/types.js

@@ -57,25 +57,30 @@ var EnumToken;
     EnumToken[EnumToken["BadStringTokenType"] = 54] = "BadStringTokenType";
     EnumToken[EnumToken["BinaryExpressionTokenType"] = 55] = "BinaryExpressionTokenType";
     EnumToken[EnumToken["UnaryExpressionTokenType"] = 56] = "UnaryExpressionTokenType";
+    EnumToken[EnumToken["FlexTokenType"] = 57] = "FlexTokenType";
     /* catch all */
-    EnumToken[EnumToken["ListToken"] = 57] = "ListToken";
+    EnumToken[EnumToken["ListToken"] = 58] = "ListToken";
     /* arithmetic tokens */
-    EnumToken[EnumToken["Add"] = 58] = "Add";
-    EnumToken[EnumToken["Mul"] = 59] = "Mul";
-    EnumToken[EnumToken["Div"] = 60] = "Div";
-    EnumToken[EnumToken["Sub"] = 61] = "Sub";
+    EnumToken[EnumToken["Add"] = 59] = "Add";
+    EnumToken[EnumToken["Mul"] = 60] = "Mul";
+    EnumToken[EnumToken["Div"] = 61] = "Div";
+    EnumToken[EnumToken["Sub"] = 62] = "Sub";
     /* new tokens */
-    EnumToken[EnumToken["ColumnCombinatorTokenType"] = 62] = "ColumnCombinatorTokenType";
-    EnumToken[EnumToken["ContainMatchTokenType"] = 63] = "ContainMatchTokenType";
-    EnumToken[EnumToken["StartMatchTokenType"] = 64] = "StartMatchTokenType";
-    EnumToken[EnumToken["EndMatchTokenType"] = 65] = "EndMatchTokenType";
-    EnumToken[EnumToken["MatchExpressionTokenType"] = 66] = "MatchExpressionTokenType";
-    EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 67] = "NameSpaceAttributeTokenType";
-    EnumToken[EnumToken["FractionTokenType"] = 68] = "FractionTokenType";
+    EnumToken[EnumToken["ColumnCombinatorTokenType"] = 63] = "ColumnCombinatorTokenType";
+    EnumToken[EnumToken["ContainMatchTokenType"] = 64] = "ContainMatchTokenType";
+    EnumToken[EnumToken["StartMatchTokenType"] = 65] = "StartMatchTokenType";
+    EnumToken[EnumToken["EndMatchTokenType"] = 66] = "EndMatchTokenType";
+    EnumToken[EnumToken["MatchExpressionTokenType"] = 67] = "MatchExpressionTokenType";
+    EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 68] = "NameSpaceAttributeTokenType";
+    EnumToken[EnumToken["FractionTokenType"] = 69] = "FractionTokenType";
+    EnumToken[EnumToken["IdenListTokenType"] = 70] = "IdenListTokenType";
+    EnumToken[EnumToken["GridTemplateFuncTokenType"] = 71] = "GridTemplateFuncTokenType";
     /* aliases */
     EnumToken[EnumToken["Time"] = 25] = "Time";
     EnumToken[EnumToken["Iden"] = 7] = "Iden";
+    EnumToken[EnumToken["EOF"] = 47] = "EOF";
     EnumToken[EnumToken["Hash"] = 28] = "Hash";
+    EnumToken[EnumToken["Flex"] = 57] = "Flex";
     EnumToken[EnumToken["Angle"] = 24] = "Angle";
     EnumToken[EnumToken["Color"] = 49] = "Color";
     EnumToken[EnumToken["Comma"] = 9] = "Comma";
@@ -90,12 +95,25 @@ var EnumToken;
     EnumToken[EnumToken["Frequency"] = 26] = "Frequency";
     EnumToken[EnumToken["Resolution"] = 27] = "Resolution";
     EnumToken[EnumToken["Whitespace"] = 36] = "Whitespace";
+    EnumToken[EnumToken["IdenList"] = 70] = "IdenList";
     EnumToken[EnumToken["DashedIden"] = 8] = "DashedIden";
+    EnumToken[EnumToken["GridTemplateFunc"] = 71] = "GridTemplateFunc";
     EnumToken[EnumToken["ImageFunc"] = 19] = "ImageFunc";
     EnumToken[EnumToken["CommentNodeType"] = 0] = "CommentNodeType";
     EnumToken[EnumToken["CDOCOMMNodeType"] = 1] = "CDOCOMMNodeType";
     EnumToken[EnumToken["TimingFunction"] = 17] = "TimingFunction";
     EnumToken[EnumToken["TimelineFunction"] = 16] = "TimelineFunction";
 })(EnumToken || (EnumToken = {}));
+const funcLike = [
+    EnumToken.ParensTokenType,
+    EnumToken.FunctionTokenType,
+    EnumToken.UrlFunctionTokenType,
+    EnumToken.StartParensTokenType,
+    EnumToken.ImageFunctionTokenType,
+    EnumToken.TimingFunctionTokenType,
+    EnumToken.TimingFunctionTokenType,
+    EnumToken.PseudoClassFuncTokenType,
+    EnumToken.GridTemplateFuncTokenType
+];
 
-export { EnumToken };
+export { EnumToken, funcLike };

package/dist/lib/ast/utils/minifyfeature.js

@@ -1,7 +1,8 @@
 class MinifyFeature {
-    static get ordering() { return 10000; }
-    register(options) { }
-    run(ast, options = {}, parent, context) {
+    static get ordering() {
+        return 10000;
+    }
+    register(options) {
     }
 }
 

package/dist/lib/ast/walk.js

@@ -1,3 +1,5 @@
+import { EnumToken } from './types.js';
+
 function* walk(node, filter) {
     const parents = [node];
     const root = node;
@@ -27,20 +29,38 @@ function* walk(node, filter) {
         }
     }
 }
-function* walkValues(values) {
+function* walkValues(values, root = null, filter) {
     const stack = values.slice();
     const weakMap = new WeakMap;
     let value;
     while (stack.length > 0) {
         value = stack.shift();
+        let option = null;
+        if (filter != null) {
+            option = filter(value);
+            if (option === 'ignore') {
+                continue;
+            }
+            if (option === 'stop') {
+                break;
+            }
+        }
         // @ts-ignore
-        yield { value, parent: weakMap.get(value) };
-        if ('chi' in value) {
-            for (const child of value.chi) {
+        if (option !== 'children') {
+            // @ts-ignore
+            yield { value, parent: weakMap.get(value), root };
+        }
+        if (option !== 'ignore-children' && 'chi' in value) {
+            for (const child of value.chi.slice()) {
                 weakMap.set(child, value);
             }
             stack.unshift(...value.chi);
         }
+        else if (value.typ == EnumToken.BinaryExpressionTokenType) {
+            weakMap.set(value.l, value);
+            weakMap.set(value.r, value);
+            stack.unshift(value.l, value.r);
+        }
     }
 }
 

package/dist/lib/fs/resolve.js

@@ -35,13 +35,14 @@ function splitPath(result) {
             parts[parts.length - 1] += chr;
         }
     }
-    let k = parts.length;
-    while (k--) {
+    let k = -1;
+    while (++k < parts.length) {
         if (parts[k] == '.') {
-            parts.splice(k, 1);
+            parts.splice(k--, 1);
         }
         else if (parts[k] == '..') {
             parts.splice(k - 1, 2);
+            k -= 2;
         }
     }
     return { parts, i };

package/dist/lib/parser/declaration/list.js

@@ -1,8 +1,8 @@
 import { PropertySet } from './set.js';
-import '../../renderer/utils/color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { parseString } from '../parse.js';
+import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { getConfig } from '../utils/config.js';
 import { PropertyMap } from './map.js';
@@ -21,7 +21,11 @@ class PropertyList {
         this.declarations = new Map;
     }
     set(nam, value) {
-        return this.add({ typ: EnumToken.DeclarationNodeType, nam, val: Array.isArray(value) ? value : parseString(String(value)) });
+        return this.add({
+            typ: EnumToken.DeclarationNodeType,
+            nam,
+            val: Array.isArray(value) ? value : parseString(String(value))
+        });
     }
     add(declaration) {
         if (declaration.typ != EnumToken.DeclarationNodeType || !this.options.removeDuplicateDeclarations) {