@tbela99/css-parser 0.9.0 → 1.0.0

package/dist/lib/ast/walk.js

@@ -1,5 +1,12 @@
 import { EnumToken } from './types.js';
 
+var WalkerOptionEnum;
+(function (WalkerOptionEnum) {
+    WalkerOptionEnum[WalkerOptionEnum["Ignore"] = 0] = "Ignore";
+    WalkerOptionEnum[WalkerOptionEnum["Stop"] = 1] = "Stop";
+    WalkerOptionEnum[WalkerOptionEnum["Children"] = 2] = "Children";
+    WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 3] = "IgnoreChildren";
+})(WalkerOptionEnum || (WalkerOptionEnum = {}));
 var WalkerValueEvent;
 (function (WalkerValueEvent) {
     WalkerValueEvent[WalkerValueEvent["Enter"] = 0] = "Enter";
@@ -18,10 +25,10 @@ function* walk(node, filter) {
         let option = null;
         if (filter != null) {
             option = filter(node);
-            if (option === 'ignore') {
+            if (option === WalkerOptionEnum.Ignore) {
                 continue;
             }
-            if (option === 'stop') {
+            if (option === WalkerOptionEnum.Stop) {
                 break;
             }
         }
@@ -30,7 +37,7 @@ function* walk(node, filter) {
             // @ts-ignore
             yield { node, parent: map.get(node), root };
         }
-        if (option !== 'ignore-children' && 'chi' in node) {
+        if (option !== WalkerOptionEnum.IgnoreChildren && 'chi' in node) {
             parents.unshift(...node.chi);
             for (const child of node.chi.slice()) {
                 map.set(child, node);
@@ -62,19 +69,20 @@ function* walkValues(values, root = null, filter, reverse) {
             event: WalkerValueEvent.Enter
         };
     }
+    const eventType = filter.event ?? WalkerValueEvent.Enter;
     while (stack.length > 0) {
         let value = reverse ? stack.pop() : stack.shift();
         let option = null;
-        if (filter.fn != null && filter.event == WalkerValueEvent.Enter) {
+        if (filter.fn != null && eventType == WalkerValueEvent.Enter) {
             const isValid = filter.type == null || value.typ == filter.type ||
                 (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
                 (typeof filter.type == 'function' && filter.type(value));
             if (isValid) {
-                option = filter.fn(value, map.get(value) ?? root, WalkerValueEvent.Enter);
-                if (option === 'ignore') {
+                option = filter.fn(value, map.get(value) ?? root);
+                if (option === WalkerOptionEnum.Ignore) {
                     continue;
                 }
-                if (option === 'stop') {
+                if (option === WalkerOptionEnum.Stop) {
                     break;
                 }
                 // @ts-ignore
@@ -83,8 +91,7 @@ function* walkValues(values, root = null, filter, reverse) {
                 }
             }
         }
-        // @ts-ignore
-        if (filter.event == WalkerValueEvent.Enter && option !== 'children') {
+        if (eventType == WalkerValueEvent.Enter && option !== WalkerOptionEnum.Children) {
             yield {
                 value,
                 parent: map.get(value) ?? root,
@@ -94,7 +101,7 @@ function* walkValues(values, root = null, filter, reverse) {
                 root: root ?? null
             };
         }
-        if (option !== 'ignore-children' && 'chi' in value) {
+        if (option !== WalkerOptionEnum.IgnoreChildren && 'chi' in value) {
             const sliced = value.chi.slice();
             for (const child of sliced) {
                 map.set(child, value);
@@ -107,24 +114,23 @@ function* walkValues(values, root = null, filter, reverse) {
             }
         }
         else if (value.typ == EnumToken.BinaryExpressionTokenType) {
-            map.set(value.l, map.get(value) ?? root);
-            map.set(value.r, map.get(value) ?? root);
+            map.set(value.l, value);
+            map.set(value.r, value);
             stack.unshift(value.l, value.r);
         }
-        if (filter.event == WalkerValueEvent.Leave && filter.fn != null) {
+        if (eventType == WalkerValueEvent.Leave && filter.fn != null) {
             const isValid = filter.type == null || value.typ == filter.type ||
                 (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
                 (typeof filter.type == 'function' && filter.type(value));
             if (isValid) {
-                option = filter.fn(value, map.get(value), WalkerValueEvent.Leave);
+                option = filter.fn(value, map.get(value));
                 // @ts-ignore
                 if (option != null && 'typ' in option) {
                     map.set(option, map.get(value) ?? root);
                 }
             }
         }
-        // @ts-ignore
-        if (filter.event == WalkerValueEvent.Leave && option !== 'children') {
+        if (eventType == WalkerValueEvent.Leave && option !== WalkerOptionEnum.Children) {
             yield {
                 value,
                 parent: map.get(value) ?? root,
@@ -138,4 +144,4 @@ function* walkValues(values, root = null, filter, reverse) {
     }
 }
 
-export { WalkerValueEvent, walk, walkValues };
+export { WalkerOptionEnum, WalkerValueEvent, walk, walkValues };

package/dist/lib/parser/parse.js

@@ -1,8 +1,8 @@
-import { webkitPseudoAliasMap, isIdentStart, isIdent, mathFuncs, isColor, isHexColor, isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isHash, 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';
-import { walkValues, walk } from '../ast/walk.js';
+import { walkValues, walk, WalkerOptionEnum } from '../ast/walk.js';
 import { expand } from '../ast/expand.js';
 import { parseDeclarationNode } from './utils/declaration.js';
 import { renderToken } from '../renderer/render.js';
@@ -14,6 +14,8 @@ import '../validation/parser/parse.js';
 import { validateSelector } from '../validation/selector.js';
 import { validateAtRule } from '../validation/atrule.js';
 import '../validation/syntaxes/complex-selector.js';
+import { validateKeyframeSelector } from '../validation/syntaxes/keyframe-selector.js';
+import { validateAtRuleKeyframes } from '../validation/at-rules/keyframes.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];
@@ -46,13 +48,15 @@ async function doParse(iterator, options = {}) {
         src: '',
         sourcemap: false,
         minify: true,
+        pass: 1,
         parseColor: true,
-        nestingRules: false,
+        nestingRules: true,
         resolveImport: false,
         resolveUrls: false,
         removeCharset: true,
         removeEmpty: true,
         removeDuplicateDeclarations: true,
+        computeTransform: true,
         computeShorthand: true,
         computeCalcExpression: true,
         inlineCssVariables: false,
@@ -121,11 +125,13 @@ async function doParse(iterator, options = {}) {
             }
             else if (item.token == '{') {
                 let inBlock = 1;
+                tokens = [item];
                 do {
                     item = iter.next().value;
                     if (item == null) {
                         break;
                     }
+                    tokens.push(item);
                     if (item.token == '{') {
                         inBlock++;
                     }
@@ -133,6 +139,13 @@ async function doParse(iterator, options = {}) {
                         inBlock--;
                     }
                 } while (inBlock != 0);
+                if (tokens.length > 0) {
+                    errors.push({
+                        action: 'drop',
+                        message: 'invalid block',
+                        rawTokens: tokens.slice()
+                    });
+                }
             }
             tokens = [];
             map = new Map;
@@ -165,7 +178,8 @@ async function doParse(iterator, options = {}) {
         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);
+            // @ts-ignore
+            const index = context.chi.findIndex((node) => node == context);
             if (index > -1) {
                 context.chi.splice(index, 1);
             }
@@ -225,7 +239,10 @@ 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);
+            }
         }
     }
     const endTime = performance.now();
@@ -326,8 +343,13 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
                         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;
@@ -362,12 +384,20 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
             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
@@ -448,14 +478,16 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
             acc.push(renderToken(curr, { removeComments: true }));
             return acc;
         }, []);
+        const nam = renderToken(atRule, { removeComments: true });
+        // @ts-ignore
         const node = {
-            typ: EnumToken.AtRuleNodeType,
-            nam: renderToken(atRule, { removeComments: true }),
-            tokens: t,
+            typ: /^(-[a-z]+-)?keyframes$/.test(nam) ? EnumToken.KeyframeAtRuleNodeType : EnumToken.AtRuleNodeType,
+            nam,
+            // 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) {
@@ -481,7 +513,7 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
                     isValid = false;
                 }
             }
-            const valid = isValid ? validateAtRule(node, options, context) : {
+            const valid = isValid ? (node.typ == EnumToken.KeyframeAtRuleNodeType ? validateAtRuleKeyframes(node) : validateAtRule(node, options, context)) : {
                 valid: ValidationLevel.Drop,
                 node,
                 syntax: '@' + node.nam,
@@ -497,7 +529,10 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
                 node.typ = EnumToken.InvalidAtRuleTokenType;
             }
             else {
-                node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false, removeComments: true }), '');
+                node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr, {
+                    minify: false,
+                    removeComments: true
+                }), '');
             }
         }
         // @ts-ignore
@@ -510,77 +545,84 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
         if (delim.typ == EnumToken.BlockStartTokenType) {
             const position = map.get(tokens[0]);
             const uniq = new Map;
-            parseTokens(tokens, { minify: true }).reduce((acc, curr, index, array) => {
-                if (curr.typ == EnumToken.CommentTokenType) {
-                    return acc;
-                }
-                if (curr.typ == EnumToken.WhitespaceTokenType) {
-                    if (trimWhiteSpace.includes(array[index - 1]?.typ) ||
-                        trimWhiteSpace.includes(array[index + 1]?.typ) ||
-                        combinators.includes(array[index - 1]?.val) ||
-                        combinators.includes(array[index + 1]?.val)) {
-                        return acc;
-                    }
-                }
-                let t = renderToken(curr, { minify: false });
-                if (t == ',') {
-                    acc.push([]);
-                    // uniqTokens.push([]);
-                }
-                else {
-                    acc[acc.length - 1].push(t);
-                    // uniqTokens[uniqTokens.length - 1].push(curr);
-                }
-                return acc;
-            }, [[]]).reduce((acc, curr) => {
-                let i = 0;
-                for (; i < curr.length; i++) {
-                    if (i + 1 < curr.length && curr[i] == '*') {
-                        if (curr[i] == '*') {
-                            let index = curr[i + 1] == ' ' ? 2 : 1;
-                            if (!['>', '~', '+'].includes(curr[index])) {
-                                curr.splice(i, index);
-                            }
-                        }
-                    }
-                }
-                acc.set(curr.join(''), curr);
-                return acc;
-            }, uniq);
-            const ruleType = context.typ == EnumToken.AtRuleNodeType && context.nam == 'keyframes' ? EnumToken.KeyFrameRuleNodeType : EnumToken.RuleNodeType;
+            parseTokens(tokens, { minify: true });
+            const ruleType = context.typ == EnumToken.KeyframeAtRuleNodeType ? EnumToken.KeyFrameRuleNodeType : EnumToken.RuleNodeType;
             if (ruleType == EnumToken.RuleNodeType) {
                 parseSelector(tokens);
-                if (options.validation) {
-                    // @ts-ignore
-                    const valid = validateSelector(tokens, options, context);
-                    if (valid.valid != ValidationLevel.Valid) {
-                        const node = {
-                            typ: EnumToken.InvalidRuleTokenType,
-                            // @ts-ignore
-                            sel: tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), ''),
-                            chi: []
-                        };
-                        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) }
-                        });
+            }
+            if (options.validation) {
+                // @ts-ignore
+                const valid = ruleType == EnumToken.KeyFrameRuleNodeType ? validateKeyframeSelector(tokens) : validateSelector(tokens, options, context);
+                if (valid.valid != ValidationLevel.Valid) {
+                    const node = {
+                        typ: EnumToken.InvalidRuleTokenType,
+                        sel: tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), ''),
+                        chi: []
+                    };
+                    errors.push({
+                        action: 'drop',
+                        message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), '') + '"',
                         // @ts-ignore
-                        context.chi.push(node);
-                        Object.defineProperty(node, 'parent', { ...definedPropertySettings, value: context });
-                        return node;
-                    }
+                        location: { src, ...(map.get(valid.node) ?? position) }
+                    });
+                    // @ts-ignore
+                    context.chi.push(node);
+                    Object.defineProperty(node, 'parent', { ...definedPropertySettings, value: context });
+                    return node;
                 }
             }
             const node = {
                 typ: ruleType,
-                sel: [...uniq.keys()].join(','),
+                sel: [...tokens.reduce((acc, curr, index, array) => {
+                        if (curr.typ == EnumToken.CommentTokenType) {
+                            return acc;
+                        }
+                        if (curr.typ == EnumToken.WhitespaceTokenType) {
+                            if (trimWhiteSpace.includes(array[index - 1]?.typ) ||
+                                trimWhiteSpace.includes(array[index + 1]?.typ) ||
+                                combinators.includes(array[index - 1]?.val) ||
+                                combinators.includes(array[index + 1]?.val)) {
+                                return acc;
+                            }
+                        }
+                        if (ruleType == EnumToken.KeyFrameRuleNodeType) {
+                            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') {
+                                Object.assign(curr, { typ: EnumToken.IdenTokenType, val: 'to' });
+                            }
+                        }
+                        let t = renderToken(curr, { minify: false });
+                        if (t == ',') {
+                            acc.push([]);
+                            // uniqTokens.push([]);
+                        }
+                        else {
+                            acc[acc.length - 1].push(t);
+                            // uniqTokens[uniqTokens.length - 1].push(curr);
+                        }
+                        return acc;
+                    }, [[]]).reduce((acc, curr) => {
+                        let i = 0;
+                        for (; i < curr.length; i++) {
+                            if (i + 1 < curr.length && curr[i] == '*') {
+                                if (curr[i] == '*') {
+                                    let index = curr[i + 1] == ' ' ? 2 : 1;
+                                    if (!['>', '~', '+'].includes(curr[index])) {
+                                        curr.splice(i, index);
+                                    }
+                                }
+                            }
+                        }
+                        acc.set(curr.join(''), curr);
+                        return acc;
+                    }, uniq).keys()].join(','),
                 chi: []
             };
             Object.defineProperty(node, 'tokens', {
                 ...definedPropertySettings,
-                enumerable: true,
+                enumerable: false,
                 value: tokens.slice()
             });
             let raw = [...uniq.values()];
@@ -660,7 +702,8 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
                     }
                 }
             }
-            if (value == null || value.length == 0) {
+            const nam = renderToken(name.shift(), { removeComments: true });
+            if (value == null || (!nam.startsWith('--') && value.length == 0)) {
                 errors.push({
                     action: 'drop',
                     message: 'doParse: invalid declaration',
@@ -668,33 +711,30 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
                 });
                 return null;
             }
+            for (const { value: token } of walkValues(value, null, {
+                fn: (node) => node.typ == EnumToken.FunctionTokenType && node.val == 'calc' ? WalkerOptionEnum.IgnoreChildren : null,
+                type: EnumToken.FunctionTokenType
+            })) {
+                if (token.typ == EnumToken.FunctionTokenType && token.val == 'calc') {
+                    for (const { value: node, parent } of walkValues(token.chi, token)) {
+                        // fix expressions starting with '/' or '*' such as '/4' in (1 + 1)/4
+                        if (node.typ == EnumToken.LiteralTokenType && node.val.length > 0) {
+                            if (node.val[0] == '/' || node.val[0] == '*') {
+                                parent.chi.splice(parent.chi.indexOf(node), 1, { typ: node.val[0] == '/' ? EnumToken.Div : EnumToken.Mul }, ...parseString(node.val.slice(1)));
+                            }
+                        }
+                    }
+                }
+            }
             const node = {
                 typ: EnumToken.DeclarationNodeType,
                 // @ts-ignore
-                nam: renderToken(name.shift(), { removeComments: true }),
+                nam,
                 // @ts-ignore
                 val: value
             };
             const result = parseDeclarationNode(node, errors, src, position);
             if (result != null) {
-                // 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 });
@@ -777,8 +817,6 @@ function parseAtRulePrelude(tokens, atRule) {
             }
         }
         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;
@@ -1053,10 +1091,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 {
@@ -1233,25 +1277,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)) {
@@ -1261,55 +1305,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)) {
@@ -1336,7 +1380,7 @@ function parseTokens(tokens, options = {}) {
                         upper++;
                     }
                     if (upper < t.chi.length &&
-                        t.chi[upper].typ == EnumToken.Iden &&
+                        t.chi[upper].typ == EnumToken.IdenTokenType &&
                         ['i', 's'].includes(t.chi[upper].val.toLowerCase())) {
                         t.chi[m].attr = t.chi[upper].val;
                         t.chi.splice(upper, 1);
@@ -1429,7 +1473,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';
@@ -1439,10 +1485,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];
@@ -1476,7 +1523,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)) ||

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

@@ -11,7 +11,7 @@ function parseDeclarationNode(node, errors, src, position) {
     while (node.val[0]?.typ == EnumToken.WhitespaceTokenType) {
         node.val.shift();
     }
-    if (node.val.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ)).length == 0) {
+    if (!node.nam.startsWith('--') && node.val.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ)).length == 0) {
         errors.push({
             action: 'drop',
             message: 'doParse: invalid declaration',