@tbela99/css-parser 0.8.0 → 0.9.1

package/dist/lib/validation/syntaxes/complex-selector.js

@@ -1,4 +1,5 @@
 import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
 import { EnumToken, ValidationLevel } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
@@ -6,9 +7,11 @@ import '../../parser/parse.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
+import { validateCompoundSelector } from './compound-selector.js';
 
 const combinatorsTokens = [EnumToken.ChildCombinatorTokenType, EnumToken.ColumnCombinatorTokenType,
-    EnumToken.DescendantCombinatorTokenType, EnumToken.NextSiblingCombinatorTokenType, EnumToken.SubsequentSiblingCombinatorTokenType];
+    // EnumToken.DescendantCombinatorTokenType,
+    EnumToken.NextSiblingCombinatorTokenType, EnumToken.SubsequentSiblingCombinatorTokenType];
 // <compound-selector> [ <combinator>? <compound-selector> ]*
 function validateComplexSelector(tokens, root, options) {
     // [ <type-selector>? <subclass-selector>* [ <pseudo-element-selector> <pseudo-class-selector>* ]* ]!
@@ -25,257 +28,24 @@ function validateComplexSelector(tokens, root, options) {
             tokens
         };
     }
-    while (tokens.length > 0) {
-        if (combinatorsTokens.includes(tokens[0].typ)) {
-            // @ts-ignore
-            return {
-                valid: ValidationLevel.Drop,
-                matches: [],
-                // @ts-ignore
-                node: tokens[0],
-                syntax: null,
-                error: 'unexpected combinator',
-                tokens
-            };
-        }
-        if (tokens[0].typ == EnumToken.NestingSelectorTokenType) {
-            if (!options?.nestedSelector) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    // @ts-ignore
-                    node: tokens[0],
-                    syntax: null,
-                    error: 'nested selector not allowed',
-                    tokens
-                };
-            }
-            while (tokens.length > 0 && tokens[0].typ == EnumToken.NestingSelectorTokenType) {
-                tokens.shift();
-                consumeWhitespace(tokens);
-            }
-            if (tokens.length == 0) {
-                break;
-            }
-        }
-        if (EnumToken.IdenTokenType == tokens[0].typ) {
-            tokens.shift();
-            consumeWhitespace(tokens);
-            if (tokens.length == 0) {
-                break;
-            }
-        }
-        if (EnumToken.UniversalSelectorTokenType == tokens[0].typ) {
-            tokens.shift();
-            consumeWhitespace(tokens);
-        }
-        while (tokens.length > 0) {
-            if (tokens[0].typ == EnumToken.PseudoClassFuncTokenType) {
-                if (tokens[0].val.startsWith(':-webkit-')) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        // @ts-ignore
-                        node: tokens[0],
-                        syntax: null,
-                        error: 'invalid pseudo-class',
-                        tokens
-                    };
-                }
-            }
-            if ([
-                EnumToken.ClassSelectorTokenType,
-                EnumToken.HashTokenType,
-                EnumToken.PseudoClassTokenType,
-                EnumToken.PseudoClassFuncTokenType
-            ].includes(tokens[0].typ)) {
-                tokens.shift();
-                consumeWhitespace(tokens);
-                continue;
-            }
-            if (tokens[0].typ == EnumToken.NestingSelectorTokenType) {
-                if (!options?.nestedSelector) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        // @ts-ignore
-                        node: tokens[0],
-                        syntax: null,
-                        error: 'nested selector not allowed',
-                        tokens
-                    };
-                }
-                tokens.shift();
-                consumeWhitespace(tokens);
-                continue;
-            }
-            // validate namespace
-            if (tokens[0].typ == EnumToken.NameSpaceAttributeTokenType) {
-                if (!((tokens[0].l == null || tokens[0].l.typ == EnumToken.IdenTokenType || (tokens[0].l.typ == EnumToken.LiteralTokenType && tokens[0].l.val == '*')) &&
-                    tokens[0].r.typ == EnumToken.IdenTokenType)) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: tokens[0],
-                        syntax: null,
-                        error: 'expecting wq-name',
-                        tokens
-                    };
-                }
-                tokens.shift();
-                consumeWhitespace(tokens);
-                continue;
-            }
-            // validate attribute
-            else if (tokens[0].typ == EnumToken.AttrTokenType) {
-                const children = tokens[0].chi.slice();
-                consumeWhitespace(children);
-                if (children.length == 0) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: tokens[0],
-                        syntax: null,
-                        error: 'invalid attribute selector',
-                        tokens
-                    };
-                }
-                if (![
-                    EnumToken.IdenTokenType,
-                    EnumToken.NameSpaceAttributeTokenType,
-                    EnumToken.MatchExpressionTokenType
-                ].includes(children[0].typ)) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: tokens[0],
-                        syntax: null,
-                        error: 'invalid attribute selector',
-                        tokens
-                    };
-                }
-                if (children[0].typ == EnumToken.MatchExpressionTokenType) {
-                    if (![EnumToken.IdenTokenType,
-                        EnumToken.NameSpaceAttributeTokenType].includes(children[0].l.typ) ||
-                        ![
-                            EnumToken.EqualMatchTokenType, EnumToken.DashMatchTokenType,
-                            EnumToken.StartMatchTokenType, EnumToken.ContainMatchTokenType,
-                            EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType
-                        ].includes(children[0].op.typ) ||
-                        ![EnumToken.StringTokenType,
-                            EnumToken.IdenTokenType].includes(children[0].r.typ)) {
-                        // @ts-ignore
-                        return {
-                            valid: ValidationLevel.Drop,
-                            matches: [],
-                            node: tokens[0],
-                            syntax: null,
-                            error: 'invalid attribute selector',
-                            tokens
-                        };
-                    }
-                    if (children[0].attr != null && !['i', 's'].includes(children[0].attr)) {
-                        // @ts-ignore
-                        return {
-                            valid: ValidationLevel.Drop,
-                            matches: [],
-                            node: tokens[0],
-                            syntax: null,
-                            error: 'invalid attribute selector',
-                            tokens
-                        };
-                    }
-                }
-                children.shift();
-                consumeWhitespace(children);
-                if (children.length > 0) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: children[0],
-                        syntax: null,
-                        error: 'unexpected token',
-                        tokens
-                    };
-                }
-                tokens.shift();
-                consumeWhitespace(tokens);
-                continue;
-            }
-            break;
-        }
-        if (tokens.length == 0) {
-            break;
-        }
-        // combinator
-        if (!combinatorsTokens.includes(tokens[0].typ)) {
-            if (tokens[0].typ == EnumToken.NestingSelectorTokenType) {
-                if (!options?.nestedSelector) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        // @ts-ignore
-                        node: tokens[0],
-                        syntax: null,
-                        error: 'nested selector not allowed',
-                        tokens
-                    };
-                }
-                tokens.shift();
-                consumeWhitespace(tokens);
-                continue;
-            }
-            if (tokens.length > 0 &&
-                [
-                    EnumToken.IdenTokenType,
-                    EnumToken.AttrTokenType,
-                    EnumToken.NameSpaceAttributeTokenType,
-                    EnumToken.ClassSelectorTokenType,
-                    EnumToken.HashTokenType,
-                    EnumToken.PseudoClassTokenType,
-                    EnumToken.PseudoClassFuncTokenType
-                ].includes(tokens[0].typ)) {
-                continue;
-            }
-            // @ts-ignore
-            return {
-                valid: ValidationLevel.Drop,
-                matches: [],
-                node: tokens[0],
-                syntax: null,
-                error: 'expecting combinator or subclass-selector',
-                tokens
-            };
-        }
-        const token = tokens.shift();
-        consumeWhitespace(tokens);
-        if (tokens.length == 0) {
-            // @ts-ignore
-            return {
-                valid: ValidationLevel.Drop,
-                matches: [],
-                node: token,
-                syntax: null,
-                error: 'expected compound-selector',
-                tokens
-            };
+    // const config = getSyntaxConfig();
+    //
+    // let match: number = 0;
+    let result = null;
+    // const combinators: EnumToken[] = combinatorsTokens.filter((t: EnumToken) => t != EnumToken.DescendantCombinatorTokenType);
+    for (const t of splitTokenList(tokens, combinatorsTokens)) {
+        result = validateCompoundSelector(t, root, options);
+        if (result.valid == ValidationLevel.Drop) {
+            return result;
         }
     }
     // @ts-ignore
-    return {
-        valid: ValidationLevel.Valid,
+    return result ?? {
+        valid: ValidationLevel.Drop,
         matches: [],
-        node: null,
+        node: root,
         syntax: null,
-        error: '',
+        error: 'expecting compound-selector',
         tokens
     };
 }

package/dist/lib/validation/syntaxes/compound-selector.js

@@ -0,0 +1,226 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import { mozExtensions, webkitExtensions } from '../../syntax/syntax.js';
+import '../../parser/utils/config.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { getSyntaxConfig } from '../config.js';
+
+function validateCompoundSelector(tokens, root, options) {
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: 'expected selector',
+            tokens
+        };
+    }
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    const config = getSyntaxConfig();
+    let match = 0;
+    let length = tokens.length;
+    while (tokens.length > 0) {
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.NestingSelectorTokenType) {
+            if (!options?.nestedSelector) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    // @ts-ignore
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'nested selector not allowed',
+                    tokens
+                };
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        // <type-selector>
+        while (tokens.length > 0 &&
+            [
+                EnumToken.IdenTokenType,
+                EnumToken.NameSpaceAttributeTokenType,
+                EnumToken.ClassSelectorTokenType,
+                EnumToken.HashTokenType,
+                EnumToken.UniversalSelectorTokenType
+            ].includes(tokens[0].typ)) {
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.PseudoClassFuncTokenType) {
+            if (!mozExtensions.has(tokens[0].val + '()') &&
+                !webkitExtensions.has(tokens[0].val + '()') &&
+                !((tokens[0].val + '()') in config.selectors)) {
+                if (!options?.lenient || /^(:?)-webkit-/.test(tokens[0].val)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        // @ts-ignore
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'unknown pseudo-class: ' + tokens[0].val + '()',
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && (tokens[0].typ == EnumToken.PseudoElementTokenType || tokens[0].typ == EnumToken.PseudoClassTokenType)) {
+            const isPseudoElement = tokens[0].typ == EnumToken.PseudoElementTokenType;
+            if (
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/WebKit_Extensions#pseudo-elements
+            !(isPseudoElement && tokens[0].val.startsWith('::-webkit-')) &&
+                !mozExtensions.has(tokens[0].val) &&
+                !webkitExtensions.has(tokens[0].val) &&
+                !(tokens[0].val in config.selectors) &&
+                !(!isPseudoElement &&
+                    (':' + tokens[0].val) in config.selectors)) {
+                if (!options?.lenient || /^(:?)-webkit-/.test(tokens[0].val)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        // @ts-ignore
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'unknown pseudo-class: ' + tokens[0].val,
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.AttrTokenType) {
+            const children = tokens[0].chi.slice();
+            consumeWhitespace(children);
+            if (children.length == 0) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'invalid attribute selector',
+                    tokens
+                };
+            }
+            if (![
+                EnumToken.IdenTokenType,
+                EnumToken.NameSpaceAttributeTokenType,
+                EnumToken.MatchExpressionTokenType
+            ].includes(children[0].typ)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'invalid attribute selector',
+                    tokens
+                };
+            }
+            if (children[0].typ == EnumToken.MatchExpressionTokenType) {
+                if (children.length != 1) {
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid <attribute-selector>',
+                        tokens
+                    };
+                }
+                if (![
+                    EnumToken.IdenTokenType,
+                    EnumToken.NameSpaceAttributeTokenType
+                ].includes(children[0].l.typ) ||
+                    ![
+                        EnumToken.EqualMatchTokenType, EnumToken.DashMatchTokenType,
+                        EnumToken.StartMatchTokenType, EnumToken.ContainMatchTokenType,
+                        EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType
+                    ].includes(children[0].op.typ) ||
+                    ![
+                        EnumToken.StringTokenType,
+                        EnumToken.IdenTokenType
+                    ].includes(children[0].r.typ)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid attribute selector',
+                        tokens
+                    };
+                }
+                if (children[0].attr != null && !['i', 's'].includes(children[0].attr)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid attribute selector',
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        if (length == tokens.length) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                // @ts-ignore
+                node: tokens[0],
+                // @ts-ignore
+                syntax: null,
+                error: 'expected compound selector',
+                tokens
+            };
+        }
+        length = tokens.length;
+    }
+    return match == 0 ? {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        // @ts-ignore
+        node: root,
+        // @ts-ignore
+        syntax: null,
+        error: 'expected compound selector',
+        tokens
+    } :
+        // @ts-ignore
+        {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: null,
+            tokens
+        };
+}
+
+export { validateCompoundSelector };

package/dist/lib/validation/syntaxes/image.js

@@ -0,0 +1,29 @@
+import { EnumToken, ValidationLevel } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+import { validateSyntax } from '../syntax.js';
+import { getParsedSyntax } from '../config.js';
+import { validateURL } from './url.js';
+
+function validateImage(token) {
+    if (token.typ == EnumToken.UrlFunctionTokenType) {
+        return validateURL(token);
+    }
+    if (token.typ == EnumToken.ImageFunctionTokenType) {
+        return validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, token.val + '()'), token.chi);
+    }
+    return {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        node: token,
+        syntax: 'image()',
+        error: 'expected <image> or <url>',
+        tokens: []
+    };
+}
+
+export { validateImage };

package/dist/lib/validation/syntaxes/keyframe-block-list.js

@@ -7,7 +7,7 @@ import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 import { validateKeyframeSelector } from './keyframe-selector.js';
 
-function validateKeyframeBlockList(tokens, atRule) {
+function validateKeyframeBlockList(tokens, atRule, options) {
     let i = 0;
     let j = 0;
     let result = null;

package/dist/lib/validation/syntaxes/keyframe-selector.js

@@ -7,7 +7,7 @@ import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 
-function validateKeyframeSelector(tokens, atRule) {
+function validateKeyframeSelector(tokens, atRule, options) {
     consumeWhitespace(tokens);
     if (tokens.length == 0) {
         // @ts-ignore

package/dist/lib/validation/syntaxes/layer-name.js

@@ -15,7 +15,7 @@ function validateLayerName(tokens) {
             acc[acc.length - 1].push(curr);
         }
         return acc;
-    }, [[]]).slice(1);
+    }, [[]]);
     for (let i = 0; i < slice.length; i++) {
         if (slice[i].length == 0) {
             // @ts-ignore
@@ -28,26 +28,15 @@ function validateLayerName(tokens) {
                 tokens
             };
         }
-        if (slice[i][0].typ != EnumToken.IdenTokenType) {
-            // @ts-ignore
-            return {
-                valid: ValidationLevel.Drop,
-                matches: tokens,
-                node: slice[i][0],
-                syntax: 'ident',
-                error: 'expecting ident',
-                tokens
-            };
-        }
-        for (let j = 1; j < slice[i].length; j++) {
-            if (slice[i][j].typ != EnumToken.ClassSelectorTokenType) {
+        for (let j = 0; j < slice[i].length; j++) {
+            if (slice[i][j].typ != EnumToken.IdenTokenType && slice[i][j].typ != EnumToken.ClassSelectorTokenType) {
                 // @ts-ignore
                 return {
                     valid: ValidationLevel.Drop,
                     matches: tokens,
                     node: slice[i][j],
-                    syntax: 'layer-name',
-                    error: 'expecting class selector',
+                    syntax: '<layer-name>',
+                    error: 'expecting ident or class selector',
                     tokens
                 };
             }

package/dist/lib/validation/syntaxes/relative-selector-list.js

@@ -1,4 +1,4 @@
-import { EnumToken, ValidationLevel } from '../../ast/types.js';
+import { ValidationLevel } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
@@ -6,22 +6,52 @@ import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 import { validateRelativeSelector } from './relative-selector.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
 
 function validateRelativeSelectorList(tokens, root, options) {
-    let i = 0;
-    let j = 0;
-    let result = null;
-    while (i + 1 < tokens.length) {
-        if (tokens[++i].typ == EnumToken.CommaTokenType) {
-            result = validateRelativeSelector(tokens.slice(j, i), root, options);
-            if (result.valid == ValidationLevel.Drop) {
-                return result;
-            }
-            j = i + 1;
-            i = j;
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: 'expecting relative selector list',
+            tokens
+        };
+    }
+    for (const t of splitTokenList(tokens)) {
+        if (t.length == 0) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                // @ts-ignore
+                node: root,
+                // @ts-ignore
+                syntax: null,
+                error: 'unexpected comma',
+                tokens
+            };
+        }
+        const result = validateRelativeSelector(t, root, options);
+        if (result.valid == ValidationLevel.Drop) {
+            return result;
         }
     }
-    return validateRelativeSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1), root, options);
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        // @ts-ignore
+        node: root,
+        // @ts-ignore
+        syntax: null,
+        error: '',
+        tokens
+    };
 }
 
 export { validateRelativeSelectorList };