@tbela99/css-parser 0.0.1 → 0.2.0

package/dist/lib/ast/expand.js

@@ -2,37 +2,38 @@ import { splitRule, combinators } from './minify.js';
 import { parseString } from '../parser/parse.js';
 import { renderToken } from '../renderer/render.js';
 import '../renderer/utils/color.js';
+import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 
 function expand(ast) {
     //
-    if (!['Rule', 'StyleSheet', 'AtRule'].includes(ast.typ)) {
+    if (![EnumToken.RuleNodeType, EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType].includes(ast.typ)) {
         return ast;
     }
-    if ('Rule' == ast.typ) {
+    if (EnumToken.RuleNodeType == ast.typ) {
         return {
-            typ: 'StyleSheet',
+            typ: EnumToken.StyleSheetNodeType,
             chi: expandRule(ast)
         };
     }
     if (!('chi' in ast)) {
-        return { ...ast };
+        return ast;
     }
     const result = { ...ast, chi: [] };
     // @ts-ignore
     for (let i = 0; i < ast.chi.length; i++) {
         // @ts-ignore
         const node = ast.chi[i];
-        if (node.typ == 'Rule') {
+        if (node.typ == EnumToken.RuleNodeType) {
             // @ts-ignore
             result.chi.push(...expandRule(node));
             // i += expanded.length - 1;
         }
-        else if (node.typ == 'AtRule' && '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 == 'Rule' || node.chi[j].typ == 'AtRule') {
+                if (node.chi[j].typ == EnumToken.RuleNodeType || node.chi[j].typ == EnumToken.AtRuleNodeType) {
                     hasRule = true;
                     break;
                 }
@@ -50,10 +51,10 @@ function expand(ast) {
 function expandRule(node) {
     const ast = { ...node, chi: node.chi.slice() };
     const result = [];
-    if (ast.typ == 'Rule') {
+    if (ast.typ == EnumToken.RuleNodeType) {
         let i = 0;
         for (; i < ast.chi.length; i++) {
-            if (ast.chi[i].typ == 'Rule') {
+            if (ast.chi[i].typ == EnumToken.RuleNodeType) {
                 const rule = ast.chi[i];
                 if (!rule.sel.includes('&')) {
                     const selRule = splitRule(rule.sel);
@@ -69,14 +70,13 @@ function expandRule(node) {
                 ast.chi.splice(i--, 1);
                 result.push(...expandRule(rule));
             }
-            else if (ast.chi[i].typ == 'AtRule') {
+            else if (ast.chi[i].typ == EnumToken.AtRuleNodeType) {
                 let astAtRule = ast.chi[i];
                 const values = [];
                 if (astAtRule.nam == 'scope') {
                     if (astAtRule.val.includes('&')) {
                         astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
                     }
-                    // @ts-ignore
                     astAtRule = expand(astAtRule);
                 }
                 else {
@@ -85,7 +85,7 @@ function expandRule(node) {
                     // @ts-ignore
                     astAtRule.chi.length = 0;
                     for (const r of expandRule(clone)) {
-                        if (r.typ == 'AtRule' && '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 == 'Rule') {
+                        else if (r.typ == EnumToken.RuleNodeType) {
                             // @ts-ignore
                             astAtRule.chi.push(...expandRule(r));
                         }
@@ -119,7 +119,7 @@ function expandRule(node) {
 function replaceCompound(input, replace) {
     const tokens = parseString(input);
     for (const t of walkValues(tokens)) {
-        if (t.value.typ == 'Literal') {
+        if (t.value.typ == EnumToken.LiteralTokenType) {
             if (t.value.val == '&') {
                 t.value.val = replace;
             }

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

@@ -0,0 +1,225 @@
+import { EnumToken } from '../types.js';
+import { reduceNumber } from '../../renderer/render.js';
+import { walkValues } from '../walk.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
+import { compute } from './utils/math.js';
+import { IterableWeakSet } from '../../iterable/set.js';
+
+class ComputeCalcExpression extends MinifyFeature {
+    static get ordering() {
+        return 1;
+    }
+    static register(options) {
+        if (options.computeCalcExpression) {
+            for (const feature of options.features) {
+                if (feature instanceof ComputeCalcExpression) {
+                    return;
+                }
+            }
+            // @ts-ignore
+            options.features.push(new ComputeCalcExpression());
+        }
+    }
+    run(ast) {
+        if (!('chi' in ast)) {
+            return ast;
+        }
+        // @ts-ignore
+        for (const node of ast.chi) {
+            if (node.typ != EnumToken.DeclarationNodeType) {
+                continue;
+            }
+            const set = new IterableWeakSet;
+            for (const { parent } of walkValues(node.val)) {
+                if (parent != null && parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') {
+                    if (!set.has(parent)) {
+                        set.add(parent);
+                        parent.chi = evaluate(parent.chi);
+                    }
+                }
+            }
+        }
+        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) {
+            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 };
+}
+/**
+ * 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.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 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 = 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 { ComputeCalcExpression };

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

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

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

@@ -0,0 +1,130 @@
+import { EnumToken } from '../types.js';
+import { walkValues } from '../walk.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
+import { IterableWeakSet } from '../../iterable/set.js';
+
+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 InlineCssVariables extends MinifyFeature {
+    static get ordering() {
+        return 0;
+    }
+    static register(options) {
+        if (options.inlineCssVariables) {
+            for (const feature of options.features) {
+                if (feature instanceof InlineCssVariables) {
+                    return;
+                }
+            }
+            // @ts-ignore
+            options.features.push(new InlineCssVariables());
+        }
+    }
+    run(ast, options = {}, parent, context) {
+        if (!('variableScope' in context)) {
+            context.variableScope = new Map;
+        }
+        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 == EnumToken.CDOCOMMNodeType || node.typ == EnumToken.CommentNodeType) {
+                continue;
+            }
+            if (node.typ != EnumToken.DeclarationNodeType) {
+                break;
+            }
+            // css variable
+            if (node.nam.startsWith('--')) {
+                if (!variableScope.has(node.nam)) {
+                    const info = {
+                        globalScope: isRoot,
+                        // @ts-ignore
+                        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);
+                    info.globalScope = isRoot;
+                    if (!isRoot) {
+                        ++info.declarationCount;
+                    }
+                    if (info.replaceable) {
+                        info.replaceable = isRoot && info.declarationCount == 1;
+                    }
+                    info.parent.add(ast);
+                    info.node = node;
+                }
+            }
+            else {
+                replace(node, variableScope);
+            }
+        }
+    }
+    cleanup(ast, options = {}, context) {
+        const variableScope = context.variableScope;
+        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 == EnumToken.DeclarationNodeType && parent.chi[i].nam == info.node.nam) {
+                            parent.chi.splice(i, 1);
+                        }
+                    }
+                    if (parent.chi?.length == 0 && 'parent' in parent) {
+                        // @ts-ignore
+                        for (i = 0; i < parent.parent.chi?.length; i++) {
+                            // @ts-ignore
+                            if (parent.parent.chi[i] == parent) {
+                                // @ts-ignore
+                                parent.parent.chi.splice(i, 1);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+export { InlineCssVariables };

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

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

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 };