@tbela99/css-parser 1.0.0 → 1.1.0

package/dist/lib/validation/at-rules/page-margin-box.js

@@ -1,55 +1,52 @@
-import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import '../../parser/utils/config.js';
 
 function validateAtRulePageMarginBox(atRule, options, root) {
     if (Array.isArray(atRule.tokens) && atRule.tokens.length > 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: null,
             syntax: '@' + atRule.nam,
-            error: '',
-            tokens: []
+            error: ''
         };
     }
     if (!('chi' in atRule)) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@' + atRule.nam,
-            error: 'expected margin-box body',
-            tokens: []
+            error: 'expected margin-box body'
         };
     }
     for (const token of atRule.chi) {
         if (![EnumToken.DeclarationNodeType, EnumToken.CommentNodeType, EnumToken.WhitespaceTokenType].includes(token.typ)) {
             // @ts-ignore
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: token,
                 syntax: 'declaration-list',
-                error: 'expected margin-box body',
-                tokens: []
+                error: 'expected margin-box body'
             };
         }
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: null,
         syntax: '@' + atRule.nam,
-        error: '',
-        tokens: []
+        error: ''
     };
 }
 

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

@@ -1,10 +1,11 @@
-import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import '../../parser/utils/config.js';
 import { splitTokenList } from '../utils/list.js';
 
 function validateAtRulePage(atRule, options, root) {
@@ -12,7 +13,7 @@ function validateAtRulePage(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
+            valid: SyntaxValidationResult.Valid,
             matches: [],
             node: null,
             syntax: '@page',
@@ -25,7 +26,7 @@ function validateAtRulePage(atRule, options, root) {
         if (tokens.length == 0) {
             // @ts-ignore
             return {
-                valid: ValidationLevel.Drop,
+                valid: SyntaxValidationResult.Drop,
                 matches: [],
                 node: tokens[0] ?? atRule,
                 syntax: '@page',
@@ -44,7 +45,7 @@ function validateAtRulePage(atRule, options, root) {
             if (tokens[0].typ != EnumToken.WhitespaceTokenType) {
                 // @ts-ignore
                 return {
-                    valid: ValidationLevel.Drop,
+                    valid: SyntaxValidationResult.Drop,
                     matches: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@page',
@@ -63,7 +64,7 @@ function validateAtRulePage(atRule, options, root) {
                 if (tokens[0].typ != EnumToken.WhitespaceTokenType) {
                     // @ts-ignore
                     return {
-                        valid: ValidationLevel.Drop,
+                        valid: SyntaxValidationResult.Drop,
                         matches: [],
                         node: tokens[0] ?? atRule,
                         syntax: '@page',
@@ -76,7 +77,7 @@ function validateAtRulePage(atRule, options, root) {
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
+        valid: SyntaxValidationResult.Valid,
         matches: [],
         node: atRule,
         syntax: '@page',

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

@@ -1,21 +1,21 @@
-import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
-import { parseSelector } from '../../parser/parse.js';
-import { colorFontTech, fontFeaturesTech, fontFormat } from '../../syntax/syntax.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
+import { colorFontTech, fontFeaturesTech, fontFormat } from '../../syntax/syntax.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 { validateComplexSelector } from '../syntaxes/complex-selector.js';
 
 function validateAtRuleSupports(atRule, options, root) {
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             matches: [],
             node: atRule,
             syntax: '@' + atRule.nam,
@@ -33,22 +33,20 @@ function validateAtRuleSupports(atRule, options, root) {
     if (!('chi' in atRule)) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@' + atRule.nam,
-            error: 'expected at-rule body',
-            tokens: []
+            error: 'expected at-rule body'
         };
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@' + atRule.nam,
-        error: '',
-        tokens: []
+        error: ''
     };
 }
 function validateAtRuleSupportsConditions(atRule, tokenList) {
@@ -57,8 +55,8 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
         if (tokens.length == 0) {
             // @ts-ignore
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: tokens[0] ?? atRule,
                 syntax: '@' + atRule.nam,
                 error: 'unexpected token',
@@ -69,20 +67,20 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
         while (tokens.length > 0) {
             result = validateSupportCondition(atRule, tokens[0]);
             // supports-condition
-            if (result.valid == ValidationLevel.Valid) {
+            if (result.valid == SyntaxValidationResult.Valid) {
                 previousToken = tokens[0];
                 tokens.shift();
             }
             else {
                 result = validateSupportFeature(tokens[0]);
-                if ( /*result == null || */result.valid == ValidationLevel.Valid) {
+                if ( /*result == null || */result.valid == SyntaxValidationResult.Valid) {
                     previousToken = tokens[0];
                     tokens.shift();
                 }
                 else {
                     if (tokens[0].typ == EnumToken.ParensTokenType) {
                         result = validateAtRuleSupportsConditions(atRule, tokens[0].chi);
-                        if ( /* result == null || */result.valid == ValidationLevel.Valid) {
+                        if ( /* result == null || */result.valid == SyntaxValidationResult.Valid) {
                             previousToken = tokens[0];
                             tokens.shift();
                             // continue;
@@ -98,7 +96,7 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                     //
                     //     return  {
                     //         valid: ValidationLevel.Drop,
-                    //         matches: [],
+                    //         context: [],
                     //         node: tokens[0] ?? atRule,
                     //         syntax: '@' + atRule.nam,
                     //         // @ts-ignore
@@ -115,73 +113,66 @@ function validateAtRuleSupportsConditions(atRule, tokenList) {
                 if (previousToken?.typ != EnumToken.ParensTokenType) {
                     // @ts-ignore
                     return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: tokens[0] ?? previousToken ?? atRule,
                         syntax: '@' + atRule.nam,
-                        error: 'expected whitespace',
-                        tokens: []
+                        error: 'expected whitespace'
                     };
                 }
             }
             if (![EnumToken.MediaFeatureOrTokenType, EnumToken.MediaFeatureAndTokenType].includes(tokens[0].typ)) {
                 // @ts-ignore
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@' + atRule.nam,
-                    error: 'expected and/or',
-                    tokens: []
+                    error: 'expected and/or'
                 };
             }
             if (tokens.length == 1) {
                 // @ts-ignore
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@' + atRule.nam,
-                    error: 'expected supports-condition',
-                    tokens: []
+                    error: 'expected supports-condition'
                 };
             }
             tokens.shift();
             if (!consumeWhitespace(tokens)) {
                 // @ts-ignore
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@' + atRule.nam,
-                    error: 'expected whitespace',
-                    tokens: []
+                    error: 'expected whitespace'
                 };
             }
         }
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@' + atRule.nam,
-        error: '',
-        tokens: []
+        error: ''
     };
 }
 function validateSupportCondition(atRule, token) {
     if (token.typ == EnumToken.MediaFeatureNotTokenType) {
         return validateSupportCondition(atRule, token.val);
     }
-    if (token.typ != EnumToken.ParensTokenType && !(['when', 'else'].includes(atRule.nam) && token.typ == EnumToken.FunctionTokenType && ['supports', 'font-format', 'font-tech'].includes(token.val))) {
-        // @ts-ignore
+    if (token.typ == EnumToken.FunctionTokenType && token.val.localeCompare('selector', undefined, { sensitivity: 'base' }) == 0) {
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: token,
             syntax: '@' + atRule.nam,
-            error: 'expected supports condition-in-parens',
-            tokens: []
+            error: ''
         };
     }
     const chi = token.chi.filter((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
@@ -191,12 +182,11 @@ function validateSupportCondition(atRule, token) {
     if (chi[0].typ == EnumToken.IdenTokenType) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: null,
             syntax: '@' + atRule.nam,
-            error: '',
-            tokens: []
+            error: ''
         };
     }
     if (chi[0].typ == EnumToken.MediaFeatureNotTokenType) {
@@ -206,55 +196,59 @@ function validateSupportCondition(atRule, token) {
         // @ts-ignore
         return chi[0].l.typ == EnumToken.IdenTokenType && chi[0].op.typ == EnumToken.ColonTokenType ?
             {
-                valid: ValidationLevel.Valid,
-                matches: [],
+                valid: SyntaxValidationResult.Valid,
+                context: [],
                 node: null,
                 syntax: 'supports-condition',
-                error: '',
-                tokens: []
+                error: ''
             } : {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: token,
             syntax: 'supports-condition',
-            error: 'expected supports condition-in-parens',
-            tokens: []
+            error: 'expected supports condition-in-parens'
         };
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Drop,
-        matches: [],
+        valid: SyntaxValidationResult.Drop,
+        context: [],
         node: token,
         syntax: 'supports-condition',
-        error: 'expected supports condition-in-parens',
-        tokens: []
+        error: 'expected supports condition-in-parens'
     };
 }
 function validateSupportFeature(token) {
+    if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+        return validateSupportFeature(token.val);
+    }
     if (token.typ == EnumToken.FunctionTokenType) {
         if (token.val.localeCompare('selector', undefined, { sensitivity: 'base' }) == 0) {
-            return validateComplexSelector(parseSelector(token.chi));
+            return {
+                valid: SyntaxValidationResult.Valid,
+                context: [],
+                node: token,
+                syntax: 'selector',
+                error: ''
+            };
         }
         if (token.val.localeCompare('font-tech', undefined, { sensitivity: 'base' }) == 0) {
             const chi = token.chi.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
             // @ts-ignore
             return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && colorFontTech.concat(fontFeaturesTech).some((t) => t.localeCompare(chi[0].val, undefined, { sensitivity: 'base' }) == 0) ?
                 {
-                    valid: ValidationLevel.Valid,
-                    matches: [],
+                    valid: SyntaxValidationResult.Valid,
+                    context: [],
                     node: token,
                     syntax: 'font-tech',
-                    error: '',
-                    tokens: []
+                    error: ''
                 } :
                 {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: token,
                     syntax: 'font-tech',
-                    error: 'expected font-tech',
-                    tokens: []
+                    error: 'expected font-tech'
                 };
         }
         if (token.val.localeCompare('font-format', undefined, { sensitivity: 'base' }) == 0) {
@@ -262,31 +256,28 @@ function validateSupportFeature(token) {
             // @ts-ignore
             return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && fontFormat.some((t) => t.localeCompare(chi[0].val, undefined, { sensitivity: 'base' }) == 0) ?
                 {
-                    valid: ValidationLevel.Valid,
-                    matches: [],
+                    valid: SyntaxValidationResult.Valid,
+                    context: [],
                     node: token,
                     syntax: 'font-format',
-                    error: '',
-                    tokens: []
+                    error: ''
                 } :
                 {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: token,
                     syntax: 'font-format',
-                    error: 'expected font-format',
-                    tokens: []
+                    error: 'expected font-format'
                 };
         }
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Drop,
-        matches: [],
+        valid: SyntaxValidationResult.Drop,
+        context: [],
         node: token,
         syntax: '@supports',
-        error: 'expected feature',
-        tokens: []
+        error: 'expected feature'
     };
 }
 

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

@@ -1,10 +1,11 @@
-import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import { SyntaxValidationResult, 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/tokenize.js';
 import '../../parser/utils/config.js';
+import { generalEnclosedFunc } from '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';
 import { validateMediaFeature, validateMediaCondition } from './media.js';
@@ -16,8 +17,8 @@ function validateAtRuleWhen(atRule, options, root) {
     if (slice.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: atRule,
             syntax: '@when',
             error: '',
@@ -25,14 +26,14 @@ function validateAtRuleWhen(atRule, options, root) {
         };
     }
     const result = validateAtRuleWhenQueryList(atRule.tokens, atRule);
-    if (result.valid == ValidationLevel.Drop) {
+    if (result.valid == SyntaxValidationResult.Drop) {
         return result;
     }
     if (!('chi' in atRule)) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@when',
             error: 'expected at-rule body',
@@ -40,12 +41,11 @@ function validateAtRuleWhen(atRule, options, root) {
         };
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@when',
-        error: '',
-        tokens: result.tokens
+        error: ''
     };
 }
 // media() = media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )
@@ -61,10 +61,10 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
             continue;
         }
         while (split.length > 0) {
-            if (split[0].typ != EnumToken.FunctionTokenType || !['media', 'supports', 'font-tech', 'font-format'].includes(split[0].val)) {
+            if (split[0].typ != EnumToken.FunctionTokenType || !generalEnclosedFunc.includes(split[0].val)) {
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: split[0] ?? atRule,
                     syntax: '@when',
                     error: 'unexpected token',
@@ -78,26 +78,24 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
                 // result = valida
                 if (chi.length != 1 || !(validateMediaFeature(chi[0]) || validateMediaCondition(split[0], atRule))) {
                     result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: split[0] ?? atRule,
                         syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
-                        error: 'unexpected token',
-                        tokens: []
+                        error: 'unexpected token'
                     };
                     break;
                 }
             }
-            else if (['supports', 'font-tech', 'font-format'].includes(split[0].val)) {
+            else if (generalEnclosedFunc.includes(split[0].val)) {
                 // result = valida
                 if (!validateSupportCondition(atRule, split[0])) {
                     result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: split[0] ?? atRule,
                         syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
-                        error: 'unexpected token',
-                        tokens: []
+                        error: 'unexpected token'
                     };
                     break;
                 }
@@ -112,8 +110,8 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
             }
             if (![EnumToken.MediaFeatureAndTokenType, EnumToken.MediaFeatureOrTokenType].includes(split[0].typ)) {
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: split[0] ?? atRule,
                     syntax: '@when',
                     error: 'expecting and/or media-condition',
@@ -128,8 +126,8 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
             consumeWhitespace(split);
             if (split.length == 0) {
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: split[0] ?? atRule,
                     syntax: '@when',
                     error: 'expecting media-condition',
@@ -147,13 +145,12 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
     }
     if (matched.length == 0) {
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             // @ts-ignore
             node: result?.node ?? atRule,
             syntax: '@when',
-            error: 'invalid at-rule body',
-            tokens: []
+            error: 'invalid at-rule body'
         };
     }
     tokenList.length = 0;
@@ -166,12 +163,11 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
         tokenList.push(...match);
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@when',
-        error: '',
-        tokens: tokenList
+        error: ''
     };
 }