@tbela99/css-parser 0.8.0 → 0.9.1

package/dist/lib/parser/parse.js

@@ -1,4 +1,4 @@
-import { isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isIdent, isHexColor, isHash, isIdentStart, mathFuncs, isColor, mediaTypes } from '../syntax/syntax.js';
+import { webkitPseudoAliasMap, isIdentStart, isIdent, mathFuncs, isColor, isHexColor, isPseudo, pseudoElements, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isHash, mediaTypes } from '../syntax/syntax.js';
 import './utils/config.js';
 import { EnumToken, funcLike, ValidationLevel } from '../ast/types.js';
 import { minify, definedPropertySettings, combinators } from '../ast/minify.js';
@@ -13,6 +13,7 @@ import '../validation/parser/types.js';
 import '../validation/parser/parse.js';
 import { validateSelector } from '../validation/selector.js';
 import { validateAtRule } from '../validation/atrule.js';
+import '../validation/syntaxes/complex-selector.js';
 
 const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
 const trimWhiteSpace = [EnumToken.CommentTokenType, EnumToken.GtTokenType, EnumToken.GteTokenType, EnumToken.LtTokenType, EnumToken.LteTokenType, EnumToken.ColumnCombinatorTokenType];
@@ -29,51 +30,14 @@ const enumTokenHints = new Set([
     EnumToken.StartMatchTokenType, EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType, EnumToken.DashMatchTokenType, EnumToken.ContainMatchTokenType,
     EnumToken.EOFTokenType
 ]);
-const webkitPseudoAliasMap = {
-    '-webkit-autofill': 'autofill',
-    '-webkit-any': 'is',
-    '-moz-any': 'is',
-    '-webkit-border-after': 'border-block-end',
-    '-webkit-border-after-color': 'border-block-end-color',
-    '-webkit-border-after-style': 'border-block-end-style',
-    '-webkit-border-after-width': 'border-block-end-width',
-    '-webkit-border-before': 'border-block-start',
-    '-webkit-border-before-color': 'border-block-start-color',
-    '-webkit-border-before-style': 'border-block-start-style',
-    '-webkit-border-before-width': 'border-block-start-width',
-    '-webkit-border-end': 'border-inline-end',
-    '-webkit-border-end-color': 'border-inline-end-color',
-    '-webkit-border-end-style': 'border-inline-end-style',
-    '-webkit-border-end-width': 'border-inline-end-width',
-    '-webkit-border-start': 'border-inline-start',
-    '-webkit-border-start-color': 'border-inline-start-color',
-    '-webkit-border-start-style': 'border-inline-start-style',
-    '-webkit-border-start-width': 'border-inline-start-width',
-    '-webkit-box-align': 'align-items',
-    '-webkit-box-direction': 'flex-direction',
-    '-webkit-box-flex': 'flex-grow',
-    '-webkit-box-lines': 'flex-flow',
-    '-webkit-box-ordinal-group': 'order',
-    '-webkit-box-orient': 'flex-direction',
-    '-webkit-box-pack': 'justify-content',
-    '-webkit-column-break-after': 'break-after',
-    '-webkit-column-break-before': 'break-before',
-    '-webkit-column-break-inside': 'break-inside',
-    '-webkit-font-feature-settings': 'font-feature-settings',
-    '-webkit-hyphenate-character': 'hyphenate-character',
-    '-webkit-initial-letter': 'initial-letter',
-    '-webkit-margin-end': 'margin-block-end',
-    '-webkit-margin-start': 'margin-block-start',
-    '-webkit-padding-after': 'padding-block-end',
-    '-webkit-padding-before': 'padding-block-start',
-    '-webkit-padding-end': 'padding-inline-end',
-    '-webkit-padding-start': 'padding-inline-start',
-    '-webkit-min-device-pixel-ratio': 'min-resolution',
-    '-webkit-max-device-pixel-ratio': 'max-resolution'
-};
 function reject(reason) {
     throw new Error(reason ?? 'Parsing aborted');
 }
+/**
+ * parse css string
+ * @param iterator
+ * @param options
+ */
 async function doParse(iterator, options = {}) {
     if (options.signal != null) {
         options.signal.addEventListener('abort', reject);
@@ -82,6 +46,7 @@ async function doParse(iterator, options = {}) {
         src: '',
         sourcemap: false,
         minify: true,
+        pass: 1,
         parseColor: true,
         nestingRules: false,
         resolveImport: false,
@@ -95,6 +60,7 @@ async function doParse(iterator, options = {}) {
         setParent: true,
         removePrefix: false,
         validation: true,
+        lenient: true,
         ...options
     };
     if (options.expandNestingRules) {
@@ -133,9 +99,10 @@ async function doParse(iterator, options = {}) {
     }
     const iter = tokenize(iterator);
     let item;
+    const rawTokens = [];
     while (item = iter.next().value) {
         stats.bytesIn = item.bytesIn;
-        //
+        rawTokens.push(item);
         // doParse error
         if (item.hint != null && BadTokensTypes.includes(item.hint)) {
             // bad token
@@ -145,7 +112,8 @@ async function doParse(iterator, options = {}) {
             tokens.push(item);
         }
         if (item.token == ';' || item.token == '{') {
-            let node = await parseNode(tokens, context, stats, options, errors, src, map);
+            let node = await parseNode(tokens, context, stats, options, errors, src, map, rawTokens);
+            rawTokens.length = 0;
             if (node != null) {
                 // @ts-ignore
                 stack.push(node);
@@ -171,7 +139,8 @@ async function doParse(iterator, options = {}) {
             map = new Map;
         }
         else if (item.token == '}') {
-            await parseNode(tokens, context, stats, options, errors, src, map);
+            await parseNode(tokens, context, stats, options, errors, src, map, rawTokens);
+            rawTokens.length = 0;
             const previousNode = stack.pop();
             // @ts-ignore
             context = stack[stack.length - 1] ?? ast;
@@ -194,9 +163,10 @@ async function doParse(iterator, options = {}) {
         }
     }
     if (tokens.length > 0) {
-        await parseNode(tokens, context, stats, options, errors, src, map);
+        await parseNode(tokens, context, stats, options, errors, src, map, rawTokens);
+        rawTokens.length = 0;
         if (context != null && context.typ == EnumToken.InvalidRuleTokenType) {
-            const index = context.chi.findIndex(node => node == context);
+            const index = context.chi.findIndex((node) => node == context);
             if (index > -1) {
                 context.chi.splice(index, 1);
             }
@@ -206,6 +176,7 @@ async function doParse(iterator, options = {}) {
         const previousNode = stack.pop();
         // @ts-ignore
         context = stack[stack.length - 1] ?? ast;
+        // remove empty nodes
         // @ts-ignore
         if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
             // @ts-ignore
@@ -255,36 +226,12 @@ async function doParse(iterator, options = {}) {
     }
     if (options.minify) {
         if (ast.chi.length > 0) {
-            minify(ast, options, true, errors, false);
+            let passes = options.pass ?? 1;
+            while (passes--) {
+                minify(ast, options, true, errors, false);
+            }
         }
     }
-    // if (options.setParent) {
-    //
-    //     const nodes: Array<AstRule | AstAtRule | AstRuleStyleSheet> = [ast];
-    //     let node: AstNode;
-    //
-    //     while ((node = nodes.shift()!)) {
-    //
-    //         // @ts-ignore
-    //         if (node.chi.length > 0) {
-    //
-    //             // @ts-ignore
-    //             for (const child of node.chi) {
-    //
-    //                 if (child.parent != node) {
-    //
-    //                     Object.defineProperty(child, 'parent', {...definedPropertySettings, value: node});
-    //                 }
-    //
-    //                 if ('chi' in child && child.chi.length > 0) {
-    //
-    //                     // @ts-ignore
-    //                     nodes.push(<AstRule | AstAtRule>child);
-    //                 }
-    //             }
-    //         }
-    //     }
-    // }
     const endTime = performance.now();
     if (options.signal != null) {
         options.signal.removeEventListener('abort', reject);
@@ -301,7 +248,17 @@ async function doParse(iterator, options = {}) {
         }
     };
 }
-async function parseNode(results, context, stats, options, errors, src, map) {
+function getLastNode(context) {
+    let i = context.chi.length;
+    while (i--) {
+        if ([EnumToken.CommentTokenType, EnumToken.CDOCOMMTokenType, EnumToken.WhitespaceTokenType].includes(context.chi[i].typ)) {
+            continue;
+        }
+        return context.chi[i];
+    }
+    return null;
+}
+async function parseNode(results, context, stats, options, errors, src, map, rawTokens) {
     let tokens = [];
     for (const t of results) {
         const node = getTokenType(t.token, t.hint);
@@ -356,24 +313,6 @@ async function parseNode(results, context, stats, options, errors, src, map) {
     if (tokens[0]?.typ == EnumToken.AtRuleTokenType) {
         const atRule = tokens.shift();
         const position = map.get(atRule);
-        // if (atRule.val == 'charset') {
-        //
-        //     if (context.typ  != EnumToken.StyleSheetNodeType || context.chi.some(t => t.typ != EnumToken.CDOCOMMTokenType && t.typ != EnumToken.CommentNodeType)) {
-        //
-        //         errors.push({
-        //             action: 'drop',
-        //             message: 'doParse: invalid @charset',
-        //             location: {src, ...position}
-        //         });
-        //
-        //         return null;
-        //     }
-        //
-        //     if (options.removeCharset) {
-        //
-        //         return null;
-        //     }
-        // }
         // @ts-ignore
         while ([EnumToken.WhitespaceTokenType].includes(tokens[0]?.typ)) {
             tokens.shift();
@@ -391,8 +330,13 @@ async function parseNode(results, context, stats, options, errors, src, map) {
                         continue;
                     }
                     if (type != EnumToken.AtRuleNodeType) {
-                        errors.push({ action: 'drop', message: 'invalid @import', location: { src, ...position } });
-                        return null;
+                        // @ts-ignore
+                        if (!(type == EnumToken.InvalidAtRuleTokenType &&
+                            // @ts-ignore
+                            ['charset', 'layer', 'import'].includes(context.chi[i].nam))) {
+                            errors.push({ action: 'drop', message: 'invalid @import', location: { src, ...position } });
+                            return null;
+                        }
                     }
                     // @ts-ignore
                     const name = context.chi[i].nam;
@@ -427,12 +371,20 @@ async function parseNode(results, context, stats, options, errors, src, map) {
             if (tokens[0].typ == EnumToken.UrlFunctionTokenType) {
                 if (tokens[1].typ == EnumToken.UrlTokenTokenType || tokens[1].typ == EnumToken.StringTokenType) {
                     tokens.shift();
-                    if (tokens[1].typ == EnumToken.UrlTokenTokenType) {
+                    if (tokens[0]?.typ == EnumToken.UrlTokenTokenType) {
                         // @ts-ignore
                         tokens[0].typ = EnumToken.StringTokenType;
                         // @ts-ignore
                         tokens[0].val = `"${tokens[0].val}"`;
                     }
+                    // @ts-ignore
+                    while (tokens[1]?.typ == EnumToken.WhitespaceTokenType || tokens[1]?.typ == EnumToken.CommentTokenType) {
+                        tokens.splice(1, 1);
+                    }
+                    // @ts-ignore
+                    if (tokens[1]?.typ == EnumToken.EndParensTokenType) {
+                        tokens.splice(1, 1);
+                    }
                 }
             }
             // @ts-ignore
@@ -470,8 +422,43 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         // https://www.w3.org/TR/css-nesting-1/#conditionals
         // allowed nesting at-rules
         // there must be a top level rule in the stack
-        if (atRule.val == 'charset' && options.removeCharset) {
-            return null;
+        if (atRule.val == 'charset') {
+            let spaces = 0;
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/@charset
+            for (let k = 1; k < rawTokens.length; k++) {
+                if (rawTokens[k].hint == EnumToken.WhitespaceTokenType) {
+                    spaces += rawTokens[k].len;
+                    continue;
+                }
+                if (rawTokens[k].hint == EnumToken.CommentTokenType) {
+                    continue;
+                }
+                if (rawTokens[k].hint == EnumToken.CDOCOMMTokenType) {
+                    continue;
+                }
+                if (spaces > 1) {
+                    errors.push({
+                        action: 'drop',
+                        message: '@charset must have only one space',
+                        // @ts-ignore
+                        location: { src, ...(map.get(atRule) ?? position) }
+                    });
+                    return null;
+                }
+                if (rawTokens[k].hint != EnumToken.StringTokenType || rawTokens[k].token[0] != '"') {
+                    errors.push({
+                        action: 'drop',
+                        message: '@charset expects a "<charset>"',
+                        // @ts-ignore
+                        location: { src, ...(map.get(atRule) ?? position) }
+                    });
+                    return null;
+                }
+                break;
+            }
+            if (options.removeCharset) {
+                return null;
+            }
         }
         const t = parseAtRulePrelude(parseTokens(tokens, { minify: options.minify }), atRule);
         const raw = t.reduce((acc, curr) => {
@@ -481,11 +468,11 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         const node = {
             typ: EnumToken.AtRuleNodeType,
             nam: renderToken(atRule, { removeComments: true }),
-            tokens: t,
+            // tokens: t,
             val: raw.join('')
         };
         Object.defineProperties(node, {
-            tokens: { ...definedPropertySettings, enumerable: true, value: tokens.slice() },
+            tokens: { ...definedPropertySettings, enumerable: false, value: tokens.slice() },
             raw: { ...definedPropertySettings, value: raw }
         });
         if (delim.typ == EnumToken.BlockStartTokenType) {
@@ -499,11 +486,36 @@ async function parseNode(results, context, stats, options, errors, src, map) {
             node.loc = loc;
         }
         if (options.validation) {
-            const valid = validateAtRule(node, options, context);
+            let isValid = true;
+            if (node.nam == 'else') {
+                const prev = getLastNode(context);
+                if (prev != null && prev.typ == EnumToken.AtRuleNodeType && ['when', 'else'].includes(prev.nam)) {
+                    if (prev.nam == 'else') {
+                        isValid = Array.isArray(prev.tokens) && prev.tokens.length > 0;
+                    }
+                }
+                else {
+                    isValid = false;
+                }
+            }
+            const valid = isValid ? validateAtRule(node, options, context) : {
+                valid: ValidationLevel.Drop,
+                node,
+                syntax: '@' + node.nam,
+                error: '@' + node.nam + ' not allowed here'};
             if (valid.valid == ValidationLevel.Drop) {
+                errors.push({
+                    action: 'drop',
+                    message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), '') + '"',
+                    // @ts-ignore
+                    location: { src, ...(map.get(valid.node) ?? position) }
+                });
                 // @ts-ignore
                 node.typ = EnumToken.InvalidAtRuleTokenType;
             }
+            else {
+                node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false, removeComments: true }), '');
+            }
         }
         // @ts-ignore
         context.chi.push(node);
@@ -585,7 +597,7 @@ async function parseNode(results, context, stats, options, errors, src, map) {
             };
             Object.defineProperty(node, 'tokens', {
                 ...definedPropertySettings,
-                enumerable: true,
+                enumerable: false,
                 value: tokens.slice()
             });
             let raw = [...uniq.values()];
@@ -682,7 +694,24 @@ async function parseNode(results, context, stats, options, errors, src, map) {
             };
             const result = parseDeclarationNode(node, errors, src, position);
             if (result != null) {
-                if (options.validation) ;
+                // if (options.validation) {
+                //
+                //     const valid: ValidationResult = validateDeclaration(result, options, context);
+                //
+                //     // console.error({valid});
+                //
+                //     if (valid.valid == ValidationLevel.Drop) {
+                //
+                //         errors.push({
+                //             action: 'drop',
+                //             message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, {minify: false}), '') + '"',
+                //             // @ts-ignore
+                //             location: {src, ...(map.get(valid.node) ?? position)}
+                //         });
+                //
+                //         return null;
+                //     }
+                // }
                 // @ts-ignore
                 context.chi.push(result);
                 Object.defineProperty(result, 'parent', { ...definedPropertySettings, value: context });
@@ -691,6 +720,11 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         }
     }
 }
+/**
+ * parse at-rule prelude
+ * @param tokens
+ * @param atRule
+ */
 function parseAtRulePrelude(tokens, atRule) {
     // @ts-ignore
     for (const { value, parent } of walkValues(tokens, null, null, true)) {
@@ -759,17 +793,18 @@ function parseAtRulePrelude(tokens, atRule) {
                 continue;
             }
         }
-        if (value.typ == EnumToken.ParensTokenType) {
+        if (value.typ == EnumToken.ParensTokenType || (value.typ == EnumToken.FunctionTokenType && ['media', 'supports', 'style', 'scroll-state'].includes(value.val))) {
             // @todo parse range and declarations
             // parseDeclaration(parent.chi);
             let i;
             let nameIndex = -1;
             let valueIndex = -1;
+            const dashedIdent = value.typ == EnumToken.FunctionTokenType && value.val == 'style';
             for (let i = 0; i < value.chi.length; i++) {
                 if (value.chi[i].typ == EnumToken.CommentTokenType || value.chi[i].typ == EnumToken.WhitespaceTokenType) {
                     continue;
                 }
-                if (value.chi[i].typ == EnumToken.IdenTokenType) {
+                if ((dashedIdent && value.chi[i].typ == EnumToken.DashedIdenTokenType) || value.chi[i].typ == EnumToken.IdenTokenType || value.chi[i].typ == EnumToken.FunctionTokenType || value.chi[i].typ == EnumToken.ColorTokenType) {
                     nameIndex = i;
                 }
                 break;
@@ -798,6 +833,13 @@ function parseAtRulePrelude(tokens, atRule) {
                 ].includes(value.chi[valueIndex].typ)) {
                     const val = value.chi.splice(valueIndex, 1)[0];
                     const node = value.chi.splice(nameIndex, 1)[0];
+                    // 'background'
+                    // @ts-ignore
+                    if (node.typ == EnumToken.ColorTokenType && node.kin == 'dpsys') {
+                        // @ts-ignore
+                        delete node.kin;
+                        node.typ = EnumToken.IdenTokenType;
+                    }
                     while (value.chi[0]?.typ == EnumToken.WhitespaceTokenType) {
                         value.chi.shift();
                     }
@@ -815,6 +857,10 @@ function parseAtRulePrelude(tokens, atRule) {
     }
     return tokens;
 }
+/**
+ * parse selector
+ * @param tokens
+ */
 function parseSelector(tokens) {
     for (const { value, previousValue, nextValue, parent } of walkValues(tokens)) {
         if (value.typ == EnumToken.CommentTokenType ||
@@ -958,6 +1004,11 @@ function parseSelector(tokens) {
 //
 //     return doParse(`.x{${src}`, options).then((result: ParseResult) => <AstDeclaration[]>(<AstRule>result.ast.chi[0]).chi.filter(t => t.typ == EnumToken.DeclarationNodeType));
 // }
+/**
+ * parse string
+ * @param src
+ * @param options
+ */
 function parseString(src, options = { location: false }) {
     return parseTokens([...tokenize(src)].map(t => {
         const token = getTokenType(t.token, t.hint);
@@ -1019,10 +1070,16 @@ function getTokenType(val, hint) {
             val: val.slice(0, -1),
             chi: []
         }
-            : {
-                typ: EnumToken.PseudoClassTokenType,
+            : (
+            // https://www.w3.org/TR/selectors-4/#single-colon-pseudos
+            val.startsWith('::') || pseudoElements.includes(val) ? {
+                typ: EnumToken.PseudoElementTokenType,
                 val
-            };
+            } :
+                {
+                    typ: EnumToken.PseudoClassTokenType,
+                    val
+                });
     }
     if (isAtKeyword(val)) {
         return {
@@ -1039,7 +1096,7 @@ function getTokenType(val, hint) {
                 chi: []
             };
         }
-        if (['linear-gradient', 'radial-gradient', 'repeating-linear-gradient', 'repeating-radial-gradient', 'conic-gradient', 'image', 'image-set', 'element', 'cross-fade'].includes(val)) {
+        if (['linear-gradient', 'radial-gradient', 'repeating-linear-gradient', 'repeating-radial-gradient', 'conic-gradient', 'image', 'image-set', 'element', 'cross-fade', 'paint'].includes(val)) {
             return {
                 typ: EnumToken.ImageFunctionTokenType,
                 val,
@@ -1139,6 +1196,11 @@ function getTokenType(val, hint) {
         val
     };
 }
+/**
+ * parse token list
+ * @param tokens
+ * @param options
+ */
 function parseTokens(tokens, options = {}) {
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
@@ -1194,25 +1256,25 @@ function parseTokens(tokens, options = {}) {
                     break;
                 }
             }
-            Object.assign(t, {
+            const attr = Object.assign(t, {
                 typ: inAttr == 0 ? EnumToken.AttrTokenType : EnumToken.InvalidAttrTokenType,
                 chi: tokens.splice(i + 1, k - i)
             });
             // @ts-ignore
-            if (t.chi.at(-1).typ == EnumToken.AttrEndTokenType) {
+            if (attr.chi.at(-1).typ == EnumToken.AttrEndTokenType) {
                 // @ts-ignore
-                t.chi.pop();
+                attr.chi.pop();
             }
             // @ts-ignore
-            if (t.chi.length > 1) {
+            if (attr.chi.length > 1) {
                 /*(<AttrToken>t).chi =*/
                 // @ts-ignore
-                parseTokens(t.chi, t.typ);
+                parseTokens(attr.chi, t.typ);
             }
-            let m = t.chi.length;
+            let m = attr.chi.length;
             let val;
-            for (m = 0; m < t.chi.length; m++) {
-                val = t.chi[m];
+            for (m = 0; m < attr.chi.length; m++) {
+                val = attr.chi[m];
                 if (val.typ == EnumToken.StringTokenType) {
                     const slice = val.val.slice(1, -1);
                     if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
@@ -1222,55 +1284,55 @@ function parseTokens(tokens, options = {}) {
                 else if (val.typ == EnumToken.LiteralTokenType && val.val == '|') {
                     let upper = m;
                     let lower = m;
-                    while (++upper < t.chi.length) {
-                        if (t.chi[upper].typ == EnumToken.CommentTokenType) {
+                    while (++upper < attr.chi.length) {
+                        if (attr.chi[upper].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
                     while (lower-- > 0) {
-                        if (t.chi[lower].typ == EnumToken.CommentTokenType) {
+                        if (attr.chi[lower].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
                     // @ts-ignore
-                    t.chi[m] = {
+                    attr.chi[m] = {
                         typ: EnumToken.NameSpaceAttributeTokenType,
-                        l: t.chi[lower],
-                        r: t.chi[upper]
+                        l: attr.chi[lower],
+                        r: attr.chi[upper]
                     };
-                    t.chi.splice(upper, 1);
+                    attr.chi.splice(upper, 1);
                     if (lower >= 0) {
-                        t.chi.splice(lower, 1);
+                        attr.chi.splice(lower, 1);
                         m--;
                     }
                 }
                 else if ([
                     EnumToken.DashMatchTokenType, EnumToken.StartMatchTokenType, EnumToken.ContainMatchTokenType, EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType, EnumToken.DelimTokenType
-                ].includes(t.chi[m].typ)) {
+                ].includes(attr.chi[m].typ)) {
                     let upper = m;
                     let lower = m;
-                    while (++upper < t.chi.length) {
-                        if (t.chi[upper].typ == EnumToken.CommentTokenType) {
+                    while (++upper < attr.chi.length) {
+                        if (attr.chi[upper].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
                     while (lower-- > 0) {
-                        if (t.chi[lower].typ == EnumToken.CommentTokenType) {
+                        if (attr.chi[lower].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
-                    val = t.chi[lower];
+                    val = attr.chi[lower];
                     if (val.typ == EnumToken.StringTokenType) {
                         const slice = val.val.slice(1, -1);
                         if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
                             Object.assign(val, { typ: EnumToken.IdenTokenType, val: slice });
                         }
                     }
-                    val = t.chi[upper];
+                    val = attr.chi[upper];
                     if (val.typ == EnumToken.StringTokenType) {
                         const slice = val.val.slice(1, -1);
                         if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
@@ -1390,7 +1452,9 @@ function parseTokens(tokens, options = {}) {
                 t.typ = EnumToken.ColorTokenType;
                 // @ts-ignore
                 t.kin = t.val;
+                // @ts-ignore
                 if (t.chi[0].typ == EnumToken.IdenTokenType) {
+                    // @ts-ignore
                     if (t.chi[0].val == 'from') {
                         // @ts-ignore
                         t.cal = 'rel';
@@ -1400,10 +1464,11 @@ function parseTokens(tokens, options = {}) {
                         // @ts-ignore
                         t.cal = 'mix';
                     }
-                    else if (t.val == 'color') {
-                        // @ts-ignore
-                        t.cal = 'col';
-                        // t.chi = t.chi.filter((t: Token) => [EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(t.typ));
+                    else { // @ts-ignore
+                        if (t.val == 'color') {
+                            // @ts-ignore
+                            t.cal = 'col';
+                        }
                     }
                 }
                 const filter = [EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType];
@@ -1437,7 +1502,7 @@ function parseTokens(tokens, options = {}) {
             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;
+                    const count = t.chi.filter((t) => t.typ != EnumToken.CommentTokenType).length;
                     if (count == 1 ||
                         (i == 0 &&
                             (tokens[i + 1]?.typ == EnumToken.CommaTokenType || tokens.length == i + 1)) ||
@@ -1474,4 +1539,4 @@ function parseTokens(tokens, options = {}) {
     return tokens;
 }
 
-export { doParse, parseAtRulePrelude, parseSelector, parseString, parseTokens, urlTokenMatcher };
+export { doParse, parseSelector, parseString, parseTokens, urlTokenMatcher };