@tbela99/css-parser 1.3.3 → 1.3.4

package/dist/lib/parser/tokenize.js

@@ -182,13 +182,15 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                 yield pushToken(buffer, parseInfo);
                 buffer = '';
             }
+            buffer += value;
             while (value = next(parseInfo)) {
                 charCode = value.charCodeAt(0);
                 if (!isWhiteSpace(charCode)) {
                     break;
                 }
+                buffer += value;
             }
-            yield pushToken('', parseInfo, EnumToken.WhitespaceTokenType);
+            yield pushToken(buffer, parseInfo, EnumToken.WhitespaceTokenType);
             buffer = '';
         }
         switch (charCode) {
@@ -236,8 +238,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     buffer = '';
                 }
                 if (match(parseInfo, '=')) {
-                    yield pushToken('', parseInfo, EnumToken.LteTokenType);
-                    next(parseInfo);
+                    yield pushToken(value + next(parseInfo), parseInfo, EnumToken.LteTokenType);
                     break;
                 }
                 buffer += value;
@@ -292,8 +293,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                 }
                 if (charCode == 124 /* TokenMap.PIPE */) {
                     if (match(parseInfo, '|')) {
-                        next(parseInfo);
-                        yield pushToken('', parseInfo, EnumToken.ColumnCombinatorTokenType);
+                        yield pushToken(value + next(parseInfo), parseInfo, EnumToken.ColumnCombinatorTokenType);
                     }
                     else if (match(parseInfo, '=')) {
                         buffer += next(parseInfo);
@@ -347,11 +347,10 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     buffer = '';
                 }
                 if (match(parseInfo, '=')) {
-                    yield pushToken('', parseInfo, EnumToken.GteTokenType);
-                    next(parseInfo);
+                    yield pushToken(value + next(parseInfo), parseInfo, EnumToken.GteTokenType);
                 }
                 else {
-                    yield pushToken('', parseInfo, EnumToken.GtTokenType);
+                    yield pushToken(value, parseInfo, EnumToken.GtTokenType);
                 }
                 consumeWhiteSpace(parseInfo);
                 break;
@@ -402,7 +401,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     yield pushToken(buffer, parseInfo);
                     buffer = '';
                 }
-                yield pushToken('', parseInfo, EnumToken.EndParensTokenType);
+                yield pushToken(value, parseInfo, EnumToken.EndParensTokenType);
                 break;
             case 40 /* TokenMap.OPEN_PAREN */:
                 if (buffer.length == 0) {
@@ -468,7 +467,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                                 // ')'
                                 if (charCode == 0x29) {
                                     yield pushToken(buffer, parseInfo, hasNewLine ? EnumToken.BadStringTokenType : EnumToken.StringTokenType);
-                                    yield pushToken('', parseInfo, EnumToken.EndParensTokenType);
+                                    yield pushToken(value, parseInfo, EnumToken.EndParensTokenType);
                                     buffer = '';
                                     break;
                                 }
@@ -492,7 +491,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                             charCode = value.charCodeAt(0);
                             if (charCode == 0x29) { // ')'
                                 yield pushToken(buffer, parseInfo, EnumToken.UrlTokenTokenType);
-                                yield pushToken('', parseInfo, EnumToken.EndParensTokenType);
+                                yield pushToken(value, parseInfo, EnumToken.EndParensTokenType);
                                 buffer = '';
                                 break;
                             }
@@ -526,8 +525,7 @@ function* tokenize(parseInfo, yieldEOFToken = true) {
                     buffer = '';
                 }
                 if (match(parseInfo, 'important')) {
-                    yield pushToken('', parseInfo, EnumToken.ImportantTokenType);
-                    next(parseInfo, 9);
+                    yield pushToken(value + next(parseInfo, 9), parseInfo, EnumToken.ImportantTokenType);
                     buffer = '';
                     break;
                 }

package/dist/lib/renderer/render.js

@@ -69,7 +69,7 @@ function doRender(data, options = {}) {
     const sourcemap = options.sourcemap ? new SourceMap : null;
     const cache = Object.create(null);
     const result = {
-        code: renderAstNode(options.expandNestingRules ? expand(data) : data, options, sourcemap, {
+        code: renderAstNode(options.expandNestingRules && [EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType, EnumToken.RuleNodeType].includes(data.typ) && 'chi' in data ? expand(data) : data, options, sourcemap, {
             ind: 0,
             lin: 1,
             col: 1
@@ -209,7 +209,7 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
                     str = `${node.nam}:${options.indent}${(options.minify ? filterValues(node.val) : node.val).reduce(reducer, '').trimEnd()};`;
                 }
                 else if (node.typ == EnumToken.AtRuleNodeType && !('chi' in node)) {
-                    str = `${data.val === '' ? '' : options.indent || ' '}${data.val};`;
+                    str = `${node.val === '' ? '' : options.indent || ' '}${node.val};`;
                 }
                 else {
                     str = renderAstNode(node, options, sourcemap, { ...position }, errors, reducer, cache, level + 1, indents);

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

@@ -4190,7 +4190,27 @@ var atRules = {
 		}
 	},
 	"@nest": {
-		syntax: "<complex-selector-list>"
+	},
+	"@stylistic": {
+		syntax: " @stylistic { <feature-value-declaration-list> } "
+	},
+	"@historical-forms": {
+		syntax: " @historical-forms { <feature-value-declaration-list> } "
+	},
+	"@styleset": {
+		syntax: " @styleset { <feature-value-declaration-list> } "
+	},
+	"@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 };