@tbela99/css-parser 0.0.1-rc7 → 0.1.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 (![4 /* NodeType.RuleNodeType */, 2 /* NodeType.StyleSheetNodeType */, 3 /* NodeType.AtRuleNodeType */].includes(ast.typ)) {
         return ast;
     }
-    if ('Rule' == ast.typ) {
+    if (4 /* NodeType.RuleNodeType */ == ast.typ) {
         return {
-            typ: 'StyleSheet',
+            typ: 2 /* NodeType.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 == 4 /* NodeType.RuleNodeType */) {
             // @ts-ignore
             result.chi.push(...expandRule(node));
             // i += expanded.length - 1;
         }
-        else if (node.typ == 'AtRule' && 'chi' in node) {
+        else if (node.typ == 3 /* NodeType.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 == 4 /* NodeType.RuleNodeType */ || node.chi[j].typ == 3 /* NodeType.AtRuleNodeType */) {
                     hasRule = true;
                     break;
                 }
@@ -50,14 +51,10 @@ function expand(ast) {
 function expandRule(node) {
     const ast = { ...node, chi: node.chi.slice() };
     const result = [];
-    if (ast.typ == 'Rule') {
+    if (ast.typ == 4 /* NodeType.RuleNodeType */) {
         let i = 0;
-        // @ts-ignore
-        delete ast.raw;
-        // @ts-ignore
-        delete ast.optimized;
         for (; i < ast.chi.length; i++) {
-            if (ast.chi[i].typ == 'Rule') {
+            if (ast.chi[i].typ == 4 /* NodeType.RuleNodeType */) {
                 const rule = ast.chi[i];
                 if (!rule.sel.includes('&')) {
                     const selRule = splitRule(rule.sel);
@@ -70,19 +67,16 @@ function expandRule(node) {
                 else {
                     rule.sel = replaceCompound(rule.sel, ast.sel);
                 }
-                delete rule.raw;
-                delete rule.optimized;
                 ast.chi.splice(i--, 1);
                 result.push(...expandRule(rule));
             }
-            else if (ast.chi[i].typ == 'AtRule') {
+            else if (ast.chi[i].typ == 3 /* NodeType.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 {
@@ -91,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 == 3 /* NodeType.AtRuleNodeType */ && 'chi' in r) {
                             if (astAtRule.val !== '' && r.val !== '') {
                                 if (astAtRule.nam == 'media' && r.nam == 'media') {
                                     r.val = astAtRule.val + ' and ' + r.val;
@@ -103,7 +97,7 @@ function expandRule(node) {
                             // @ts-ignore
                             values.push(r);
                         }
-                        else if (r.typ == 'Rule') {
+                        else if (r.typ == 4 /* NodeType.RuleNodeType */) {
                             // @ts-ignore
                             astAtRule.chi.push(...expandRule(r));
                         }
@@ -125,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,256 @@
+import { EnumToken } from '../types.js';
+import { reduceNumber, renderToken } from '../../renderer/render.js';
+import { walkValues } from '../walk.js';
+import { MinifyFeature } from '../utiles/minifyfeature.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 != 5 /* NodeType.DeclarationNodeType */) {
+                continue;
+            }
+            const set = new Set;
+            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 || 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 };

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,115 @@
+import { EnumToken } from '../types.js';
+import { walkValues } from '../walk.js';
+import { MinifyFeature } from '../utiles/minifyfeature.js';
+
+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 == 2 /* NodeType.StyleSheetNodeType */ && ast.typ == 4 /* NodeType.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 */) {
+                continue;
+            }
+            if (node.typ != 5 /* NodeType.DeclarationNodeType */) {
+                break;
+            }
+            // css variable
+            if (node.nam.startsWith('--')) {
+                if (!variableScope.has(node.nam)) {
+                    const info = {
+                        globalScope: isRoot,
+                        // @ts-ignore
+                        parent: new Set(),
+                        declarationCount: 1,
+                        replaceable: isRoot,
+                        node: node
+                    };
+                    info.parent.add(ast);
+                    variableScope.set(node.nam, info);
+                }
+                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 {
+                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();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    cleanup(ast, options = {}, context) {
+        const variableScope = context.variableScope;
+        for (const info of variableScope.values()) {
+            if (info.replaceable) {
+                let i;
+                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) {
+                            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,45 @@
+import { PropertyList } from '../../parser/declaration/list.js';
+import '../../renderer/utils/color.js';
+import '../types.js';
+import '../minify.js';
+import '../../parser/parse.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import { MinifyFeature } from '../utiles/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 == 0 /* NodeType.CommentNodeType */ || node.typ == 5 /* NodeType.DeclarationNodeType */) {
+                properties.add(node);
+                continue;
+            }
+            break;
+        }
+        // @ts-ignore
+        ast.chi = [...properties].concat(ast.chi.slice(k));
+        return ast;
+    }
+}
+
+export { ComputeShorthand };