@tbela99/css-parser 1.3.2 → 1.3.4

package/dist/lib/ast/minify.js

@@ -1,4 +1,4 @@
-import { parseString } from '../parser/parse.js';
+import { replaceToken, parseString } from '../parser/parse.js';
 import '../parser/tokenize.js';
 import '../parser/utils/config.js';
 import { EnumToken } from './types.js';
@@ -29,6 +29,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
     let preprocess = false;
     let postprocess = false;
     let parents;
+    let replacement;
     if (!('features' in options)) {
         // @ts-ignore
         options = {
@@ -38,82 +39,92 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             removePrefix: false,
             features: [], ...options
         };
-        // @ts-ignore
         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) {
+        if (feature.processMode & FeatureWalkMode.Pre) {
             preprocess = true;
         }
-        if (feature.postProcess) {
+        if (feature.processMode & FeatureWalkMode.Post) {
             postprocess = true;
         }
     }
     if (preprocess) {
-        parents = [ast];
+        parents = new Set([ast]);
         for (const parent of parents) {
             if (parent.typ == EnumToken.CommentTokenType ||
                 parent.typ == EnumToken.CDOCOMMTokenType) {
-                Object.defineProperty(parent, 'parent', {
-                    ...definedPropertySettings,
-                    value: parent
-                });
                 continue;
             }
+            replacement = parent;
             for (const feature of options.features) {
-                if (!feature.preProcess) {
+                if ((feature.processMode & FeatureWalkMode.Pre) === 0 || (feature.accept != null && !feature.accept.has(parent.typ))) {
                     continue;
                 }
-                feature.run(parent, options, parent.parent ?? ast, context, FeatureWalkMode.Pre);
+                const result = feature.run(replacement, options, parent.parent ?? ast, context, FeatureWalkMode.Pre);
+                if (result != null) {
+                    replacement = result;
+                }
+            }
+            if (replacement != parent && parent.parent != null) {
+                // @ts-ignore
+                replaceToken(parent.parent, parent, replacement);
             }
-            if (('chi' in parent)) {
+            if (('chi' in replacement)) {
                 // @ts-ignore
-                for (const node of parent.chi) {
-                    parents.push(Object.defineProperty(node, 'parent', {
+                for (const node of replacement.chi) {
+                    parents.add(Object.defineProperty(node, 'parent', {
                         ...definedPropertySettings,
-                        value: parent
+                        value: replacement
                     }));
                 }
             }
         }
         for (const feature of options.features) {
-            if (feature.preProcess && 'cleanup' in feature) {
+            if ((feature.processMode & FeatureWalkMode.Pre) && 'cleanup' in feature) {
                 // @ts-ignore
                 feature.cleanup(ast, options, context, FeatureWalkMode.Pre);
             }
         }
     }
     doMinify(ast, options, recursive, errors, nestingContent, context);
-    parents = [ast];
+    parents = new Set([ast]);
     for (const parent of parents) {
         if (parent.typ == EnumToken.CommentTokenType ||
             parent.typ == EnumToken.CDOCOMMTokenType) {
             continue;
         }
+        replacement = parent;
         if (postprocess) {
             for (const feature of options.features) {
-                if (!feature.postProcess) {
+                if ((feature.processMode & FeatureWalkMode.Post) === 0 || (feature.accept != null && !feature.accept.has(parent.typ))) {
                     continue;
                 }
-                feature.run(parent, options, parent.parent ?? ast, context, FeatureWalkMode.Post);
+                const result = feature.run(replacement, options, parent.parent ?? ast, context, FeatureWalkMode.Post);
+                if (result != null) {
+                    replacement = result;
+                }
             }
         }
-        if (('chi' in parent)) {
+        if (replacement != null && replacement != parent && parent.parent != null) {
             // @ts-ignore
-            for (const node of parent.chi) {
-                parents.push(Object.defineProperty(node, 'parent', {
+            replaceToken(parent.parent, parent, replacement);
+        }
+        if (('chi' in replacement)) {
+            for (const node of replacement.chi) {
+                parents.add(Object.defineProperty(node, 'parent', {
                     ...definedPropertySettings,
-                    value: parent
+                    value: replacement
                 }));
             }
         }
     }
     if (postprocess) {
         for (const feature of options.features) {
-            if (feature.postProcess && 'cleanup' in feature) {
+            if (feature.processMode & FeatureWalkMode.Post && 'cleanup' in feature) {
                 // @ts-ignore
                 feature.cleanup(ast, options, context, FeatureWalkMode.Post);
             }
@@ -125,12 +136,10 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
  * reduce selectors
  * @param acc
  * @param curr
- * @param index
- * @param array
  *
  * @private
  */
-function reduce(acc, curr, index, array) {
+function reduce(acc, curr) {
     // trim :is()
     // if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
     //
@@ -171,21 +180,18 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
         }
         let i = 0;
         let previous = null;
-        let node;
+        let node = null;
         let nodeIndex = -1;
-        // @ts-ignore
         for (; i < ast.chi.length; i++) {
-            // @ts-ignore
             if (ast.chi[i].typ == EnumToken.CommentNodeType) {
                 continue;
             }
-            // @ts-ignore
             node = ast.chi[i];
             if (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face') {
                 continue;
             }
-            if (node.typ == EnumToken.KeyframeAtRuleNodeType) {
-                if (previous?.typ == EnumToken.KeyframeAtRuleNodeType &&
+            if (node.typ == EnumToken.KeyframesAtRuleNodeType) {
+                if (previous?.typ == EnumToken.KeyframesAtRuleNodeType &&
                     node.nam == previous.nam &&
                     node.val == previous.val) {
                     ast.chi?.splice(nodeIndex--, 1);
@@ -193,15 +199,11 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                     i = nodeIndex;
                     continue;
                 }
-                if (node.chi.length > 0) {
-                    doMinify(node, options, true, errors, nestingContent, context);
-                }
             }
-            else if (node.typ == EnumToken.KeyFrameRuleNodeType) {
-                if (previous?.typ == EnumToken.KeyFrameRuleNodeType &&
+            else if (node.typ == EnumToken.KeyFramesRuleNodeType) {
+                if (previous?.typ == EnumToken.KeyFramesRuleNodeType &&
                     node.sel == previous.sel) {
                     previous.chi.push(...node.chi);
-                    // @ts-ignore
                     ast.chi.splice(i--, 1);
                     continue;
                 }
@@ -223,25 +225,26 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                 }
             }
             else if (node.typ == EnumToken.AtRuleNodeType) {
-                // @ts-ignore
                 if (node.nam == 'media' && ['all', '', null].includes(node.val)) {
-                    // @ts-ignore
                     ast.chi?.splice(i, 1, ...node.chi);
                     i--;
                     continue;
                 }
-                // @ts-ignore
                 if (previous?.typ == EnumToken.AtRuleNodeType &&
+                    node.nam != 'font-face' &&
                     previous.nam == node.nam &&
                     previous.val == node.val) {
                     if ('chi' in node) {
                         // @ts-ignore
                         previous.chi.push(...node.chi);
+                        if (!hasDeclaration(previous)) {
+                            context.nodes.delete(previous);
+                            doMinify(previous, options, recursive, errors, nestingContent, context);
+                        }
                     }
                     ast?.chi?.splice(i--, 1);
                     continue;
                 }
-                // @ts-ignore
                 if (!hasDeclaration(node)) {
                     doMinify(node, options, recursive, errors, nestingContent, context);
                 }
@@ -252,47 +255,33 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
             // @ts-ignore
             else if (node.typ == EnumToken.RuleNodeType) {
                 reduceRuleSelector(node);
-                let wrapper;
+                let wrapper = null;
                 let match;
-                // @ts-ignore
                 if (options.nestingRules) {
-                    // @ts-ignore
                     if (previous?.typ == EnumToken.RuleNodeType) {
-                        // @ts-ignore
                         reduceRuleSelector(previous);
                         // @ts-ignore
                         match = matchSelectors(previous.raw, node.raw, ast.typ);
-                        // @ts-ignore
                         if (match != null) {
-                            // @ts-ignore
                             wrapper = wrapNodes(previous, node, match, ast, reducer, i, nodeIndex);
                             nodeIndex = i - 1;
-                            // @ts-ignore
                             previous = ast.chi[nodeIndex];
                         }
                     }
-                    // @ts-ignore
                     if (wrapper != null) {
-                        // @ts-ignore
                         while (i < ast.chi.length) {
-                            // @ts-ignore
                             const nextNode = ast.chi[i];
-                            // @ts-ignore
                             if (nextNode.typ != EnumToken.RuleNodeType) {
                                 break;
                             }
                             reduceRuleSelector(nextNode);
-                            // @ts-ignore
-                            match = matchSelectors(wrapper.raw, nextNode.raw, ast.typ);
-                            // @ts-ignore
+                            match = matchSelectors(wrapper.raw, nextNode.raw);
                             if (match == null) {
                                 break;
                             }
-                            // @ts-ignore
                             wrapper = wrapNodes(wrapper, nextNode, match, ast, reducer, i, nodeIndex);
                         }
                         nodeIndex = --i;
-                        // @ts-ignore
                         previous = ast.chi[nodeIndex];
                         doMinify(wrapper, options, recursive, errors, nestingContent, context);
                         continue;
@@ -339,7 +328,6 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                             curr.unshift('&');
                             wrap = false;
                         }
-                        // @ts-ignore
                         acc.push(curr);
                         return acc;
                     }, []);
@@ -365,82 +353,67 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                         }
                     }
                     if (rule == null) {
-                        rule = selector.map(s => {
+                        rule = selector.map((s) => {
                             if (s[0] == '&') {
                                 s.splice(0, 1, ...node.optimized.optimized);
                             }
                             return s.join('');
                         }).join(',');
                     }
-                    // @ts-ignore
                     let sel = wrap ? node.optimized.optimized.join('') + `:is(${rule})` : rule;
                     if (sel.length < node.sel.length) {
                         node.sel = sel;
                     }
                 }
+                doMinify(node, options, recursive, errors, nestingContent, context);
             }
-            // @ts-ignore
             if (previous != null) {
-                // @ts-ignore
                 if ('chi' in previous && ('chi' in node)) {
-                    // @ts-ignore
                     if (previous.typ == node.typ) {
                         let shouldMerge = true;
-                        // @ts-ignore
                         let k = previous.chi.length;
                         while (k-- > 0) {
-                            // @ts-ignore
                             if (previous.chi[k].typ == EnumToken.CommentNodeType) {
                                 continue;
                             }
-                            // @ts-ignore
                             shouldMerge = previous.chi[k].typ == EnumToken.DeclarationNodeType;
                             break;
                         }
                         if (shouldMerge) {
                             // @ts-ignore
-                            if (((node.typ == EnumToken.RuleNodeType || node.typ == EnumToken.KeyFrameRuleNodeType) && node.sel == previous.sel) ||
+                            if (((node.typ == EnumToken.RuleNodeType || node.typ == EnumToken.KeyFramesRuleNodeType) && node.sel == previous.sel) ||
                                 // @ts-ignore
                                 (node.typ == EnumToken.AtRuleNodeType) && node.val != 'font-face' && node.val == previous.val) {
                                 // @ts-ignore
                                 node.chi.unshift(...previous.chi);
-                                // @ts-ignore
+                                doMinify(node, options, recursive, errors, nestingContent, context);
                                 ast.chi.splice(nodeIndex, 1);
-                                i--;
-                                previous = node;
+                                previous = ast.chi[--i];
                                 nodeIndex = i;
                                 continue;
                             }
-                            else if (node.typ == previous?.typ && [EnumToken.KeyFrameRuleNodeType, EnumToken.RuleNodeType].includes(node.typ)) {
+                            else if (node.typ == previous?.typ && [EnumToken.KeyFramesRuleNodeType, EnumToken.RuleNodeType].includes(node.typ)) {
                                 const intersect = diff(previous, node, reducer, options);
                                 if (intersect != null) {
                                     if (intersect.node1.chi.length == 0) {
-                                        // @ts-ignore
                                         ast.chi.splice(i--, 1);
                                     }
                                     else {
-                                        // @ts-ignore
                                         ast.chi.splice(i--, 1, intersect.node1);
                                     }
                                     if (intersect.node2.chi.length == 0) {
-                                        // @ts-ignore
                                         ast.chi.splice(nodeIndex, 1, intersect.result);
                                         i--;
-                                        // @ts-ignore
                                         if (nodeIndex == i) {
                                             nodeIndex = i;
                                         }
                                     }
                                     else {
-                                        // @ts-ignore
                                         ast.chi.splice(nodeIndex, 1, intersect.result, intersect.node2);
-                                        // @ts-ignore
                                         i = (nodeIndex ?? 0) + 1;
                                     }
                                     reduceRuleSelector(intersect.result);
-                                    // @ts-ignore
                                     if (node != ast.chi[i]) {
-                                        // @ts-ignore
                                         node = ast.chi[i];
                                     }
                                     previous = intersect.result;
@@ -449,9 +422,7 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                             }
                         }
                     }
-                    // @ts-ignore
                     if (recursive && previous != node) {
-                        // @ts-ignore
                         if (!hasDeclaration(previous)) {
                             doMinify(previous, options, recursive, errors, nestingContent, context);
                         }
@@ -459,9 +430,7 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                 }
             }
             if (!nestingContent &&
-                // @ts-ignore
                 previous != null &&
-                // previous.optimized != null &&
                 previous.typ == EnumToken.RuleNodeType &&
                 previous.sel.includes('&')) {
                 fixSelector(previous);
@@ -469,20 +438,15 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
             previous = node;
             nodeIndex = i;
         }
-        // @ts-ignore
         if (recursive && node != null && ('chi' in node)) {
-            // @ts-ignore
-            if (node.typ == EnumToken.KeyframeAtRuleNodeType || !node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
-                // @ts-ignore
+            if (node.typ == EnumToken.KeyframesAtRuleNodeType || !node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
                 if (!(node.typ == EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
                     doMinify(node, options, recursive, errors, nestingContent, context);
                 }
             }
         }
         if (!nestingContent &&
-            // @ts-ignore
             node != null &&
-            // previous.optimized != null &&
             node.typ == EnumToken.RuleNodeType &&
             node.sel.includes('&')) {
             fixSelector(node);
@@ -633,7 +597,6 @@ function splitRule(buffer) {
         }
         if (chr == ',') {
             if (str !== '') {
-                // @ts-ignore
                 result.at(-1).push(str);
                 str = '';
             }
@@ -642,7 +605,6 @@ function splitRule(buffer) {
         }
         if (chr == '.') {
             if (str !== '') {
-                // @ts-ignore
                 result.at(-1).push(str);
                 str = '';
             }
@@ -651,20 +613,17 @@ function splitRule(buffer) {
         }
         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
                 result.at(-1).push(str);
                 str = '';
             }
@@ -706,7 +665,6 @@ function splitRule(buffer) {
         }
     }
     if (str !== '') {
-        // @ts-ignore
         result.at(-1).push(str);
     }
     return result;
@@ -771,7 +729,7 @@ function reduceSelector(acc, curr) {
  *
  * @private
  */
-function matchSelectors(selector1, selector2 /*, parentType: EnumToken, errors: ErrorDescription[] */) {
+function matchSelectors(selector1, selector2) {
     let match = [[]];
     const j = Math.min(selector1.reduce((acc, curr) => Math.min(acc, curr.length), selector1.length > 0 ? selector1[0].length : 0), selector2.reduce((acc, curr) => Math.min(acc, curr.length), selector2.length > 0 ? selector2[0].length : 0));
     let i = 0;
@@ -846,7 +804,6 @@ function matchSelectors(selector1, selector2 /*, parentType: EnumToken, errors:
  * @private
  */
 function fixSelector(node) {
-    // @ts-ignore
     if (node.sel.includes('&')) {
         const attributes = parseString(node.sel);
         for (const attr of walkValues(attributes)) {
@@ -881,40 +838,27 @@ function wrapNodes(previous, node, match, ast, reducer, i, nodeIndex) {
     let nSel = match.selector2.reduce(reducer, []).join(',');
     // @ts-ignore
     const wrapper = { ...previous, chi: [], sel: match.match.reduce(reducer, []).join(',') };
-    // @ts-ignore
     Object.defineProperty(wrapper, 'raw', {
         ...definedPropertySettings,
-        // @ts-ignore
         value: match.match.map(t => t.slice())
     });
     if (pSel == '&' || pSel === '') {
-        // @ts-ignore
         wrapper.chi.push(...previous.chi);
-        // @ts-ignore
         if ((nSel == '&' || nSel === '')) {
-            // @ts-ignore
             wrapper.chi.push(...node.chi);
         }
         else {
-            // @ts-ignore
             wrapper.chi.push(node);
         }
     }
     else {
-        // @ts-ignore
         wrapper.chi.push(previous, node);
     }
-    // @ts-ignore
     ast.chi.splice(i, 1, wrapper);
-    // @ts-ignore
     ast.chi.splice(nodeIndex, 1);
-    // @ts-ignore
     previous.sel = pSel;
-    // @ts-ignore
     previous.raw = match.selector1;
-    // @ts-ignore
     node.sel = nSel;
-    // @ts-ignore
     node.raw = match.selector2;
     reduceRuleSelector(wrapper);
     return wrapper;

package/dist/lib/ast/transform/compute.js

@@ -46,8 +46,6 @@ function compute(transformLists) {
             });
         }
     }
-    // console.error({matrix});
-    // matrix = toZero(matrix) as Matrix;
     return {
         matrix: serialize(toZero(matrix)),
         cumulative,
@@ -71,7 +69,7 @@ function computeMatrix(transformList, matrixVar) {
                 {
                     values.length = 0;
                     const children = stripCommaToken(transformList[i].chi.slice());
-                    const valCount = transformList[i].val == 'translate3d' || transformList[i].val == 'translate' ? 3 : 1;
+                    const valCount = transformList[i].val == 'translate3d' ? 3 : transformList[i].val == 'translate' ? 2 : 1;
                     for (let j = 0; j < children.length; j++) {
                         if (children[j].typ == EnumToken.WhitespaceTokenType) {
                             continue;
@@ -158,7 +156,7 @@ function computeMatrix(transformList, matrixVar) {
                     const children = stripCommaToken(transformList[i].chi.slice());
                     for (let k = 0; k < children.length; k++) {
                         child = children[k];
-                        if (child.typ != EnumToken.NumberTokenType) {
+                        if (child.typ != EnumToken.NumberTokenType && child.typ != EnumToken.PercentageTokenType) {
                             return null;
                         }
                         values.push(getNumber(child));

package/dist/lib/ast/transform/matrix.js

@@ -30,27 +30,27 @@ function parseMatrix(mat) {
 function matrix(values) {
     const matrix = identity();
     if (values.length === 6) {
-        matrix[0 * 4 + 0] = values[0];
-        matrix[0 * 4 + 1] = values[1];
-        matrix[1 * 4 + 0] = values[2];
-        matrix[1 * 4 + 1] = values[3];
-        matrix[3 * 4 + 0] = values[4];
+        matrix[0] = values[0];
+        matrix[1] = values[1];
+        matrix[4] = values[2];
+        matrix[4 + 1] = values[3];
+        matrix[3 * 4] = values[4];
         matrix[3 * 4 + 1] = values[5];
     }
     else if (values.length === 16) {
-        matrix[0 * 4 + 0] = values[0];
-        matrix[0 * 4 + 1] = values[1];
-        matrix[0 * 4 + 2] = values[2];
-        matrix[0 * 4 + 3] = values[3];
-        matrix[1 * 4 + 0] = values[4];
-        matrix[1 * 4 + 1] = values[5];
-        matrix[1 * 4 + 2] = values[6];
-        matrix[1 * 4 + 3] = values[7];
-        matrix[2 * 4 + 0] = values[8];
+        matrix[0] = values[0];
+        matrix[1] = values[1];
+        matrix[2] = values[2];
+        matrix[3] = values[3];
+        matrix[4] = values[4];
+        matrix[4 + 1] = values[5];
+        matrix[4 + 2] = values[6];
+        matrix[4 + 3] = values[7];
+        matrix[2 * 4] = values[8];
         matrix[2 * 4 + 1] = values[9];
         matrix[2 * 4 + 2] = values[10];
         matrix[2 * 4 + 3] = values[11];
-        matrix[3 * 4 + 0] = values[12];
+        matrix[3 * 4] = values[12];
         matrix[3 * 4 + 1] = values[13];
         matrix[3 * 4 + 2] = values[14];
         matrix[3 * 4 + 3] = values[15];
@@ -75,11 +75,11 @@ function serialize(matrix) {
             typ: EnumToken.FunctionTokenType,
             val: 'matrix',
             chi: [
-                matrix[0 * 4 + 0],
-                matrix[0 * 4 + 1],
-                matrix[1 * 4 + 0],
-                matrix[1 * 4 + 1],
-                matrix[3 * 4 + 0],
+                matrix[0],
+                matrix[1],
+                matrix[4],
+                matrix[4 + 1],
+                matrix[3 * 4],
                 matrix[3 * 4 + 1]
             ].reduce((acc, t) => {
                 if (acc.length > 0) {