@tbela99/css-parser 1.0.0 → 1.1.1-alpha4

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

@@ -1,121 +1,152 @@
-import { EnumToken } from '../types.js';
+import { EnumToken, SyntaxValidationResult } from '../types.js';
 import { getSyntaxConfig } from '../../validation/config.js';
-import { ValidationTokenEnum } from '../../validation/parser/types.js';
+import '../../validation/parser/types.js';
 import '../../validation/parser/parse.js';
-import '../minify.js';
+import { splitRule, definedPropertySettings } from '../minify.js';
 import { walkValues } from '../walk.js';
-import '../../parser/parse.js';
-import '../../renderer/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
+import { parseAtRulePrelude, parseString } from '../../parser/parse.js';
+import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
+import { pseudoAliasMap } from '../../syntax/syntax.js';
+import { renderToken } from '../../renderer/render.js';
+import { funcLike } from '../../renderer/color/utils/constants.js';
 import '../../validation/syntaxes/complex-selector.js';
+import { evaluateSyntax } from '../../validation/syntax.js';
 
 const config = getSyntaxConfig();
+function replacePseudo(tokens) {
+    return tokens.map((raw) => raw.map(r => {
+        if (r.includes('(')) {
+            const index = r.indexOf('(');
+            const name = r.slice(0, index) + '()';
+            if (name in pseudoAliasMap) {
+                return pseudoAliasMap[name] + r.slice(index);
+            }
+            return r;
+        }
+        return r in pseudoAliasMap && pseudoAliasMap[r] in config["selectors" /* ValidationSyntaxGroupEnum.Selectors */] ? pseudoAliasMap[r] : r;
+    }));
+}
+function replaceAstNodes(tokens, root) {
+    let result = false;
+    for (const { value, parent } of walkValues(tokens, root)) {
+        if (value.typ == EnumToken.IdenTokenType || value.typ == EnumToken.PseudoClassFuncTokenType || value.typ == EnumToken.PseudoClassTokenType || value.typ == EnumToken.PseudoElementTokenType) {
+            let key = value.val + (value.typ == EnumToken.PseudoClassFuncTokenType ? '()' : '');
+            if (key in pseudoAliasMap) {
+                const isPseudClass = pseudoAliasMap[key].startsWith('::');
+                value.val = pseudoAliasMap[key];
+                if (value.typ == EnumToken.IdenTokenType &&
+                    ['min-resolution', 'max-resolution'].includes(value.val) &&
+                    parent?.typ == EnumToken.MediaQueryConditionTokenType &&
+                    parent.r?.[0]?.typ == EnumToken.NumberTokenType) {
+                    Object.assign(parent.r?.[0], {
+                        typ: EnumToken.ResolutionTokenType,
+                        unit: 'x',
+                    });
+                }
+                else if (isPseudClass && value.typ == EnumToken.PseudoElementTokenType) {
+                    // @ts-ignore
+                    value.typ = EnumToken.PseudoClassTokenType;
+                }
+                result = true;
+            }
+        }
+    }
+    return result;
+}
 class ComputePrefixFeature {
-    static get ordering() {
+    get ordering() {
         return 2;
     }
+    get preProcess() {
+        return true;
+    }
+    get postProcess() {
+        return false;
+    }
     static register(options) {
         if (options.removePrefix) {
             // @ts-ignore
             options.features.push(new ComputePrefixFeature(options));
         }
     }
-    run(ast) {
-        // @ts-ignore
-        const j = ast.chi.length;
-        let k = 0;
-        // @ts-ignore
-        for (; k < j; k++) {
-            // @ts-ignore
-            const node = ast.chi[k];
-            if (node.typ == EnumToken.DeclarationNodeType) {
-                if (node.nam.charAt(0) == '-') {
-                    const match = node.nam.match(/^-([^-]+)-(.+)$/);
-                    if (match != null) {
-                        const nam = match[2];
-                        if (nam.toLowerCase() in config.declarations) {
-                            node.nam = nam;
+    run(node) {
+        if (node.typ == EnumToken.RuleNodeType) {
+            node.sel = replacePseudo(splitRule(node.sel)).reduce((acc, curr, index) => acc + (index > 0 ? ',' : '') + curr.join(''), '');
+            if (node.raw != null) {
+                node.raw = replacePseudo(node.raw);
+            }
+            if (node.optimized != null) {
+                node.optimized.selector = replacePseudo(node.optimized.selector);
+            }
+            if (node.tokens != null) {
+                replaceAstNodes(node.tokens);
+            }
+        }
+        else if (node.typ == EnumToken.DeclarationNodeType) {
+            if (node.nam.charAt(0) == '-') {
+                const match = node.nam.match(/^-([^-]+)-(.+)$/);
+                if (match != null) {
+                    let nam = match[2];
+                    if (!(nam in config.declarations)) {
+                        if (node.nam in pseudoAliasMap) {
+                            nam = pseudoAliasMap[node.nam];
                         }
                     }
-                }
-                if (node.nam.toLowerCase() in config.declarations) {
-                    for (const { value } of walkValues(node.val)) {
-                        if (value.typ == EnumToken.IdenTokenType && value.val.charAt(0) == '-' && value.val.charAt(1) != '-') {
-                            // @ts-ignore
-                            const values = config.declarations[node.nam].ast?.slice?.();
-                            const match = value.val.match(/^-(.*?)-(.*)$/);
-                            if (values != null && match != null) {
-                                const val = matchToken({ ...value, val: match[2] }, values);
-                                if (val != null) {
-                                    // @ts-ignore
-                                    value.val = val.val;
-                                }
-                            }
-                        }
+                    if (nam in config.declarations) {
+                        node.nam = nam;
                     }
                 }
             }
-        }
-        return ast;
-    }
-}
-function matchToken(token, matches) {
-    let result;
-    for (let i = 0; i < matches.length; i++) {
-        switch (matches[i].typ) {
-            case ValidationTokenEnum.Whitespace:
-            case ValidationTokenEnum.Comma:
-                break;
-            case ValidationTokenEnum.Keyword:
-                if (token.typ == EnumToken.IdenTokenType && token.val == matches[i].val) {
-                    return token;
-                }
-                break;
-            case ValidationTokenEnum.PropertyType:
-                if (['ident', 'custom-ident'].includes(matches[i].val)) {
-                    if (token.typ == EnumToken.IdenTokenType && token.val == matches[i].val) {
-                        return token;
+            let hasPrefix = false;
+            for (const { value } of walkValues(node.val)) {
+                if ((value.typ == EnumToken.IdenTokenType || (value.typ != EnumToken.ParensTokenType && funcLike.includes(value.typ))) && value.val.match(/^-([^-]+)-(.+)$/) != null) {
+                    if (value.val.endsWith('-gradient')) {
+                        // not supported yet
+                        break;
                     }
+                    hasPrefix = true;
+                    break;
                 }
-                else {
-                    const val = matches[i].val;
-                    if (val in config.declarations || val in config.syntaxes) {
-                        // @ts-ignore
-                        result = matchToken(token, (config.syntaxes[val] ?? config.declarations[val]).ast.slice());
-                        if (result != null) {
-                            return result;
+            }
+            if (hasPrefix) {
+                const nodes = structuredClone(node.val);
+                for (const { value } of walkValues(nodes)) {
+                    if ((value.typ == EnumToken.IdenTokenType || funcLike.includes(value.typ))) {
+                        const match = value.val.match(/^-([^-]+)-(.+)$/);
+                        if (match == null) {
+                            continue;
                         }
+                        value.val = match[2];
                     }
                 }
-                break;
-            case ValidationTokenEnum.PipeToken:
-                for (let j = 0; j < matches[i].chi.length; j++) {
-                    result = matchToken(token, matches[i].chi[j]);
-                    if (result != null) {
-                        return result;
-                    }
+                if (SyntaxValidationResult.Valid == evaluateSyntax({ ...node, val: nodes }, {}).valid) {
+                    node.val = nodes;
                 }
-                break;
-            case ValidationTokenEnum.ColumnToken:
-            case ValidationTokenEnum.AmpersandToken:
-                result = matchToken(token, matches[i].l);
-                if (result == null) {
-                    result = matchToken(token, matches[i].r);
+            }
+        }
+        else if (node.typ == EnumToken.AtRuleNodeType || node.typ == EnumToken.KeyframeAtRuleNodeType) {
+            if (node.nam.startsWith('-')) {
+                const match = node.nam.match(/^-([^-]+)-(.+)$/);
+                if (match != null && '@' + match[2] in config.atRules) {
+                    node.nam = match[2];
                 }
-                if (result != null) {
-                    return result;
+            }
+            if (node.typ == EnumToken.AtRuleNodeType && node.val !== '') {
+                if (node.tokens == null) {
+                    Object.defineProperty(node, 'tokens', {
+                        // @ts-ignore
+                        ...definedPropertySettings,
+                        value: parseAtRulePrelude(parseString(node.val), node),
+                    });
                 }
-                break;
-            case ValidationTokenEnum.Bracket:
-                result = matchToken(token, matches[i].chi);
-                if (result != null) {
-                    return result;
+                if (replaceAstNodes(node.tokens)) {
+                    node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr), '');
                 }
-                break;
+            }
         }
+        return node;
     }
-    return null;
 }
 
 export { ComputePrefixFeature };

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

@@ -3,14 +3,21 @@ import { EnumToken } from '../types.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import '../../parser/utils/config.js';
 
 class ComputeShorthandFeature {
-    static get ordering() {
+    get ordering() {
         return 3;
     }
+    get preProcess() {
+        return false;
+    }
+    get postProcess() {
+        return true;
+    }
     static register(options) {
         if (options.computeShorthand) {
             // @ts-ignore
@@ -18,21 +25,37 @@ class ComputeShorthandFeature {
         }
     }
     run(ast, options = {}, parent, context) {
+        if (!('chi' in ast)) {
+            return ast;
+        }
         // @ts-ignore
         const j = ast.chi.length;
         let k = 0;
+        let l;
         let properties = new PropertyList(options);
         const rules = [];
         // @ts-ignore
         for (; k < j; k++) {
+            l = k;
+            // capture comments with the next token
+            while (l + 1 < j) {
+                // @ts-ignore
+                const node = ast.chi[l];
+                if (node.typ == EnumToken.CommentNodeType) {
+                    l++;
+                    continue;
+                }
+                break;
+            }
             // @ts-ignore
-            const node = ast.chi[k];
-            if (node.typ == EnumToken.CommentNodeType || node.typ == EnumToken.DeclarationNodeType) {
-                properties.add(node);
+            const node = ast.chi[l];
+            if (node.typ == EnumToken.DeclarationNodeType) {
+                properties.add(...ast.chi.slice(k, l + 1));
             }
             else {
-                rules.push(node);
+                rules.push(...ast.chi.slice(k, l + 1));
             }
+            k = l;
         }
         // @ts-ignore
         ast.chi = [...properties, ...rules];

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

@@ -3,16 +3,23 @@ import { consumeWhitespace } from '../../validation/utils/whitespace.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 import { filterValues, renderToken } from '../../renderer/render.js';
 import '../../renderer/color/utils/constants.js';
-import '../../parser/utils/config.js';
 import { compute } from '../transform/compute.js';
 import { eqMatrix } from '../transform/minify.js';
 
 class TransformCssFeature {
-    static get ordering() {
+    get ordering() {
         return 4;
     }
+    get preProcess() {
+        return false;
+    }
+    get postProcess() {
+        return true;
+    }
     static register(options) {
         // @ts-ignore
         if (options.computeTransform) {
@@ -37,7 +44,7 @@ class TransformCssFeature {
             consumeWhitespace(children);
             let { matrix, cumulative, minified } = compute(children) ?? {};
             if (matrix == null || cumulative == null || minified == null) {
-                return;
+                continue;
             }
             let r = [filterValues(node.val.slice())];
             if (eqMatrix(matrix, cumulative)) {

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

@@ -0,0 +1,7 @@
+var FeatureWalkMode;
+(function (FeatureWalkMode) {
+    FeatureWalkMode[FeatureWalkMode["Pre"] = 0] = "Pre";
+    FeatureWalkMode[FeatureWalkMode["Post"] = 1] = "Post";
+})(FeatureWalkMode || (FeatureWalkMode = {}));
+
+export { FeatureWalkMode };

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

@@ -1,6 +1,12 @@
 import { EnumToken } from '../types.js';
 import { rem, compute } from './math.js';
 import { reduceNumber } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import '../minify.js';
+import '../walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 import { mathFuncs } from '../../syntax/syntax.js';
 
 /**
@@ -517,4 +523,4 @@ function factor(tokens, ops) {
     return tokens;
 }
 
-export { evaluate, evaluateFunc, inlineExpression };
+export { buildExpression, evaluate, evaluateFunc, inlineExpression };

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

@@ -1,5 +1,11 @@
 import { EnumToken } from '../types.js';
 import { reduceNumber } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import '../minify.js';
+import '../walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 
 function gcd(x, y) {
     x = Math.abs(x);