@tbela99/css-parser 1.1.1 → 1.3.0

package/dist/lib/syntax/syntax.js

@@ -1,10 +1,10 @@
-import { EnumToken } from '../ast/types.js';
+import { EnumToken, ColorType } from '../ast/types.js';
 import '../ast/minify.js';
 import { walkValues, WalkerOptionEnum } from '../ast/walk.js';
 import '../parser/parse.js';
 import '../parser/tokenize.js';
 import '../parser/utils/config.js';
-import { COLORS_NAMES, colorsFunc, funcLike, ColorKind } from '../renderer/color/utils/constants.js';
+import { COLORS_NAMES, colorsFunc, funcLike } from './color/utils/constants.js';
 import { buildExpression } from '../ast/math/expression.js';
 import '../renderer/sourcemap/lib/encode.js';
 
@@ -498,15 +498,24 @@ function isPolarColorspace(token) {
     return ['hsl', 'hwb', 'lch', 'oklch'].includes(token.val);
 }
 function isHueInterpolationMethod(token) {
-    if (token.typ != EnumToken.IdenTokenType) {
+    if (!Array.isArray(token)) {
+        return token.typ == EnumToken.IdenTokenType && 'hue' === token.val?.toLowerCase?.();
+    }
+    if (token.length != 2 || token[0].typ != EnumToken.IdenTokenType || token[1].typ != EnumToken.IdenTokenType) {
         return false;
     }
-    return ['shorter', 'longer', 'increasing', 'decreasing'].includes(token.val);
+    return ['shorter', 'longer', 'increasing', 'decreasing'].includes(token[0].val?.toLowerCase?.()) && 'hue' === token[1].val?.toLowerCase?.();
 }
 function isIdentColor(token) {
-    return token.typ == EnumToken.ColorTokenType && [ColorKind.SYS, ColorKind.DPSYS, ColorKind.LIT].includes(token.kin) && isIdent(token.val);
+    return token.typ == EnumToken.ColorTokenType && [ColorType.SYS, ColorType.DPSYS, ColorType.LIT].includes(token.kin) && isIdent(token.val);
+}
+function isPercentageToken(token) {
+    return token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == 0);
 }
 function isColor(token) {
+    if (token.typ == EnumToken.ColorTokenType) {
+        return true;
+    }
     if (token.typ == EnumToken.IdenTokenType) {
         // named color
         return token.val.toLowerCase() in COLORS_NAMES;
@@ -595,79 +604,80 @@ function isColor(token) {
                 }
                 return true;
             }
-            else { // @ts-ignore
-                if (token.val == 'color-mix') {
-                    // @ts-ignore
-                    const children = token.chi.reduce((acc, t) => {
-                        if (t.typ == EnumToken.CommaTokenType) {
-                            acc.push([]);
-                        }
-                        else {
-                            if (![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ)) {
-                                acc[acc.length - 1].push(t);
-                            }
+            // @ts-ignore
+            else if (token.val == 'color-mix') {
+                // @ts-ignore
+                const children = token.chi.reduce((acc, t) => {
+                    if (t.typ == EnumToken.CommaTokenType) {
+                        acc.push([]);
+                    }
+                    else {
+                        if (![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ)) {
+                            acc[acc.length - 1].push(t);
                         }
-                        return acc;
-                    }, [[]]);
-                    if (children.length == 3) {
-                        if (children[0].length > 3 ||
-                            children[0][0].typ != EnumToken.IdenTokenType ||
-                            children[0][0].val != 'in' ||
-                            !isColorspace(children[0][1]) ||
-                            (children[0].length == 3 && !isHueInterpolationMethod(children[0][2])) ||
-                            children[1].length > 2 ||
-                            children[1][0].typ != EnumToken.ColorTokenType ||
-                            children[2].length > 2 ||
-                            children[2][0].typ != EnumToken.ColorTokenType) {
+                    }
+                    return acc;
+                }, [[]]);
+                if (children.length == 3) {
+                    if (children[0].length > 4 ||
+                        children[0][0].typ != EnumToken.IdenTokenType ||
+                        'in' !== children[0][0].val?.toLowerCase?.() ||
+                        !isColorspace(children[0][1]) ||
+                        (children[0].length >= 3 && !isHueInterpolationMethod(children[0].slice(2))) ||
+                        children[1].length > 2 ||
+                        !isColor(children[1][0]) ||
+                        (children[1].length == 2 && !isPercentageToken(children[1][1])) ||
+                        children[2].length > 2 ||
+                        (children[2].length == 2 && !isPercentageToken(children[2][1])) ||
+                        !isColor(children[2][0])) {
+                        return false;
+                    }
+                    if (children[1].length == 2) {
+                        if (!(children[1][1].typ == EnumToken.PercentageTokenType || (children[1][1].typ == EnumToken.NumberTokenType && children[1][1].val == 0))) {
                             return false;
                         }
-                        if (children[1].length == 2) {
-                            if (!(children[1][1].typ == EnumToken.PercentageTokenType || (children[1][1].typ == EnumToken.NumberTokenType && children[1][1].val == '0'))) {
-                                return false;
-                            }
-                        }
-                        if (children[2].length == 2) {
-                            if (!(children[2][1].typ == EnumToken.PercentageTokenType || (children[2][1].typ == EnumToken.NumberTokenType && children[2][1].val == '0'))) {
-                                return false;
-                            }
+                    }
+                    if (children[2].length == 2) {
+                        if (!(children[2][1].typ == EnumToken.PercentageTokenType || (children[2][1].typ == EnumToken.NumberTokenType && children[2][1].val == 0))) {
+                            return false;
                         }
-                        return true;
                     }
-                    return false;
+                    return true;
                 }
-                else {
-                    const keywords = ['from', 'none'];
+                return false;
+            }
+            else {
+                const keywords = ['from', 'none'];
+                // @ts-ignore
+                if (['rgb', 'hsl', 'hwb', 'lab', 'lch', 'oklab', 'oklch'].includes(token.val)) {
                     // @ts-ignore
-                    if (['rgb', 'hsl', 'hwb', 'lab', 'lch', 'oklab', 'oklch'].includes(token.val)) {
-                        // @ts-ignore
-                        keywords.push('alpha', ...token.val.slice(-3).split(''));
+                    keywords.push('alpha', ...token.val.slice(-3).split(''));
+                }
+                // @ts-ignore
+                for (const v of token.chi) {
+                    if (v.typ == EnumToken.CommaTokenType) {
+                        isLegacySyntax = true;
                     }
-                    // @ts-ignore
-                    for (const v of token.chi) {
-                        if (v.typ == EnumToken.CommaTokenType) {
-                            isLegacySyntax = true;
+                    if (v.typ == EnumToken.IdenTokenType) {
+                        if (!(keywords.includes(v.val) || v.val.toLowerCase() in COLORS_NAMES)) {
+                            return false;
                         }
-                        if (v.typ == EnumToken.IdenTokenType) {
-                            if (!(keywords.includes(v.val) || v.val.toLowerCase() in COLORS_NAMES)) {
+                        if (keywords.includes(v.val)) {
+                            if (isLegacySyntax) {
                                 return false;
                             }
-                            if (keywords.includes(v.val)) {
-                                if (isLegacySyntax) {
-                                    return false;
-                                }
-                                // @ts-ignore
-                                if (v.val == 'from' && ['rgba', 'hsla'].includes(token.val)) {
-                                    return false;
-                                }
+                            // @ts-ignore
+                            if (v.val == 'from' && ['rgba', 'hsla'].includes(token.val)) {
+                                return false;
                             }
-                            continue;
-                        }
-                        if (v.typ == EnumToken.FunctionTokenType && (mathFuncs.includes(v.val) || v.val == 'var' || colorsFunc.includes(v.val))) {
-                            continue;
-                        }
-                        if (![EnumToken.ColorTokenType, EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.LiteralTokenType].includes(v.typ)) {
-                            return false;
                         }
+                        continue;
+                    }
+                    if (v.typ == EnumToken.FunctionTokenType && (mathFuncs.includes(v.val) || v.val == 'var' || colorsFunc.includes(v.val))) {
+                        continue;
+                    }
+                    if (![EnumToken.ColorTokenType, EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.LiteralTokenType].includes(v.typ)) {
+                        return false;
                     }
                 }
             }
@@ -680,7 +690,7 @@ function parseColor(token) {
     // @ts-ignore
     token.typ = EnumToken.ColorTokenType;
     // @ts-ignore
-    token.kin = ColorKind[token.val.replaceAll('-', '_').toUpperCase()];
+    token.kin = ColorType[token.val.replaceAll('-', '_').toUpperCase()];
     // @ts-ignore
     if (token.chi[0].typ == EnumToken.IdenTokenType) {
         // @ts-ignore
@@ -772,15 +782,6 @@ function isIdent(name) {
     }
     return true;
 }
-function isNonPrintable(codepoint) {
-    // null -> backspace
-    return (codepoint >= 0 && codepoint <= 0x8) ||
-        // tab
-        codepoint == 0xb ||
-        // delete
-        codepoint == 0x7f ||
-        (codepoint >= 0xe && codepoint <= 0x1f);
-}
 function isPseudo(name) {
     return name.charAt(0) == ':' &&
         ((name.endsWith('(') && isIdent(name.charAt(1) == ':' ? name.slice(2, -1) : name.slice(1, -1))) ||
@@ -887,7 +888,7 @@ function parseDimension(name) {
     }
     const dimension = {
         typ: EnumToken.DimensionTokenType,
-        val: name.slice(0, index),
+        val: +name.slice(0, index),
         unit: name.slice(index)
     };
     if (isAngle(dimension)) {
@@ -947,4 +948,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentColor, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseColor, parseDimension, pseudoAliasMap, pseudoElements, transformFunctions, webkitExtensions, wildCardFuncs };
+export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentColor, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPercentageToken, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseColor, parseDimension, pseudoAliasMap, pseudoElements, transformFunctions, webkitExtensions, wildCardFuncs };

package/dist/lib/syntax/utils.js

@@ -0,0 +1,70 @@
+import { EnumToken } from '../ast/types.js';
+import '../ast/minify.js';
+import '../ast/walk.js';
+import '../parser/parse.js';
+import '../parser/tokenize.js';
+import '../parser/utils/config.js';
+import './color/utils/constants.js';
+import '../renderer/sourcemap/lib/encode.js';
+
+function length2Px(value) {
+    let result = null;
+    if (value.typ == EnumToken.NumberTokenType) {
+        result = +value.val;
+    }
+    else {
+        switch (value.unit) {
+            case 'cm':
+                // @ts-ignore
+                result = value.val * 37.8;
+                break;
+            case 'mm':
+                // @ts-ignore
+                result = value.val * 3.78;
+                break;
+            case 'Q':
+                // @ts-ignore
+                result = value.val * 37.8 / 40;
+                break;
+            case 'in':
+                // @ts-ignore
+                result = value.val / 96;
+                break;
+            case 'pc':
+                // @ts-ignore
+                result = value.val / 16;
+                break;
+            case 'pt':
+                // @ts-ignore
+                result = value.val * 4 / 3;
+                break;
+            case 'px':
+                result = +value.val;
+                break;
+        }
+    }
+    return isNaN(result) ? null : result;
+}
+/**
+ * minify number
+ * @param val
+ */
+function minifyNumber(val) {
+    val = String(val);
+    if (val === '0') {
+        return '0';
+    }
+    const chr = val.charAt(0);
+    if (chr == '-') {
+        const slice = val.slice(0, 2);
+        if (slice == '-0') {
+            return val.length == 2 ? '0' : '-' + val.slice(2);
+        }
+    }
+    if (chr == '0') {
+        return val.slice(1);
+    }
+    return val;
+}
+
+export { length2Px, minifyNumber };

package/dist/lib/validation/at-rules/container.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';

package/dist/lib/validation/at-rules/counter-style.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function validateAtRuleCounterStyle(atRule, options, root) {

package/dist/lib/validation/at-rules/custom-media.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { validateAtRuleMediaQueryList } from './media.js';

package/dist/lib/validation/at-rules/document.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';
@@ -45,7 +45,7 @@ function validateAtRuleDocument(atRule, options, root) {
             };
         }
         // @ts-ignore
-        if ((t[0].typ != EnumToken.FunctionTokenType && t[0].typ != EnumToken.UrlFunctionTokenType) || !['url', 'url-prefix', 'domain', 'media-document', 'regexp'].some((f) => f.localeCompare(t[0].val, undefined, { sensitivity: 'base' }) == 0)) {
+        if ((t[0].typ != EnumToken.FunctionTokenType && t[0].typ != EnumToken.UrlFunctionTokenType) || !['url', 'url-prefix', 'domain', 'media-document', 'regexp'].includes(t[0].val?.toLowerCase?.())) {
             return {
                 valid: SyntaxValidationResult.Drop,
                 context: [],

package/dist/lib/validation/at-rules/font-feature-values.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { validateFamilyName } from '../syntaxes/family-name.js';
 import '../syntaxes/complex-selector.js';
@@ -23,7 +23,7 @@ function validateAtRuleFontFeatureValues(atRule, options, root) {
             tokens: []
         };
     }
-    const result = validateFamilyName(atRule.tokens, atRule);
+    const result = validateFamilyName(atRule.tokens);
     if (result.valid == SyntaxValidationResult.Drop) {
         return result;
     }

package/dist/lib/validation/at-rules/import.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { validateAtRuleMediaQueryList } from './media.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
@@ -94,8 +94,7 @@ function validateAtRuleImport(atRule, options, root) {
     if (tokens.length > 0) {
         // @ts-ignore
         if (tokens[0].typ == EnumToken.IdenTokenType) {
-            // @ts-ignore
-            if ('layer'.localeCompare(tokens[0].val, undefined, { sensitivity: 'base' }) == 0) {
+            if ('layer' === tokens[0].val.toLowerCase()) {
                 tokens.shift();
                 // @ts-ignore
                 if (!consumeWhitespace(tokens)) {
@@ -113,7 +112,7 @@ function validateAtRuleImport(atRule, options, root) {
         // @ts-ignore
         else if (tokens[0].typ == EnumToken.FunctionTokenType) {
             // @ts-ignore
-            if ('layer'.localeCompare(tokens[0].val, undefined, { sensitivity: 'base' }) == 0) {
+            if ('layer' === tokens[0].val.toLowerCase()) {
                 const result = validateLayerName(tokens[0].chi);
                 if (result.valid == SyntaxValidationResult.Drop) {
                     return result;
@@ -122,8 +121,9 @@ function validateAtRuleImport(atRule, options, root) {
                 // @ts-ignore
                 consumeWhitespace(tokens);
             }
+            // tokens[0]?.val
             // @ts-ignore
-            if ('supports'.localeCompare(tokens[0]?.val, undefined, { sensitivity: 'base' }) == 0) {
+            if ('supports' === tokens[0]?.val?.toLowerCase?.()) {
                 const result = validateAtRuleSupportsConditions(atRule, tokens[0].chi);
                 if (result.valid == SyntaxValidationResult.Drop) {
                     return result;

package/dist/lib/validation/at-rules/keyframes.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 
@@ -19,19 +19,9 @@ function validateAtRuleKeyframes(atRule, options, root) {
             error: 'expecting at-rule prelude'
         };
     }
-    const tokens = atRule.tokens.slice();
+    const tokens = atRule.tokens.filter((t) => t.typ != EnumToken.CommentTokenType).slice();
     consumeWhitespace(tokens);
-    if (tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@keyframes',
-            error: 'expecting at-rule prelude'
-        };
-    }
-    if (![EnumToken.StringTokenType, EnumToken.IdenTokenType].includes(tokens[0].typ)) {
+    if (tokens.length == 0 || ![EnumToken.StringTokenType, EnumToken.IdenTokenType].includes(tokens[0].typ)) {
         // @ts-ignore
         return {
             valid: SyntaxValidationResult.Drop,

package/dist/lib/validation/at-rules/layer.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { validateLayerName } from '../syntaxes/layer-name.js';
 import '../syntaxes/complex-selector.js';

package/dist/lib/validation/at-rules/media.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import { generalEnclosedFunc } from '../../renderer/color/utils/constants.js';
+import { generalEnclosedFunc } from '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';

package/dist/lib/validation/at-rules/namespace.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { validateURL } from '../syntaxes/url.js';

package/dist/lib/validation/at-rules/page-margin-box.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function validateAtRulePageMarginBox(atRule, options, root) {

package/dist/lib/validation/at-rules/page.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { splitTokenList } from '../utils/list.js';
 

package/dist/lib/validation/at-rules/supports.js

@@ -5,7 +5,7 @@ import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { colorFontTech, fontFeaturesTech, fontFormat } from '../../syntax/syntax.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';
@@ -166,7 +166,7 @@ function validateSupportCondition(atRule, token) {
     if (token.typ == EnumToken.MediaFeatureNotTokenType) {
         return validateSupportCondition(atRule, token.val);
     }
-    if (token.typ == EnumToken.FunctionTokenType && token.val.localeCompare('selector', undefined, { sensitivity: 'base' }) == 0) {
+    if (token.typ == EnumToken.FunctionTokenType && 'selector' === token.val.toLowerCase()) {
         return {
             valid: SyntaxValidationResult.Valid,
             context: [],
@@ -223,7 +223,7 @@ function validateSupportFeature(token) {
         return validateSupportFeature(token.val);
     }
     if (token.typ == EnumToken.FunctionTokenType) {
-        if (token.val.localeCompare('selector', undefined, { sensitivity: 'base' }) == 0) {
+        if ('selector' === token.val.toLowerCase()) {
             return {
                 valid: SyntaxValidationResult.Valid,
                 context: [],
@@ -232,10 +232,10 @@ function validateSupportFeature(token) {
                 error: ''
             };
         }
-        if (token.val.localeCompare('font-tech', undefined, { sensitivity: 'base' }) == 0) {
+        if ('font-tech' === token.val.toLowerCase()) {
             const chi = token.chi.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
             // @ts-ignore
-            return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && colorFontTech.concat(fontFeaturesTech).some((t) => t.localeCompare(chi[0].val, undefined, { sensitivity: 'base' }) == 0) ?
+            return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && colorFontTech.concat(fontFeaturesTech).includes(chi[0].val.toLowerCase()) ?
                 {
                     valid: SyntaxValidationResult.Valid,
                     context: [],
@@ -251,10 +251,10 @@ function validateSupportFeature(token) {
                     error: 'expected font-tech'
                 };
         }
-        if (token.val.localeCompare('font-format', undefined, { sensitivity: 'base' }) == 0) {
+        if ('font-format' === token.val.toLowerCase()) {
             const chi = token.chi.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
             // @ts-ignore
-            return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && fontFormat.some((t) => t.localeCompare(chi[0].val, undefined, { sensitivity: 'base' }) == 0) ?
+            return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && fontFormat.includes(chi[0].val, toLowerCase()) ?
                 {
                     valid: SyntaxValidationResult.Valid,
                     context: [],

package/dist/lib/validation/at-rules/when.js

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import { generalEnclosedFunc } from '../../renderer/color/utils/constants.js';
+import { generalEnclosedFunc } from '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';

package/dist/lib/validation/atrule.js

@@ -4,7 +4,7 @@ import '../ast/walk.js';
 import '../parser/parse.js';
 import '../parser/tokenize.js';
 import '../parser/utils/config.js';
-import '../renderer/color/utils/constants.js';
+import '../syntax/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
 import { getSyntaxConfig, getParsedSyntax } from './config.js';
 import { validateAtRuleMedia } from './at-rules/media.js';
@@ -77,7 +77,7 @@ function validateAtRule(atRule, options, root) {
         return validateAtRuleCustomMedia(atRule);
     }
     if (['position-try', 'property', 'font-palette-values'].includes(atRule.nam)) {
-        if (!('tokens' in atRule)) {
+        if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             return {
                 valid: SyntaxValidationResult.Drop,
                 node: atRule,

package/dist/lib/validation/config.js

@@ -21,9 +21,6 @@ function getSyntax(group, key) {
                     key = matches[1] + matches[3];
                 }
             }
-            if (!(key in obj)) {
-                return null;
-            }
         }
         // @ts-ignore
         obj = obj[key];

package/dist/lib/validation/config.json.js

@@ -3340,7 +3340,7 @@ var syntaxes = {
 		syntax: "cover | contain | entry | exit | entry-crossing | exit-crossing"
 	},
 	"track-breadth": {
-		syntax: "<length-percentage> | <flex> | min-content | max-content | auto"
+		syntax: "<length-percentage> | <flex> | min-content | max-content | auto | <-non-standard-size>"
 	},
 	"track-list": {
 		syntax: "[ <line-names>? [ <track-size> | <track-repeat> ] ]+ <line-names>?"