@tbela99/css-parser 1.0.0 → 1.1.0

package/dist/lib/validation/at-rules/container.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 { splitTokenList } from '../utils/list.js';
 
@@ -14,48 +15,44 @@ function validateAtRuleContainer(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: '@' + atRule.nam,
-            error: 'expected supports query list',
-            tokens: []
+            error: 'expected supports query list'
         };
     }
     const result = validateAtRuleContainerQueryList(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: '@' + atRule.nam,
-            error: 'expected at-rule body',
-            tokens: []
+            error: 'expected at-rule body'
         };
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@' + atRule.nam,
         error: '',
-        tokens: []
     };
 }
 function validateAtRuleContainerQueryList(tokens, atRule) {
     if (tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@' + atRule.nam,
-            error: 'expected container query list',
-            tokens
+            error: 'expected container query list'
         };
     }
     let result = null;
@@ -64,12 +61,11 @@ function validateAtRuleContainerQueryList(tokens, atRule) {
         consumeWhitespace(queries);
         if (queries.length == 0) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: atRule,
                 syntax: '@' + atRule.nam,
-                error: 'expected container query list',
-                tokens
+                error: 'expected container query list'
             };
         }
         result = null;
@@ -79,12 +75,11 @@ function validateAtRuleContainerQueryList(tokens, atRule) {
         while (queries.length > 0) {
             if (queries.length == 0) {
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: atRule,
                     syntax: '@' + atRule.nam,
-                    error: 'expected container query list',
-                    tokens
+                    error: 'expected container query list'
                 };
             }
             if (queries[0].typ == EnumToken.IdenTokenType) {
@@ -100,12 +95,11 @@ function validateAtRuleContainerQueryList(tokens, atRule) {
             }
             if (token?.typ != EnumToken.ParensTokenType && (token?.typ != EnumToken.FunctionTokenType || !['scroll-state', 'style'].includes(token.val))) {
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: queries[0],
                     syntax: '@' + atRule.nam,
-                    error: 'expected container query-in-parens',
-                    tokens
+                    error: 'expected container query-in-parens'
                 };
             }
             if (token?.typ == EnumToken.ParensTokenType) {
@@ -117,7 +111,7 @@ function validateAtRuleContainerQueryList(tokens, atRule) {
             else {
                 result = validateContainerStyleFeature(token.chi, atRule);
             }
-            if (result.valid == ValidationLevel.Drop) {
+            if (result.valid == SyntaxValidationResult.Drop) {
                 return result;
             }
             queries.shift();
@@ -128,12 +122,11 @@ function validateAtRuleContainerQueryList(tokens, atRule) {
             token = queries[0];
             if (token?.typ != EnumToken.MediaFeatureAndTokenType && token?.typ != EnumToken.MediaFeatureOrTokenType) {
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: queries[0],
                     syntax: '@' + atRule.nam,
-                    error: 'expecting and/or container query token',
-                    tokens
+                    error: 'expecting and/or container query token'
                 };
             }
             if (tokenType == null) {
@@ -141,35 +134,32 @@ function validateAtRuleContainerQueryList(tokens, atRule) {
             }
             if (tokenType == null || tokenType != token?.typ) {
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: queries[0],
                     syntax: '@' + atRule.nam,
-                    error: 'mixing and/or not allowed at the same level',
-                    tokens
+                    error: 'mixing and/or not allowed at the same level'
                 };
             }
             queries.shift();
             consumeWhitespace(queries);
             if (queries.length == 0) {
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: queries[0],
                     syntax: '@' + atRule.nam,
-                    error: 'expected container query-in-parens',
-                    tokens
+                    error: 'expected container query-in-parens'
                 };
             }
         }
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@' + atRule.nam,
-        error: '',
-        tokens
+        error: ''
     };
 }
 function validateContainerStyleFeature(tokens, atRule) {
@@ -182,22 +172,20 @@ function validateContainerStyleFeature(tokens, atRule) {
         if ([EnumToken.DashedIdenTokenType, EnumToken.IdenTokenType].includes(tokens[0].typ) ||
             (tokens[0].typ == EnumToken.MediaQueryConditionTokenType && tokens[0].op.typ == EnumToken.ColonTokenType)) {
             return {
-                valid: ValidationLevel.Valid,
-                matches: [],
+                valid: SyntaxValidationResult.Valid,
+                context: [],
                 node: atRule,
                 syntax: '@' + atRule.nam,
-                error: '',
-                tokens
+                error: ''
             };
         }
     }
     return {
-        valid: ValidationLevel.Drop,
-        matches: [],
+        valid: SyntaxValidationResult.Drop,
+        context: [],
         node: atRule,
         syntax: '@' + atRule.nam,
-        error: 'expected container query features',
-        tokens
+        error: 'expected container query features'
     };
 }
 function validateContainerSizeFeature(tokens, atRule) {
@@ -205,12 +193,11 @@ function validateContainerSizeFeature(tokens, atRule) {
     consumeWhitespace(tokens);
     if (tokens.length == 0) {
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@' + atRule.nam,
-            error: 'expected container query features',
-            tokens
+            error: 'expected container query features'
         };
     }
     if (tokens.length == 1) {
@@ -223,21 +210,19 @@ function validateContainerSizeFeature(tokens, atRule) {
         }
         if (![EnumToken.DashedIdenTokenType, EnumToken.MediaQueryConditionTokenType].includes(tokens[0].typ)) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: atRule,
                 syntax: '@' + atRule.nam,
-                error: 'expected container query features',
-                tokens
+                error: 'expected container query features'
             };
         }
         return {
-            valid: ValidationLevel.Valid,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: atRule,
             syntax: '@' + atRule.nam,
-            error: '',
-            tokens
+            error: ''
         };
     }
     return validateAtRuleContainerQueryStyleInParams(tokens, atRule);
@@ -247,12 +232,11 @@ function validateAtRuleContainerQueryStyleInParams(tokens, atRule) {
     consumeWhitespace(tokens);
     if (tokens.length == 0) {
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@' + atRule.nam,
-            error: 'expected container query features',
-            tokens
+            error: 'expected container query features'
         };
     }
     let token = tokens[0];
@@ -265,12 +249,11 @@ function validateAtRuleContainerQueryStyleInParams(tokens, atRule) {
         }
         if (tokens[0].typ != EnumToken.ParensTokenType) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: atRule,
                 syntax: '@' + atRule.nam,
-                error: 'expected container query-in-parens',
-                tokens
+                error: 'expected container query-in-parens'
             };
         }
         const slices = tokens[0].chi.slice();
@@ -278,24 +261,23 @@ function validateAtRuleContainerQueryStyleInParams(tokens, atRule) {
         if (slices.length == 1) {
             if ([EnumToken.MediaFeatureNotTokenType, EnumToken.ParensTokenType].includes(slices[0].typ)) {
                 result = validateAtRuleContainerQueryStyleInParams(slices, atRule);
-                if (result.valid == ValidationLevel.Drop) {
+                if (result.valid == SyntaxValidationResult.Drop) {
                     return result;
                 }
             }
             else if (![EnumToken.DashedIdenTokenType, EnumToken.MediaQueryConditionTokenType].includes(slices[0].typ)) {
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: atRule,
                     syntax: '@' + atRule.nam,
-                    error: 'expected container query features',
-                    tokens
+                    error: 'expected container query features'
                 };
             }
         }
         else {
             result = validateAtRuleContainerQueryStyleInParams(slices, atRule);
-            if (result.valid == ValidationLevel.Drop) {
+            if (result.valid == SyntaxValidationResult.Drop) {
                 return result;
             }
         }
@@ -306,12 +288,11 @@ function validateAtRuleContainerQueryStyleInParams(tokens, atRule) {
         }
         if (![EnumToken.MediaFeatureAndTokenType, EnumToken.MediaFeatureOrTokenType].includes(tokens[0].typ)) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: tokens[0],
                 syntax: '@' + atRule.nam,
-                error: 'expecting and/or container query token',
-                tokens
+                error: 'expecting and/or container query token'
             };
         }
         if (tokenType == null) {
@@ -319,34 +300,31 @@ function validateAtRuleContainerQueryStyleInParams(tokens, atRule) {
         }
         if (tokenType != tokens[0].typ) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: tokens[0],
                 syntax: '@' + atRule.nam,
-                error: 'mixing and/or not allowed at the same level',
-                tokens
+                error: 'mixing and/or not allowed at the same level'
             };
         }
         tokens.shift();
         consumeWhitespace(tokens);
         if (tokens.length == 0) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: tokens[0],
                 syntax: '@' + atRule.nam,
-                error: 'expected container query-in-parens',
-                tokens
+                error: 'expected container query-in-parens'
             };
         }
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@' + atRule.nam,
-        error: '',
-        tokens
+        error: ''
     };
 }
 

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

@@ -1,17 +1,18 @@
-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 validateAtRuleCounterStyle(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: '@counter-style',
@@ -23,7 +24,7 @@ function validateAtRuleCounterStyle(atRule, options, root) {
     if (tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             matches: [],
             node: atRule,
             syntax: '@counter-style',
@@ -34,7 +35,7 @@ function validateAtRuleCounterStyle(atRule, options, root) {
     if (tokens.length > 1) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             matches: [],
             node: tokens[1] ?? atRule,
             syntax: '@counter-style',
@@ -45,7 +46,7 @@ function validateAtRuleCounterStyle(atRule, options, root) {
     if (![EnumToken.IdenTokenType, EnumToken.DashedIdenTokenType].includes(tokens[0].typ)) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             matches: [],
             node: tokens[0],
             syntax: '@counter-style',
@@ -56,7 +57,7 @@ function validateAtRuleCounterStyle(atRule, options, root) {
     if (!('chi' in atRule)) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             matches: [],
             node: atRule,
             syntax: '@counter-style',
@@ -66,7 +67,7 @@ function validateAtRuleCounterStyle(atRule, options, root) {
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
+        valid: SyntaxValidationResult.Valid,
         matches: [],
         node: atRule,
         syntax: '@counter-style',

package/dist/lib/validation/at-rules/custom-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 '../../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 { validateAtRuleMediaQueryList } from './media.js';
 
@@ -13,37 +14,34 @@ function validateAtRuleCustomMedia(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: '',
-            tokens: []
+            error: ''
         };
     }
     const queries = atRule.tokens.slice();
     consumeWhitespace(queries);
     if (queries.length == 0 || queries[0].typ != EnumToken.DashedIdenTokenType) {
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@custom-media',
-            error: 'expecting dashed identifier',
-            tokens: []
+            error: 'expecting dashed identifier'
         };
     }
     queries.shift();
     const result = validateAtRuleMediaQueryList(queries, atRule);
-    if (result.valid == ValidationLevel.Drop) {
+    if (result.valid == SyntaxValidationResult.Drop) {
         atRule.tokens = [];
         return {
-            valid: ValidationLevel.Valid,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: atRule,
             syntax: '@custom-media',
-            error: '',
-            tokens: []
+            error: ''
         };
     }
     return result;

package/dist/lib/validation/at-rules/document.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 { splitTokenList } from '../utils/list.js';
 import { validateURL } from '../syntaxes/url.js';
@@ -13,12 +14,11 @@ function validateAtRuleDocument(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: '@document',
-            error: 'expecting at-rule prelude',
-            tokens: []
+            error: 'expecting at-rule prelude'
         };
     }
     const tokens = atRule.tokens.slice();
@@ -27,39 +27,36 @@ function validateAtRuleDocument(atRule, options, root) {
     if (tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@document',
-            error: 'expecting at-rule prelude',
-            tokens
+            error: 'expecting at-rule prelude'
         };
     }
     for (const t of splitTokenList(tokens)) {
         if (t.length != 1) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: t[0] ?? atRule,
                 syntax: '@document',
-                error: 'unexpected token',
-                tokens
+                error: 'unexpected token'
             };
         }
         // @ts-ignore
         if ((t[0].typ != EnumToken.FunctionTokenType && t[0].typ != EnumToken.UrlFunctionTokenType) || !['url', 'url-prefix', 'domain', 'media-document', 'regexp'].some((f) => f.localeCompare(t[0].val, undefined, { sensitivity: 'base' }) == 0)) {
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: t[0] ?? atRule,
                 syntax: '@document',
-                error: 'expecting any of url-prefix(), domain(), media-document(), regexp() but found ' + t[0].val,
-                tokens
+                error: 'expecting any of url-prefix(), domain(), media-document(), regexp() but found ' + t[0].val
             };
         }
         if (t[0].typ == EnumToken.UrlFunctionTokenType) {
             result = validateURL(t[0]);
-            if (result?.valid == ValidationLevel.Drop) {
+            if (result?.valid == SyntaxValidationResult.Drop) {
                 return result;
             }
             continue;
@@ -69,12 +66,11 @@ function validateAtRuleDocument(atRule, options, root) {
         if (children.length != 1 || (children[0].typ != EnumToken.StringTokenType && children[0].typ != EnumToken.UrlTokenTokenType)) {
             // @ts-ignore
             return {
-                valid: ValidationLevel.Drop,
-                matches: [],
+                valid: SyntaxValidationResult.Drop,
+                context: [],
                 node: tokens[0],
                 syntax: '@document',
-                error: 'expecting string argument',
-                tokens
+                error: 'expecting string argument'
             };
         }
         tokens.shift();
@@ -82,12 +78,11 @@ function validateAtRuleDocument(atRule, options, root) {
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@document',
-        error: '',
-        tokens
+        error: ''
     };
 }
 

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

@@ -1,21 +1,21 @@
-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 { validateFamilyName } from '../syntaxes/family-name.js';
 import '../syntaxes/complex-selector.js';
-import '../parser/types.js';
-import '../parser/parse.js';
+import '../syntax.js';
 import '../config.js';
 
 function validateAtRuleFontFeatureValues(atRule, options, root) {
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             matches: [],
             node: null,
             syntax: '@' + atRule.nam,
@@ -24,13 +24,13 @@ function validateAtRuleFontFeatureValues(atRule, options, root) {
         };
     }
     const result = validateFamilyName(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,
+            valid: SyntaxValidationResult.Drop,
             matches: [],
             node: atRule,
             syntax: '@' + atRule.nam,
@@ -40,7 +40,7 @@ function validateAtRuleFontFeatureValues(atRule, options, root) {
     }
     // @ts-ignore
     return {
-        valid: ValidationLevel.Valid,
+        valid: SyntaxValidationResult.Valid,
         matches: [],
         node: atRule,
         syntax: '@' + atRule.nam,