@tbela99/css-parser 0.8.0 → 0.9.0

package/dist/lib/validation/parser/parse.js

@@ -1,6 +1,20 @@
 import { ValidationTokenEnum } from './types.js';
 import { isIdent, isPseudo } from '../../syntax/syntax.js';
 
+var WalkValidationTokenEnum;
+(function (WalkValidationTokenEnum) {
+    WalkValidationTokenEnum[WalkValidationTokenEnum["IgnoreChildren"] = 0] = "IgnoreChildren";
+    WalkValidationTokenEnum[WalkValidationTokenEnum["IgnoreNode"] = 1] = "IgnoreNode";
+    WalkValidationTokenEnum[WalkValidationTokenEnum["IgnoreAll"] = 2] = "IgnoreAll";
+})(WalkValidationTokenEnum || (WalkValidationTokenEnum = {}));
+var WalkValidationTokenKeyTypeEnum;
+(function (WalkValidationTokenKeyTypeEnum) {
+    WalkValidationTokenKeyTypeEnum["Array"] = "array";
+    WalkValidationTokenKeyTypeEnum["Children"] = "chi";
+    WalkValidationTokenKeyTypeEnum["Left"] = "l";
+    WalkValidationTokenKeyTypeEnum["Right"] = "r";
+    WalkValidationTokenKeyTypeEnum["Prelude"] = "prelude";
+})(WalkValidationTokenKeyTypeEnum || (WalkValidationTokenKeyTypeEnum = {}));
 const skipped = [
     ValidationTokenEnum.Star,
     ValidationTokenEnum.HashMark,
@@ -167,13 +181,66 @@ function* tokenize(syntax, position = { ind: 0, lin: 1, col: 0 }, currentPositio
         yield getTokenType(buffer, position, currentPosition);
     }
 }
+function columnCallback(token, parent, key) {
+    if (key == WalkValidationTokenKeyTypeEnum.Prelude) {
+        return WalkValidationTokenEnum.IgnoreAll;
+    }
+    if (token.typ == ValidationTokenEnum.ColumnToken || token.typ == ValidationTokenEnum.Whitespace) {
+        return WalkValidationTokenEnum.IgnoreNode;
+    }
+    return WalkValidationTokenEnum.IgnoreChildren;
+}
+function toColumnArray(ast, parent) {
+    const result = new Map;
+    // @ts-ignore
+    for (const { token } of walkValidationToken(ast, null, columnCallback)) {
+        result.set(JSON.stringify(token), token);
+    }
+    const node = {
+        typ: ValidationTokenEnum.ColumnArrayToken,
+        chi: [...result.values()]
+    };
+    if (parent != null) {
+        replaceNode(parent, ast, node);
+    }
+    return node;
+}
+function replaceNode(parent, target, node) {
+    if ('l' in parent && parent.l == target) {
+        parent.l = node;
+    }
+    if ('r' in parent && parent.r == target) {
+        parent.r = node;
+    }
+    if ('chi' in parent) {
+        // @ts-ignore
+        for (let i = 0; i < parent.chi.length; i++) {
+            // @ts-ignore
+            if (parent.chi[i] == target) {
+                // @ts-ignore
+                parent.chi[i] = node;
+                break;
+            }
+        }
+    }
+}
+function transform(context) {
+    for (const { token, parent } of walkValidationToken(context)) {
+        switch (token.typ) {
+            case ValidationTokenEnum.ColumnToken:
+                toColumnArray(token, parent);
+                break;
+        }
+    }
+    return context;
+}
 function parseSyntax(syntax) {
     const root = Object.defineProperty({
         typ: ValidationTokenEnum.Root,
         chi: []
     }, 'pos', { ...objectProperties, value: { ind: 0, lin: 1, col: 0 } });
     // return minify(doParseSyntax(syntaxes, tokenize(syntaxes), root)) as ValidationRootToken;
-    return minify(doParseSyntax(syntax, tokenize(syntax), root));
+    return minify(transform(doParseSyntax(syntax, tokenize(syntax), root)));
 }
 function matchParens(syntax, iterator) {
     let item;
@@ -941,6 +1008,10 @@ function renderSyntax(token, parent) {
                 (token.chi == null ? '' : ' {\n' + token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '')).slice(1, -1) + '\n}';
         case ValidationTokenEnum.Block:
             return '{' + token.chi.reduce((acc, t) => acc + renderSyntax(t), '') + '}';
+        case ValidationTokenEnum.DeclarationDefinitionToken:
+            return token.nam + ': ' + renderSyntax(token.val);
+        case ValidationTokenEnum.ColumnArrayToken:
+            return token.chi.reduce((acc, curr) => acc + (acc.trim().length > 0 ? '||' : '') + renderSyntax(curr), '');
         default:
             throw new Error('Unhandled token: ' + JSON.stringify({ token }));
     }
@@ -1032,37 +1103,44 @@ function minify(ast) {
     }
     return ast;
 }
-function* walkValidationToken(token, parent, callback) {
+function* walkValidationToken(token, parent, callback, key) {
     if (Array.isArray(token)) {
         for (const child of token) {
-            yield* walkValidationToken(child, parent);
+            yield* walkValidationToken(child, parent, callback, WalkValidationTokenKeyTypeEnum.Array);
         }
         return;
     }
-    yield { token, parent };
-    if ('prelude' in token) {
+    let action = null;
+    if (callback != null) {
+        // @ts-ignore
+        action = callback(token, parent, key);
+    }
+    if (action != WalkValidationTokenEnum.IgnoreNode && action != WalkValidationTokenEnum.IgnoreAll) {
+        yield { token, parent };
+    }
+    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'prelude' in token) {
         for (const child of token.prelude) {
-            yield* walkValidationToken(child, token);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Prelude);
         }
     }
-    if ('chi' in token) {
+    if (action != WalkValidationTokenEnum.IgnoreChildren && 'chi' in token) {
         // @ts-ignore
         for (const child of token.chi) {
-            yield* walkValidationToken(child, token);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Children);
         }
     }
-    if ('l' in token) {
+    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'l' in token) {
         // @ts-ignore
         for (const child of token.l) {
-            yield* walkValidationToken(child, token);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Left);
         }
     }
-    if ('r' in token) {
+    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'r' in token) {
         // @ts-ignore
         for (const child of token.r) {
-            yield* walkValidationToken(child, token);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Right);
         }
     }
 }
 
-export { parseSyntax, renderSyntax, walkValidationToken };
+export { WalkValidationTokenEnum, WalkValidationTokenKeyTypeEnum, parseSyntax, renderSyntax, walkValidationToken };

package/dist/lib/validation/parser/types.js

@@ -41,6 +41,7 @@ var ValidationTokenEnum;
     ValidationTokenEnum[ValidationTokenEnum["DeclarationDefinitionToken"] = 37] = "DeclarationDefinitionToken";
     ValidationTokenEnum[ValidationTokenEnum["SemiColon"] = 38] = "SemiColon";
     ValidationTokenEnum[ValidationTokenEnum["Character"] = 39] = "Character";
+    ValidationTokenEnum[ValidationTokenEnum["ColumnArrayToken"] = 40] = "ColumnArrayToken";
 })(ValidationTokenEnum || (ValidationTokenEnum = {}));
 var ValidationSyntaxGroupEnum;
 (function (ValidationSyntaxGroupEnum) {

package/dist/lib/validation/selector.js

@@ -8,11 +8,14 @@ import '../parser/utils/config.js';
 import { validateRelativeSelectorList } from './syntaxes/relative-selector-list.js';
 import './syntaxes/complex-selector.js';
 import { validateKeyframeBlockList } from './syntaxes/keyframe-block-list.js';
+import './parser/types.js';
+import './parser/parse.js';
+import './config.js';
 import { validateSelectorList } from './syntaxes/selector-list.js';
 
 function validateSelector(selector, options, root) {
     if (root == null) {
-        return validateRelativeSelectorList(selector, root);
+        return validateSelectorList(selector, root, options);
     }
     // @ts-ignore
     if (root.typ == EnumToken.AtRuleNodeType && root.nam.match(/^(-[a-z]+-)?keyframes$/)) {
@@ -25,14 +28,14 @@ function validateSelector(selector, options, root) {
             isNested++;
             if (isNested > 0) {
                 // @ts-ignore
-                return validateRelativeSelectorList(selector, root, { nestedSelector: true });
+                return validateRelativeSelectorList(selector, root, { ...(options ?? {}), nestedSelector: true });
             }
         }
         currentRoot = currentRoot.parent;
     }
     const nestedSelector = isNested > 0;
     // @ts-ignore
-    return nestedSelector ? validateRelativeSelectorList(selector, root, { nestedSelector }) : validateSelectorList(selector, root, { nestedSelector });
+    return nestedSelector ? validateRelativeSelectorList(selector, root, { ...(options ?? {}), nestedSelector }) : validateSelectorList(selector, root, { ...(options ?? {}), nestedSelector });
 }
 
 export { validateSelector };

package/dist/lib/validation/syntax.js

@@ -1,5 +1,5 @@
 import { ValidationTokenEnum, specialValues } from './parser/types.js';
-import './parser/parse.js';
+import { renderSyntax } from './parser/parse.js';
 import { ValidationLevel, EnumToken, funcLike } from '../ast/types.js';
 import '../ast/minify.js';
 import '../ast/walk.js';
@@ -8,8 +8,10 @@ import { isLength } from '../syntax/syntax.js';
 import '../parser/utils/config.js';
 import '../renderer/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
-import { getParsedSyntax, getSyntaxConfig } from './config.js';
+import { getSyntaxConfig, getParsedSyntax } from './config.js';
 import { validateSelector } from './selector.js';
+import './syntaxes/complex-selector.js';
+import { validateImage } from './syntaxes/image.js';
 
 const config = getSyntaxConfig();
 function consumeToken(tokens) {
@@ -30,6 +32,12 @@ function splice(tokens, matches) {
     return tokens;
 }
 function validateSyntax(syntaxes, tokens, root, options, context = { level: 0 }) {
+    console.error(JSON.stringify({
+        syntax: syntaxes.reduce((acc, curr) => acc + renderSyntax(curr), ''),
+        syntaxes,
+        tokens,
+        s: new Error('bar').stack
+    }, null, 1));
     if (syntaxes == null) {
         // @ts-ignore
         return {
@@ -485,7 +493,7 @@ function validateSyntax(syntaxes, tokens, root, options, context = { level: 0 })
     return result;
 }
 function isOptionalSyntax(syntaxes) {
-    return syntaxes.every(t => t.typ == ValidationTokenEnum.Whitespace || t.isOptional || t.isRepeatable || (t.typ == ValidationTokenEnum.PropertyType && isOptionalSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, t.val) ?? getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, t.val))));
+    return syntaxes.length > 0 && syntaxes.every(t => t.typ == ValidationTokenEnum.Whitespace || t.isOptional || t.isRepeatable || (t.typ == ValidationTokenEnum.PropertyType && isOptionalSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, t.val) ?? getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, t.val) ?? [])));
 }
 function doValidateSyntax(syntax, token, tokens, root, options, context) {
     let valid = false;
@@ -706,7 +714,21 @@ function doValidateSyntax(syntax, token, tokens, root, options, context) {
             break;
         case ValidationTokenEnum.PropertyType:
             //
-            if (['media-feature', 'mf-plain'].includes(syntax.val)) {
+            if ('image' == syntax.val) {
+                valid = token.typ == EnumToken.UrlFunctionTokenType || token.typ == EnumToken.ImageFunctionTokenType;
+                if (!valid) {
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: token,
+                        syntax,
+                        error: 'unexpected <image>',
+                        tokens
+                    };
+                }
+                result = validateImage(token);
+            }
+            else if (['media-feature', 'mf-plain'].includes(syntax.val)) {
                 valid = token.typ == EnumToken.DeclarationNodeType;
                 result = {
                     valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
@@ -751,6 +773,18 @@ function doValidateSyntax(syntax, token, tokens, root, options, context) {
             }
             else if (syntax.val == 'group-rule-body') {
                 valid = [EnumToken.AtRuleNodeType, EnumToken.RuleNodeType].includes(token.typ);
+                if (!valid && token.typ == EnumToken.DeclarationNodeType && root?.typ == EnumToken.AtRuleNodeType && root.nam == 'media') {
+                    // allowed only if nested rule
+                    let parent = root;
+                    while (parent != null) {
+                        if (parent.typ == EnumToken.RuleNodeType) {
+                            valid = true;
+                            break;
+                        }
+                        // @ts-ignore
+                        parent = parent.parent;
+                    }
+                }
                 // @ts-ignore
                 result = {
                     valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
@@ -1419,6 +1453,18 @@ function doValidateSyntax(syntax, token, tokens, root, options, context) {
                 tokens
             };
             break;
+        case ValidationTokenEnum.DeclarationDefinitionToken:
+            if (token.typ != EnumToken.DeclarationNodeType || token.nam != syntax.nam) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: token,
+                    syntax,
+                    error: '',
+                    tokens
+                };
+            }
+            return validateSyntax([syntax.val], token.val, root, options, context);
         default:
             throw new Error('not implemented: ' + JSON.stringify({ syntax, token, tokens }, null, 1));
     }

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

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

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
     };
 }