@tbela99/css-parser 0.6.0 → 0.7.0

package/dist/lib/parser/parse.js

@@ -1,5 +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 { isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isIdent, isHexColor, isHash, isIdentStart, isColor } 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 { expand } from '../ast/expand.js';
@@ -7,6 +8,7 @@ import { parseDeclaration } from './utils/declaration.js';
 import { renderToken } from '../renderer/render.js';
 import { COLORS_NAMES, systemColors, deprecatedSystemColors } from '../renderer/color/utils/constants.js';
 import { tokenize } from './tokenize.js';
+import { validateSelector } from '../validation/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];
@@ -24,13 +26,51 @@ const enumTokenHints = new Set([
     EnumToken.EOFTokenType
 ]);
 const webkitPseudoAliasMap = {
-    '-webkit-autofill': 'autofill'
+    '-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');
 }
 async function doParse(iterator, options = {}) {
-    // return new Promise(async (resolve, reject) => {
     if (options.signal != null) {
         options.signal.addEventListener('abort', reject);
     }
@@ -49,6 +89,8 @@ async function doParse(iterator, options = {}) {
         computeCalcExpression: true,
         inlineCssVariables: false,
         setParent: true,
+        removePrefix: false,
+        validation: false,
         ...options
     };
     if (options.expandNestingRules) {
@@ -129,7 +171,13 @@ async function doParse(iterator, options = {}) {
             await parseNode(tokens, context, stats, options, errors, src, map);
             const previousNode = stack.pop();
             // @ts-ignore
-            context = stack[stack.length - 1] || ast;
+            context = stack[stack.length - 1] ?? ast;
+            if (previousNode != null && previousNode.typ == EnumToken.InvalidRuleTokenType) {
+                const index = context.chi.findIndex(node => node == previousNode);
+                if (index > -1) {
+                    context.chi.splice(index, 1);
+                }
+            }
             // @ts-ignore
             if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
                 context.chi.pop();
@@ -140,6 +188,12 @@ async function doParse(iterator, options = {}) {
     }
     if (tokens.length > 0) {
         await parseNode(tokens, context, stats, options, errors, src, map);
+        if (context != null && context.typ == EnumToken.InvalidRuleTokenType) {
+            const index = context.chi.findIndex(node => node == context);
+            if (index > -1) {
+                context.chi.splice(index, 1);
+            }
+        }
     }
     while (stack.length > 0 && context != ast) {
         const previousNode = stack.pop();
@@ -420,6 +474,7 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         if (delim.typ == EnumToken.BlockStartTokenType) {
             const position = map.get(tokens[0]);
             const uniq = new Map;
+            // const uniqTokens: Token[][] = [[]];
             parseTokens(tokens, { minify: true }).reduce((acc, curr, index, array) => {
                 if (curr.typ == EnumToken.CommentTokenType) {
                     return acc;
@@ -435,18 +490,49 @@ async function parseNode(results, context, stats, options, errors, src, map) {
                 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;
+            if (ruleType == EnumToken.RuleNodeType) {
+                const valid = validateSelector(parseSelector(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 }), '') + '"',
+                        location: { src, ...(map.get(valid.node) ?? position) }
+                    });
+                    context.chi.push(node);
+                    return node;
+                }
+            }
             const node = {
-                typ: context.typ == EnumToken.AtRuleNodeType && context.nam == 'keyframes' ? EnumToken.KeyFrameRuleNodeType : EnumToken.RuleNodeType,
-                // @ts-ignore
+                typ: ruleType,
                 sel: [...uniq.keys()].join(','),
                 chi: []
             };
@@ -529,6 +615,145 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         }
     }
 }
+function parseSelector(tokens) {
+    for (const { value, previousValue, nextValue, parent } of walkValues(tokens)) {
+        if (value.typ == EnumToken.CommentTokenType ||
+            value.typ == EnumToken.WhitespaceTokenType ||
+            value.typ == EnumToken.CommaTokenType ||
+            value.typ == EnumToken.IdenTokenType ||
+            value.typ == EnumToken.HashTokenType) {
+            continue;
+        }
+        if (parent == null) {
+            if (value.typ == EnumToken.GtTokenType) {
+                // @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
+                    value.typ = EnumToken.NestingSelectorTokenType;
+                    // @ts-ignore
+                    delete value.val;
+                }
+                else if (value.val.charAt(0) == '.') {
+                    if (!isIdent(value.val.slice(1))) {
+                        // @ts-ignore
+                        value.typ = EnumToken.InvalidClassSelectorTokenType;
+                    }
+                    else {
+                        // @ts-ignore
+                        value.typ = EnumToken.ClassSelectorTokenType;
+                    }
+                }
+                // @ts-ignore
+                if (value.typ == EnumToken.DelimTokenType) {
+                    // @ts-ignore
+                    value.typ = EnumToken.NextSiblingCombinatorTokenType;
+                }
+                else if (['*', '>', '+', '~'].includes(value.val)) {
+                    switch (value.val) {
+                        case '*':
+                            // @ts-ignore
+                            value.typ = EnumToken.UniversalSelectorTokenType;
+                            break;
+                        case '>':
+                            // @ts-ignore
+                            value.typ = EnumToken.ChildCombinatorTokenType;
+                            break;
+                        case '+':
+                            // @ts-ignore
+                            value.typ = EnumToken.NextSiblingCombinatorTokenType;
+                            break;
+                        case '~':
+                            // @ts-ignore
+                            value.typ = EnumToken.SubsequentSiblingCombinatorTokenType;
+                            break;
+                    }
+                    // @ts-ignore
+                    // @ts-ignore
+                    delete value.val;
+                }
+            }
+            else if (value.typ == EnumToken.ColorTokenType) {
+                if (value.kin == 'lit' || value.kin == 'hex' || value.kin == 'sys' || value.kin == 'dpsys') {
+                    if (value.kin == 'hex') {
+                        if (!isIdent(value.val.slice(1))) {
+                            continue;
+                        }
+                        // @ts-ignore
+                        value.typ = EnumToken.HashTokenType;
+                    }
+                    else {
+                        // @ts-ignore
+                        value.typ = EnumToken.IdenTokenType;
+                    }
+                    // @ts-ignore
+                    delete value.kin;
+                }
+            }
+        }
+    }
+    let i = 0;
+    const combinators = [
+        EnumToken.ChildCombinatorTokenType,
+        EnumToken.NextSiblingCombinatorTokenType,
+        EnumToken.SubsequentSiblingCombinatorTokenType
+    ];
+    for (; i < tokens.length; i++) {
+        if (combinators.includes(tokens[i].typ)) {
+            if (i + 1 < tokens.length && [EnumToken.WhitespaceTokenType, EnumToken.DescendantCombinatorTokenType].includes(tokens[i + 1].typ)) {
+                tokens.splice(i + 1, 1);
+            }
+            if (i > 0 && [EnumToken.WhitespaceTokenType, EnumToken.DescendantCombinatorTokenType].includes(tokens[i - 1].typ)) {
+                tokens.splice(i - 1, 1);
+                i--;
+                continue;
+            }
+        }
+        if (tokens[i].typ == EnumToken.WhitespaceTokenType) {
+            tokens[i].typ = EnumToken.DescendantCombinatorTokenType;
+        }
+    }
+    return tokens;
+}
 function parseString(src, options = { location: false }) {
     return parseTokens([...tokenize(src)].map(t => {
         const token = getTokenType(t.token, t.hint);
@@ -573,7 +798,7 @@ function getTokenType(val, hint) {
         return { typ: EnumToken.StartParensTokenType };
     }
     if (val == '=') {
-        return { typ: EnumToken.DelimTokenType, val };
+        return { typ: EnumToken.DelimTokenType };
     }
     if (val == ';') {
         return { typ: EnumToken.SemiColonTokenType };
@@ -731,7 +956,7 @@ function parseTokens(tokens, options = {}) {
             const typ = tokens[i + 1]?.typ;
             if (typ != null) {
                 if (typ == EnumToken.FunctionTokenType) {
-                    tokens[i + 1].val = ':' + tokens[i + 1].val;
+                    tokens[i + 1].val = ':' + (tokens[i + 1].val in webkitPseudoAliasMap ? webkitPseudoAliasMap[tokens[i + 1].val] : tokens[i + 1].val);
                     tokens[i + 1].typ = EnumToken.PseudoClassFuncTokenType;
                 }
                 else if (typ == EnumToken.IdenTokenType) {
@@ -762,7 +987,10 @@ function parseTokens(tokens, options = {}) {
                     break;
                 }
             }
-            Object.assign(t, { typ: EnumToken.AttrTokenType, chi: tokens.splice(i + 1, k - i) });
+            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) {
                 // @ts-ignore
@@ -1033,4 +1261,4 @@ function parseTokens(tokens, options = {}) {
     return tokens;
 }
 
-export { doParse, parseString, parseTokens, urlTokenMatcher };
+export { doParse, parseSelector, parseString, parseTokens, urlTokenMatcher };

package/dist/lib/parser/tokenize.js

@@ -1,7 +1,8 @@
-import { isWhiteSpace, isNewLine, isDigit, isNonPrintable } from './utils/syntax.js';
 import { EnumToken } from '../ast/types.js';
 import '../ast/minify.js';
 import './parse.js';
+import { isWhiteSpace, isNewLine, isDigit, isNonPrintable } from '../syntax/syntax.js';
+import './utils/config.js';
 import '../renderer/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
 
@@ -55,7 +56,7 @@ function* consumeString(quoteStr, buffer, parseInfo) {
                 continue;
             }
             if (escapeSequence.trimEnd().length > 0) {
-                const codepoint = Number(`0x${escapeSequence.trimEnd()}`);
+                const codepoint = parseInt(escapeSequence, 16);
                 if (codepoint == 0 ||
                     // leading surrogate
                     (0xD800 <= codepoint && codepoint <= 0xDBFF) ||
@@ -235,9 +236,22 @@ function* tokenize(stream) {
             case '~':
             case '|':
             case '$':
-                if (value == '|' && peek(parseInfo) == '|') {
-                    next(parseInfo);
-                    yield pushToken('', parseInfo, EnumToken.ColumnCombinatorTokenType);
+                if (buffer.length > 0) {
+                    yield pushToken(buffer, parseInfo);
+                    buffer = '';
+                }
+                if (value == '|') {
+                    if (peek(parseInfo) == '|') {
+                        next(parseInfo);
+                        yield pushToken('', parseInfo, EnumToken.ColumnCombinatorTokenType);
+                    }
+                    else if (peek(parseInfo) == '=') {
+                        buffer += next(parseInfo);
+                        yield pushToken(buffer, parseInfo);
+                    }
+                    else {
+                        yield pushToken('|', parseInfo);
+                    }
                     buffer = '';
                     break;
                 }

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

@@ -1,5 +1,6 @@
 import config from '../../../config.json.js';
 
+Object.freeze(config);
 const getConfig = () => config;
 
 export { getConfig };

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

@@ -2,7 +2,8 @@ import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { walkValues } from '../../ast/walk.js';
 import '../parse.js';
-import { isWhiteSpace } from './syntax.js';
+import { isWhiteSpace } from '../../syntax/syntax.js';
+import './config.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 

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

@@ -2,6 +2,7 @@ import { colorsFunc } from '../../renderer/render.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../parse.js';
+import './config.js';
 import { COLORS_NAMES } from '../../renderer/color/utils/constants.js';
 
 // https://www.w3.org/TR/CSS21/syndata.html#syntax

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

@@ -3,6 +3,7 @@ import '../../ast/minify.js';
 import '../parse.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
+import './config.js';
 
 // https://www.w3.org/TR/css-values-4/#math-function
 const funcList = ['clamp', 'calc'];

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

@@ -6,6 +6,7 @@ import '../../ast/minify.js';
 import '../../parser/parse.js';
 import { srgb2xyz } from './xyz.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function a98rgb2srgbvalues(r, g, b, a = null) {
     //  @ts-ignore

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

@@ -18,6 +18,7 @@ import { xyzd502srgb, srgb2xyz } from './xyz.js';
 import { p32srgbvalues, srgb2p3values } from './p3.js';
 import { XYZ_D65_to_D50 } from './xyzd50.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function convert(token, to) {
     if (token.kin == to) {

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

@@ -1,7 +1,8 @@
-import '../../parser/parse.js';
-import { isRectangularOrthogonalColorspace, isPolarColorspace } from '../../parser/utils/syntax.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../parser/parse.js';
+import { isRectangularOrthogonalColorspace, isPolarColorspace } from '../../syntax/syntax.js';
+import '../../parser/utils/config.js';
 import { getNumber } from './color.js';
 import { srgb2rgb } from './rgb.js';
 import './utils/constants.js';

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

@@ -6,6 +6,7 @@ import { hsl2rgb, hwb2rgb, cmyk2rgb, oklab2rgb, oklch2rgb, lab2rgb, lch2rgb } fr
 import { NAMES_COLORS } from './utils/constants.js';
 import { getComponents } from './utils/components.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function toHexString(acc, value) {
     return acc + value.toString(16).padStart(2, '0');

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

@@ -8,6 +8,7 @@ import '../../ast/minify.js';
 import '../../parser/parse.js';
 import { hslvalues } from './srgb.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function hex2hsl(token) {
     // @ts-ignore

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

@@ -7,6 +7,7 @@ import '../../ast/minify.js';
 import '../../parser/parse.js';
 import { lab2srgb, lch2srgb, oklab2srgb, oklch2srgb } from './srgb.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function rgb2hwb(token) {
     // @ts-ignore

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

@@ -9,6 +9,7 @@ import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../parser/parse.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 // L: 0% = 0.0, 100% = 100.0
 // for a and b: -100% = -125, 100% = 125

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

@@ -6,6 +6,7 @@ import '../../ast/minify.js';
 import '../../parser/parse.js';
 import { srgb2lab, xyz2lab, hex2lab, rgb2lab, hsl2lab, hwb2lab, getLABComponents, oklab2lab, oklch2lab } from './lab.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function hex2lch(token) {
     // @ts-ignore

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

@@ -9,6 +9,7 @@ import '../../parser/parse.js';
 import { lch2labvalues } from './lab.js';
 import { getOKLCHComponents } from './oklch.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function hex2oklab(token) {
     // @ts-ignore

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

@@ -7,6 +7,7 @@ import '../../parser/parse.js';
 import { lab2lchvalues } from './lch.js';
 import { srgb2oklab, hex2oklab, rgb2oklab, hsl2oklab, hwb2oklab, lab2oklab, lch2oklab, getOKLABComponents } from './oklab.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function hex2oklch(token) {
     // @ts-ignore

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

@@ -6,6 +6,7 @@ import '../../ast/minify.js';
 import '../../parser/parse.js';
 import { srgb2xyz } from './xyz.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function p32srgbvalues(r, g, b, alpha) {
     // @ts-ignore

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

@@ -6,6 +6,7 @@ import '../../ast/minify.js';
 import '../../parser/parse.js';
 import { srgb2xyz } from './xyz.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function rec20202srgb(r, g, b, a) {
     // @ts-ignore

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

@@ -6,6 +6,7 @@ import '../../parser/parse.js';
 import { reduceNumber } from '../render.js';
 import { colorRange } from './utils/constants.js';
 import { evaluate } from '../../ast/math/expression.js';
+import '../../parser/utils/config.js';
 
 function parseRelativeColor(relativeKeys, original, rExp, gExp, bExp, aExp) {
     let r;

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

@@ -6,6 +6,7 @@ import '../../parser/parse.js';
 import { expandHexValue } from './hex.js';
 import { hwb2srgb, hslvalues, hsl2srgbvalues, cmyk2srgb, oklab2srgb, oklch2srgb, lab2srgb, lch2srgb } from './srgb.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function srgb2rgb(value) {
     return minmax(Math.round(value * 255), 0, 255);

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

@@ -11,6 +11,7 @@ import { getLCHComponents } from './lch.js';
 import { getOKLCHComponents } from './oklch.js';
 import { XYZ_to_lin_sRGB } from './xyz.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 // from https://www.w3.org/TR/css-color-4/#color-conversion-code
 // srgb-linear -> srgb

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

@@ -4,6 +4,7 @@ import '../../../parser/parse.js';
 import { COLORS_NAMES } from './constants.js';
 import { expandHexValue } from '../hex.js';
 import '../../sourcemap/lib/encode.js';
+import '../../../parser/utils/config.js';
 
 function getComponents(token) {
     if (token.kin == 'hex' || token.kin == 'lit') {

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

@@ -2,6 +2,7 @@ import { EnumToken } from '../../../ast/types.js';
 import '../../../ast/minify.js';
 import '../../../parser/parse.js';
 import '../../sourcemap/lib/encode.js';
+import '../../../parser/utils/config.js';
 
 const colorRange = {
     lab: {

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

@@ -5,6 +5,7 @@ import '../../ast/minify.js';
 import '../../parser/parse.js';
 import { lsrgb2srgbvalues, srgb2lsrgbvalues } from './srgb.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function xyzd502srgb(x, y, z) {
     // @ts-ignore

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

@@ -7,6 +7,7 @@ import { xyz2lab } from './lab.js';
 import { lab2lchvalues } from './lch.js';
 import { XYZ_D50_to_D65 } from './xyz.js';
 import '../sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 function xyzd502lch(x, y, z, alpha) {
     // @ts-ignore