@tbela99/css-parser 0.7.1 → 0.9.0

package/dist/lib/ast/types.js

@@ -2,6 +2,7 @@ var ValidationLevel;
 (function (ValidationLevel) {
     ValidationLevel[ValidationLevel["Valid"] = 0] = "Valid";
     ValidationLevel[ValidationLevel["Drop"] = 1] = "Drop";
+    ValidationLevel[ValidationLevel["Lenient"] = 2] = "Lenient"; /* preserve unknown at-rules, declarations and pseudo-classes */
 })(ValidationLevel || (ValidationLevel = {}));
 var EnumToken;
 (function (EnumToken) {
@@ -44,61 +45,70 @@ var EnumToken;
     EnumToken[EnumToken["WhitespaceTokenType"] = 36] = "WhitespaceTokenType";
     EnumToken[EnumToken["IncludeMatchTokenType"] = 37] = "IncludeMatchTokenType";
     EnumToken[EnumToken["DashMatchTokenType"] = 38] = "DashMatchTokenType";
-    EnumToken[EnumToken["LtTokenType"] = 39] = "LtTokenType";
-    EnumToken[EnumToken["LteTokenType"] = 40] = "LteTokenType";
-    EnumToken[EnumToken["GtTokenType"] = 41] = "GtTokenType";
-    EnumToken[EnumToken["GteTokenType"] = 42] = "GteTokenType";
-    EnumToken[EnumToken["PseudoClassTokenType"] = 43] = "PseudoClassTokenType";
-    EnumToken[EnumToken["PseudoClassFuncTokenType"] = 44] = "PseudoClassFuncTokenType";
-    EnumToken[EnumToken["DelimTokenType"] = 45] = "DelimTokenType";
-    EnumToken[EnumToken["UrlTokenTokenType"] = 46] = "UrlTokenTokenType";
-    EnumToken[EnumToken["EOFTokenType"] = 47] = "EOFTokenType";
-    EnumToken[EnumToken["ImportantTokenType"] = 48] = "ImportantTokenType";
-    EnumToken[EnumToken["ColorTokenType"] = 49] = "ColorTokenType";
-    EnumToken[EnumToken["AttrTokenType"] = 50] = "AttrTokenType";
-    EnumToken[EnumToken["BadCommentTokenType"] = 51] = "BadCommentTokenType";
-    EnumToken[EnumToken["BadCdoTokenType"] = 52] = "BadCdoTokenType";
-    EnumToken[EnumToken["BadUrlTokenType"] = 53] = "BadUrlTokenType";
-    EnumToken[EnumToken["BadStringTokenType"] = 54] = "BadStringTokenType";
-    EnumToken[EnumToken["BinaryExpressionTokenType"] = 55] = "BinaryExpressionTokenType";
-    EnumToken[EnumToken["UnaryExpressionTokenType"] = 56] = "UnaryExpressionTokenType";
-    EnumToken[EnumToken["FlexTokenType"] = 57] = "FlexTokenType";
+    EnumToken[EnumToken["EqualMatchTokenType"] = 39] = "EqualMatchTokenType";
+    EnumToken[EnumToken["LtTokenType"] = 40] = "LtTokenType";
+    EnumToken[EnumToken["LteTokenType"] = 41] = "LteTokenType";
+    EnumToken[EnumToken["GtTokenType"] = 42] = "GtTokenType";
+    EnumToken[EnumToken["GteTokenType"] = 43] = "GteTokenType";
+    EnumToken[EnumToken["PseudoClassTokenType"] = 44] = "PseudoClassTokenType";
+    EnumToken[EnumToken["PseudoClassFuncTokenType"] = 45] = "PseudoClassFuncTokenType";
+    EnumToken[EnumToken["DelimTokenType"] = 46] = "DelimTokenType";
+    EnumToken[EnumToken["UrlTokenTokenType"] = 47] = "UrlTokenTokenType";
+    EnumToken[EnumToken["EOFTokenType"] = 48] = "EOFTokenType";
+    EnumToken[EnumToken["ImportantTokenType"] = 49] = "ImportantTokenType";
+    EnumToken[EnumToken["ColorTokenType"] = 50] = "ColorTokenType";
+    EnumToken[EnumToken["AttrTokenType"] = 51] = "AttrTokenType";
+    EnumToken[EnumToken["BadCommentTokenType"] = 52] = "BadCommentTokenType";
+    EnumToken[EnumToken["BadCdoTokenType"] = 53] = "BadCdoTokenType";
+    EnumToken[EnumToken["BadUrlTokenType"] = 54] = "BadUrlTokenType";
+    EnumToken[EnumToken["BadStringTokenType"] = 55] = "BadStringTokenType";
+    EnumToken[EnumToken["BinaryExpressionTokenType"] = 56] = "BinaryExpressionTokenType";
+    EnumToken[EnumToken["UnaryExpressionTokenType"] = 57] = "UnaryExpressionTokenType";
+    EnumToken[EnumToken["FlexTokenType"] = 58] = "FlexTokenType";
     /* catch all */
-    EnumToken[EnumToken["ListToken"] = 58] = "ListToken";
+    EnumToken[EnumToken["ListToken"] = 59] = "ListToken";
     /* arithmetic tokens */
-    EnumToken[EnumToken["Add"] = 59] = "Add";
-    EnumToken[EnumToken["Mul"] = 60] = "Mul";
-    EnumToken[EnumToken["Div"] = 61] = "Div";
-    EnumToken[EnumToken["Sub"] = 62] = "Sub";
+    EnumToken[EnumToken["Add"] = 60] = "Add";
+    EnumToken[EnumToken["Mul"] = 61] = "Mul";
+    EnumToken[EnumToken["Div"] = 62] = "Div";
+    EnumToken[EnumToken["Sub"] = 63] = "Sub";
     /* new tokens */
-    EnumToken[EnumToken["ColumnCombinatorTokenType"] = 63] = "ColumnCombinatorTokenType";
-    EnumToken[EnumToken["ContainMatchTokenType"] = 64] = "ContainMatchTokenType";
-    EnumToken[EnumToken["StartMatchTokenType"] = 65] = "StartMatchTokenType";
-    EnumToken[EnumToken["EndMatchTokenType"] = 66] = "EndMatchTokenType";
-    EnumToken[EnumToken["MatchExpressionTokenType"] = 67] = "MatchExpressionTokenType";
-    EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 68] = "NameSpaceAttributeTokenType";
-    EnumToken[EnumToken["FractionTokenType"] = 69] = "FractionTokenType";
-    EnumToken[EnumToken["IdenListTokenType"] = 70] = "IdenListTokenType";
-    EnumToken[EnumToken["GridTemplateFuncTokenType"] = 71] = "GridTemplateFuncTokenType";
-    EnumToken[EnumToken["KeyFrameRuleNodeType"] = 72] = "KeyFrameRuleNodeType";
-    EnumToken[EnumToken["ClassSelectorTokenType"] = 73] = "ClassSelectorTokenType";
-    EnumToken[EnumToken["UniversalSelectorTokenType"] = 74] = "UniversalSelectorTokenType";
-    EnumToken[EnumToken["ChildCombinatorTokenType"] = 75] = "ChildCombinatorTokenType";
-    EnumToken[EnumToken["DescendantCombinatorTokenType"] = 76] = "DescendantCombinatorTokenType";
-    EnumToken[EnumToken["NextSiblingCombinatorTokenType"] = 77] = "NextSiblingCombinatorTokenType";
-    EnumToken[EnumToken["SubsequentSiblingCombinatorTokenType"] = 78] = "SubsequentSiblingCombinatorTokenType";
-    EnumToken[EnumToken["NestingSelectorTokenType"] = 79] = "NestingSelectorTokenType";
-    EnumToken[EnumToken["InvalidRuleTokenType"] = 80] = "InvalidRuleTokenType";
-    EnumToken[EnumToken["InvalidClassSelectorTokenType"] = 81] = "InvalidClassSelectorTokenType";
-    EnumToken[EnumToken["InvalidAttrTokenType"] = 82] = "InvalidAttrTokenType";
+    EnumToken[EnumToken["ColumnCombinatorTokenType"] = 64] = "ColumnCombinatorTokenType";
+    EnumToken[EnumToken["ContainMatchTokenType"] = 65] = "ContainMatchTokenType";
+    EnumToken[EnumToken["StartMatchTokenType"] = 66] = "StartMatchTokenType";
+    EnumToken[EnumToken["EndMatchTokenType"] = 67] = "EndMatchTokenType";
+    EnumToken[EnumToken["MatchExpressionTokenType"] = 68] = "MatchExpressionTokenType";
+    EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 69] = "NameSpaceAttributeTokenType";
+    EnumToken[EnumToken["FractionTokenType"] = 70] = "FractionTokenType";
+    EnumToken[EnumToken["IdenListTokenType"] = 71] = "IdenListTokenType";
+    EnumToken[EnumToken["GridTemplateFuncTokenType"] = 72] = "GridTemplateFuncTokenType";
+    EnumToken[EnumToken["KeyFrameRuleNodeType"] = 73] = "KeyFrameRuleNodeType";
+    EnumToken[EnumToken["ClassSelectorTokenType"] = 74] = "ClassSelectorTokenType";
+    EnumToken[EnumToken["UniversalSelectorTokenType"] = 75] = "UniversalSelectorTokenType";
+    EnumToken[EnumToken["ChildCombinatorTokenType"] = 76] = "ChildCombinatorTokenType";
+    EnumToken[EnumToken["DescendantCombinatorTokenType"] = 77] = "DescendantCombinatorTokenType";
+    EnumToken[EnumToken["NextSiblingCombinatorTokenType"] = 78] = "NextSiblingCombinatorTokenType";
+    EnumToken[EnumToken["SubsequentSiblingCombinatorTokenType"] = 79] = "SubsequentSiblingCombinatorTokenType";
+    EnumToken[EnumToken["NestingSelectorTokenType"] = 80] = "NestingSelectorTokenType";
+    EnumToken[EnumToken["InvalidRuleTokenType"] = 81] = "InvalidRuleTokenType";
+    EnumToken[EnumToken["InvalidClassSelectorTokenType"] = 82] = "InvalidClassSelectorTokenType";
+    EnumToken[EnumToken["InvalidAttrTokenType"] = 83] = "InvalidAttrTokenType";
+    EnumToken[EnumToken["InvalidAtRuleTokenType"] = 84] = "InvalidAtRuleTokenType";
+    EnumToken[EnumToken["MediaQueryConditionTokenType"] = 85] = "MediaQueryConditionTokenType";
+    EnumToken[EnumToken["MediaFeatureTokenType"] = 86] = "MediaFeatureTokenType";
+    EnumToken[EnumToken["MediaFeatureOnlyTokenType"] = 87] = "MediaFeatureOnlyTokenType";
+    EnumToken[EnumToken["MediaFeatureNotTokenType"] = 88] = "MediaFeatureNotTokenType";
+    EnumToken[EnumToken["MediaFeatureAndTokenType"] = 89] = "MediaFeatureAndTokenType";
+    EnumToken[EnumToken["MediaFeatureOrTokenType"] = 90] = "MediaFeatureOrTokenType";
+    EnumToken[EnumToken["PseudoPageTokenType"] = 91] = "PseudoPageTokenType";
     /* aliases */
     EnumToken[EnumToken["Time"] = 25] = "Time";
     EnumToken[EnumToken["Iden"] = 7] = "Iden";
-    EnumToken[EnumToken["EOF"] = 47] = "EOF";
+    EnumToken[EnumToken["EOF"] = 48] = "EOF";
     EnumToken[EnumToken["Hash"] = 28] = "Hash";
-    EnumToken[EnumToken["Flex"] = 57] = "Flex";
+    EnumToken[EnumToken["Flex"] = 58] = "Flex";
     EnumToken[EnumToken["Angle"] = 24] = "Angle";
-    EnumToken[EnumToken["Color"] = 49] = "Color";
+    EnumToken[EnumToken["Color"] = 50] = "Color";
     EnumToken[EnumToken["Comma"] = 9] = "Comma";
     EnumToken[EnumToken["String"] = 20] = "String";
     EnumToken[EnumToken["Length"] = 23] = "Length";
@@ -111,9 +121,9 @@ var EnumToken;
     EnumToken[EnumToken["Frequency"] = 26] = "Frequency";
     EnumToken[EnumToken["Resolution"] = 27] = "Resolution";
     EnumToken[EnumToken["Whitespace"] = 36] = "Whitespace";
-    EnumToken[EnumToken["IdenList"] = 70] = "IdenList";
+    EnumToken[EnumToken["IdenList"] = 71] = "IdenList";
     EnumToken[EnumToken["DashedIden"] = 8] = "DashedIden";
-    EnumToken[EnumToken["GridTemplateFunc"] = 71] = "GridTemplateFunc";
+    EnumToken[EnumToken["GridTemplateFunc"] = 72] = "GridTemplateFunc";
     EnumToken[EnumToken["ImageFunc"] = 19] = "ImageFunc";
     EnumToken[EnumToken["CommentNodeType"] = 0] = "CommentNodeType";
     EnumToken[EnumToken["CDOCOMMNodeType"] = 1] = "CDOCOMMNodeType";

package/dist/lib/ast/walk.js

@@ -1,5 +1,15 @@
 import { EnumToken } from './types.js';
 
+var WalkerValueEvent;
+(function (WalkerValueEvent) {
+    WalkerValueEvent[WalkerValueEvent["Enter"] = 0] = "Enter";
+    WalkerValueEvent[WalkerValueEvent["Leave"] = 1] = "Leave";
+})(WalkerValueEvent || (WalkerValueEvent = {}));
+/**
+ * walk ast nodes
+ * @param node
+ * @param filter
+ */
 function* walk(node, filter) {
     const parents = [node];
     const root = node;
@@ -28,40 +38,104 @@ function* walk(node, filter) {
         }
     }
 }
-function* walkValues(values, root = null, filter) {
+/**
+ * walk ast values
+ * @param values
+ * @param root
+ * @param filter
+ * @param reverse
+ */
+function* walkValues(values, root = null, filter, reverse) {
+    // const set = new Set<Token>();
     const stack = values.slice();
     const map = new Map;
-    let value;
     let previous = null;
-    while ((value = stack.shift())) {
+    // let parent: FunctionToken | ParensToken | BinaryExpressionToken | null = null;
+    if (filter != null && typeof filter == 'function') {
+        filter = {
+            event: WalkerValueEvent.Enter,
+            fn: filter
+        };
+    }
+    else if (filter == null) {
+        filter = {
+            event: WalkerValueEvent.Enter
+        };
+    }
+    while (stack.length > 0) {
+        let value = reverse ? stack.pop() : stack.shift();
         let option = null;
-        if (filter != null) {
-            option = filter(value);
-            if (option === 'ignore') {
-                continue;
-            }
-            if (option === 'stop') {
-                break;
+        if (filter.fn != null && filter.event == WalkerValueEvent.Enter) {
+            const isValid = filter.type == null || value.typ == filter.type ||
+                (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
+                (typeof filter.type == 'function' && filter.type(value));
+            if (isValid) {
+                option = filter.fn(value, map.get(value) ?? root, WalkerValueEvent.Enter);
+                if (option === 'ignore') {
+                    continue;
+                }
+                if (option === 'stop') {
+                    break;
+                }
+                // @ts-ignore
+                if (option != null && typeof option == 'object' && 'typ' in option) {
+                    map.set(option, map.get(value) ?? root);
+                }
             }
         }
         // @ts-ignore
-        if (option !== 'children') {
-            // @ts-ignore
-            yield { value, parent: map.get(value), previousValue: previous, nextValue: stack[0] ?? null, root };
+        if (filter.event == WalkerValueEvent.Enter && option !== 'children') {
+            yield {
+                value,
+                parent: map.get(value) ?? root,
+                previousValue: previous,
+                nextValue: stack[0] ?? null,
+                // @ts-ignore
+                root: root ?? null
+            };
         }
         if (option !== 'ignore-children' && 'chi' in value) {
-            for (const child of value.chi.slice()) {
+            const sliced = value.chi.slice();
+            for (const child of sliced) {
                 map.set(child, value);
             }
-            stack.unshift(...value.chi);
+            if (reverse) {
+                stack.push(...sliced);
+            }
+            else {
+                stack.unshift(...sliced);
+            }
         }
         else if (value.typ == EnumToken.BinaryExpressionTokenType) {
-            map.set(value.l, value);
-            map.set(value.r, value);
+            map.set(value.l, map.get(value) ?? root);
+            map.set(value.r, map.get(value) ?? root);
             stack.unshift(value.l, value.r);
         }
+        if (filter.event == WalkerValueEvent.Leave && filter.fn != null) {
+            const isValid = filter.type == null || value.typ == filter.type ||
+                (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
+                (typeof filter.type == 'function' && filter.type(value));
+            if (isValid) {
+                option = filter.fn(value, map.get(value), WalkerValueEvent.Leave);
+                // @ts-ignore
+                if (option != null && 'typ' in option) {
+                    map.set(option, map.get(value) ?? root);
+                }
+            }
+        }
+        // @ts-ignore
+        if (filter.event == WalkerValueEvent.Leave && option !== 'children') {
+            yield {
+                value,
+                parent: map.get(value) ?? root,
+                previousValue: previous,
+                nextValue: stack[0] ?? null,
+                // @ts-ignore
+                root: root ?? null
+            };
+        }
         previous = value;
     }
 }
 
-export { walk, walkValues };
+export { WalkerValueEvent, walk, walkValues };

package/dist/lib/parser/declaration/list.js

@@ -2,6 +2,7 @@ import { PropertySet } from './set.js';
 import { getConfig } from '../utils/config.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import { parseString } from '../parse.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';

package/dist/lib/parser/declaration/map.js

@@ -3,6 +3,7 @@ import { getConfig } from '../utils/config.js';
 import { matchType } from '../utils/type.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import { parseString } from '../parse.js';
 import { renderToken } from '../../renderer/render.js';
 import '../../renderer/color/utils/constants.js';
@@ -161,55 +162,6 @@ class PropertyMap {
         }
         return this;
     }
-    matchTypes(declaration) {
-        const patterns = this.pattern.slice();
-        const values = [...declaration.val];
-        let i;
-        let j;
-        const map = new Map;
-        for (i = 0; i < patterns.length; i++) {
-            for (j = 0; j < values.length; j++) {
-                if (!map.has(patterns[i])) {
-                    // @ts-ignore
-                    map.set(patterns[i], this.config.properties?.[patterns[i]]?.constraints?.mapping?.max ?? 1);
-                }
-                let count = map.get(patterns[i]);
-                if (count > 0 && matchType(values[j], this.config.properties[patterns[i]])) {
-                    Object.defineProperty(values[j], 'propertyName', {
-                        enumerable: false,
-                        writable: true,
-                        value: patterns[i]
-                    });
-                    map.set(patterns[i], --count);
-                    values.splice(j--, 1);
-                }
-            }
-        }
-        if (this.config.set != null) {
-            for (const [key, val] of Object.entries(this.config.set)) {
-                if (map.has(key)) {
-                    for (const v of val) {
-                        // missing
-                        if (map.get(v) == 1) {
-                            let i = declaration.val.length;
-                            while (i--) {
-                                // @ts-ignore
-                                if (declaration.val[i].propertyName == key) {
-                                    const val = { ...declaration.val[i] };
-                                    Object.defineProperty(val, 'propertyName', {
-                                        enumerable: false,
-                                        writable: true,
-                                        value: v
-                                    });
-                                    declaration.val.splice(i, 0, val, { typ: EnumToken.WhitespaceTokenType });
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
     [Symbol.iterator]() {
         let iterable;
         let requiredCount = 0;
@@ -248,9 +200,15 @@ class PropertyMap {
                     // @ts-ignore
                     let typ = (EnumToken[this.config.separator?.typ] ?? EnumToken.CommaTokenType);
                     // @ts-ignore
-                    const sep = this.config.separator == null ? null : { ...this.config.separator, typ: EnumToken[this.config.separator.typ] };
+                    const sep = this.config.separator == null ? null : {
+                        ...this.config.separator,
+                        typ: EnumToken[this.config.separator.typ]
+                    };
                     // @ts-ignore
-                    const separator = this.config.separator ? renderToken({ ...this.config.separator, typ: EnumToken[this.config.separator.typ] }) : ',';
+                    const separator = this.config.separator ? renderToken({
+                        ...this.config.separator,
+                        typ: EnumToken[this.config.separator.typ]
+                    }) : ',';
                     this.matchTypes(declaration);
                     values.push(value);
                     for (i = 0; i < declaration.val.length; i++) {
@@ -445,7 +403,6 @@ class PropertyMap {
                             acc.push(curr);
                             return acc;
                         }, []);
-                        // @todo remove renderToken call
                         if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
                             if (!this.config.properties[curr[0]].required) {
                                 continue;
@@ -543,6 +500,7 @@ class PropertyMap {
                 }
                 // @ts-ignore
                 if (values.length == 1 &&
+                    // @ts-ignore
                     typeof values[0].val == 'string' &&
                     this.config.default.includes(values[0].val.toLowerCase()) &&
                     this.config.default[0] != values[0].val.toLowerCase()) {
@@ -561,6 +519,7 @@ class PropertyMap {
             // @ts-ignore
             next() {
                 let v = iterable.next();
+                // @ts-ignore
                 while (v.done || v.value instanceof PropertySet) {
                     if (v.value instanceof PropertySet) {
                         // @ts-ignore
@@ -583,6 +542,55 @@ class PropertyMap {
             }
         };
     }
+    matchTypes(declaration) {
+        const patterns = this.pattern.slice();
+        const values = [...declaration.val];
+        let i;
+        let j;
+        const map = new Map;
+        for (i = 0; i < patterns.length; i++) {
+            for (j = 0; j < values.length; j++) {
+                if (!map.has(patterns[i])) {
+                    // @ts-ignore
+                    map.set(patterns[i], this.config.properties?.[patterns[i]]?.constraints?.mapping?.max ?? 1);
+                }
+                let count = map.get(patterns[i]);
+                if (count > 0 && matchType(values[j], this.config.properties[patterns[i]])) {
+                    Object.defineProperty(values[j], 'propertyName', {
+                        enumerable: false,
+                        writable: true,
+                        value: patterns[i]
+                    });
+                    map.set(patterns[i], --count);
+                    values.splice(j--, 1);
+                }
+            }
+        }
+        if (this.config.set != null) {
+            for (const [key, val] of Object.entries(this.config.set)) {
+                if (map.has(key)) {
+                    for (const v of val) {
+                        // missing
+                        if (map.get(v) == 1) {
+                            let i = declaration.val.length;
+                            while (i--) {
+                                // @ts-ignore
+                                if (declaration.val[i].propertyName == key) {
+                                    const val = { ...declaration.val[i] };
+                                    Object.defineProperty(val, 'propertyName', {
+                                        enumerable: false,
+                                        writable: true,
+                                        value: v
+                                    });
+                                    declaration.val.splice(i, 0, val, { typ: EnumToken.WhitespaceTokenType });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     removeDefaults(map, value) {
         for (const [key, val] of map) {
             const config = this.config.properties[key];

package/dist/lib/parser/declaration/set.js

@@ -1,6 +1,7 @@
 import { eq } from '../utils/eq.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../parse.js';
 import { isLength } from '../../syntax/syntax.js';
 import '../utils/config.js';
@@ -180,20 +181,8 @@ class PropertySet {
                         return acc;
                     }, [])
                 }][Symbol.iterator]();
-            // return {
-            //     next() {
-            //
-            //         return iterator.next();
-            //     }
-            // }
         }
         return iterator;
-        // return {
-        //     next() {
-        //
-        //         return iterator.next();
-        //     }
-        // }
     }
 }