@tbela99/css-parser 1.1.1 → 1.3.0

package/dist/lib/parser/parse.js

@@ -1,12 +1,12 @@
-import { isColor, parseColor, isIdent, mediaTypes, isDimension, parseDimension, isPseudo, pseudoElements, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isHexColor, isHash, isIdentStart, isIdentColor, mathFuncs } from '../syntax/syntax.js';
-import './utils/config.js';
-import { EnumToken, ValidationLevel, SyntaxValidationResult } from '../ast/types.js';
+import { isIdentStart, isIdent, isIdentColor, mathFuncs, isColor, parseColor, isPseudo, pseudoElements, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isHexColor, isHash, mediaTypes } from '../syntax/syntax.js';
+import { EnumToken, ColorType, ValidationLevel, SyntaxValidationResult } from '../ast/types.js';
 import { minify, definedPropertySettings, combinators } from '../ast/minify.js';
 import { walkValues, walk, WalkerOptionEnum } from '../ast/walk.js';
 import { expand } from '../ast/expand.js';
+import './utils/config.js';
 import { parseDeclarationNode } from './utils/declaration.js';
 import { renderToken } from '../renderer/render.js';
-import { funcLike, ColorKind, COLORS_NAMES, systemColors, deprecatedSystemColors, colorsFunc } from '../renderer/color/utils/constants.js';
+import { funcLike, timingFunc, timelineFunc, COLORS_NAMES, systemColors, deprecatedSystemColors, colorsFunc } from '../syntax/color/utils/constants.js';
 import { buildExpression } from '../ast/math/expression.js';
 import { tokenize } from './tokenize.js';
 import '../validation/config.js';
@@ -122,6 +122,18 @@ async function doParse(iterator, options = {}) {
         stats.bytesIn = item.bytesIn;
         rawTokens.push(item);
         if (item.hint != null && BadTokensTypes.includes(item.hint)) {
+            const node = getTokenType(item.token, item.hint);
+            errors.push({
+                action: 'drop',
+                message: 'Bad token',
+                syntax: null,
+                node,
+                location: {
+                    src,
+                    sta: item.sta,
+                    end: item.end
+                }
+            });
             // bad token
             continue;
         }
@@ -166,7 +178,12 @@ async function doParse(iterator, options = {}) {
                     errors.push({
                         action: 'drop',
                         message: 'invalid block',
-                        rawTokens: tokens.slice()
+                        rawTokens: tokens.slice(),
+                        location: {
+                            src,
+                            sta: tokens[0].sta,
+                            end: tokens[tokens.length - 1].end
+                        }
                     });
                 }
             }
@@ -234,7 +251,6 @@ async function doParse(iterator, options = {}) {
                 }
             }
             catch (error) {
-                // console.error(error);
                 // @ts-ignore
                 errors.push({ action: 'ignore', message: 'doParse: ' + error.message, error });
             }
@@ -335,6 +351,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                 errors.push({
                     action: 'drop',
                     message: `CDOCOMM not allowed here ${JSON.stringify(tokens[i], null, 1)}`,
+                    node: tokens[i],
                     location
                 });
                 continue;
@@ -389,7 +406,8 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                         if (!(type == EnumToken.InvalidAtRuleTokenType &&
                             // @ts-ignore
                             ['charset', 'layer', 'import'].includes(context.chi[i].nam))) {
-                            errors.push({ action: 'drop', message: 'invalid @import', location });
+                            // @ts-ignore
+                            errors.push({ action: 'drop', message: 'invalid @import', location, rawTokens: [atRule, ...tokens] });
                             return null;
                         }
                     }
@@ -465,7 +483,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                         action: 'drop',
                         message: '@charset must have only one space',
                         // @ts-ignore
-                        location
+                        location, rawTokens: [atRule, ...tokens]
                     });
                     return null;
                 }
@@ -485,7 +503,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
         }
         const t = parseAtRulePrelude(parseTokens(tokens, { minify: options.minify }), atRule);
         const raw = t.reduce((acc, curr) => {
-            acc.push(renderToken(curr, { removeComments: true }));
+            acc.push(renderToken(curr, { removeComments: true, convertColor: false }));
             return acc;
         }, []);
         const nam = renderToken(atRule, { removeComments: true });
@@ -507,7 +525,6 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
             node.loc = loc;
             node.loc.end = { ...map.get(delim).end };
         }
-        // if (options.validation) {
         let isValid = true;
         if (node.nam == 'else') {
             const prev = getLastNode(context);
@@ -535,6 +552,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
             errors.push({
                 action: 'drop',
                 message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), '') + '"',
+                node,
                 // @ts-ignore
                 location: { src, ...(map.get(valid.node) ?? location) }
             });
@@ -544,6 +562,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
         else {
             node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr, {
                 minify: false,
+                convertColor: false,
                 removeComments: true
             }), '');
         }
@@ -582,7 +601,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                             if (curr.typ == EnumToken.IdenTokenType && curr.val == 'from') {
                                 Object.assign(curr, { typ: EnumToken.PercentageTokenType, val: '0' });
                             }
-                            else if (curr.typ == EnumToken.PercentageTokenType && curr.val == '100') {
+                            else if (curr.typ == EnumToken.PercentageTokenType && curr.val == 100) {
                                 Object.assign(curr, { typ: EnumToken.IdenTokenType, val: 'to' });
                             }
                         }
@@ -635,6 +654,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                 errors.push({
                     action: 'drop',
                     message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), '') + '"',
+                    node,
                     // @ts-ignore
                     location
                 });
@@ -659,7 +679,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                             val: tokens[i].val.charAt(0)
                         }, {
                             typ: EnumToken.NumberTokenType,
-                            val: tokens[i].val.slice(1)
+                            val: +tokens[i].val.slice(1)
                         });
                     }
                     else if (start == '/' && isFunction(val)) {
@@ -675,7 +695,7 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                 if (name == null && [EnumToken.IdenTokenType, EnumToken.DashedIdenTokenType].includes(tokens[i].typ)) {
                     name = tokens.slice(0, i + 1);
                 }
-                else if (name == null && tokens[i].typ == EnumToken.ColorTokenType && [ColorKind.SYS, ColorKind.DPSYS].includes(tokens[i].kin)) {
+                else if (name == null && tokens[i].typ == EnumToken.ColorTokenType && [ColorType.SYS, ColorType.DPSYS].includes(tokens[i].kin)) {
                     name = tokens.slice(0, i + 1);
                     tokens[i].typ = EnumToken.IdenTokenType;
                 }
@@ -784,12 +804,11 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                         value: valid.valid == SyntaxValidationResult.Valid
                     });
                     if (valid.valid == SyntaxValidationResult.Drop) {
-                        // console.error({result, valid});
-                        // console.error(JSON.stringify({result, options, valid}, null, 1));
                         errors.push({
                             action: 'drop',
                             message: valid.error,
                             syntax: valid.syntax,
+                            node: valid.node,
                             location: map.get(valid.node) ?? valid.node?.loc ?? result.loc ?? location
                         });
                         if (!options.lenient) {
@@ -861,9 +880,10 @@ function parseAtRulePrelude(tokens, atRule) {
                 }
             }
         }
+        const val = value.typ == EnumToken.IdenTokenType ? value.val.toLowerCase() : null;
         if (value.typ == EnumToken.IdenTokenType) {
             if (parent == null && mediaTypes.some((t) => {
-                if (value.val.localeCompare(t, 'en', { sensitivity: 'base' }) == 0) {
+                if (val === t) {
                     // @ts-ignore
                     value.typ = EnumToken.MediaFeatureTokenType;
                     return true;
@@ -872,18 +892,18 @@ function parseAtRulePrelude(tokens, atRule) {
             })) {
                 continue;
             }
-            if (value.typ == EnumToken.IdenTokenType && 'and'.localeCompare(value.val, 'en', { sensitivity: 'base' }) == 0) {
+            if (value.typ == EnumToken.IdenTokenType && 'and' === val) {
                 // @ts-ignore
                 value.typ = EnumToken.MediaFeatureAndTokenType;
                 continue;
             }
-            if (value.typ == EnumToken.IdenTokenType && 'or'.localeCompare(value.val, 'en', { sensitivity: 'base' }) == 0) {
+            if (value.typ == EnumToken.IdenTokenType && 'or' === val) {
                 // @ts-ignore
                 value.typ = EnumToken.MediaFeatureOrTokenType;
                 continue;
             }
             if (value.typ == EnumToken.IdenTokenType &&
-                ['not', 'only'].some((t) => t.localeCompare(value.val, 'en', { sensitivity: 'base' }) == 0)) {
+                ['not', 'only'].some((t) => val === t)) {
                 // @ts-ignore
                 const array = parent?.chi ?? tokens;
                 const startIndex = array.indexOf(value);
@@ -950,10 +970,7 @@ function parseAtRulePrelude(tokens, atRule) {
                 break;
             }
             if (valueIndex == -1) {
-                // @ts-ignore
-                // value.chi[nameIndex].typ = EnumToken.MediaFeatureTokenType;
                 continue;
-                // return tokens;
             }
             for (i = nameIndex + 1; i < value.chi.length; i++) {
                 if ([
@@ -965,7 +982,7 @@ function parseAtRulePrelude(tokens, atRule) {
                     const node = value.chi.splice(nameIndex, 1)[0];
                     // 'background'
                     // @ts-ignore
-                    if (node.typ == EnumToken.ColorTokenType && node.kin == ColorKind.DPSYS) {
+                    if (node.typ == EnumToken.ColorTokenType && node.kin == ColorType.DPSYS) {
                         // @ts-ignore
                         delete node.kin;
                         node.typ = EnumToken.IdenTokenType;
@@ -992,7 +1009,7 @@ function parseAtRulePrelude(tokens, atRule) {
  * @param tokens
  */
 function parseSelector(tokens) {
-    for (const { value, previousValue, nextValue, parent } of walkValues(tokens)) {
+    for (const { value, parent } of walkValues(tokens)) {
         if (value.typ == EnumToken.CommentTokenType ||
             value.typ == EnumToken.WhitespaceTokenType ||
             value.typ == EnumToken.CommaTokenType ||
@@ -1005,43 +1022,6 @@ function parseSelector(tokens) {
                 // @ts-ignore
                 value.typ = EnumToken.ChildCombinatorTokenType;
             }
-            // @ts-ignore
-            else if (value.typ == EnumToken.WhitespaceTokenType) {
-                if (nextValue != null && nextValue.typ == EnumToken.LiteralTokenType) {
-                    if (['>', '+', '~'].includes(nextValue.val)) {
-                        switch (value.val) {
-                            case '>':
-                                // @ts-ignore
-                                nextValue.typ = EnumToken.ChildCombinatorTokenType;
-                                break;
-                            case '+':
-                                // @ts-ignore
-                                nextValue.typ = EnumToken.NextSiblingCombinatorTokenType;
-                                break;
-                            case '~':
-                                // @ts-ignore
-                                nextValue.typ = EnumToken.SubsequentSiblingCombinatorTokenType;
-                                break;
-                        }
-                        // @ts-ignore
-                        delete nextValue.val;
-                        continue;
-                    }
-                }
-                if (previousValue != null && [
-                    EnumToken.ChildCombinatorTokenType,
-                    EnumToken.DescendantCombinatorTokenType,
-                    EnumToken.NextSiblingCombinatorTokenType,
-                    EnumToken.SubsequentSiblingCombinatorTokenType,
-                    EnumToken.ColumnCombinatorTokenType,
-                    EnumToken.NameSpaceAttributeTokenType,
-                    EnumToken.CommaTokenType
-                ].includes(previousValue.typ)) {
-                    continue;
-                }
-                // @ts-ignore
-                value.typ = EnumToken.DescendantCombinatorTokenType;
-            }
             else if (value.typ == EnumToken.LiteralTokenType) {
                 if (value.val.charAt(0) == '&') {
                     // @ts-ignore
@@ -1059,12 +1039,7 @@ function parseSelector(tokens) {
                         value.typ = EnumToken.ClassSelectorTokenType;
                     }
                 }
-                // @ts-ignore
-                if (value.typ == EnumToken.DelimTokenType) {
-                    // @ts-ignore
-                    value.typ = EnumToken.NextSiblingCombinatorTokenType;
-                }
-                else if (['*', '>', '+', '~'].includes(value.val)) {
+                if (['*', '>', '+', '~'].includes(value.val)) {
                     switch (value.val) {
                         case '*':
                             // @ts-ignore
@@ -1084,13 +1059,12 @@ function parseSelector(tokens) {
                             break;
                     }
                     // @ts-ignore
-                    // @ts-ignore
                     delete value.val;
                 }
             }
             else if (value.typ == EnumToken.ColorTokenType) {
-                if (value.kin == ColorKind.LIT || value.kin == ColorKind.HEX || value.kin == ColorKind.SYS || value.kin == ColorKind.DPSYS) {
-                    if (value.kin == ColorKind.HEX) {
+                if (value.kin == ColorType.LIT || value.kin == ColorType.HEX || value.kin == ColorType.SYS || value.kin == ColorType.DPSYS) {
+                    if (value.kin == ColorType.HEX) {
                         if (!isIdent(value.val.slice(1))) {
                             continue;
                         }
@@ -1130,10 +1104,6 @@ function parseSelector(tokens) {
     }
     return tokens;
 }
-// export async function parseDeclarations(src: string, options: ParserOptions = {}): Promise<AstDeclaration[]> {
-//
-//     return doParse(`.x{${src}`, options).then((result: ParseResult) => <AstDeclaration[]>(<AstRule>result.ast.chi[0]).chi.filter(t => t.typ == EnumToken.DeclarationNodeType));
-// }
 /**
  * parse css string
  * @param src
@@ -1223,14 +1193,14 @@ function getTokenType(val, hint) {
                 chi: []
             };
         }
-        if (['ease', 'ease-in', 'ease-out', 'ease-in-out', 'linear', 'step-start', 'step-end', 'steps', 'cubic-bezier'].includes(val)) {
+        if (timingFunc.includes(val.toLowerCase())) {
             return {
                 typ: EnumToken.TimingFunctionTokenType,
                 val,
                 chi: []
             };
         }
-        if (['view', 'scroll'].includes(val)) {
+        if (timelineFunc.includes(val)) {
             return {
                 typ: EnumToken.TimelineFunctionTokenType,
                 val,
@@ -1246,19 +1216,19 @@ function getTokenType(val, hint) {
     if (isNumber(val)) {
         return {
             typ: EnumToken.NumberTokenType,
-            val
+            val: +val
         };
     }
     if (isPercentage(val)) {
         return {
             typ: EnumToken.PercentageTokenType,
-            val: val.slice(0, -1)
+            val: +val.slice(0, -1)
         };
     }
     if (isFlex(val)) {
         return {
             typ: EnumToken.FlexTokenType,
-            val: val.slice(0, -2)
+            val: +val.slice(0, -2)
         };
     }
     if (isDimension(val)) {
@@ -1269,7 +1239,7 @@ function getTokenType(val, hint) {
         return {
             typ: EnumToken.ColorTokenType,
             val: v,
-            kin: ColorKind.LIT
+            kin: ColorType.LIT
         };
     }
     if (isIdent(val)) {
@@ -1277,14 +1247,14 @@ function getTokenType(val, hint) {
             return {
                 typ: EnumToken.ColorTokenType,
                 val,
-                kin: ColorKind.SYS
+                kin: ColorType.SYS
             };
         }
         if (deprecatedSystemColors.has(v)) {
             return {
                 typ: EnumToken.ColorTokenType,
                 val,
-                kin: ColorKind.DPSYS
+                kin: ColorType.DPSYS
             };
         }
         return {
@@ -1296,7 +1266,7 @@ function getTokenType(val, hint) {
         return {
             typ: EnumToken.ColorTokenType,
             val,
-            kin: ColorKind.HEX
+            kin: ColorType.HEX
         };
     }
     if (val.charAt(0) == '#' && isHash(val)) {
@@ -1373,7 +1343,6 @@ function parseTokens(tokens, options = {}) {
             }
             // @ts-ignore
             if (attr.chi.length > 1) {
-                /*(<AttrToken>t).chi =*/
                 // @ts-ignore
                 parseTokens(attr.chi, t.typ);
             }
@@ -1593,7 +1562,6 @@ function parseTokens(tokens, options = {}) {
             // @ts-ignore
             if (t.chi.length > 0) {
                 if (t.typ == EnumToken.PseudoClassFuncTokenType && t.val == ':is' && options.minify) {
-                    //
                     const count = t.chi.filter((t) => t.typ != EnumToken.CommentTokenType).length;
                     if (count == 1 ||
                         (i == 0 &&
@@ -1604,28 +1572,6 @@ function parseTokens(tokens, options = {}) {
                     }
                 }
             }
-            continue;
-        }
-        if (options.parseColor) {
-            if (t.typ == EnumToken.IdenTokenType) {
-                // named color
-                const value = t.val.toLowerCase();
-                if (value in COLORS_NAMES) {
-                    Object.assign(t, {
-                        typ: EnumToken.ColorTokenType,
-                        val: COLORS_NAMES[value].length < value.length ? COLORS_NAMES[value] : value,
-                        kin: ColorKind.HEX
-                    });
-                }
-                continue;
-            }
-            if (t.typ == EnumToken.HashTokenType && isHexColor(t.val)) {
-                // hex color
-                // @ts-ignore
-                t.typ = EnumToken.ColorTokenType;
-                // @ts-ignore
-                t.kin = ColorKind.HEX;
-            }
         }
     }
     return tokens;

package/dist/lib/parser/tokenize.js

@@ -3,8 +3,8 @@ import '../ast/minify.js';
 import '../ast/walk.js';
 import './parse.js';
 import './utils/config.js';
-import { isWhiteSpace, isIdentStart, isIdent, isNewLine, isDigit, isNonPrintable } from '../syntax/syntax.js';
-import '../renderer/color/utils/constants.js';
+import { isWhiteSpace, isIdentStart, isIdent, isNewLine, isDigit } from '../syntax/syntax.js';
+import '../syntax/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
 
 var TokenMap;
@@ -92,11 +92,6 @@ function* consumeString(quoteStr, buffer, parseInfo) {
                 }
                 break;
             }
-            if (i == 1) {
-                buffer += value + sequence[i];
-                next(parseInfo, 2);
-                continue;
-            }
             if (escapeSequence.trimEnd().length > 0) {
                 const codepoint = parseInt(escapeSequence, 16);
                 if (codepoint == 0 ||
@@ -119,7 +114,6 @@ function* consumeString(quoteStr, buffer, parseInfo) {
             buffer += value;
             yield pushToken(buffer, parseInfo, hasNewLine ? EnumToken.BadStringTokenType : EnumToken.StringTokenType);
             next(parseInfo);
-            // i += value.length;
             buffer = '';
             return;
         }
@@ -161,15 +155,9 @@ function prev(parseInfo, count = 1) {
 function next(parseInfo, count = 1) {
     let char = '';
     let chr = '';
-    if (count < 0) {
-        return '';
-    }
     while (count-- && (chr = parseInfo.stream.charAt(parseInfo.currentPosition.ind + 1))) {
         char += chr;
         const codepoint = parseInfo.stream.charCodeAt(++parseInfo.currentPosition.ind);
-        if (isNaN(codepoint)) {
-            return char;
-        }
         if (isNewLine(codepoint)) {
             parseInfo.currentPosition.lin++;
             parseInfo.currentPosition.col = 0;
@@ -436,8 +424,6 @@ function* tokenize(stream) {
                     value = peek(parseInfo);
                     // let cp: number;
                     let whitespace = '';
-                    let hasWhiteSpace = false;
-                    let errorState = false;
                     if (value == '"' || value == "'") {
                         const quote = value;
                         let inquote = true;
@@ -477,7 +463,6 @@ function* tokenize(stream) {
                                 if (isWhiteSpace(charCode)) {
                                     whitespace += value;
                                     while (value = peek(parseInfo)) {
-                                        hasWhiteSpace = true;
                                         if (isWhiteSpace(value?.charCodeAt(0))) {
                                             whitespace += next(parseInfo);
                                             continue;
@@ -533,42 +518,33 @@ function* tokenize(stream) {
                                 buffer = '';
                                 break;
                             }
-                            if (isWhiteSpace(charCode)) {
-                                hasWhiteSpace = true;
-                                whitespace = value;
-                                while (isWhiteSpace(peek(parseInfo)?.charCodeAt(0))) {
-                                    whitespace += next(parseInfo);
-                                }
-                                continue;
-                            }
-                            if (isNonPrintable(charCode) ||
-                                // '"'
-                                charCode == 0x22 ||
-                                // "'"
-                                charCode == 0x27 ||
-                                // \('
-                                charCode == 0x28 ||
-                                hasWhiteSpace) {
-                                errorState = true;
-                            }
-                            if (errorState) {
-                                buffer += whitespace + value;
-                                while (value = peek(parseInfo)) {
-                                    charCode = value.charCodeAt(0);
-                                    if (charCode == 0x5c) {
-                                        buffer += next(parseInfo, 2);
-                                        continue;
-                                    }
-                                    // ')'
-                                    if (charCode == 0x29) {
-                                        break;
-                                    }
-                                    buffer += next(parseInfo);
-                                }
-                                yield pushToken(buffer, parseInfo, EnumToken.BadUrlTokenType);
-                                buffer = '';
-                                break;
-                            }
+                            // if (errorState) {
+                            //
+                            //     buffer += whitespace + value;
+                            //
+                            //     while (value = peek(parseInfo)) {
+                            //
+                            //         charCode = value.charCodeAt(0);
+                            //
+                            //         if (charCode == 0x5c) {
+                            //
+                            //             buffer += next(parseInfo, 2);
+                            //             continue;
+                            //         }
+                            //
+                            //         // ')'
+                            //         if (charCode == 0x29) {
+                            //
+                            //             break;
+                            //         }
+                            //
+                            //         buffer += next(parseInfo);
+                            //     }
+                            //
+                            //     yield pushToken(buffer, parseInfo, EnumToken.BadUrlTokenType);
+                            //     buffer = '';
+                            //     break;
+                            // }
                             buffer += value;
                         }
                     }

package/dist/lib/parser/utils/declaration.js

@@ -5,7 +5,7 @@ import '../parse.js';
 import '../tokenize.js';
 import './config.js';
 import { isWhiteSpace } from '../../syntax/syntax.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function parseDeclarationNode(node, errors, location) {

package/dist/lib/parser/utils/type.js

@@ -5,7 +5,7 @@ import '../parse.js';
 import '../tokenize.js';
 import './config.js';
 import { mathFuncs } from '../../syntax/syntax.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function matchType(val, properties) {
@@ -14,7 +14,7 @@ function matchType(val, properties) {
         (properties.types.some((t) => EnumToken[t] == val.typ))) {
         return true;
     }
-    if (val.typ == EnumToken.NumberTokenType && val.val == '0') {
+    if (val.typ == EnumToken.NumberTokenType && val.val == 0) {
         // @ts-ignore
         return properties.types.some((type) => {
             // @ts-ignore