@tbela99/css-parser 0.8.0 → 0.9.0

package/dist/lib/validation/at-rules/counter-style.js

@@ -15,7 +15,7 @@ function validateAtRuleCounterStyle(atRule, options, root) {
             matches: [],
             node: atRule,
             syntax: '@counter-style',
-            error: 'expected media query list',
+            error: 'expected counter style name',
             tokens: []
         };
     }
@@ -23,7 +23,7 @@ function validateAtRuleCounterStyle(atRule, options, root) {
     if (tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
+            valid: ValidationLevel.Drop,
             matches: [],
             node: atRule,
             syntax: '@counter-style',

package/dist/lib/validation/at-rules/custom-media.js

@@ -0,0 +1,52 @@
+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 { validateAtRuleMediaQueryList } from './media.js';
+
+function validateAtRuleCustomMedia(atRule, options, root) {
+    // media-query-list
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: null,
+            syntax: null,
+            error: '',
+            tokens: []
+        };
+    }
+    const queries = atRule.tokens.slice();
+    consumeWhitespace(queries);
+    if (queries.length == 0 || queries[0].typ != EnumToken.DashedIdenTokenType) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@custom-media',
+            error: 'expecting dashed identifier',
+            tokens: []
+        };
+    }
+    queries.shift();
+    const result = validateAtRuleMediaQueryList(queries, atRule);
+    if (result.valid == ValidationLevel.Drop) {
+        atRule.tokens = [];
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: atRule,
+            syntax: '@custom-media',
+            error: '',
+            tokens: []
+        };
+    }
+    return result;
+}
+
+export { validateAtRuleCustomMedia };

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

@@ -0,0 +1,5 @@
+import { validateAtRuleWhen } from './when.js';
+
+const validateAtRuleElse = validateAtRuleWhen;
+
+export { validateAtRuleElse };

package/dist/lib/validation/at-rules/font-feature-values.js

@@ -7,6 +7,9 @@ import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 import { validateFamilyName } from '../syntaxes/family-name.js';
 import '../syntaxes/complex-selector.js';
+import '../parser/types.js';
+import '../parser/parse.js';
+import '../config.js';
 
 function validateAtRuleFontFeatureValues(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {

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

@@ -10,6 +10,9 @@ import { validateAtRuleMediaQueryList } from './media.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { validateLayerName } from '../syntaxes/layer-name.js';
 import '../syntaxes/complex-selector.js';
+import '../parser/types.js';
+import '../parser/parse.js';
+import '../config.js';
 
 function validateAtRuleImport(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {

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

@@ -7,6 +7,9 @@ import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 import { validateLayerName } from '../syntaxes/layer-name.js';
 import '../syntaxes/complex-selector.js';
+import '../parser/types.js';
+import '../parser/parse.js';
+import '../config.js';
 
 function validateAtRuleLayer(atRule, options, root) {
     // media-query-list

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

@@ -13,15 +13,28 @@ function validateAtRuleMedia(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: null,
+            syntax: null,
+            error: '',
+            tokens: []
+        };
+    }
+    let result = null;
+    const slice = atRule.tokens.slice();
+    consumeWhitespace(slice);
+    if (slice.length == 0) {
+        return {
+            valid: ValidationLevel.Valid,
             matches: [],
             node: atRule,
             syntax: '@media',
-            error: 'expected media query list',
+            error: '',
             tokens: []
         };
     }
-    const result = validateAtRuleMediaQueryList(atRule.tokens, atRule);
+    result = validateAtRuleMediaQueryList(atRule.tokens, atRule);
     if (result.valid == ValidationLevel.Drop) {
         return result;
     }
@@ -47,10 +60,20 @@ function validateAtRuleMedia(atRule, options, root) {
     };
 }
 function validateAtRuleMediaQueryList(tokenList, atRule) {
-    for (const tokens of splitTokenList(tokenList)) {
+    const split = splitTokenList(tokenList);
+    const matched = [];
+    let result = null;
+    let previousToken;
+    let mediaFeatureType;
+    for (let i = 0; i < split.length; i++) {
+        const tokens = split[i].slice();
+        const match = [];
+        result = null;
+        mediaFeatureType = null;
+        previousToken = null;
         if (tokens.length == 0) {
             // @ts-ignore
-            return {
+            result = {
                 valid: ValidationLevel.Drop,
                 matches: [],
                 node: tokens[0] ?? atRule,
@@ -58,26 +81,38 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
                 error: 'unexpected token',
                 tokens: []
             };
+            continue;
         }
-        let previousToken = null;
         while (tokens.length > 0) {
-            // media-condition
-            if (validateMediaCondition(tokens[0])) {
-                previousToken = tokens[0];
-                tokens.shift();
-            }
-            // media-type
-            else if (validateMediaFeature(tokens[0])) {
-                previousToken = tokens[0];
-                tokens.shift();
+            previousToken = tokens[0];
+            // media-condition | media-type | custom-media
+            if (!(validateMediaCondition(tokens[0], atRule) || validateMediaFeature(tokens[0]) || validateCustomMediaCondition(tokens[0], atRule))) {
+                if (tokens[0].typ == EnumToken.ParensTokenType) {
+                    result = validateAtRuleMediaQueryList(tokens[0].chi, atRule);
+                }
+                else {
+                    result = {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0] ?? atRule,
+                        syntax: '@media',
+                        error: 'expecting media feature or media condition',
+                        tokens: []
+                    };
+                }
+                if (result.valid == ValidationLevel.Drop) {
+                    break;
+                }
+                result = null;
             }
+            match.push(tokens.shift());
             if (tokens.length == 0) {
                 break;
             }
             if (!consumeWhitespace(tokens)) {
                 if (previousToken?.typ != EnumToken.ParensTokenType) {
                     // @ts-ignore
-                    return {
+                    result = {
                         valid: ValidationLevel.Drop,
                         matches: [],
                         node: tokens[0] ?? atRule,
@@ -85,11 +120,12 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
                         error: 'expected media query list',
                         tokens: []
                     };
+                    break;
                 }
             }
-            if (![EnumToken.MediaFeatureOrTokenType, EnumToken.MediaFeatureAndTokenType].includes(tokens[0].typ)) {
+            else if (![EnumToken.MediaFeatureOrTokenType, EnumToken.MediaFeatureAndTokenType].includes(tokens[0].typ)) {
                 // @ts-ignore
-                return {
+                result = {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
@@ -97,31 +133,70 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
                     error: 'expected and/or',
                     tokens: []
                 };
+                break;
+            }
+            if (mediaFeatureType == null) {
+                mediaFeatureType = tokens[0];
             }
-            if (tokens.length == 1) {
+            if (mediaFeatureType.typ != tokens[0].typ) {
                 // @ts-ignore
-                return {
+                result = {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@media',
-                    error: 'expected media-condition',
+                    error: 'mixing and/or not allowed at the same level',
                     tokens: []
                 };
+                break;
             }
-            tokens.shift();
-            if (!consumeWhitespace(tokens)) {
+            match.push({ typ: EnumToken.WhitespaceTokenType }, tokens.shift());
+            consumeWhitespace(tokens);
+            if (tokens.length == 0) {
                 // @ts-ignore
-                return {
+                result = {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@media',
-                    error: 'expected whitespace',
+                    error: 'expected media-condition',
                     tokens: []
                 };
+                break;
             }
+            match.push({ typ: EnumToken.WhitespaceTokenType });
         }
+        if (result == null && match.length > 0) {
+            matched.push(match);
+        }
+    }
+    if (result != null) {
+        return result;
+    }
+    if (matched.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@media',
+            error: 'expected media query list',
+            tokens: []
+        };
+    }
+    tokenList.length = 0;
+    let hasAll = false;
+    for (let i = 0; i < matched.length; i++) {
+        if (tokenList.length > 0) {
+            tokenList.push({ typ: EnumToken.CommaTokenType });
+        }
+        if (matched[i].length == 1 && matched.length > 1 && matched[i][0].typ == EnumToken.MediaFeatureTokenType && matched[i][0].val == 'all') {
+            hasAll = true;
+            continue;
+        }
+        tokenList.push(...matched[i]);
+    }
+    if (hasAll && tokenList.length == 0) {
+        tokenList.push({ typ: EnumToken.MediaFeatureTokenType, val: 'all' });
     }
     // @ts-ignore
     return {
@@ -133,9 +208,9 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
         tokens: []
     };
 }
-function validateMediaCondition(token) {
+function validateCustomMediaCondition(token, atRule) {
     if (token.typ == EnumToken.MediaFeatureNotTokenType) {
-        return validateMediaCondition(token.val);
+        return validateMediaCondition(token.val, atRule);
     }
     if (token.typ != EnumToken.ParensTokenType) {
         return false;
@@ -144,11 +219,24 @@ function validateMediaCondition(token) {
     if (chi.length != 1) {
         return false;
     }
+    return chi[0].typ == EnumToken.DashedIdenTokenType;
+}
+function validateMediaCondition(token, atRule) {
+    if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+        return validateMediaCondition(token.val, atRule);
+    }
+    if (token.typ != EnumToken.ParensTokenType && !(['when', 'else'].includes(atRule.nam) && token.typ == EnumToken.FunctionTokenType && ['media', 'supports'].includes(token.val))) {
+        return false;
+    }
+    const chi = token.chi.filter((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+    if (chi.length != 1) {
+        return false;
+    }
     if (chi[0].typ == EnumToken.IdenTokenType) {
         return true;
     }
     if (chi[0].typ == EnumToken.MediaFeatureNotTokenType) {
-        return validateMediaCondition(chi[0].val);
+        return validateMediaCondition(chi[0].val, atRule);
     }
     if (chi[0].typ == EnumToken.MediaQueryConditionTokenType) {
         return chi[0].l.typ == EnumToken.IdenTokenType;
@@ -163,4 +251,4 @@ function validateMediaFeature(token) {
     return val.typ == EnumToken.MediaFeatureTokenType;
 }
 
-export { validateAtRuleMedia, validateAtRuleMediaQueryList };
+export { validateAtRuleMedia, validateAtRuleMediaQueryList, validateMediaCondition, validateMediaFeature };

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

@@ -19,7 +19,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 +37,7 @@ function validateAtRuleSupports(atRule, options, root) {
             valid: ValidationLevel.Drop,
             matches: [],
             node: atRule,
-            syntax: '@supports',
+            syntax: '@' + atRule.nam,
             error: 'expected at-rule body',
             tokens: []
         };
@@ -47,7 +47,7 @@ function validateAtRuleSupports(atRule, options, root) {
         valid: ValidationLevel.Valid,
         matches: [],
         node: atRule,
-        syntax: '@supports',
+        syntax: '@' + atRule.nam,
         error: '',
         tokens: []
     };
@@ -60,7 +60,7 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                 valid: ValidationLevel.Drop,
                 matches: [],
                 node: tokens[0] ?? atRule,
-                syntax: '@supports',
+                syntax: '@' + atRule.nam,
                 error: 'unexpected token',
                 tokens: []
             };
@@ -94,7 +94,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 +106,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 +117,7 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
-                    syntax: '@supports',
+                    syntax: '@' + atRule.nam,
                     error: 'expected supports-condition',
                     tokens: []
                 };
@@ -129,7 +129,7 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                     valid: ValidationLevel.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
-                    syntax: '@supports',
+                    syntax: '@' + atRule.nam,
                     error: 'expected whitespace',
                     tokens: []
                 };
@@ -142,13 +142,13 @@ 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 +163,7 @@ function validateSupportCondition(atRule, token) {
             valid: ValidationLevel.Valid,
             matches: [],
             node: null,
-            syntax: '@supports',
+            syntax: '@' + atRule.nam,
             error: '',
             tokens: []
         };

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