@tbela99/css-parser 1.3.2 → 1.3.4

package/dist/lib/syntax/syntax.js

@@ -528,7 +528,7 @@ function isColor(token) {
     }
     if (token.typ == EnumToken.IdenTokenType) {
         // named color
-        return token.val.toLowerCase() in COLORS_NAMES;
+        return token.val.toLowerCase() in COLORS_NAMES || 'currentcolor' === token.val.toLowerCase() || 'transparent' === token.val.toLowerCase();
     }
     let isLegacySyntax = false;
     if (token.typ == EnumToken.FunctionTokenType) {
@@ -581,8 +581,13 @@ function isColor(token) {
                             return false;
                         }
                     }
-                    if (children[i].typ == EnumToken.FunctionTokenType && !mathFuncs.includes(children[i].val)) {
-                        return false;
+                    if (children[i].typ == EnumToken.FunctionTokenType) {
+                        if ('var' == children[i].val.toLowerCase()) {
+                            continue;
+                        }
+                        if (!mathFuncs.includes(children[i].val)) {
+                            return false;
+                        }
                     }
                 }
                 if (children.length == 4 || (isRelative && children.length == 6)) {
@@ -869,23 +874,29 @@ function isNumber(name) {
     }
     return true;
 }
-function isDimension(name) {
-    let index = name.length;
-    while (index--) {
-        if (isLetter(name.charCodeAt(index))) {
-            continue;
-        }
-        index++;
-        break;
-    }
-    const number = name.slice(0, index);
-    return number.length > 0 && isIdentStart(name.charCodeAt(index)) && isNumber(number);
-}
+// export function isDimension(name: string) {
+//
+//     let index: number = name.length;
+//
+//     while (index--) {
+//
+//         if (isLetter(<number>name.charCodeAt(index))) {
+//
+//             continue
+//         }
+//
+//         index++;
+//         break;
+//     }
+//
+//     const number: string = name.slice(0, index);
+//     return number.length > 0 && isIdentStart(name.charCodeAt(index)) && isNumber(number);
+// }
 function isPercentage(name) {
     return name.endsWith('%') && isNumber(name.slice(0, -1));
 }
-function isFlex(name) {
-    return name.endsWith('fr') && isNumber(name.slice(0, -2));
+function isFlex(dimension) {
+    return 'unit' in dimension && 'fr' == dimension.unit.toLowerCase();
 }
 function parseDimension(name) {
     let index = name.length;
@@ -901,6 +912,9 @@ function parseDimension(name) {
         val: +name.slice(0, index),
         unit: name.slice(index)
     };
+    if (index < 0 || Number.isNaN(dimension.val)) {
+        return null;
+    }
     if (isAngle(dimension)) {
         // @ts-ignore
         dimension.typ = EnumToken.AngleTokenType;
@@ -924,6 +938,10 @@ function parseDimension(name) {
         // @ts-ignore
         dimension.typ = EnumToken.FrequencyTokenType;
     }
+    else if (isFlex(dimension)) {
+        // @ts-ignore
+        dimension.typ = EnumToken.FlexTokenType;
+    }
     return dimension;
 }
 function isHexColor(name) {
@@ -958,4 +976,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentColor, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPercentageToken, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseColor, parseDimension, pseudoAliasMap, pseudoElements, transformFunctions, webkitExtensions, wildCardFuncs };
+export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentColor, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPercentageToken, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseColor, parseDimension, pseudoAliasMap, pseudoElements, transformFunctions, webkitExtensions, wildCardFuncs };

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

@@ -11,6 +11,17 @@ import { splitTokenList } from '../utils/list.js';
 
 const validateContainerScrollStateFeature = validateContainerSizeFeature;
 function validateAtRuleContainer(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

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

@@ -8,6 +8,17 @@ import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function validateAtRuleCounterStyle(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

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

@@ -12,6 +12,17 @@ import '../syntax.js';
 import '../config.js';
 
 function validateAtRuleFontFeatureValues(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {

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

@@ -9,6 +9,17 @@ import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 
 function validateAtRuleKeyframes(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore
         return {

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

@@ -12,6 +12,17 @@ import '../syntax.js';
 import '../config.js';
 
 function validateAtRuleLayer(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

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

@@ -10,6 +10,17 @@ import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';
 
 function validateAtRuleMedia(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

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

@@ -8,6 +8,17 @@ import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function validateAtRulePageMarginBox(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     if (Array.isArray(atRule.tokens) && atRule.tokens.length > 0) {
         // @ts-ignore
         return {

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

@@ -9,6 +9,17 @@ import '../../renderer/sourcemap/lib/encode.js';
 import { splitTokenList } from '../utils/list.js';
 
 function validateAtRulePage(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     // media-query-list
     if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
         // @ts-ignore

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

@@ -23,6 +23,17 @@ function validateAtRuleSupports(atRule, options, root) {
             tokens: []
         };
     }
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     const result = validateAtRuleSupportsConditions(atRule, atRule.tokens);
     if (result) {
         if (result.node == null) {

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

@@ -12,6 +12,17 @@ import { validateMediaFeature, validateMediaCondition } from './media.js';
 import { validateSupportCondition } from './supports.js';
 
 function validateAtRuleWhen(atRule, options, root) {
+    if (!Array.isArray(atRule.chi)) {
+        // @ts-ignore
+        return {
+            valid: SyntaxValidationResult.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected supports body',
+            tokens: []
+        };
+    }
     const slice = Array.isArray(atRule.tokens) ? atRule.tokens.slice() : [];
     consumeWhitespace(slice);
     if (slice.length == 0) {

package/dist/lib/validation/config.js

@@ -1,5 +1,4 @@
 import config from './config.json.js';
-import './parser/types.js';
 import { parseSyntax } from './parser/parse.js';
 
 const parsedSyntaxes = new Map();
@@ -51,7 +50,6 @@ function getParsedSyntax(group, key) {
     const index = group + '.' + keys.join('.');
     // @ts-ignore
     if (!parsedSyntaxes.has(index)) {
-        // @ts-ignore
         const syntax = parseSyntax(obj.syntax);
         // @ts-ignore
         parsedSyntaxes.set(index, syntax.chi);

package/dist/lib/validation/config.json.js

@@ -1619,6 +1619,9 @@ var declarations = {
 	"text-anchor": {
 		syntax: "start | middle | end"
 	},
+	"text-autospace": {
+		syntax: "normal | <autospace> | auto"
+	},
 	"text-box": {
 		syntax: "normal | <'text-box-trim'> || <'text-box-edge'>"
 	},
@@ -4186,19 +4189,28 @@ var atRules = {
 			}
 		}
 	},
-	charset: {
-		syntax: "<string>"
+	"@nest": {
 	},
-	container: {
-		syntax: "[ <container-name> ]? <container-condition>"
+	"@stylistic": {
+		syntax: " @stylistic { <feature-value-declaration-list> } "
 	},
-	nest: {
-		syntax: "<complex-selector-list>"
+	"@historical-forms": {
+		syntax: " @historical-forms { <feature-value-declaration-list> } "
 	},
-	scope: {
-		syntax: "[ ( <scope-start> ) ]? [ to ( <scope-end> ) ]?"
+	"@styleset": {
+		syntax: " @styleset { <feature-value-declaration-list> } "
 	},
-	"position-try": {
+	"@character-variant": {
+		syntax: " @character-variant { <feature-value-declaration-list> } "
+	},
+	"@swash": {
+		syntax: " @swash { <feature-value-declaration-list> } "
+	},
+	"@ornaments": {
+		syntax: " @ornaments { <feature-value-declaration-list> } "
+	},
+	"@annotation": {
+		syntax: " @annotation { <feature-value-declaration-list> } "
 	}
 };
 var config = {

package/dist/lib/validation/parser/parse.js

@@ -1,4 +1,3 @@
-import { ValidationTokenEnum } from './types.js';
 import { isIdent, isPseudo } from '../../syntax/syntax.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
@@ -9,6 +8,58 @@ import '../../parser/utils/config.js';
 import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
+var ValidationTokenEnum;
+(function (ValidationTokenEnum) {
+    ValidationTokenEnum[ValidationTokenEnum["Root"] = 0] = "Root";
+    ValidationTokenEnum[ValidationTokenEnum["Keyword"] = 1] = "Keyword";
+    ValidationTokenEnum[ValidationTokenEnum["PropertyType"] = 2] = "PropertyType";
+    ValidationTokenEnum[ValidationTokenEnum["DeclarationType"] = 3] = "DeclarationType";
+    ValidationTokenEnum[ValidationTokenEnum["AtRule"] = 4] = "AtRule";
+    ValidationTokenEnum[ValidationTokenEnum["ValidationFunctionDefinition"] = 5] = "ValidationFunctionDefinition";
+    ValidationTokenEnum[ValidationTokenEnum["OpenBracket"] = 6] = "OpenBracket";
+    ValidationTokenEnum[ValidationTokenEnum["CloseBracket"] = 7] = "CloseBracket";
+    ValidationTokenEnum[ValidationTokenEnum["OpenParenthesis"] = 8] = "OpenParenthesis";
+    ValidationTokenEnum[ValidationTokenEnum["CloseParenthesis"] = 9] = "CloseParenthesis";
+    ValidationTokenEnum[ValidationTokenEnum["Comma"] = 10] = "Comma";
+    ValidationTokenEnum[ValidationTokenEnum["Pipe"] = 11] = "Pipe";
+    ValidationTokenEnum[ValidationTokenEnum["Column"] = 12] = "Column";
+    ValidationTokenEnum[ValidationTokenEnum["Star"] = 13] = "Star";
+    ValidationTokenEnum[ValidationTokenEnum["OpenCurlyBrace"] = 14] = "OpenCurlyBrace";
+    ValidationTokenEnum[ValidationTokenEnum["CloseCurlyBrace"] = 15] = "CloseCurlyBrace";
+    ValidationTokenEnum[ValidationTokenEnum["HashMark"] = 16] = "HashMark";
+    ValidationTokenEnum[ValidationTokenEnum["QuestionMark"] = 17] = "QuestionMark";
+    ValidationTokenEnum[ValidationTokenEnum["Function"] = 18] = "Function";
+    ValidationTokenEnum[ValidationTokenEnum["Number"] = 19] = "Number";
+    ValidationTokenEnum[ValidationTokenEnum["Whitespace"] = 20] = "Whitespace";
+    ValidationTokenEnum[ValidationTokenEnum["Parenthesis"] = 21] = "Parenthesis";
+    ValidationTokenEnum[ValidationTokenEnum["Bracket"] = 22] = "Bracket";
+    ValidationTokenEnum[ValidationTokenEnum["Block"] = 23] = "Block";
+    ValidationTokenEnum[ValidationTokenEnum["AtLeastOnce"] = 24] = "AtLeastOnce";
+    ValidationTokenEnum[ValidationTokenEnum["Separator"] = 25] = "Separator";
+    ValidationTokenEnum[ValidationTokenEnum["Exclamation"] = 26] = "Exclamation";
+    ValidationTokenEnum[ValidationTokenEnum["Ampersand"] = 27] = "Ampersand";
+    ValidationTokenEnum[ValidationTokenEnum["PipeToken"] = 28] = "PipeToken";
+    ValidationTokenEnum[ValidationTokenEnum["ColumnToken"] = 29] = "ColumnToken";
+    ValidationTokenEnum[ValidationTokenEnum["AmpersandToken"] = 30] = "AmpersandToken";
+    ValidationTokenEnum[ValidationTokenEnum["Parens"] = 31] = "Parens";
+    ValidationTokenEnum[ValidationTokenEnum["PseudoClassToken"] = 32] = "PseudoClassToken";
+    ValidationTokenEnum[ValidationTokenEnum["PseudoClassFunctionToken"] = 33] = "PseudoClassFunctionToken";
+    ValidationTokenEnum[ValidationTokenEnum["StringToken"] = 34] = "StringToken";
+    ValidationTokenEnum[ValidationTokenEnum["AtRuleDefinition"] = 35] = "AtRuleDefinition";
+    ValidationTokenEnum[ValidationTokenEnum["DeclarationNameToken"] = 36] = "DeclarationNameToken";
+    ValidationTokenEnum[ValidationTokenEnum["DeclarationDefinitionToken"] = 37] = "DeclarationDefinitionToken";
+    ValidationTokenEnum[ValidationTokenEnum["SemiColon"] = 38] = "SemiColon";
+    ValidationTokenEnum[ValidationTokenEnum["Character"] = 39] = "Character";
+    ValidationTokenEnum[ValidationTokenEnum["InfinityToken"] = 40] = "InfinityToken";
+})(ValidationTokenEnum || (ValidationTokenEnum = {}));
+var ValidationSyntaxGroupEnum;
+(function (ValidationSyntaxGroupEnum) {
+    ValidationSyntaxGroupEnum["Declarations"] = "declarations";
+    ValidationSyntaxGroupEnum["Functions"] = "functions";
+    ValidationSyntaxGroupEnum["Syntaxes"] = "syntaxes";
+    ValidationSyntaxGroupEnum["Selectors"] = "selectors";
+    ValidationSyntaxGroupEnum["AtRules"] = "atRules";
+})(ValidationSyntaxGroupEnum || (ValidationSyntaxGroupEnum = {}));
 const skipped = [
     ValidationTokenEnum.Star,
     ValidationTokenEnum.HashMark,
@@ -1040,4 +1091,4 @@ function minify(ast) {
     return ast;
 }
 
-export { parseSyntax, renderSyntax };
+export { ValidationSyntaxGroupEnum, ValidationTokenEnum, parseSyntax, renderSyntax };