@tbela99/css-parser 1.0.0 → 1.1.0

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

@@ -1,16 +1,16 @@
-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 { 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 '../syntax.js';
 import '../config.js';
 import { validateAtRuleSupportsConditions } from './supports.js';
 
@@ -18,35 +18,32 @@ function validateAtRuleImport(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: null,
             syntax: '@' + atRule.nam,
-            error: 'expected @import media query list',
-            tokens: []
+            error: 'expected @import media query list'
         };
     }
     if ('chi' in atRule) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: null,
             syntax: '@' + atRule.nam,
-            error: 'unexpected at-rule body',
-            tokens: []
+            error: 'unexpected at-rule body'
         };
     }
     const tokens = atRule.tokens.filter((t) => ![EnumToken.CommentTokenType].includes(t.typ));
     if (tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: null,
             syntax: '@' + atRule.nam,
-            error: 'expected @import media query list',
-            tokens: []
+            error: 'expected @import media query list'
         };
     }
     if (tokens[0].typ == EnumToken.StringTokenType) {
@@ -59,12 +56,11 @@ function validateAtRuleImport(atRule, options, root) {
         if (slice.length != 1 || ![EnumToken.StringTokenType, EnumToken.UrlTokenTokenType].includes(slice[0].typ)) {
             // @ts-ignore
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: tokens[0],
                 syntax: '@' + atRule.nam,
-                error: 'invalid url()',
-                tokens
+                error: 'invalid url()'
             };
         }
         else {
@@ -73,12 +69,11 @@ function validateAtRuleImport(atRule, options, root) {
             if (!consumeWhitespace(tokens)) {
                 // @ts-ignore
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: tokens[0],
                     syntax: '@' + atRule.nam,
-                    error: 'expecting whitespace',
-                    tokens
+                    error: 'expecting whitespace'
                 };
             }
         }
@@ -89,12 +84,11 @@ function validateAtRuleImport(atRule, options, root) {
     else {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: tokens[0],
             syntax: '@' + atRule.nam,
-            error: 'expecting url() or string',
-            tokens
+            error: 'expecting url() or string'
         };
     }
     if (tokens.length > 0) {
@@ -107,12 +101,11 @@ function validateAtRuleImport(atRule, options, root) {
                 if (!consumeWhitespace(tokens)) {
                     // @ts-ignore
                     return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: tokens[0],
                         syntax: '@' + atRule.nam,
-                        error: 'expecting whitespace',
-                        tokens
+                        error: 'expecting whitespace'
                     };
                 }
             }
@@ -122,7 +115,7 @@ function validateAtRuleImport(atRule, options, root) {
             // @ts-ignore
             if ('layer'.localeCompare(tokens[0].val, undefined, { sensitivity: 'base' }) == 0) {
                 const result = validateLayerName(tokens[0].chi);
-                if (result.valid == ValidationLevel.Drop) {
+                if (result.valid == SyntaxValidationResult.Drop) {
                     return result;
                 }
                 tokens.shift();
@@ -132,7 +125,7 @@ function validateAtRuleImport(atRule, options, root) {
             // @ts-ignore
             if ('supports'.localeCompare(tokens[0]?.val, undefined, { sensitivity: 'base' }) == 0) {
                 const result = validateAtRuleSupportsConditions(atRule, tokens[0].chi);
-                if (result.valid == ValidationLevel.Drop) {
+                if (result.valid == SyntaxValidationResult.Drop) {
                     return result;
                 }
                 tokens.shift();
@@ -141,60 +134,16 @@ function validateAtRuleImport(atRule, options, root) {
             }
         }
     }
-    // if (tokens.length > 0) {
-    //
-    //     // @ts-ignore
-    //     if (tokens[0].typ == EnumToken.AtRuleTokenType) {
-    //
-    //         if ((tokens[0] as AstAtRule).nam != 'supports') {
-    //
-    //             // @ts-ignore
-    //             return {
-    //                 valid: ValidationLevel.Drop,
-    //                 matches: [],
-    //                 node: tokens[0],
-    //                 syntax: '@' + atRule.nam,
-    //                 error: 'expecting @supports or media query list',
-    //                 tokens
-    //             }
-    //         }
-    //
-    //         // @ts-ignore
-    //         const result: ValidationSyntaxResult = validateAtRuleSupports(tokens[0] as AstAtRule, options, atRule);
-    //
-    //         if (result.valid == ValidationLevel.Drop) {
-    //
-    //             return result;
-    //         }
-    //
-    //         tokens.shift();
-    //
-    //         // @ts-ignore
-    //         if (!consumeWhitespace(tokens)) {
-    //
-    //             // @ts-ignore
-    //             return {
-    //                 valid: ValidationLevel.Drop,
-    //                 matches: [],
-    //                 node: tokens[0],
-    //                 syntax: '@' + atRule.nam,
-    //                 error: 'expecting whitespace',
-    //                 tokens
-    //             }
-    //         }
-    //     }
-    // }
     if (tokens.length > 0) {
         return validateAtRuleMediaQueryList(tokens, atRule);
     }
     // @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/keyframes.js

@@ -1,22 +1,22 @@
-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 { consumeWhitespace } from '../utils/whitespace.js';
 
 function validateAtRuleKeyframes(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@keyframes',
-            error: 'expecting at-rule prelude',
-            tokens: []
+            error: 'expecting at-rule prelude'
         };
     }
     const tokens = atRule.tokens.slice();
@@ -24,23 +24,21 @@ function validateAtRuleKeyframes(atRule, options, root) {
     if (tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@keyframes',
-            error: 'expecting at-rule prelude',
-            tokens
+            error: 'expecting at-rule prelude'
         };
     }
     if (![EnumToken.StringTokenType, EnumToken.IdenTokenType].includes(tokens[0].typ)) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@keyframes',
-            error: 'expecting ident or string token',
-            tokens
+            error: 'expecting ident or string token'
         };
     }
     tokens.shift();
@@ -48,22 +46,20 @@ function validateAtRuleKeyframes(atRule, options, root) {
     if (tokens.length > 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: tokens[0],
             syntax: '@keyframes',
-            error: 'unexpected token',
-            tokens
+            error: 'unexpected token'
         };
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@keyframes',
-        error: '',
-        tokens
+        error: ''
     };
 }
 

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

@@ -1,14 +1,14 @@
-import { ValidationLevel } from '../../ast/types.js';
+import { SyntaxValidationResult } 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 { validateLayerName } from '../syntaxes/layer-name.js';
 import '../syntaxes/complex-selector.js';
-import '../parser/types.js';
-import '../parser/parse.js';
+import '../syntax.js';
 import '../config.js';
 
 function validateAtRuleLayer(atRule, options, root) {
@@ -16,7 +16,7 @@ function validateAtRuleLayer(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
+            valid: SyntaxValidationResult.Valid,
             matches: [],
             node: atRule,
             syntax: '@layer',

package/dist/lib/validation/at-rules/media.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';
 
@@ -13,8 +14,8 @@ function validateAtRuleMedia(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: null,
             error: '',
@@ -26,37 +27,34 @@ function validateAtRuleMedia(atRule, options, root) {
     consumeWhitespace(slice);
     if (slice.length == 0) {
         return {
-            valid: ValidationLevel.Valid,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: atRule,
             syntax: '@media',
-            error: '',
-            tokens: []
+            error: ''
         };
     }
     result = validateAtRuleMediaQueryList(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: '@media',
-            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: '@media',
-        error: '',
-        tokens: []
+        error: ''
     };
 }
 function validateAtRuleMediaQueryList(tokenList, atRule) {
@@ -74,12 +72,11 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
         if (tokens.length == 0) {
             // @ts-ignore
             result = {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: tokens[0] ?? atRule,
                 syntax: '@media',
-                error: 'unexpected token',
-                tokens: []
+                error: 'unexpected token'
             };
             continue;
         }
@@ -92,15 +89,14 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
                 }
                 else {
                     result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: tokens[0] ?? atRule,
                         syntax: '@media',
-                        error: 'expecting media feature or media condition',
-                        tokens: []
+                        error: 'expecting media feature or media condition'
                     };
                 }
-                if (result.valid == ValidationLevel.Drop) {
+                if (result.valid == SyntaxValidationResult.Drop) {
                     break;
                 }
                 result = null;
@@ -113,12 +109,11 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
                 if (previousToken?.typ != EnumToken.ParensTokenType) {
                     // @ts-ignore
                     result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: tokens[0] ?? atRule,
                         syntax: '@media',
-                        error: 'expected media query list',
-                        tokens: []
+                        error: 'expected media query list'
                     };
                     break;
                 }
@@ -126,12 +121,11 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
             else if (![EnumToken.MediaFeatureOrTokenType, EnumToken.MediaFeatureAndTokenType].includes(tokens[0].typ)) {
                 // @ts-ignore
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@media',
-                    error: 'expected and/or',
-                    tokens: []
+                    error: 'expected and/or'
                 };
                 break;
             }
@@ -141,12 +135,11 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
             if (mediaFeatureType.typ != tokens[0].typ) {
                 // @ts-ignore
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@media',
-                    error: 'mixing and/or not allowed at the same level',
-                    tokens: []
+                    error: 'mixing and/or not allowed at the same level'
                 };
                 break;
             }
@@ -155,12 +148,11 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
             if (tokens.length == 0) {
                 // @ts-ignore
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: tokens[0] ?? atRule,
                     syntax: '@media',
-                    error: 'expected media-condition',
-                    tokens: []
+                    error: 'expected media-condition'
                 };
                 break;
             }
@@ -175,12 +167,11 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
     }
     if (matched.length == 0) {
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@media',
-            error: 'expected media query list',
-            tokens: []
+            error: 'expected media query list'
         };
     }
     tokenList.length = 0;
@@ -200,12 +191,11 @@ function validateAtRuleMediaQueryList(tokenList, atRule) {
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@media',
-        error: '',
-        tokens: []
+        error: ''
     };
 }
 function validateCustomMediaCondition(token, atRule) {
@@ -225,7 +215,7 @@ function validateMediaCondition(token, atRule) {
     if (token.typ == EnumToken.MediaFeatureNotTokenType) {
         return validateMediaCondition(token.val, atRule);
     }
-    if (token.typ != EnumToken.ParensTokenType && !(['when', 'else', 'import'].includes(atRule.nam) && token.typ == EnumToken.FunctionTokenType && ['media', 'supports', 'selector'].includes(token.val))) {
+    if (token.typ != EnumToken.ParensTokenType && !(['when', 'else', 'import'].includes(atRule.nam) && token.typ == EnumToken.FunctionTokenType && generalEnclosedFunc.includes(token.val))) {
         return false;
     }
     const chi = token.chi.filter((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);

package/dist/lib/validation/at-rules/namespace.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 { consumeWhitespace } from '../utils/whitespace.js';
 import { validateURL } from '../syntaxes/url.js';
 
@@ -12,23 +13,21 @@ function validateAtRuleNamespace(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@namespace',
-            error: 'expected at-rule prelude',
-            tokens: []
+            error: 'expected at-rule prelude'
         };
     }
     if ('chi' in atRule) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@namespace',
-            error: 'unexpected at-rule body',
-            tokens: []
+            error: 'unexpected at-rule body'
         };
     }
     const tokens = atRule.tokens.slice();
@@ -40,17 +39,16 @@ function validateAtRuleNamespace(atRule, options, root) {
     if (tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@namespace',
-            error: 'expected string or url()',
-            tokens
+            error: 'expected string or url()'
         };
     }
     if (tokens[0].typ != EnumToken.StringTokenType) {
         const result = validateURL(tokens[0]);
-        if (result.valid != ValidationLevel.Valid) {
+        if (result.valid != SyntaxValidationResult.Valid) {
             return result;
         }
         tokens.shift();
@@ -63,22 +61,20 @@ function validateAtRuleNamespace(atRule, options, root) {
     if (tokens.length > 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: tokens[0],
             syntax: '@namespace',
-            error: 'unexpected token',
-            tokens
+            error: 'unexpected token'
         };
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@namespace',
-        error: '',
-        tokens
+        error: ''
     };
 }