@tbela99/css-parser 0.4.1 → 0.5.1

package/dist/lib/parser/parse.js

@@ -1,6 +1,6 @@
 import { isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isIdent, isHexColor, isHash, isIdentStart, isColor } from './utils/syntax.js';
 import { EnumToken, funcLike } from '../ast/types.js';
-import { minify, combinators } from '../ast/minify.js';
+import { minify, definedPropertySettings, combinators } from '../ast/minify.js';
 import { walkValues, walk } from '../ast/walk.js';
 import { expand } from '../ast/expand.js';
 import { parseDeclaration } from './utils/declaration.js';
@@ -16,194 +16,229 @@ const BadTokensTypes = [
     EnumToken.BadUrlTokenType,
     EnumToken.BadStringTokenType
 ];
+const enumTokenHints = new Set([
+    EnumToken.WhitespaceTokenType, EnumToken.SemiColonTokenType, EnumToken.ColonTokenType, EnumToken.BlockStartTokenType,
+    EnumToken.BlockStartTokenType, EnumToken.AttrStartTokenType, EnumToken.AttrEndTokenType, EnumToken.StartParensTokenType, EnumToken.EndParensTokenType,
+    EnumToken.CommaTokenType, EnumToken.GtTokenType, EnumToken.LtTokenType, EnumToken.GteTokenType, EnumToken.LteTokenType, EnumToken.CommaTokenType,
+    EnumToken.StartMatchTokenType, EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType, EnumToken.DashMatchTokenType, EnumToken.ContainMatchTokenType,
+    EnumToken.EOFTokenType
+]);
 const webkitPseudoAliasMap = {
     '-webkit-autofill': 'autofill'
 };
+function reject(reason) {
+    throw new Error(reason ?? 'Parsing aborted');
+}
 async function doParse(iterator, options = {}) {
-    return new Promise(async (resolve, reject) => {
-        if (options.signal != null) {
-            options.signal.addEventListener('abort', reject);
-        }
-        options = {
-            src: '',
-            sourcemap: false,
-            minify: true,
-            parseColor: true,
-            nestingRules: false,
-            resolveImport: false,
-            resolveUrls: false,
-            removeCharset: false,
-            removeEmpty: true,
-            removeDuplicateDeclarations: true,
-            computeShorthand: true,
-            computeCalcExpression: true,
-            inlineCssVariables: false,
-            ...options
+    // return new Promise(async (resolve, reject) => {
+    if (options.signal != null) {
+        options.signal.addEventListener('abort', reject);
+    }
+    options = {
+        src: '',
+        sourcemap: false,
+        minify: true,
+        parseColor: true,
+        nestingRules: false,
+        resolveImport: false,
+        resolveUrls: false,
+        removeCharset: true,
+        removeEmpty: true,
+        removeDuplicateDeclarations: true,
+        computeShorthand: true,
+        computeCalcExpression: true,
+        inlineCssVariables: false,
+        setParent: true,
+        ...options
+    };
+    if (options.expandNestingRules) {
+        options.nestingRules = false;
+    }
+    if (options.resolveImport) {
+        options.resolveUrls = true;
+    }
+    const startTime = performance.now();
+    const errors = [];
+    const src = options.src;
+    const stack = [];
+    const stats = {
+        bytesIn: 0,
+        importedBytesIn: 0,
+        parse: `0ms`,
+        minify: `0ms`,
+        total: `0ms`
+    };
+    let ast = {
+        typ: EnumToken.StyleSheetNodeType,
+        chi: []
+    };
+    let tokens = [];
+    let map = new Map;
+    let context = ast;
+    if (options.sourcemap) {
+        ast.loc = {
+            sta: {
+                ind: 0,
+                lin: 1,
+                col: 1
+            },
+            src: ''
         };
-        if (options.expandNestingRules) {
-            options.nestingRules = false;
+    }
+    const iter = tokenize(iterator);
+    let item;
+    while (item = iter.next().value) {
+        stats.bytesIn = item.bytesIn;
+        //
+        // doParse error
+        if (item.hint != null && BadTokensTypes.includes(item.hint)) {
+            // bad token
+            continue;
         }
-        if (options.resolveImport) {
-            options.resolveUrls = true;
+        if (item.hint != EnumToken.EOFTokenType) {
+            tokens.push(item);
         }
-        const startTime = performance.now();
-        const errors = [];
-        const src = options.src;
-        const stack = [];
-        const stats = {
-            bytesIn: 0,
-            importedBytesIn: 0,
-            parse: `0ms`,
-            minify: `0ms`,
-            total: `0ms`
-        };
-        let ast = {
-            typ: EnumToken.StyleSheetNodeType,
-            chi: []
-        };
-        let tokens = [];
-        let map = new Map;
-        let context = ast;
-        if (options.sourcemap) {
-            ast.loc = {
-                sta: {
-                    ind: 0,
-                    lin: 1,
-                    col: 1
-                },
-                src: ''
-            };
-        }
-        const iter = tokenize(iterator);
-        let item;
-        while (item = iter.next().value) {
-            stats.bytesIn = item.bytesIn;
-            //
-            // doParse error
-            if (item.hint != null && BadTokensTypes.includes(item.hint)) {
-                // bad token
-                continue;
-            }
-            if (item.hint != EnumToken.EOFTokenType) {
-                tokens.push(item);
-            }
-            if (item.token == ';' || item.token == '{') {
-                let node = await parseNode(tokens, context, stats, options, errors, src, map);
-                if (node != null) {
-                    stack.push(node);
-                    // @ts-ignore
-                    context = node;
-                }
-                else if (item.token == '{') {
-                    // node == null
-                    // consume and throw away until the closing '}' or EOF
-                    let inBlock = 1;
-                    do {
-                        item = iter.next().value;
-                        if (item == null) {
-                            break;
-                        }
-                        if (item.token == '{') {
-                            inBlock++;
-                        }
-                        else if (item.token == '}') {
-                            inBlock--;
-                        }
-                    } while (inBlock != 0);
-                }
-                tokens = [];
-                map = new Map;
-            }
-            else if (item.token == '}') {
-                await parseNode(tokens, context, stats, options, errors, src, map);
-                const previousNode = stack.pop();
-                // @ts-ignore
-                context = stack[stack.length - 1] || ast;
+        if (item.token == ';' || item.token == '{') {
+            let node = await parseNode(tokens, context, stats, options, errors, src, map);
+            if (node != null) {
+                stack.push(node);
                 // @ts-ignore
-                if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
-                    context.chi.pop();
-                }
-                tokens = [];
-                map = new Map;
+                context = node;
+            }
+            else if (item.token == '{') {
+                // node == null
+                // consume and throw away until the closing '}' or EOF
+                let inBlock = 1;
+                do {
+                    item = iter.next().value;
+                    if (item == null) {
+                        break;
+                    }
+                    if (item.token == '{') {
+                        inBlock++;
+                    }
+                    else if (item.token == '}') {
+                        inBlock--;
+                    }
+                } while (inBlock != 0);
             }
+            tokens = [];
+            map = new Map;
         }
-        if (tokens.length > 0) {
+        else if (item.token == '}') {
             await parseNode(tokens, context, stats, options, errors, src, map);
-        }
-        while (stack.length > 0 && context != ast) {
             const previousNode = stack.pop();
             // @ts-ignore
-            context = stack[stack.length - 1] ?? ast;
+            context = stack[stack.length - 1] || ast;
             // @ts-ignore
             if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
                 context.chi.pop();
-                continue;
             }
-            break;
+            tokens = [];
+            map = new Map;
         }
-        const endParseTime = performance.now();
-        if (options.expandNestingRules) {
-            ast = expand(ast);
+    }
+    if (tokens.length > 0) {
+        await parseNode(tokens, context, stats, options, errors, src, map);
+    }
+    while (stack.length > 0 && context != ast) {
+        const previousNode = stack.pop();
+        // @ts-ignore
+        context = stack[stack.length - 1] ?? ast;
+        // @ts-ignore
+        if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
+            context.chi.pop();
+            continue;
         }
-        if (options.visitor != null) {
-            for (const result of walk(ast)) {
-                if (result.node.typ == EnumToken.DeclarationNodeType &&
-                    // @ts-ignore
-                    (typeof options.visitor.Declaration == 'function' || options.visitor.Declaration?.[result.node.nam] != null)) {
-                    const callable = typeof options.visitor.Declaration == 'function' ? options.visitor.Declaration : options.visitor.Declaration[result.node.nam];
-                    const results = await callable(result.node);
-                    if (results == null || (Array.isArray(results) && results.length == 0)) {
-                        continue;
-                    }
-                    // @ts-ignore
-                    result.parent.chi.splice(result.parent.chi.indexOf(result.node), 1, ...(Array.isArray(results) ? results : [results]));
+        break;
+    }
+    const endParseTime = performance.now();
+    if (options.expandNestingRules) {
+        ast = expand(ast);
+    }
+    if (options.visitor != null) {
+        for (const result of walk(ast)) {
+            if (result.node.typ == EnumToken.DeclarationNodeType &&
+                // @ts-ignore
+                (typeof options.visitor.Declaration == 'function' || options.visitor.Declaration?.[result.node.nam] != null)) {
+                const callable = typeof options.visitor.Declaration == 'function' ? options.visitor.Declaration : options.visitor.Declaration[result.node.nam];
+                const results = await callable(result.node);
+                if (results == null || (Array.isArray(results) && results.length == 0)) {
+                    continue;
                 }
-                else if (options.visitor.Rule != null && result.node.typ == EnumToken.RuleNodeType) {
-                    const results = await options.visitor.Rule(result.node);
-                    if (results == null || (Array.isArray(results) && results.length == 0)) {
-                        continue;
-                    }
-                    // @ts-ignore
-                    result.parent.chi.splice(result.parent.chi.indexOf(result.node), 1, ...(Array.isArray(results) ? results : [results]));
+                // @ts-ignore
+                result.parent.chi.splice(result.parent.chi.indexOf(result.node), 1, ...(Array.isArray(results) ? results : [results]));
+            }
+            else if (options.visitor.Rule != null && result.node.typ == EnumToken.RuleNodeType) {
+                const results = await options.visitor.Rule(result.node);
+                if (results == null || (Array.isArray(results) && results.length == 0)) {
+                    continue;
                 }
-                else if (options.visitor.AtRule != null &&
-                    result.node.typ == EnumToken.AtRuleNodeType &&
-                    // @ts-ignore
-                    (typeof options.visitor.AtRule == 'function' || options.visitor.AtRule?.[result.node.nam] != null)) {
-                    const callable = typeof options.visitor.AtRule == 'function' ? options.visitor.AtRule : options.visitor.AtRule[result.node.nam];
-                    const results = await callable(result.node);
-                    if (results == null || (Array.isArray(results) && results.length == 0)) {
-                        continue;
-                    }
-                    // @ts-ignore
-                    result.parent.chi.splice(result.parent.chi.indexOf(result.node), 1, ...(Array.isArray(results) ? results : [results]));
+                // @ts-ignore
+                result.parent.chi.splice(result.parent.chi.indexOf(result.node), 1, ...(Array.isArray(results) ? results : [results]));
+            }
+            else if (options.visitor.AtRule != null &&
+                result.node.typ == EnumToken.AtRuleNodeType &&
+                // @ts-ignore
+                (typeof options.visitor.AtRule == 'function' || options.visitor.AtRule?.[result.node.nam] != null)) {
+                const callable = typeof options.visitor.AtRule == 'function' ? options.visitor.AtRule : options.visitor.AtRule[result.node.nam];
+                const results = await callable(result.node);
+                if (results == null || (Array.isArray(results) && results.length == 0)) {
+                    continue;
                 }
+                // @ts-ignore
+                result.parent.chi.splice(result.parent.chi.indexOf(result.node), 1, ...(Array.isArray(results) ? results : [results]));
             }
         }
-        if (options.minify) {
-            if (ast.chi.length > 0) {
-                minify(ast, options, true, errors, false);
+    }
+    if (options.minify) {
+        if (ast.chi.length > 0) {
+            minify(ast, options, true, errors, false);
+        }
+    }
+    if (options.setParent) {
+        const nodes = [ast];
+        let node;
+        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(child);
+                    }
+                }
             }
         }
-        const endTime = performance.now();
-        if (options.signal != null) {
-            options.signal.removeEventListener('abort', reject);
+    }
+    const endTime = performance.now();
+    if (options.signal != null) {
+        options.signal.removeEventListener('abort', reject);
+    }
+    stats.bytesIn += stats.importedBytesIn;
+    return {
+        ast,
+        errors,
+        stats: {
+            ...stats,
+            parse: `${(endParseTime - startTime).toFixed(2)}ms`,
+            minify: `${(endTime - endParseTime).toFixed(2)}ms`,
+            total: `${(endTime - startTime).toFixed(2)}ms`
         }
-        stats.bytesIn += stats.importedBytesIn;
-        resolve({
-            ast,
-            errors,
-            stats: {
-                ...stats,
-                parse: `${(endParseTime - startTime).toFixed(2)}ms`,
-                minify: `${(endTime - endParseTime).toFixed(2)}ms`,
-                total: `${(endTime - startTime).toFixed(2)}ms`
-            }
-        });
-    });
+    };
+    // });
 }
 async function parseNode(results, context, stats, options, errors, src, map) {
-    let tokens = results.map((t) => mapToken(t, map));
+    let tokens = [];
+    for (const t of results) {
+        const node = getTokenType(t.token, t.hint);
+        map.set(node, t.position);
+        tokens.push(node);
+    }
     let i;
     let loc;
     for (i = 0; i < tokens.length; i++) {
@@ -311,12 +346,16 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         }
         if (atRule.val == 'import') {
             // @ts-ignore
-            if (tokens[0].typ == EnumToken.UrlFunctionTokenType && tokens[1].typ == EnumToken.UrlTokenTokenType) {
-                tokens.shift();
-                // @ts-ignore
-                tokens[0].typ = EnumToken.StringTokenType;
-                // @ts-ignore
-                tokens[0].val = `"${tokens[0].val}"`;
+            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) {
+                        // @ts-ignore
+                        tokens[0].typ = EnumToken.StringTokenType;
+                        // @ts-ignore
+                        tokens[0].val = `"${tokens[0].val}"`;
+                    }
+                }
             }
             // @ts-ignore
             if (tokens[0].typ == EnumToken.StringTokenType) {
@@ -327,6 +366,7 @@ async function parseNode(results, context, stats, options, errors, src, map) {
                         const root = await options.load(url, options.src).then((src) => {
                             return doParse(src, Object.assign({}, options, {
                                 minify: false,
+                                setParent: false,
                                 // @ts-ignore
                                 src: options.resolve(url, options.src).absolute
                             }));
@@ -360,7 +400,7 @@ async function parseNode(results, context, stats, options, errors, src, map) {
             nam: renderToken(atRule, { removeComments: true }),
             val: raw.join('')
         };
-        Object.defineProperty(node, 'raw', { enumerable: false, configurable: true, writable: true, value: raw });
+        Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: raw });
         if (delim.typ == EnumToken.BlockStartTokenType) {
             node.chi = [];
         }
@@ -486,11 +526,6 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         }
     }
 }
-function mapToken(token, map) {
-    const node = getTokenType(token.token, token.hint);
-    map.set(node, token.position);
-    return node;
-}
 function parseString(src, options = { location: false }) {
     return parseTokens([...tokenize(src)].map(t => {
         const token = getTokenType(t.token, t.hint);
@@ -505,13 +540,7 @@ function getTokenType(val, hint) {
         throw new Error('empty string?');
     }
     if (hint != null) {
-        return ([
-            EnumToken.WhitespaceTokenType, EnumToken.SemiColonTokenType, EnumToken.ColonTokenType, EnumToken.BlockStartTokenType,
-            EnumToken.BlockStartTokenType, EnumToken.AttrStartTokenType, EnumToken.AttrEndTokenType, EnumToken.StartParensTokenType, EnumToken.EndParensTokenType,
-            EnumToken.CommaTokenType, EnumToken.GtTokenType, EnumToken.LtTokenType, EnumToken.GteTokenType, EnumToken.LteTokenType, EnumToken.CommaTokenType,
-            EnumToken.StartMatchTokenType, EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType, EnumToken.DashMatchTokenType, EnumToken.ContainMatchTokenType,
-            EnumToken.EOFTokenType
-        ].includes(hint) ? { typ: hint } : { typ: hint, val });
+        return enumTokenHints.has(hint) ? { typ: hint } : { typ: hint, val };
     }
     if (val == ' ') {
         return { typ: EnumToken.WhitespaceTokenType };
@@ -630,10 +659,10 @@ function getTokenType(val, hint) {
         return parseDimension(val);
     }
     const v = val.toLowerCase();
-    if (v == 'currentcolor' || val == 'transparent' || v in COLORS_NAMES) {
+    if (v == 'currentcolor' || v == 'transparent' || v in COLORS_NAMES) {
         return {
             typ: EnumToken.ColorTokenType,
-            val,
+            val: v,
             kin: 'lit'
         };
     }

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

@@ -5,7 +5,7 @@ function eq(a, b) {
     if (typeof a != 'object' || typeof b != 'object') {
         return a === b;
     }
-    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+    if (a.constructor != b.constructor) {
         return false;
     }
     if (Array.isArray(a)) {

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

@@ -8,14 +8,14 @@ import { COLORS_NAMES } from '../../renderer/color/utils/constants.js';
 // https://www.w3.org/TR/2021/CRD-css-syntax-3-20211224/#typedef-ident-token
 // '\\'
 const REVERSE_SOLIDUS = 0x5c;
-const dimensionUnits = [
+const dimensionUnits = new Set([
     'q', 'cap', 'ch', 'cm', 'cqb', 'cqh', 'cqi', 'cqmax', 'cqmin', 'cqw', 'dvb',
     'dvh', 'dvi', 'dvmax', 'dvmin', 'dvw', 'em', 'ex', 'ic', 'in', 'lh', 'lvb',
     'lvh', 'lvi', 'lvmax', 'lvw', 'mm', 'pc', 'pt', 'px', 'rem', 'rlh', 'svb',
     'svh', 'svi', 'svmin', 'svw', 'vb', 'vh', 'vi', 'vmax', 'vmin', 'vw'
-];
+]);
 function isLength(dimension) {
-    return 'unit' in dimension && dimensionUnits.includes(dimension.unit.toLowerCase());
+    return 'unit' in dimension && dimensionUnits.has(dimension.unit.toLowerCase());
 }
 function isResolution(dimension) {
     return 'unit' in dimension && ['dpi', 'dpcm', 'dppx', 'x'].includes(dimension.unit.toLowerCase());
@@ -75,7 +75,7 @@ function isColor(token) {
             for (let i = 1; i < children.length - 2; i++) {
                 if (children[i].typ == EnumToken.IdenTokenType) {
                     if (children[i].val != 'none' &&
-                        !(isRelative && ['alpha', 'r', 'g', 'b'].includes(children[i].val) || isColorspace(children[i]))) {
+                        !(isRelative && ['alpha', 'r', 'g', 'b', 'x', 'y', 'z'].includes(children[i].val) || isColorspace(children[i]))) {
                         return false;
                     }
                 }
@@ -83,10 +83,14 @@ function isColor(token) {
                     return false;
                 }
             }
+            if (children.length == 4 || (isRelative && children.length == 6)) {
+                return true;
+            }
             if (children.length == 8 || children.length == 6) {
                 const sep = children.at(-2);
                 const alpha = children.at(-1);
-                if (sep.typ != EnumToken.LiteralTokenType || sep.val != '/') {
+                // @ts-ignore
+                if ((children.length > 6 || !isRelative) && sep.typ != EnumToken.LiteralTokenType || sep.val != '/') {
                     return false;
                 }
                 if (alpha.typ == EnumToken.IdenTokenType && alpha.val != 'none') {

package/dist/lib/renderer/color/color.js

@@ -328,10 +328,47 @@ function convert(token, to) {
             case 'lch':
                 values.push(...lch2srgb(token));
                 break;
-            case 'color':
+            case 'oklch':
                 // @ts-ignore
                 values.push(...srgb2oklch(...color2srgbvalues(token)));
                 break;
+            case 'color':
+                const val = color2srgbvalues(token);
+                switch (to) {
+                    case 'srgb':
+                        values.push(...val);
+                        break;
+                    case 'srgb-linear':
+                        // @ts-ignore
+                        values.push(...srgb2lsrgbvalues(...val));
+                        break;
+                    case 'display-p3':
+                        // @ts-ignore
+                        values.push(...srgb2p3values(...val));
+                        break;
+                    case 'prophoto-rgb':
+                        // @ts-ignore
+                        values.push(...srgb2prophotorgbvalues(...val));
+                        break;
+                    case 'a98-rgb':
+                        // @ts-ignore
+                        values.push(...srgb2a98values(...val));
+                        break;
+                    case 'rec2020':
+                        // @ts-ignore
+                        values.push(...srgb2rec2020values(...val));
+                        break;
+                    case 'xyz':
+                    case 'xyz-d65':
+                        // @ts-ignore
+                        values.push(...srgb2xyz(...val));
+                        break;
+                    case 'xyz-d50':
+                        // @ts-ignore
+                        values.push(...(XYZ_D65_to_D50(...srgb2xyz(...val))));
+                        break;
+                }
+                break;
         }
         if (values.length > 0) {
             return values2colortoken(values, to);

package/dist/lib/renderer/color/colormix.js

@@ -4,7 +4,7 @@ import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { getNumber } from './color.js';
 import { srgb2rgb } from './rgb.js';
-import { powerlessColorComponent } from './utils/constants.js';
+import './utils/constants.js';
 import { getComponents } from './utils/components.js';
 import { srgb2hwb } from './hwb.js';
 import { srgb2hsl } from './hsl.js';
@@ -12,7 +12,6 @@ import { srgbvalues, srgb2lsrgbvalues } from './srgb.js';
 import { srgb2lch, xyz2lchvalues } from './lch.js';
 import { srgb2lab } from './lab.js';
 import { srgb2p3values } from './p3.js';
-import { eq } from '../../parser/utils/eq.js';
 import { srgb2oklch } from './oklch.js';
 import { srgb2oklab } from './oklab.js';
 import { srgb2a98values } from './a98rgb.js';
@@ -109,10 +108,10 @@ function colorMix(colorSpace, hueInterpolationMethod, color1, percentage1, color
     }
     const components1 = getComponents(color1);
     const components2 = getComponents(color2);
-    if (eq(components1[3], powerlessColorComponent) && values2.length == 4) {
+    if ((components1[3] != null && components1[3].typ == EnumToken.IdenTokenType && components1[3].val == 'none') && values2.length == 4) {
         values1[3] = values2[3];
     }
-    if (eq(components2[3], powerlessColorComponent) && values1.length == 4) {
+    if ((components2[3] != null && components2[3].typ == EnumToken.IdenTokenType && components2[3].val == 'none') && values1.length == 4) {
         values2[3] = values1[3];
     }
     const p1 = getNumber(percentage1);
@@ -224,13 +223,13 @@ function colorMix(colorSpace, hueInterpolationMethod, color1, percentage1, color
     const lchSpaces = ['lch', 'oklch'];
     // powerless
     if (lchSpaces.includes(color1.kin) || lchSpaces.includes(colorSpace.val)) {
-        if (eq(components1[2], powerlessColorComponent) || values1[2] == 0) {
+        if ((components1[2].typ == EnumToken.IdenTokenType && components1[2].val == 'none') || values1[2] == 0) {
             values1[2] = values2[2];
         }
     }
     // powerless
     if (lchSpaces.includes(color1.kin) || lchSpaces.includes(colorSpace.val)) {
-        if (eq(components2[2], powerlessColorComponent) || values2[2] == 0) {
+        if ((components2[2].typ == EnumToken.IdenTokenType && components2[2].val == 'none') || values2[2] == 0) {
             values2[2] = values1[2];
         }
     }

package/dist/lib/renderer/color/hsl.js

@@ -3,7 +3,6 @@ import { getNumber } from './color.js';
 import { hex2rgb, lab2rgb, lch2rgb, oklab2rgb, oklch2rgb } from './rgb.js';
 import './utils/constants.js';
 import { getComponents } from './utils/components.js';
-import { eq } from '../../parser/utils/eq.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../parser/parse.js';
@@ -32,7 +31,7 @@ function rgb2hsl(token) {
     t = chi[3];
     // @ts-ignore
     let a = null;
-    if (t != null && !eq(t, { typ: EnumToken.IdenTokenType, val: 'none' })) {
+    if (t != null && !(t.typ == EnumToken.IdenTokenType && t.val == 'none')) {
         // @ts-ignore
         a = getNumber(t) / 255;
     }