@tbela99/css-parser 0.9.1 → 1.1.0

package/dist/lib/ast/minify.js

@@ -1,12 +1,15 @@
 import { parseString } from '../parser/parse.js';
+import '../parser/tokenize.js';
+import '../parser/utils/config.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { replaceCompound } from './expand.js';
-import { isIdent, isFunction, isWhiteSpace, isIdentStart } from '../syntax/syntax.js';
-import '../parser/utils/config.js';
+import { isWhiteSpace, isIdent, isFunction, isIdentStart } from '../syntax/syntax.js';
 import { eq } from '../parser/utils/eq.js';
 import { doRender, renderToken } from '../renderer/render.js';
+import '../renderer/color/utils/constants.js';
 import * as index from './features/index.js';
+import { FeatureWalkMode } from './features/type.js';
 
 const combinators = ['+', '>', '~', '||', '|'];
 const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
@@ -23,13 +26,9 @@ const features = Object.values(index).sort((a, b) => a.ordering - b.ordering);
  * @param context
  */
 function minify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
-    if (!('nodes' in context)) {
-        context.nodes = new Set;
-    }
-    if (context.nodes.has(ast)) {
-        return ast;
-    }
-    context.nodes.add(ast);
+    let preprocess = false;
+    let postprocess = false;
+    let parents;
     if (!('features' in options)) {
         // @ts-ignore
         options = {
@@ -43,35 +42,125 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         for (const feature of features) {
             feature.register(options);
         }
+        options.features.sort((a, b) => a.ordering - b.ordering);
+    }
+    for (const feature of options.features) {
+        if (feature.preProcess) {
+            preprocess = true;
+        }
+        if (feature.postProcess) {
+            postprocess = true;
+        }
     }
-    function reducer(acc, curr, index, array) {
-        // trim :is()
-        if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
-            curr = curr.slice(1, -1);
+    if (preprocess) {
+        parents = [ast];
+        for (const parent of parents) {
+            if (parent.typ == EnumToken.CommentTokenType ||
+                parent.typ == EnumToken.CDOCOMMTokenType) {
+                Object.defineProperty(parent, 'parent', {
+                    ...definedPropertySettings,
+                    value: parent
+                });
+                continue;
+            }
+            for (const feature of options.features) {
+                if (!feature.preProcess) {
+                    continue;
+                }
+                feature.run(parent, options, parent.parent ?? ast, context, FeatureWalkMode.Pre);
+            }
+            if (('chi' in parent)) {
+                // @ts-ignore
+                for (const node of parent.chi) {
+                    parents.push(Object.defineProperty(node, 'parent', {
+                        ...definedPropertySettings,
+                        value: parent
+                    }));
+                }
+            }
         }
-        if (curr[0] == '&') {
-            if (curr[1] == ' ' && !isIdent(curr[2]) && !isFunction(curr[2])) {
-                curr.splice(0, 2);
+        for (const feature of options.features) {
+            if (feature.preProcess && 'cleanup' in feature) {
+                // @ts-ignore
+                feature.cleanup(ast, options, context, FeatureWalkMode.Pre);
             }
-            else if (combinators.includes(curr[1])) {
-                curr.shift();
+        }
+    }
+    doMinify(ast, options, recursive, errors, nestingContent, context);
+    parents = [ast];
+    for (const parent of parents) {
+        // parent = parents.shift() as AstNode;
+        if (parent.typ == EnumToken.CommentTokenType ||
+            parent.typ == EnumToken.CDOCOMMTokenType) {
+            continue;
+        }
+        if (postprocess) {
+            for (const feature of options.features) {
+                if (!feature.postProcess) {
+                    continue;
+                }
+                feature.run(parent, options, parent.parent ?? ast, context, FeatureWalkMode.Post);
             }
         }
-        else if (ast.typ == EnumToken.RuleNodeType && (isIdent(curr[0]) || isFunction(curr[0]))) {
+        if (('chi' in parent)) {
+            // @ts-ignore
+            for (const node of parent.chi) {
+                parents.push(Object.defineProperty(node, 'parent', {
+                    ...definedPropertySettings,
+                    value: parent
+                }));
+            }
+        }
+    }
+    if (postprocess) {
+        for (const feature of options.features) {
+            if (feature.postProcess && 'cleanup' in feature) {
+                // @ts-ignore
+                feature.cleanup(ast, options, context, FeatureWalkMode.Post);
+            }
+        }
+    }
+    return ast;
+}
+function reduce(acc, curr, index, array) {
+    // trim :is()
+    if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
+        curr = curr.slice(1, -1);
+    }
+    if (curr[0] == '&') {
+        if (curr[1] == ' ' && !isIdent(curr[2]) && !isFunction(curr[2])) {
+            curr.splice(0, 2);
+        }
+        else if (combinators.includes(curr[1])) {
+            curr.shift();
+        }
+    }
+    else { // @ts-ignore
+        if (this.typ == EnumToken.RuleNodeType && (isIdent(curr[0]) || isFunction(curr[0]))) {
             curr.unshift('&', ' ');
         }
-        acc.push(curr.join(''));
-        return acc;
     }
+    acc.push(curr.join(''));
+    return acc;
+}
+function doMinify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
+    if (!('nodes' in context)) {
+        context.nodes = new Set;
+    }
+    if (context.nodes.has(ast)) {
+        return ast;
+    }
+    context.nodes.add(ast);
     // @ts-ignore
     if ('chi' in ast && ast.chi.length > 0) {
+        const reducer = reduce.bind(ast);
         if (!nestingContent) {
             nestingContent = options.nestingRules && ast.typ == EnumToken.RuleNodeType;
         }
         let i = 0;
-        let previous;
+        let previous = null;
         let node;
-        let nodeIndex;
+        let nodeIndex = -1;
         // @ts-ignore
         for (; i < ast.chi.length; i++) {
             // @ts-ignore
@@ -83,13 +172,50 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             // @ts-ignore
             if (previous == node) {
                 // @ts-ignore
-                ast.chi.splice(i, 1);
-                i--;
+                ast.chi.splice(i--, 1);
                 continue;
             }
             if (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face') {
                 continue;
             }
+            if (node.typ == EnumToken.KeyframeAtRuleNodeType) {
+                if (previous?.typ == EnumToken.KeyframeAtRuleNodeType &&
+                    node.nam == previous.nam &&
+                    node.val == previous.val) {
+                    ast.chi?.splice(nodeIndex--, 1);
+                    previous = ast?.chi?.[nodeIndex] ?? null;
+                    i = nodeIndex;
+                    continue;
+                }
+                if (node.chi.length > 0) {
+                    doMinify(node, options, true, errors, nestingContent, context);
+                }
+            }
+            if (node.typ == EnumToken.KeyFrameRuleNodeType) {
+                if (previous?.typ == EnumToken.KeyFrameRuleNodeType &&
+                    node.sel == previous.sel) {
+                    previous.chi.push(...node.chi);
+                    // @ts-ignore
+                    ast.chi.splice(i--, 1);
+                    continue;
+                }
+                let k;
+                for (k = 0; k < node.chi.length; k++) {
+                    if (node.chi[k].typ == EnumToken.DeclarationNodeType) {
+                        let l = node.chi[k].val.length;
+                        while (l--) {
+                            if (node.chi[k].val[l].typ == EnumToken.ImportantTokenType) {
+                                node.chi.splice(k--, 1);
+                                break;
+                            }
+                            if ([EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(node.chi[k].val[l].typ)) {
+                                continue;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
             if (node.typ == EnumToken.AtRuleNodeType) {
                 // @ts-ignore
                 if (node.nam == 'media' && ['all', '', null].includes(node.val)) {
@@ -111,7 +237,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 }
                 // @ts-ignore
                 if (!hasDeclaration(node)) {
-                    minify(node, options, recursive, errors, nestingContent, context);
+                    doMinify(node, options, recursive, errors, nestingContent, context);
                 }
                 previous = node;
                 nodeIndex = i;
@@ -162,7 +288,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                         nodeIndex = --i;
                         // @ts-ignore
                         previous = ast.chi[nodeIndex];
-                        minify(wrapper, options, recursive, errors, nestingContent, context);
+                        doMinify(wrapper, options, recursive, errors, nestingContent, context);
                         continue;
                     }
                     // @ts-ignore
@@ -269,7 +395,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                     // @ts-ignore
                                     // minifyRule(node, <MinifyOptions>options, ast, context);
                                     // } else {
-                                    minify(node, options, recursive, errors, nestingContent, context);
+                                    doMinify(node, options, recursive, errors, nestingContent, context);
                                 }
                                 i--;
                                 previous = node;
@@ -324,7 +450,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                             // @ts-ignore
                             // minifyRule(previous, <MinifyOptions>options, ast, context);
                             // } else {
-                            minify(previous, options, recursive, errors, nestingContent, context);
+                            doMinify(previous, options, recursive, errors, nestingContent, context);
                         }
                     }
                 }
@@ -335,11 +461,15 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                             // @ts-ignore
                             // minifyRule(previous, <MinifyOptions>options, ast, context);
                             // } else {
-                            minify(previous, options, recursive, errors, nestingContent, context);
+                            doMinify(previous, options, recursive, errors, nestingContent, context);
                         }
                     }
                 }
             }
+            // else if ('chi' in node) {
+            //
+            //     doMinify(node, options, recursive, errors, nestingContent, context);
+            // }
             if (!nestingContent &&
                 // @ts-ignore
                 previous != null &&
@@ -354,10 +484,10 @@ 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 == EnumToken.DeclarationNodeType)) {
+            if (node.typ == EnumToken.KeyframeAtRuleNodeType || !node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
                 // @ts-ignore
                 if (!(node.typ == EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
-                    minify(node, options, recursive, errors, nestingContent, context);
+                    doMinify(node, options, recursive, errors, nestingContent, context);
                 }
             }
         }
@@ -370,41 +500,6 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             fixSelector(node);
         }
     }
-    if (ast.typ == EnumToken.StyleSheetNodeType) {
-        let parent;
-        let parents = [ast];
-        while (parents.length > 0) {
-            parent = parents.shift();
-            // @ts-ignore
-            for (let k = 0; k < parent.chi.length; k++) {
-                // @ts-ignore
-                const node = parent.chi[k];
-                if (!('chi' in node) || node.typ == EnumToken.StyleSheetNodeType || (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face')) {
-                    continue;
-                }
-                // @ts-ignore
-                if (node.chi.length > 0) {
-                    parents.push(node);
-                    Object.defineProperty(node, 'parent', { ...definedPropertySettings, value: parent });
-                    for (const feature of options.features) {
-                        feature.run(node, options, parent, context);
-                    }
-                }
-                // @ts-ignore
-                if (options.removeEmpty && node.chi.length == 0) {
-                    // @ts-ignore
-                    parent.chi.splice(k, 1);
-                    k--;
-                }
-            }
-        }
-        for (const feature of options.features) {
-            if ('cleanup' in feature) {
-                // @ts-ignore
-                feature.cleanup(ast, options, context);
-            }
-        }
-    }
     return ast;
 }
 function hasDeclaration(node) {
@@ -559,6 +654,28 @@ function splitRule(buffer) {
             result.push([]);
             continue;
         }
+        if (chr == '.') {
+            if (str !== '') {
+                // @ts-ignore
+                result.at(-1).push(str);
+                str = '';
+            }
+            str += chr;
+            continue;
+        }
+        if (combinators.includes(chr)) {
+            if (str !== '') {
+                // @ts-ignore
+                result.at(-1).push(str);
+                str = '';
+            }
+            if (chr == '|' && buffer.charAt(i + 1) == '|') {
+                chr += buffer.charAt(++i);
+            }
+            // @ts-ignore
+            result.at(-1).push(chr);
+            continue;
+        }
         if (chr == ':') {
             if (str !== '') {
                 // @ts-ignore
@@ -775,7 +892,6 @@ function matchSelectors(selector1, selector2, parentType, errors) {
                 }, []);
             }
         }
-        // @todo: check hasCompoundSelector && curr[0] == '&' && curr[1] == ' '
         acc.push(match.length == 0 ? ['&'] : (hasCompoundSelector && curr[0] != '&' && (curr.length == 0 || !combinators.includes(curr[0].charAt(0))) ? ['&'].concat(curr) : curr));
         return acc;
     }
@@ -853,6 +969,9 @@ function wrapNodes(previous, node, match, ast, reducer, i, nodeIndex) {
     return wrapper;
 }
 function diff(n1, n2, reducer, options = {}) {
+    if (!('cache' in options)) {
+        options.cache = new WeakMap();
+    }
     let node1 = n1;
     let node2 = n2;
     let exchanged = false;
@@ -865,12 +984,9 @@ function diff(n1, n2, reducer, options = {}) {
     let i = node1.chi.length;
     let j = node2.chi.length;
     if (i == 0 || j == 0) {
-        // @ts-ignore
         return null;
     }
-    // @ts-ignore
     const raw1 = node1.raw;
-    // @ts-ignore
     const raw2 = node2.raw;
     if (raw1 != null && raw2 != null) {
         const prefixes1 = new Set;
@@ -918,9 +1034,16 @@ function diff(n1, n2, reducer, options = {}) {
             }
         }
     }
-    // @ts-ignore
+    const css1 = options.cache.get(node1);
+    const css2 = options.cache.get(node2);
     node1 = { ...node1, chi: node1.chi.slice() };
     node2 = { ...node2, chi: node2.chi.slice() };
+    if (css1 != null) {
+        options.cache.set(node1, css1);
+    }
+    if (css2 != null) {
+        options.cache.set(node2, css2);
+    }
     if (raw1 != null) {
         Object.defineProperty(node1, 'raw', { ...definedPropertySettings, value: raw1 });
     }
@@ -941,24 +1064,34 @@ function diff(n1, n2, reducer, options = {}) {
                 continue;
             }
             if (node1.chi[i].nam == node2.chi[j].nam) {
-                if (eq(node1.chi[i], node2.chi[j])) {
+                if (node1.chi[i].typ == node2.chi[j].typ && eq(node1.chi[i], node2.chi[j])) {
                     intersect.push(node1.chi[i]);
                     node1.chi.splice(i, 1);
                     node2.chi.splice(j, 1);
+                    options.cache.delete(node1);
+                    options.cache.delete(node2);
                     break;
                 }
             }
         }
     }
-    // @ts-ignore
     const result = (intersect.length == 0 ? null : {
         ...node1,
         // @ts-ignore
         sel: [...new Set([...(n1?.raw?.reduce(reducer, []) ?? splitRule(n1.sel)).concat(n2?.raw?.reduce(reducer, []) ?? splitRule(n2.sel))])].join(','),
         chi: intersect.reverse()
     });
-    if (result == null || [n1, n2].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + doRender(curr, options).code.length, 0) <= [node1, node2, result].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + doRender(curr, options).code.length, 0)) {
-        // @ts-ignore
+    if (result == null || [n1, n2].reduce((acc, curr) => {
+        let css = options.cache.get(curr);
+        if (css == null) {
+            css = doRender(curr, options).code;
+            options.cache.set(curr, css);
+        }
+        return curr.chi.length == 0 ? acc : acc + css.length;
+    }, 0) <= [node1, node2, result].reduce((acc, curr) => {
+        const css = doRender(curr, options).code;
+        return curr.chi.length == 0 ? acc : acc + css.length;
+    }, 0)) {
         return null;
     }
     return { result, node1: exchanged ? node2 : node1, node2: exchanged ? node1 : node2 };
@@ -967,9 +1100,6 @@ function reduceRuleSelector(node) {
     if (node.raw == null) {
         Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: splitRule(node.sel) });
     }
-    // @ts-ignore
-    // if (node.raw != null) {
-    // @ts-ignore
     let optimized = reduceSelector(node.raw.reduce((acc, curr) => {
         acc.push(curr.slice());
         return acc;
@@ -1003,7 +1133,6 @@ function reduceRuleSelector(node) {
         const sel = raw[0].join('');
         if (sel.length < node.sel.length) {
             node.sel = sel;
-            // node.raw = raw;
             Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: raw });
         }
     }