@tbela99/css-parser 0.7.1 → 0.8.0

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

@@ -1,12 +1,12 @@
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../parse.js';
+import { mathFuncs } from '../../syntax/syntax.js';
+import './config.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'];
 function matchType(val, properties) {
     if (val.typ == EnumToken.IdenTokenType && properties.keywords.includes(val.val) ||
         // @ts-ignore
@@ -22,8 +22,8 @@ function matchType(val, properties) {
         });
     }
     if (val.typ == EnumToken.FunctionTokenType) {
-        if (funcList.includes(val.val)) {
-            return val.chi.every(((t) => [EnumToken.LiteralTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.StartParensTokenType, EnumToken.EndParensTokenType].includes(t.typ) || matchType(t, properties)));
+        if (mathFuncs.includes(val.val)) {
+            return val.chi.every(((t) => [EnumToken.Add, EnumToken.Mul, EnumToken.Div, EnumToken.Sub, EnumToken.LiteralTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.DimensionTokenType, EnumToken.NumberTokenType, EnumToken.LengthTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType, EnumToken.ResolutionTokenType, EnumToken.TimeTokenType, EnumToken.BinaryExpressionTokenType].includes(t.typ) || matchType(t, properties)));
         }
         // match type defined like function 'symbols()', 'url()', 'attr()' etc.
         // return properties.types.includes((<FunctionToken>val).val + '()')
@@ -31,4 +31,4 @@ function matchType(val, properties) {
     return false;
 }
 
-export { funcList, matchType };
+export { matchType };

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

@@ -3,6 +3,7 @@ import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { srgb2xyz } from './xyz.js';
 import '../sourcemap/lib/encode.js';

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

@@ -1,5 +1,6 @@
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { srgb2rgb, lch2rgb, lab2rgb, oklch2rgb, oklab2rgb, hwb2rgb, hsl2rgb, hex2rgb } from './rgb.js';
 import { srgb2hsl, lch2hsl, lab2hsl, oklch2hsl, oklab2hsl, hwb2hsl, hex2hsl, rgb2hsl } from './hsl.js';

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

@@ -1,5 +1,6 @@
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { isRectangularOrthogonalColorspace, isPolarColorspace } from '../../syntax/syntax.js';
 import '../../parser/utils/config.js';

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

@@ -1,5 +1,6 @@
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { getNumber, minmax } from './color.js';
 import { hsl2rgb, hwb2rgb, cmyk2rgb, oklab2rgb, oklch2rgb, lab2rgb, lch2rgb } from './rgb.js';

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

@@ -5,6 +5,7 @@ import './utils/constants.js';
 import { getComponents } from './utils/components.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { hslvalues } from './srgb.js';
 import '../sourcemap/lib/encode.js';

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

@@ -4,6 +4,7 @@ import { getComponents } from './utils/components.js';
 import { getNumber, getAngle } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { lab2srgb, lch2srgb, oklab2srgb, oklch2srgb } from './srgb.js';
 import '../sourcemap/lib/encode.js';

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

@@ -7,6 +7,7 @@ import { OKLab_to_XYZ, getOKLABComponents } from './oklab.js';
 import { getNumber } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';

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

@@ -3,6 +3,7 @@ import { getComponents } from './utils/components.js';
 import { getNumber, getAngle } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { srgb2lab, xyz2lab, hex2lab, rgb2lab, hsl2lab, hwb2lab, getLABComponents, oklab2lab, oklch2lab } from './lab.js';
 import '../sourcemap/lib/encode.js';

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

@@ -5,6 +5,7 @@ import { srgb2lsrgbvalues, hex2srgb, rgb2srgb, hsl2srgb, hwb2srgb, lab2srgb, lch
 import { getNumber } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { lch2labvalues } from './lab.js';
 import { getOKLCHComponents } from './oklch.js';

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

@@ -3,6 +3,7 @@ import { getComponents } from './utils/components.js';
 import { getNumber, getAngle } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { lab2lchvalues } from './lch.js';
 import { srgb2oklab, hex2oklab, rgb2oklab, hsl2oklab, hwb2oklab, lab2oklab, lch2oklab, getOKLABComponents } from './oklab.js';

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

@@ -3,6 +3,7 @@ import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { srgb2xyz } from './xyz.js';
 import '../sourcemap/lib/encode.js';

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

@@ -0,0 +1,56 @@
+import { xyzd502srgb, srgb2xyz } from './xyz.js';
+import { XYZ_D65_to_D50 } from './xyzd50.js';
+
+function prophotorgb2srgbvalues(r, g, b, a = null) {
+    // @ts-ignore
+    return xyzd502srgb(...prophotorgb2xyz50(r, g, b, a));
+}
+function srgb2prophotorgbvalues(r, g, b, a) {
+    // @ts-ignore
+    return xyz50_to_prophotorgb(...XYZ_D65_to_D50(...srgb2xyz(r, g, b, a)));
+}
+function prophotorgb2lin_ProPhoto(r, g, b, a = null) {
+    return [r, g, b].map(v => {
+        let abs = Math.abs(v);
+        if (abs >= 16 / 512) {
+            return Math.sign(v) * Math.pow(abs, 1.8);
+        }
+        return v / 16;
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+function prophotorgb2xyz50(r, g, b, a = null) {
+    [r, g, b, a] = prophotorgb2lin_ProPhoto(r, g, b, a);
+    const xyz = [
+        0.7977666449006423 * r +
+            0.1351812974005331 * g +
+            0.0313477341283922 * b,
+        0.2880748288194013 * r +
+            0.7118352342418731 * g +
+            0.0000899369387256 * b,
+        0.8251046025104602 * b
+    ];
+    return xyz.concat(a == null || a == 1 ? [] : [a]);
+}
+function xyz50_to_prophotorgb(x, y, z, a) {
+    // @ts-ignore
+    return gam_prophotorgb(...[
+        x * 1.3457868816471585 -
+            y * 0.2555720873797946 -
+            0.0511018649755453 * z,
+        x * -0.5446307051249019 +
+            y * 1.5082477428451466 +
+            0.0205274474364214 * z,
+        1.2119675456389452 * z
+    ].concat(a == null || a == 1 ? [] : [a]));
+}
+function gam_prophotorgb(r, g, b, a) {
+    return [r, g, b].map(v => {
+        let abs = Math.abs(v);
+        if (abs >= 1 / 512) {
+            return Math.sign(v) * Math.pow(abs, 1 / 1.8);
+        }
+        return 16 * v;
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+
+export { prophotorgb2srgbvalues, srgb2prophotorgbvalues };

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

@@ -3,6 +3,7 @@ import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { srgb2xyz } from './xyz.js';
 import '../sourcemap/lib/encode.js';

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

@@ -3,10 +3,11 @@ import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { walkValues } from '../../ast/walk.js';
 import '../../parser/parse.js';
+import { mathFuncs } from '../../syntax/syntax.js';
+import '../../parser/utils/config.js';
 import { reduceNumber } from '../render.js';
+import { evaluateFunc, evaluate } from '../../ast/math/expression.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;
@@ -47,7 +48,7 @@ function parseRelativeColor(relativeKeys, original, rExp, gExp, bExp, aExp) {
             val: '1'
         } : aExp)
     };
-    return computeComponentValue(keys, values);
+    return computeComponentValue(keys, converted, values);
 }
 function getValue(t, converted, component) {
     if (t == null) {
@@ -66,7 +67,7 @@ function getValue(t, converted, component) {
     }
     return t;
 }
-function computeComponentValue(expr, values) {
+function computeComponentValue(expr, converted, values) {
     for (const object of [values, expr]) {
         if ('h' in object) {
             // normalize hue
@@ -107,34 +108,29 @@ function computeComponentValue(expr, values) {
                 expr[key] = values[exp.val];
             }
         }
-        else if (exp.typ == EnumToken.FunctionTokenType && exp.val == 'calc') {
-            for (let { value, parent } of walkValues(exp.chi)) {
-                if (value.typ == EnumToken.IdenTokenType) {
-                    if (!(value.val in values)) {
+        else if (exp.typ == EnumToken.FunctionTokenType && mathFuncs.includes(exp.val)) {
+            for (let { value, parent } of walkValues(exp.chi, exp)) {
+                if (parent == null) {
+                    parent = exp;
+                }
+                if (value.typ == EnumToken.PercentageTokenType) {
+                    replaceValue(parent, value, getValue(value, converted, key));
+                }
+                else if (value.typ == EnumToken.IdenTokenType) {
+                    // @ts-ignore
+                    if (!(value.val in values || typeof Math[value.val.toUpperCase()] == 'number')) {
                         return null;
                     }
-                    if (parent == null) {
-                        parent = exp;
-                    }
-                    if (parent.typ == EnumToken.BinaryExpressionTokenType) {
-                        if (parent.l == value) {
-                            parent.l = values[value.val];
-                        }
-                        else {
-                            parent.r = values[value.val];
-                        }
-                    }
-                    else {
-                        for (let i = 0; i < parent.chi.length; i++) {
-                            if (parent.chi[i] == value) {
-                                parent.chi.splice(i, 1, values[value.val]);
-                                break;
-                            }
-                        }
-                    }
+                    // @ts-ignore
+                    replaceValue(parent, value, values[value.val] ?? {
+                        typ: EnumToken.NumberTokenType,
+                        // @ts-ignore
+                        val: '' + Math[value.val.toUpperCase()]
+                        // @ts-ignore
+                    });
                 }
             }
-            const result = evaluate(exp.chi);
+            const result = exp.typ == EnumToken.FunctionTokenType && mathFuncs.includes(exp.val) && exp.val != 'calc' ? evaluateFunc(exp) : evaluate(exp.chi);
             if (result.length == 1 && result[0].typ != EnumToken.BinaryExpressionTokenType) {
                 expr[key] = result[0];
             }
@@ -145,5 +141,33 @@ function computeComponentValue(expr, values) {
     }
     return expr;
 }
+function replaceValue(parent, value, newValue) {
+    if (parent.typ == EnumToken.BinaryExpressionTokenType) {
+        if (parent.l == value) {
+            parent.l = newValue;
+        }
+        else {
+            parent.r = newValue;
+        }
+    }
+    else {
+        for (let i = 0; i < parent.chi.length; i++) {
+            if (parent.chi[i] == value) {
+                parent.chi.splice(i, 1, newValue);
+                break;
+            }
+            if (parent.chi[i].typ == EnumToken.BinaryExpressionTokenType) {
+                if (parent.chi[i].l == value) {
+                    parent.chi[i].l = newValue;
+                    break;
+                }
+                else if (parent.chi[i].r == value) {
+                    parent.chi[i].r = newValue;
+                    break;
+                }
+            }
+        }
+    }
+}
 
 export { parseRelativeColor };

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

@@ -2,6 +2,7 @@ import { minmax } from './color.js';
 import { COLORS_NAMES } from './utils/constants.js';
 import '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { expandHexValue } from './hex.js';
 import { hwb2srgb, hslvalues, hsl2srgbvalues, cmyk2srgb, oklab2srgb, oklch2srgb, lab2srgb, lch2srgb } from './srgb.js';

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

@@ -3,6 +3,7 @@ import { getComponents } from './utils/components.js';
 import { color2srgbvalues, getNumber, getAngle } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { expandHexValue } from './hex.js';
 import { lch2labvalues, getLABComponents, Lab_to_sRGB } from './lab.js';

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

@@ -1,5 +1,6 @@
 import { EnumToken } from '../../../ast/types.js';
 import '../../../ast/minify.js';
+import '../../../ast/walk.js';
 import '../../../parser/parse.js';
 import { COLORS_NAMES } from './constants.js';
 import { expandHexValue } from '../hex.js';

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

@@ -1,5 +1,6 @@
 import { EnumToken } from '../../../ast/types.js';
 import '../../../ast/minify.js';
+import '../../../ast/walk.js';
 import '../../../parser/parse.js';
 import '../../sourcemap/lib/encode.js';
 import '../../../parser/utils/config.js';

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

@@ -2,6 +2,7 @@ import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { lsrgb2srgbvalues, srgb2lsrgbvalues } from './srgb.js';
 import '../sourcemap/lib/encode.js';

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

@@ -2,6 +2,7 @@ import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';
 import '../../ast/minify.js';
+import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { xyz2lab } from './lab.js';
 import { lab2lchvalues } from './lch.js';

package/dist/lib/renderer/render.js

@@ -4,11 +4,12 @@ import { getComponents } from './color/utils/components.js';
 import { reduceHexValue, srgb2hexvalues, rgb2hex, hsl2hex, hwb2hex, cmyk2hex, oklab2hex, oklch2hex, lab2hex, lch2hex } from './color/hex.js';
 import { EnumToken } from '../ast/types.js';
 import '../ast/minify.js';
+import '../ast/walk.js';
 import { expand } from '../ast/expand.js';
 import { colorMix } from './color/colormix.js';
 import { parseRelativeColor } from './color/relativecolor.js';
 import { SourceMap } from './sourcemap/sourcemap.js';
-import { isColor, isNewLine } from '../syntax/syntax.js';
+import { isColor, mathFuncs, isNewLine } from '../syntax/syntax.js';
 
 const colorsFunc = ['rgb', 'rgba', 'hsl', 'hsla', 'hwb', 'device-cmyk', 'color-mix', 'color', 'oklab', 'lab', 'oklch', 'lch', 'light-dark'];
 function reduceNumber(val) {
@@ -45,6 +46,7 @@ function doRender(data, options = {}) {
         ...(options.minify ?? true ? {
             indent: '',
             newLine: '',
+            removeEmpty: true,
             removeComments: true
         } : {
             indent: ' ',
@@ -193,6 +195,9 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
                 }
                 return `${css}${options.newLine}${indentSub}${str}`;
             }, '');
+            if (options.removeEmpty && children === '') {
+                return '';
+            }
             if (children.endsWith(';')) {
                 children = children.slice(0, -1);
             }
@@ -201,8 +206,10 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
             }
             return data.sel + `${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
         case EnumToken.InvalidRuleTokenType:
+        case EnumToken.InvalidAtRuleTokenType:
             return '';
         default:
+            // return renderToken(data as Token, options, cache, reducer, errors);
             throw new Error(`render: unexpected token ${JSON.stringify(data, null, 1)}`);
     }
     return '';
@@ -394,19 +401,18 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
         case EnumToken.TimelineFunctionTokenType:
         case EnumToken.GridTemplateFuncTokenType:
             if (token.typ == EnumToken.FunctionTokenType &&
-                token.val == 'calc' &&
+                mathFuncs.includes(token.val) &&
                 token.chi.length == 1 &&
-                token.chi[0].typ != EnumToken.BinaryExpressionTokenType &&
-                token.chi[0].typ != EnumToken.FractionTokenType &&
+                ![EnumToken.BinaryExpressionTokenType, EnumToken.FractionTokenType, EnumToken.IdenTokenType].includes(token.chi[0].typ) &&
+                // @ts-ignore
                 token.chi[0].val?.typ != EnumToken.FractionTokenType) {
-                // calc(200px) => 200px
                 return token.chi.reduce((acc, curr) => acc + renderToken(curr, options, cache, reducer), '');
             }
             // @ts-ignore
             return ( /* options.minify && 'Pseudo-class-func' == token.typ && token.val.slice(0, 2) == '::' ? token.val.slice(1) :*/token.val ?? '') + '(' + token.chi.reduce(reducer, '') + ')';
         case EnumToken.MatchExpressionTokenType:
             return renderToken(token.l, options, cache, reducer, errors) +
-                renderToken({ typ: token.op }, options, cache, reducer, errors) +
+                renderToken(token.op, options, cache, reducer, errors) +
                 renderToken(token.r, options, cache, reducer, errors) +
                 (token.attr ? ' ' + token.attr : '');
         case EnumToken.NameSpaceAttributeTokenType:
@@ -419,6 +425,7 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
         case EnumToken.StartParensTokenType:
             return '(';
         case EnumToken.DelimTokenType:
+        case EnumToken.EqualMatchTokenType:
             return '=';
         case EnumToken.IncludeMatchTokenType:
             return '~=';
@@ -587,6 +594,7 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
         case EnumToken.StringTokenType:
         case EnumToken.LiteralTokenType:
         case EnumToken.DashedIdenTokenType:
+        case EnumToken.PseudoPageTokenType:
         case EnumToken.ClassSelectorTokenType:
             return /* options.minify && 'Pseudo-class' == token.typ && '::' == token.val.slice(0, 2) ? token.val.slice(1) :  */ token.val;
         case EnumToken.NestingSelectorTokenType:
@@ -595,6 +603,20 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
             return '[' + token.chi.reduce((acc, curr) => acc + renderToken(curr, options, cache), '');
         case EnumToken.InvalidClassSelectorTokenType:
             return token.val;
+        case EnumToken.DeclarationNodeType:
+            return token.nam + ':' + token.val.reduce((acc, curr) => acc + renderToken(curr, options, cache), '');
+        case EnumToken.MediaQueryConditionTokenType:
+            return renderToken(token.l, options, cache, reducer, errors) + renderToken(token.op, options, cache, reducer, errors) + token.r.reduce((acc, curr) => acc + renderToken(curr, options, cache), '');
+        case EnumToken.MediaFeatureTokenType:
+            return token.val;
+        case EnumToken.MediaFeatureNotTokenType:
+            return 'not ' + renderToken(token.val, options, cache, reducer, errors);
+        case EnumToken.MediaFeatureOnlyTokenType:
+            return 'only ' + renderToken(token.val, options, cache, reducer, errors);
+        case EnumToken.MediaFeatureAndTokenType:
+            return 'and';
+        case EnumToken.MediaFeatureOrTokenType:
+            return 'or';
         default:
             throw new Error(`render: unexpected token ${JSON.stringify(token, null, 1)}`);
     }

package/dist/lib/syntax/syntax.js

@@ -1,6 +1,7 @@
 import { colorsFunc } from '../renderer/render.js';
 import { EnumToken } from '../ast/types.js';
 import '../ast/minify.js';
+import '../ast/walk.js';
 import '../parser/parse.js';
 import '../parser/utils/config.js';
 import { COLORS_NAMES } from '../renderer/color/utils/constants.js';
@@ -15,6 +16,15 @@ const dimensionUnits = new Set([
     'lvh', 'lvi', 'lvmax', 'lvw', 'mm', 'pc', 'pt', 'px', 'rem', 'rlh', 'svb',
     'svh', 'svi', 'svmin', 'svw', 'vb', 'vh', 'vi', 'vmax', 'vmin', 'vw'
 ]);
+const fontFormat = ['collection', 'embedded-opentype', 'opentype', 'svg', 'truetype', 'woff', 'woff2'];
+const colorFontTech = ['color-colrv0', 'color-colrv1', 'color-svg', 'color-sbix', 'color-cbdt'];
+const fontFeaturesTech = ['features-opentype', 'features-aat', 'features-graphite', 'incremental-patch', 'incremental-range', 'incremental-auto', 'variations', 'palettes'];
+// https://drafts.csswg.org/mediaqueries/#media-types
+const mediaTypes = ['all', 'print', 'screen',
+    /* deprecated */
+    'aural', 'braille', 'embossed', 'handheld', 'projection', 'tty', 'tv', 'speech'];
+// https://www.w3.org/TR/css-values-4/#math-function
+const mathFuncs = ['calc', 'clamp', 'min', 'max', 'round', 'mod', 'rem', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'pow', 'sqrt', 'hypot', 'log', 'exp', 'abs', 'sign'];
 function isLength(dimension) {
     return 'unit' in dimension && dimensionUnits.has(dimension.unit.toLowerCase());
 }
@@ -89,7 +99,7 @@ function isColor(token) {
                         return false;
                     }
                 }
-                if (children[i].typ == EnumToken.FunctionTokenType && !['calc'].includes(children[i].val)) {
+                if (children[i].typ == EnumToken.FunctionTokenType && !mathFuncs.includes(children[i].val)) {
                     return false;
                 }
             }
@@ -184,7 +194,7 @@ function isColor(token) {
                     }
                     continue;
                 }
-                if (v.typ == EnumToken.FunctionTokenType && (v.val == 'calc' || v.val == 'var' || colorsFunc.includes(v.val))) {
+                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)) {
@@ -207,7 +217,7 @@ function isNonAscii(codepoint) {
 }
 function isIdentStart(codepoint) {
     // _
-    return codepoint == 0x5f || isLetter(codepoint) || isNonAscii(codepoint);
+    return codepoint == 0x5f || isLetter(codepoint) || isNonAscii(codepoint) || codepoint == REVERSE_SOLIDUS;
 }
 function isDigit(codepoint) {
     return codepoint >= 0x30 && codepoint <= 0x39;
@@ -238,6 +248,19 @@ function isIdent(name) {
     if (!isIdentStart(codepoint)) {
         return false;
     }
+    if (codepoint == REVERSE_SOLIDUS) {
+        codepoint = name.codePointAt(i + 1);
+        if (!isIdentCodepoint(codepoint)) {
+            return false;
+        }
+        i += String.fromCodePoint(codepoint).length;
+        if (i < j) {
+            codepoint = name.codePointAt(i);
+            if (!isIdentCodepoint(codepoint)) {
+                return false;
+            }
+        }
+    }
     while (i < j) {
         i += codepoint < 0x80 ? 1 : String.fromCodePoint(codepoint).length;
         codepoint = name.charCodeAt(i);
@@ -453,4 +476,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, parseDimension };
+export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, parseDimension };

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

@@ -0,0 +1,78 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+
+function validateAtRuleCounterStyle(atRule, options, root) {
+    // media-query-list
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@counter-style',
+            error: 'expected media query list',
+            tokens: []
+        };
+    }
+    const tokens = atRule.tokens.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: atRule,
+            syntax: '@counter-style',
+            error: 'expected counter style name',
+            tokens
+        };
+    }
+    if (tokens.length > 1) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[1] ?? atRule,
+            syntax: '@counter-style',
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    if (![EnumToken.IdenTokenType, EnumToken.DashedIdenTokenType].includes(tokens[0].typ)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: '@counter-style',
+            error: 'expected counter style name',
+            tokens
+        };
+    }
+    if (!('chi' in atRule)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@counter-style',
+            error: 'expected counter style body',
+            tokens
+        };
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@counter-style',
+        error: '',
+        tokens
+    };
+}
+
+export { validateAtRuleCounterStyle };