@tbela99/css-parser 0.8.0 → 0.9.1

package/dist/lib/validation/at-rules/supports.js

@@ -1,15 +1,14 @@
 import { ValidationLevel, EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
-import '../../parser/parse.js';
+import { parseSelector } from '../../parser/parse.js';
 import { colorFontTech, fontFeaturesTech, fontFormat } 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 { splitTokenList } from '../utils/list.js';
-import { validateSyntax } from '../syntax.js';
-import { getParsedSyntax } from '../config.js';
+import { validateComplexSelector } from '../syntaxes/complex-selector.js';
 
 function validateAtRuleSupports(atRule, options, root) {
     // media-query-list
@@ -19,7 +18,7 @@ function validateAtRuleSupports(atRule, options, root) {
             valid: ValidationLevel.Drop,
             matches: [],
             node: atRule,
-            syntax: '@supports',
+            syntax: '@' + atRule.nam,
             error: 'expected supports query list',
             tokens: []
         };
@@ -37,7 +36,7 @@ function validateAtRuleSupports(atRule, options, root) {
             valid: ValidationLevel.Drop,
             matches: [],
             node: atRule,
-            syntax: '@supports',
+            syntax: '@' + atRule.nam,
             error: 'expected at-rule body',
             tokens: []
         };
@@ -47,12 +46,13 @@ function validateAtRuleSupports(atRule, options, root) {
         valid: ValidationLevel.Valid,
         matches: [],
         node: atRule,
-        syntax: '@supports',
+        syntax: '@' + atRule.nam,
         error: '',
         tokens: []
     };
 }
 function validateAtRuleSupportsConditions(atRule, tokenList) {
+    let result = null;
     for (const tokens of splitTokenList(tokenList)) {
         if (tokens.length == 0) {
             // @ts-ignore
@@ -60,28 +60,52 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                 valid: ValidationLevel.Drop,
                 matches: [],
                 node: tokens[0] ?? atRule,
-                syntax: '@supports',
+                syntax: '@' + atRule.nam,
                 error: 'unexpected token',
                 tokens: []
             };
         }
         let previousToken = null;
-        let result = null;
         while (tokens.length > 0) {
             result = validateSupportCondition(atRule, tokens[0]);
             // supports-condition
-            if (result == null || result.valid == ValidationLevel.Valid) {
+            if (result.valid == ValidationLevel.Valid) {
                 previousToken = tokens[0];
                 tokens.shift();
             }
             else {
                 result = validateSupportFeature(tokens[0]);
-                if (result == null || result.valid == ValidationLevel.Valid) {
+                if ( /*result == null || */result.valid == ValidationLevel.Valid) {
                     previousToken = tokens[0];
                     tokens.shift();
                 }
                 else {
-                    return result;
+                    if (tokens[0].typ == EnumToken.ParensTokenType) {
+                        result = validateAtRuleSupportsConditions(atRule, tokens[0].chi);
+                        if ( /* result == null || */result.valid == ValidationLevel.Valid) {
+                            previousToken = tokens[0];
+                            tokens.shift();
+                            // continue;
+                        }
+                        else {
+                            return result;
+                        }
+                    }
+                    else {
+                        return result;
+                    }
+                    // if (result!= null && result.valid == ValidationLevel.Drop) {
+                    //
+                    //     return  {
+                    //         valid: ValidationLevel.Drop,
+                    //         matches: [],
+                    //         node: tokens[0] ?? atRule,
+                    //         syntax: '@' + atRule.nam,
+                    //         // @ts-ignore
+                    //         error: result.error as string ?? 'unexpected token',
+                    //         tokens: []
+                    //     };
+                    // }
                 }
             }
             if (tokens.length == 0) {
@@ -94,7 +118,7 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                         valid: ValidationLevel.Drop,
                         matches: [],
                         node: tokens[0] ?? previousToken ?? atRule,
-                        syntax: '@supports',
+                        syntax: '@' + atRule.nam,
                         error: 'expected whitespace',
                         tokens: []
                     };
@@ -106,7 +130,7 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
-                    syntax: '@supports',
+                    syntax: '@' + atRule.nam,
                     error: 'expected and/or',
                     tokens: []
                 };
@@ -117,7 +141,7 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
-                    syntax: '@supports',
+                    syntax: '@' + atRule.nam,
                     error: 'expected supports-condition',
                     tokens: []
                 };
@@ -129,26 +153,33 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
-                    syntax: '@supports',
+                    syntax: '@' + atRule.nam,
                     error: 'expected whitespace',
                     tokens: []
                 };
             }
         }
     }
-    return null;
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@' + atRule.nam,
+        error: '',
+        tokens: []
+    };
 }
 function validateSupportCondition(atRule, token) {
     if (token.typ == EnumToken.MediaFeatureNotTokenType) {
         return validateSupportCondition(atRule, token.val);
     }
-    if (token.typ != EnumToken.ParensTokenType) {
+    if (token.typ != EnumToken.ParensTokenType && !(['when', 'else'].includes(atRule.nam) && token.typ == EnumToken.FunctionTokenType && ['supports', 'font-format', 'font-tech'].includes(token.val))) {
         // @ts-ignore
         return {
             valid: ValidationLevel.Drop,
             matches: [],
             node: token,
-            syntax: '@supports',
+            syntax: '@' + atRule.nam,
             error: 'expected supports condition-in-parens',
             tokens: []
         };
@@ -163,7 +194,7 @@ function validateSupportCondition(atRule, token) {
             valid: ValidationLevel.Valid,
             matches: [],
             node: null,
-            syntax: '@supports',
+            syntax: '@' + atRule.nam,
             error: '',
             tokens: []
         };
@@ -203,7 +234,7 @@ function validateSupportCondition(atRule, token) {
 function validateSupportFeature(token) {
     if (token.typ == EnumToken.FunctionTokenType) {
         if (token.val.localeCompare('selector', undefined, { sensitivity: 'base' }) == 0) {
-            return validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, 'complex-selector'), token.chi);
+            return validateComplexSelector(parseSelector(token.chi));
         }
         if (token.val.localeCompare('font-tech', undefined, { sensitivity: 'base' }) == 0) {
             const chi = token.chi.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));

package/dist/lib/validation/at-rules/when.js

@@ -0,0 +1,178 @@
+import { ValidationLevel, EnumToken } 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 { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
+import { validateMediaFeature, validateMediaCondition } from './media.js';
+import { validateSupportCondition } from './supports.js';
+
+function validateAtRuleWhen(atRule, options, root) {
+    const slice = Array.isArray(atRule.tokens) ? atRule.tokens.slice() : [];
+    consumeWhitespace(slice);
+    if (slice.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: atRule,
+            syntax: '@when',
+            error: '',
+            tokens: []
+        };
+    }
+    const result = validateAtRuleWhenQueryList(atRule.tokens, atRule);
+    if (result.valid == ValidationLevel.Drop) {
+        return result;
+    }
+    if (!('chi' in atRule)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@when',
+            error: 'expected at-rule body',
+            tokens: []
+        };
+    }
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@when',
+        error: '',
+        tokens: result.tokens
+    };
+}
+// media() = media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )
+// supports() = supports( <declaration> )
+function validateAtRuleWhenQueryList(tokenList, atRule) {
+    const matched = [];
+    let result = null;
+    for (const split of splitTokenList(tokenList)) {
+        const match = [];
+        result = null;
+        consumeWhitespace(split);
+        if (split.length == 0) {
+            continue;
+        }
+        while (split.length > 0) {
+            if (split[0].typ != EnumToken.FunctionTokenType || !['media', 'supports', 'font-tech', 'font-format'].includes(split[0].val)) {
+                result = {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: split[0] ?? atRule,
+                    syntax: '@when',
+                    error: 'unexpected token',
+                    tokens: []
+                };
+                break;
+            }
+            const chi = split[0].chi.slice();
+            consumeWhitespace(chi);
+            if (split[0].val == 'media') {
+                // result = valida
+                if (chi.length != 1 || !(validateMediaFeature(chi[0]) || validateMediaCondition(split[0], atRule))) {
+                    result = {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: split[0] ?? atRule,
+                        syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
+                        error: 'unexpected token',
+                        tokens: []
+                    };
+                    break;
+                }
+            }
+            else if (['supports', 'font-tech', 'font-format'].includes(split[0].val)) {
+                // result = valida
+                if (!validateSupportCondition(atRule, split[0])) {
+                    result = {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: split[0] ?? atRule,
+                        syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
+                        error: 'unexpected token',
+                        tokens: []
+                    };
+                    break;
+                }
+            }
+            if (match.length > 0) {
+                match.push({ typ: EnumToken.WhitespaceTokenType });
+            }
+            match.push(split.shift());
+            consumeWhitespace(split);
+            if (split.length == 0) {
+                break;
+            }
+            if (![EnumToken.MediaFeatureAndTokenType, EnumToken.MediaFeatureOrTokenType].includes(split[0].typ)) {
+                result = {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: split[0] ?? atRule,
+                    syntax: '@when',
+                    error: 'expecting and/or media-condition',
+                    tokens: []
+                };
+                break;
+            }
+            if (match.length > 0) {
+                match.push({ typ: EnumToken.WhitespaceTokenType });
+            }
+            match.push(split.shift());
+            consumeWhitespace(split);
+            if (split.length == 0) {
+                result = {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: split[0] ?? atRule,
+                    syntax: '@when',
+                    error: 'expecting media-condition',
+                    tokens: []
+                };
+                break;
+            }
+        }
+        if (result == null && match.length > 0) {
+            matched.push(match);
+        }
+    }
+    if (result != null) {
+        return result;
+    }
+    if (matched.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: result?.node ?? atRule,
+            syntax: '@when',
+            error: 'invalid at-rule body',
+            tokens: []
+        };
+    }
+    tokenList.length = 0;
+    for (const match of matched) {
+        if (tokenList.length > 0) {
+            tokenList.push({
+                typ: EnumToken.CommaTokenType
+            });
+        }
+        tokenList.push(...match);
+    }
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@when',
+        error: '',
+        tokens: tokenList
+    };
+}
+
+export { validateAtRuleWhen, validateAtRuleWhenQueryList };

package/dist/lib/validation/atrule.js

@@ -5,7 +5,7 @@ import '../parser/parse.js';
 import '../renderer/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
 import '../parser/utils/config.js';
-import { getParsedSyntax, getSyntaxConfig } from './config.js';
+import { getSyntaxConfig, getParsedSyntax } from './config.js';
 import { validateAtRuleMedia } from './at-rules/media.js';
 import { validateAtRuleCounterStyle } from './at-rules/counter-style.js';
 import { validateAtRulePage } from './at-rules/page.js';
@@ -17,6 +17,10 @@ import { validateAtRuleFontFeatureValues } from './at-rules/font-feature-values.
 import { validateAtRuleNamespace } from './at-rules/namespace.js';
 import { validateAtRuleDocument } from './at-rules/document.js';
 import { validateAtRuleKeyframes } from './at-rules/keyframes.js';
+import { validateAtRuleWhen } from './at-rules/when.js';
+import { validateAtRuleElse } from './at-rules/else.js';
+import { validateAtRuleContainer } from './at-rules/container.js';
+import { validateAtRuleCustomMedia } from './at-rules/custom-media.js';
 
 function validateAtRule(atRule, options, root) {
     if (atRule.nam == 'charset') {
@@ -60,9 +64,21 @@ function validateAtRule(atRule, options, root) {
     if (atRule.nam == 'namespace') {
         return validateAtRuleNamespace(atRule);
     }
+    if (atRule.nam == 'when') {
+        return validateAtRuleWhen(atRule);
+    }
+    if (atRule.nam == 'else') {
+        return validateAtRuleElse(atRule);
+    }
+    if (atRule.nam == 'container') {
+        return validateAtRuleContainer(atRule);
+    }
     if (atRule.nam == 'document') {
         return validateAtRuleDocument(atRule);
     }
+    if (atRule.nam == 'custom-media') {
+        return validateAtRuleCustomMedia(atRule);
+    }
     if (['position-try', 'property', 'font-palette-values'].includes(atRule.nam)) {
         if (!('tokens' in atRule)) {
             return {
@@ -132,15 +148,14 @@ function validateAtRule(atRule, options, root) {
         }
     }
     if (!(name in config.atRules)) {
-        //     if (root?.typ == EnumToken.AtRuleNodeType) {
-        //
-        //         const syntaxes: ValidationToken = (getParsedSyntax(ValidationSyntaxGroupEnum.AtRules, '@' + (root as AstAtRule).nam) as ValidationToken[])?.[0];
-        //
-        //         if ('chi' in syntaxes) {
-        //
-        //             return validateSyntax(syntaxes.chi as ValidationToken[], [atRule], root, options);
-        //         }
-        //     }
+        if (options.lenient) {
+            return {
+                valid: ValidationLevel.Lenient,
+                node: atRule,
+                syntax: null,
+                error: ''
+            };
+        }
         return {
             valid: ValidationLevel.Drop,
             node: atRule,

package/dist/lib/validation/config.js

@@ -1,6 +1,6 @@
 import config from './config.json.js';
 import './parser/types.js';
-import { parseSyntax, walkValidationToken, renderSyntax } from './parser/parse.js';
+import { parseSyntax } from './parser/parse.js';
 
 const parsedSyntaxes = new Map();
 Object.freeze(config);
@@ -9,25 +9,30 @@ function getSyntaxConfig() {
     return config;
 }
 function getParsedSyntax(group, key) {
-    if (!(key in config[group])) {
-        const matches = key.match(/(@?)(-[a-zA-Z]+)-(.*?)$/);
-        if (matches != null) {
-            key = matches[1] + matches[3];
-        }
-        if (!(key in config[group])) {
-            return null;
+    // @ts-ignore
+    let obj = config[group];
+    const keys = Array.isArray(key) ? key : [key];
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        if (!(key in obj)) {
+            if ((i == 0 && key.charAt(0) == '@') || key.charAt(0) == '-') {
+                const matches = key.match(/^(@?)(-[a-zA-Z]+)-(.*?)$/);
+                if (matches != null) {
+                    key = matches[1] + matches[3];
+                }
+            }
+            if (!(key in obj)) {
+                return null;
+            }
         }
+        // @ts-ignore
+        obj = obj[key];
     }
-    const index = group + '.' + key;
+    const index = group + '.' + keys.join('.');
     // @ts-ignore
     if (!parsedSyntaxes.has(index)) {
         // @ts-ignore
-        const syntax = parseSyntax(config[group][key].syntax);
-        for (const node of syntax.chi) {
-            for (const { token, parent } of walkValidationToken(node)) {
-                token.text = renderSyntax(token);
-            }
-        }
+        const syntax = parseSyntax(obj.syntax);
         // @ts-ignore
         parsedSyntaxes.set(index, syntax.chi);
     }