@tbela99/css-parser 1.3.2 → 1.3.4

package/dist/index-umd-web.js

@@ -25,14 +25,26 @@
          * disable validation
          */
         ValidationLevel[ValidationLevel["None"] = 0] = "None";
+        /**
+         * validate selectors
+         */
+        ValidationLevel[ValidationLevel["Selector"] = 1] = "Selector";
+        /**
+         * validate at-rules
+         */
+        ValidationLevel[ValidationLevel["AtRule"] = 2] = "AtRule";
+        /**
+         * validate declarations
+         */
+        ValidationLevel[ValidationLevel["Declaration"] = 4] = "Declaration";
         /**
          * validate selectors and at-rules
          */
-        ValidationLevel[ValidationLevel["Default"] = 1] = "Default";
+        ValidationLevel[ValidationLevel["Default"] = 3] = "Default";
         /**
          * validate selectors, at-rules and declarations
          */
-        ValidationLevel[ValidationLevel["All"] = 2] = "All"; // selectors + at-rules + declarations
+        ValidationLevel[ValidationLevel["All"] = 7] = "All"; // selectors + at-rules + declarations
     })(exports.ValidationLevel || (exports.ValidationLevel = {}));
     /**
      * enum of all token types
@@ -336,7 +348,7 @@
         /**
          * keyframe rule node type
          */
-        EnumToken[EnumToken["KeyFrameRuleNodeType"] = 73] = "KeyFrameRuleNodeType";
+        EnumToken[EnumToken["KeyFramesRuleNodeType"] = 73] = "KeyFramesRuleNodeType";
         /**
          * class selector token type
          */
@@ -416,7 +428,7 @@
         /**
          * keyframe at rule node type
          */
-        EnumToken[EnumToken["KeyframeAtRuleNodeType"] = 93] = "KeyframeAtRuleNodeType";
+        EnumToken[EnumToken["KeyframesAtRuleNodeType"] = 93] = "KeyframesAtRuleNodeType";
         /**
          * invalid declaration node type
          */
@@ -951,12 +963,15 @@
     function lchToken(values) {
         values[2] = toPrecisionAngle(values[2]);
         const chi = [
-            { typ: exports.EnumToken.NumberTokenType, val: values[0] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[1] },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[0]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[1]) },
             { typ: exports.EnumToken.NumberTokenType, val: values[2] },
         ];
         if (values.length == 4) {
-            chi.push({ typ: exports.EnumToken.LiteralTokenType, val: '/' }, { typ: exports.EnumToken.PercentageTokenType, val: values[3] * 100 });
+            chi.push({ typ: exports.EnumToken.LiteralTokenType, val: '/' }, {
+                typ: exports.EnumToken.PercentageTokenType,
+                val: values[3] * 100
+            });
         }
         return {
             typ: exports.EnumToken.ColorTokenType,
@@ -1219,8 +1234,8 @@
     function oklchToken(values) {
         values[2] = toPrecisionAngle(values[2]);
         const chi = [
-            { typ: exports.EnumToken.NumberTokenType, val: values[0] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[1] },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[0]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[1]) },
             { typ: exports.EnumToken.NumberTokenType, val: values[2] },
         ];
         if (values.length == 4) {
@@ -1262,16 +1277,28 @@
         return values == null ? null : srgb2oklch(...values);
     }
     function lab2oklchvalues(token) {
+        const values = lab2oklabvalues(token);
+        if (values == null) {
+            return null;
+        }
         // @ts-ignore
-        return labvalues2lchvalues(...lab2oklabvalues(token));
+        return labvalues2lchvalues(...values);
     }
     function lch2oklchvalues(token) {
+        const values = lch2oklabvalues(token);
+        if (values == null) {
+            return null;
+        }
         // @ts-ignore
-        return labvalues2lchvalues(...lch2oklabvalues(token));
+        return labvalues2lchvalues(...values);
     }
     function oklab2oklchvalues(token) {
+        const values = getOKLABComponents(token);
+        if (values == null) {
+            return null;
+        }
         // @ts-ignore
-        return labvalues2lchvalues(...getOKLABComponents(token));
+        return labvalues2lchvalues(...values);
     }
     function srgb2oklch(r, g, blue, alpha) {
         // @ts-ignore
@@ -1371,9 +1398,9 @@
     }
     function oklabToken(values) {
         const chi = [
-            { typ: exports.EnumToken.NumberTokenType, val: values[0] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[1] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[2] },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[0]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[1]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[2]) },
         ];
         if (values.length == 4) {
             chi.push({ typ: exports.EnumToken.LiteralTokenType, val: '/' }, {
@@ -1589,9 +1616,9 @@
     }
     function labToken(values) {
         const chi = [
-            { typ: exports.EnumToken.NumberTokenType, val: values[0] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[1] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[2] },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[0]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[1]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[2]) },
         ];
         if (values.length == 4) {
             chi.push({ typ: exports.EnumToken.LiteralTokenType, val: '/' }, {
@@ -1992,7 +2019,7 @@
             return null;
         }
         const rgb = Lab_to_sRGB(l, a, b);
-        if (alpha != null && alpha != 1) {
+        if (alpha != null && alpha < 1) {
             rgb.push(alpha);
         }
         return rgb;
@@ -2072,6 +2099,9 @@
                 value[7] == value[8]) {
                 value = `#${value[1]}${value[3]}${value[5]}${value[7] == 'f' ? '' : value[7]}`;
             }
+            if (value.endsWith('ff')) {
+                value = value.slice(0, -2);
+            }
         }
         return named_color != null && named_color.length <= value.length ? named_color : value;
     }
@@ -2492,12 +2522,15 @@
     function hslToken(values) {
         values[0] = toPrecisionAngle(values[0] * 360);
         const chi = [
-            { typ: exports.EnumToken.NumberTokenType, val: values[0] },
-            { typ: exports.EnumToken.PercentageTokenType, val: values[1] * 100 },
-            { typ: exports.EnumToken.PercentageTokenType, val: values[2] * 100 },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[0]) },
+            { typ: exports.EnumToken.PercentageTokenType, val: toPrecisionValue(values[1]) * 100 },
+            { typ: exports.EnumToken.PercentageTokenType, val: toPrecisionValue(values[2]) * 100 },
         ];
         if (values.length == 4 && values[3] != 1) {
-            chi.push({ typ: exports.EnumToken.LiteralTokenType, val: '/' }, { typ: exports.EnumToken.PercentageTokenType, val: values[3] * 100 });
+            chi.push({ typ: exports.EnumToken.LiteralTokenType, val: '/' }, {
+                typ: exports.EnumToken.PercentageTokenType,
+                val: values[3] * 100
+            });
         }
         return {
             typ: exports.EnumToken.ColorTokenType,
@@ -2563,12 +2596,20 @@
         return hsv2hsl(...hwb2hsv(...Object.values(hslvalues(token))));
     }
     function lab2hslvalues(token) {
+        const values = lab2rgbvalues(token);
+        if (values == null) {
+            return null;
+        }
         // @ts-ignore
-        return rgbvalues2hslvalues(...lab2rgbvalues(token));
+        return rgbvalues2hslvalues(...values);
     }
     function lch2hslvalues(token) {
+        const values = lch2rgbvalues(token);
+        if (values == null) {
+            return null;
+        }
         // @ts-ignore
-        return rgbvalues2hslvalues(...lch2rgbvalues(token));
+        return rgbvalues2hslvalues(...values);
     }
     function oklab2hslvalues(token) {
         const t = oklab2srgbvalues(token);
@@ -2674,8 +2715,8 @@
         values[0] = toPrecisionAngle(values[0] * 360);
         const chi = [
             { typ: exports.EnumToken.NumberTokenType, val: values[0] },
-            { typ: exports.EnumToken.PercentageTokenType, val: values[1] * 100 },
-            { typ: exports.EnumToken.PercentageTokenType, val: values[2] * 100 },
+            { typ: exports.EnumToken.PercentageTokenType, val: toPrecisionValue(values[1]) * 100 },
+            { typ: exports.EnumToken.PercentageTokenType, val: toPrecisionValue(values[2]) * 100 },
         ];
         if (values.length == 4) {
             chi.push({ typ: exports.EnumToken.LiteralTokenType, val: '/' }, {
@@ -3069,11 +3110,10 @@
         // @ts-ignore
         const calculate = () => [colorSpace].concat(values1.map((v1, i) => {
             return {
-                // @ts-ignore
-                typ: exports.EnumToken.NumberTokenType, val: String((mul1 * v1 * p1 + mul2 * values2[i] * p2) / mul)
+                typ: exports.EnumToken.NumberTokenType, val: (mul1 * v1 * p1 + mul2 * values2[i] * p2) / mul
             };
         }).concat(mul == 1 ? [] : [{
-                typ: exports.EnumToken.NumberTokenType, val: String(mul)
+                typ: exports.EnumToken.NumberTokenType, val: mul
             }]));
         switch (colorSpace.val) {
             case 'srgb':
@@ -3816,7 +3856,7 @@
         let keys = {};
         let values = {};
         // colorFuncColorSpace x,y,z or r,g,b
-        const names = relativeKeys.startsWith('xyz') ? 'xyz' : relativeKeys.slice(-3);
+        const names = relativeKeys.startsWith('xyz') ? 'xyz' : ['srgb', 'srgb-linear', 'display-p3', 'a98-rgb', 'prophoto-rgb', 'rec2020', 'rgb'].includes(relativeKeys.toLowerCase()) ? 'rgb' : relativeKeys.slice(-3);
         const converted = convertColor(original, exports.ColorType[relativeKeys.toUpperCase().replaceAll('-', '_')]);
         if (converted == null) {
             return null;
@@ -3830,13 +3870,13 @@
             // @ts-ignore
             alpha: alpha == null ? {
                 typ: exports.EnumToken.NumberTokenType,
-                val: '1'
+                val: 1
             } : (alpha.typ == exports.EnumToken.IdenTokenType && alpha.val == 'none') ? {
                 typ: exports.EnumToken.NumberTokenType,
-                val: '0'
+                val: 0
             } : (alpha.typ == exports.EnumToken.PercentageTokenType ? {
                 typ: exports.EnumToken.NumberTokenType,
-                val: String(getNumber(alpha))
+                val: getNumber(alpha)
             } : alpha)
         };
         keys = {
@@ -3846,19 +3886,15 @@
             // @ts-ignore
             alpha: getValue(aExp == null ? {
                 typ: exports.EnumToken.NumberTokenType,
-                val: '1'
+                val: 1
             } : (aExp.typ == exports.EnumToken.IdenTokenType && aExp.val == 'none') ? {
                 typ: exports.EnumToken.NumberTokenType,
-                val: '0'
+                val: 0
             } : aExp)
         };
         return computeComponentValue(keys, converted, values);
     }
     function getValue(t, converted, component) {
-        // if (t == null) {
-        //
-        //     return t;
-        // }
         if (t.typ == exports.EnumToken.PercentageTokenType) {
             let value = getNumber(t);
             let colorSpace = exports.ColorType[converted.kin].toLowerCase().replaceAll('-', '_');
@@ -3888,55 +3924,13 @@
             }
         }
         for (const [key, exp] of Object.entries(expr)) {
-            /*
-            if (exp == null) {
-
-                if (key in values) {
-
-                    if (typeof values[<RelativeColorTypes>key] == 'number') {
-
-                        expr[<RelativeColorTypes>key] = {
-                            typ: EnumToken.NumberTokenType,
-                            val: reduceNumber(<number>values[<RelativeColorTypes>key])
-                        };
-                    } else {
-
-                        expr[<RelativeColorTypes>key] = <Token>values[<RelativeColorTypes>key];
-                    }
-                }
-
-            } else
-                */
             if ([exports.EnumToken.NumberTokenType, exports.EnumToken.PercentageTokenType, exports.EnumToken.AngleTokenType, exports.EnumToken.LengthTokenType].includes(exp.typ)) ;
             else if (exp.typ == exports.EnumToken.IdenTokenType && exp.val in values) {
-                // if (typeof values[<RelativeColorTypes>exp.val] == 'number') {
-                //
-                //     expr[<RelativeColorTypes>key] = {
-                //         typ: EnumToken.NumberTokenType,
-                //         val: reduceNumber(<number>values[<RelativeColorTypes>exp.val])
-                //     };
-                // } else {
                 expr[key] = values[exp.val];
-                // }
             }
             else if (exp.typ == exports.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 as BinaryExpressionToken | FunctionToken | ParensToken, value, getValue(value, converted, <RelativeColorTypes>key));
-                    } else
-                        */
                     if (value.typ == exports.EnumToken.IdenTokenType) {
-                        // @ts-ignore
-                        // if (!(value.val in values || typeof Math[(value as IdentToken).val.toUpperCase()] == 'number')) {
-                        //
-                        //     return null;
-                        // }
                         // @ts-ignore
                         replaceValue(parent, value, values[value.val] ?? {
                             typ: exports.EnumToken.NumberTokenType,
@@ -3950,10 +3944,6 @@
                 if (result.length == 1 && result[0].typ != exports.EnumToken.BinaryExpressionTokenType) {
                     expr[key] = result[0];
                 }
-                // else {
-                //
-                //     return null;
-                // }
             }
         }
         return expr;
@@ -3964,13 +3954,16 @@
                 if (pr.typ == exports.EnumToken.BinaryExpressionTokenType) {
                     if (pr.l == val) {
                         pr.l = newValue;
+                        return;
                     }
                     else {
                         pr.r = newValue;
+                        return;
                     }
                 }
                 else {
                     pr.chi.splice(pr.chi.indexOf(val), 1, newValue);
+                    return;
                 }
             }
         }
@@ -4058,11 +4051,14 @@
             chi: values.reduce((acc, curr, index) => index < 4 ? [...acc, {
                     typ: exports.EnumToken.PercentageTokenType,
                     // @ts-ignore
-                    val: curr * 100
+                    val: toPrecisionValue(curr) * 100
                 }] : [...acc, {
                     typ: exports.EnumToken.LiteralTokenType,
                     val: '/'
-                }, { typ: exports.EnumToken.PercentageTokenType, val: curr * 100 }], []),
+                }, {
+                    typ: exports.EnumToken.PercentageTokenType,
+                    val: toPrecisionValue(curr) * 100
+                }], []),
             kin: exports.ColorType.DEVICE_CMYK
         };
     }
@@ -4121,145 +4117,395 @@
         return multiplyMatrices(M, [x, y, z]).concat(a == null || a == 1 ? [] : [a]);
     }
 
-    /**
-     * Converts a color to another color space
-     * @param token
-     * @param to
-     *
-     * <code>
-     *
-     *     const token = {typ: EnumToken.ColorTokenType, kin: ColorType.HEX, val: '#F00'}
-     *     const result = convertColor(token, ColorType.LCH);
-     *
-     * </code>
-     */
-    function convertColor(token, to) {
-        if (token.kin == exports.ColorType.SYS ||
-            token.kin == exports.ColorType.DPSYS ||
-            (isIdentColor(token) &&
-                'currentcolor' == token.val.toLowerCase())) {
-            return token;
+    const epsilon = 1e-5;
+    function identity() {
+        return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+    }
+    function normalize(point) {
+        const [x, y, z] = point;
+        const norm = Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
+        return norm === 0 ? [0, 0, 0] : [x / norm, y / norm, z / norm];
+    }
+    function dot(point1, point2) {
+        if (point1.length === 4 && point2.length === 4) {
+            return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2] + point1[3] * point2[3];
         }
-        if (token.kin == exports.ColorType.COLOR_MIX && to != exports.ColorType.COLOR_MIX) {
-            const children = token.chi.reduce((acc, t) => {
-                if (t.typ == exports.EnumToken.ColorTokenType) {
-                    acc.push([t]);
-                }
-                else {
-                    if (![exports.EnumToken.WhitespaceTokenType, exports.EnumToken.CommentTokenType, exports.EnumToken.CommaTokenType].includes(t.typ)) {
-                        acc[acc.length - 1].push(t);
-                    }
+        return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2];
+    }
+    function multiply(matrixA, matrixB) {
+        let result = new Array(16).fill(0);
+        for (let i = 0; i < 4; i++) {
+            for (let j = 0; j < 4; j++) {
+                for (let k = 0; k < 4; k++) {
+                    // Utiliser l'indexation linéaire pour accéder aux éléments
+                    // Pour une matrice 4x4, l'index est (row * 4 + col)
+                    result[j * 4 + i] += matrixA[k * 4 + i] * matrixB[j * 4 + k];
                 }
-                return acc;
-            }, [[]]);
-            token = colorMix(children[0][1], children[0][2], children[1][0], children[1][1], children[2][0], children[2][1]);
-            if (token == null) {
-                return null;
             }
         }
-        if (token.cal == 'rel' && ['rgb', 'hsl', 'hwb', 'lab', 'lch', 'oklab', 'oklch', 'color'].includes(token.val.toLowerCase())) {
-            const chi = getComponents(token);
-            const offset = token.val == 'color' ? 2 : 1;
-            if (chi != null) {
-                // @ts-ignore
-                const color = chi[1];
-                const components = parseRelativeColor(token.val.toLowerCase() == 'color' ? chi[offset].val : token.val, color, chi[offset + 1], chi[offset + 2], chi[offset + 3], chi[offset + 4]);
-                if (components != null) {
-                    token = {
-                        ...token,
-                        chi: [...(token.val == 'color' ? [chi[offset]] : []), ...Object.values(components)]
-                    };
-                    delete token.cal;
+        return result;
+    }
+    function inverse(matrix) {
+        // Create augmented matrix [matrix | identity]
+        let augmented = [
+            ...matrix.slice(0, 4),
+            1, 0, 0, 0,
+            ...matrix.slice(4, 8),
+            0, 1, 0, 0,
+            ...matrix.slice(8, 12),
+            0, 0, 1, 0,
+            ...matrix.slice(12, 16),
+            0, 0, 0, 1
+        ];
+        // Gaussian elimination with partial pivoting
+        for (let col = 0; col < 4; col++) {
+            // Find pivot row with maximum absolute value
+            let maxRow = col;
+            let maxVal = Math.abs(augmented[col * 4 + col]);
+            for (let row = col + 1; row < 4; row++) {
+                let val = Math.abs(augmented[row * 4 + col]);
+                if (val > maxVal) {
+                    maxVal = val;
+                    maxRow = row;
                 }
             }
-        }
-        if (token.kin == to) {
-            if (token.kin == exports.ColorType.HEX || token.kin == exports.ColorType.LIT) {
-                token.val = reduceHexValue(token.val);
-                token.kin = token.val[0] == '#' ? exports.ColorType.HEX : exports.ColorType.LIT;
+            // Check for singularity
+            if (maxVal < 1e-5) {
+                return null;
             }
-            return token;
-        }
-        if (token.kin == exports.ColorType.COLOR) {
-            const colorSpace = token.chi.find(t => ![exports.EnumToken.WhitespaceTokenType, exports.EnumToken.CommentTokenType].includes(t.typ));
-            if (colorSpace.val == exports.ColorType[to].toLowerCase().replaceAll('_', '-')) {
-                return token;
+            // Swap rows if necessary
+            if (maxRow !== col) {
+                [augmented[col], augmented[maxRow]] = [augmented[maxRow], augmented[col]];
             }
-        }
-        if (to == exports.ColorType.HSL) {
-            switch (token.kin) {
-                case exports.ColorType.RGB:
-                case exports.ColorType.RGBA:
-                    return rgb2HslToken(token);
-                case exports.ColorType.HEX:
-                case exports.ColorType.LIT:
-                    return hex2HslToken(token);
-                case exports.ColorType.HWB:
-                    return hwb2HslToken(token);
-                case exports.ColorType.DEVICE_CMYK:
-                    return cmyk2HslToken(token);
-                case exports.ColorType.OKLAB:
-                    return oklab2HslToken(token);
-                case exports.ColorType.OKLCH:
-                    return oklch2HslToken(token);
-                case exports.ColorType.LAB:
-                    return lab2HslToken(token);
-                case exports.ColorType.LCH:
-                    return lch2HslToken(token);
-                case exports.ColorType.COLOR:
-                    return color2HslToken(token);
+            // Scale pivot row to make pivot element 1
+            let pivot = augmented[col * 4 + col];
+            for (let j = 0; j < 8; j++) {
+                augmented[col * 4 + j] /= pivot;
             }
-        }
-        else if (to == exports.ColorType.HWB) {
-            switch (token.kin) {
-                case exports.ColorType.RGB:
-                case exports.ColorType.RGBA:
-                    return rgb2hwbToken(token);
-                case exports.ColorType.HEX:
-                case exports.ColorType.LIT:
-                    return rgb2hwbToken(token);
-                case exports.ColorType.HSL:
-                case exports.ColorType.HSLA:
-                    return hsl2hwbToken(token);
-                case exports.ColorType.OKLAB:
-                    return oklab2hwbToken(token);
-                case exports.ColorType.OKLCH:
-                    return oklch2hwbToken(token);
-                case exports.ColorType.LAB:
-                    return lab2hwbToken(token);
-                case exports.ColorType.LCH:
-                    return lch2hwbToken(token);
-                case exports.ColorType.DEVICE_CMYK:
-                    return cmyk2hwbToken(token);
-                case exports.ColorType.COLOR:
-                    return color2hwbToken(token);
+            // Eliminate column in other rows
+            for (let row = 0; row < 4; row++) {
+                if (row !== col) {
+                    let factor = augmented[row * 4 + col];
+                    for (let j = 0; j < 8; j++) {
+                        augmented[row * 4 + j] -= factor * augmented[col * 4 + j];
+                    }
+                }
             }
         }
-        else if (to == exports.ColorType.DEVICE_CMYK) {
-            switch (token.kin) {
-                case exports.ColorType.RGB:
-                case exports.ColorType.RGBA:
-                    return rgb2cmykToken(token);
-                case exports.ColorType.HEX:
-                case exports.ColorType.LIT:
-                    return rgb2cmykToken(token);
-                case exports.ColorType.HSL:
-                case exports.ColorType.HSLA:
-                    return hsl2cmykToken(token);
-                case exports.ColorType.HWB:
-                    return hwb2cmykToken(token);
-                case exports.ColorType.OKLAB:
-                    return oklab2cmyk(token);
-                case exports.ColorType.OKLCH:
-                    return oklch2cmykToken(token);
-                case exports.ColorType.LAB:
-                    return lab2cmykToken(token);
-                //
-                case exports.ColorType.LCH:
-                    return lch2cmykToken(token);
-                case exports.ColorType.COLOR:
-                    return color2cmykToken(token);
-            }
+        // Extract the inverse from the right side of the augmented matrix
+        return augmented.slice(0, 16);
+    }
+    function round(number) {
+        const rounded = Math.round(number);
+        return Math.abs(rounded - number) <= epsilon ? rounded : +number.toPrecision(6);
+    }
+    // translate3d(25.9808px, 0, 15px ) rotateY(60deg) skewX(49.9999deg) scale(1, 1.2)
+    // translate → rotate → skew → scale
+    function decompose(original) {
+        const matrix = original.slice();
+        // Normalize last row
+        if (matrix[15] === 0) {
+            return null;
+        }
+        for (let i = 0; i < 16; i++)
+            matrix[i] /= matrix[15];
+        // Perspective extraction
+        const perspective = [0, 0, 0, 1];
+        if (matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0) {
+            const rightHandSide = [matrix[3], matrix[7], matrix[11], matrix[15]];
+            const perspectiveMatrix = matrix.slice();
+            perspectiveMatrix[3] = 0;
+            perspectiveMatrix[7] = 0;
+            perspectiveMatrix[11] = 0;
+            perspectiveMatrix[15] = 1;
+            // @ts-ignore
+            const inverted = inverse(original.slice());
+            if (inverted === null) {
+                return null;
+            }
+            const transposedInverse = transposeMatrix4(inverted);
+            perspective[0] = dot(rightHandSide, transposedInverse.slice(0, 4));
+            perspective[1] = dot(rightHandSide, transposedInverse.slice(4, 8));
+            perspective[2] = dot(rightHandSide, transposedInverse.slice(8, 12));
+            perspective[3] = dot(rightHandSide, transposedInverse.slice(12, 16));
+            // Clear perspective from matrix
+            matrix[3] = 0;
+            matrix[7] = 0;
+            matrix[11] = 0;
+            matrix[15] = 1;
+        }
+        // Translation
+        const translate = [matrix[12], matrix[13], matrix[14]];
+        matrix[12] = matrix[13] = matrix[14] = 0;
+        // Build the 3x3 matrix
+        const row0 = [matrix[0], matrix[1], matrix[2]];
+        const row1 = [matrix[4], matrix[5], matrix[6]];
+        const row2 = [matrix[8], matrix[9], matrix[10]];
+        const cross = [
+            row1[1] * row2[2] - row1[2] * row2[1],
+            row1[2] * row2[0] - row1[0] * row2[2],
+            row1[0] * row2[1] - row1[1] * row2[0],
+        ];
+        // Compute scale
+        const scaleX = Math.hypot(...row0);
+        const row0Norm = normalize(row0);
+        const skewXY = dot(row0Norm, row1);
+        const row1Proj = [
+            row1[0] - skewXY * row0Norm[0],
+            row1[1] - skewXY * row0Norm[1],
+            row1[2] - skewXY * row0Norm[2]
+        ];
+        const scaleY = Math.hypot(...row1Proj);
+        const row1Norm = normalize(row1Proj);
+        const skewXZ = dot(row0Norm, row2);
+        const skewYZ = dot(row1Norm, row2);
+        const row2Proj = [
+            row2[0] - skewXZ * row0Norm[0] - skewYZ * row1Norm[0],
+            row2[1] - skewXZ * row0Norm[1] - skewYZ * row1Norm[1],
+            row2[2] - skewXZ * row0Norm[2] - skewYZ * row1Norm[2]
+        ];
+        const row2Norm = normalize(row2Proj);
+        const determinant = row0[0] * cross[0] + row0[1] * cross[1] + row0[2] * cross[2];
+        const scaleZ = Math.hypot(...row2Proj) * (determinant < 0 ? -1 : 1);
+        // Build rotation matrix from orthonormalized vectors
+        const r00 = row0Norm[0], r01 = row1Norm[0], r02 = row2Norm[0];
+        const r10 = row0Norm[1], r11 = row1Norm[1], r12 = row2Norm[1];
+        const r20 = row0Norm[2], r21 = row1Norm[2], r22 = row2Norm[2];
+        // Convert to quaternion
+        const trace = r00 + r11 + r22;
+        let qw, qx, qy, qz;
+        if (trace > 0) {
+            const s = 0.5 / Math.sqrt(trace + 1.0);
+            qw = 0.25 / s;
+            qx = (r21 - r12) * s;
+            qy = (r02 - r20) * s;
+            qz = (r10 - r01) * s;
+        }
+        else if (r00 > r11 && r00 > r22) {
+            const s = 2.0 * Math.sqrt(1.0 + r00 - r11 - r22);
+            qw = (r21 - r12) / s;
+            qx = 0.25 * s;
+            qy = (r01 + r10) / s;
+            qz = (r02 + r20) / s;
+        }
+        else if (r11 > r22) {
+            const s = 2.0 * Math.sqrt(1.0 + r11 - r00 - r22);
+            qw = (r02 - r20) / s;
+            qx = (r01 + r10) / s;
+            qy = 0.25 * s;
+            qz = (r12 + r21) / s;
+        }
+        else {
+            const s = 2.0 * Math.sqrt(1.0 + r22 - r00 - r11);
+            qw = (r10 - r01) / s;
+            qx = (r02 + r20) / s;
+            qy = (r12 + r21) / s;
+            qz = 0.25 * s;
+        }
+        [qx, qy, qz] = toZero([qx, qy, qz]);
+        let q = [Math.abs(qx), Math.abs(qy), Math.abs(qz)].reduce((acc, curr) => {
+            if (acc == 0 || (curr > 0 && curr < acc)) {
+                acc = curr;
+            }
+            return acc;
+        }, 0);
+        if (q > 0) {
+            qx /= q;
+            qy /= q;
+            qz /= q;
+        }
+        const rotate = [qx, qy, qz, Object.is(qw, 0) ? 0 : 2 * Math.acos(qw) * 180 / Math.PI];
+        const scale = [scaleX, scaleY, scaleZ];
+        const skew = [skewXY, skewXZ, skewYZ];
+        return {
+            translate,
+            scale,
+            rotate,
+            skew,
+            perspective
+        };
+    }
+    function transposeMatrix4(m) {
+        return [
+            m[0], m[4], m[8], m[12],
+            m[1], m[5], m[9], m[13],
+            m[2], m[6], m[10], m[14],
+            m[3], m[7], m[11], m[15],
+        ];
+    }
+    function toZero(v) {
+        for (let i = 0; i < v.length; i++) {
+            if (Math.abs(v[i]) <= epsilon) {
+                v[i] = 0;
+            }
+            else {
+                v[i] = +v[i].toPrecision(6);
+            }
+        }
+        return v;
+    }
+    // https://drafts.csswg.org/css-transforms-1/#2d-matrix
+    function is2DMatrix(matrix) {
+        // m13,m14,  m23, m24, m31, m32, m34, m43 are all 0
+        return matrix[2] === 0 &&
+            matrix[3] === 0 &&
+            matrix[6] === 0 &&
+            matrix[7] === 0 &&
+            matrix[8] === 0 &&
+            matrix[9] === 0 &&
+            matrix[11] === 0 &&
+            matrix[14] === 0 &&
+            matrix[10] === 1 &&
+            matrix[15] === 1;
+    }
+
+    /**
+     * Converts a color to another color space
+     * @param token
+     * @param to
+     *
+     * @private
+     *
+     * <code>
+     *
+     *     const token = {typ: EnumToken.ColorTokenType, kin: ColorType.HEX, val: '#F00'}
+     *     const result = convertColor(token, ColorType.LCH);
+     *
+     * </code>
+     */
+    function convertColor(token, to) {
+        if (token.kin == exports.ColorType.SYS ||
+            token.kin == exports.ColorType.DPSYS ||
+            (isIdentColor(token) &&
+                'currentcolor' == token.val.toLowerCase())) {
+            return token;
+        }
+        if (token.kin == exports.ColorType.COLOR_MIX && to != exports.ColorType.COLOR_MIX) {
+            const children = token.chi.reduce((acc, t) => {
+                if (t.typ == exports.EnumToken.ColorTokenType) {
+                    acc.push([t]);
+                }
+                else {
+                    if (![exports.EnumToken.WhitespaceTokenType, exports.EnumToken.CommentTokenType, exports.EnumToken.CommaTokenType].includes(t.typ)) {
+                        acc[acc.length - 1].push(t);
+                    }
+                }
+                return acc;
+            }, [[]]);
+            token = colorMix(children[0][1], children[0][2], children[1][0], children[1][1], children[2][0], children[2][1]);
+            if (token == null) {
+                return null;
+            }
+        }
+        if (token.cal == 'rel' && ['rgb', 'hsl', 'hwb', 'lab', 'lch', 'oklab', 'oklch', 'color'].includes(token.val.toLowerCase())) {
+            const chi = getComponents(token);
+            const offset = token.val == 'color' ? 2 : 1;
+            if (chi != null) {
+                // @ts-ignore
+                const color = chi[1];
+                const components = parseRelativeColor(token.val.toLowerCase() == 'color' ? chi[offset].val : token.val, color, chi[offset + 1], chi[offset + 2], chi[offset + 3], chi[offset + 4]);
+                if (components != null) {
+                    token = {
+                        ...token,
+                        chi: [...(token.val == 'color' ? [chi[offset]] : []), ...Object.values(components)],
+                        kin: exports.ColorType[token.val.toUpperCase().replaceAll('-', '_')]
+                    };
+                    delete token.cal;
+                }
+            }
+        }
+        if (token.kin == to) {
+            if (token.kin == exports.ColorType.HEX || token.kin == exports.ColorType.LIT) {
+                token.val = reduceHexValue(token.val);
+                token.kin = token.val[0] == '#' ? exports.ColorType.HEX : exports.ColorType.LIT;
+            }
+            return token;
+        }
+        if (token.kin == exports.ColorType.COLOR) {
+            const colorSpace = token.chi.find(t => ![exports.EnumToken.WhitespaceTokenType, exports.EnumToken.CommentTokenType].includes(t.typ));
+            if (colorSpace.val == exports.ColorType[to].toLowerCase().replaceAll('_', '-')) {
+                for (const chi of token.chi) {
+                    if (chi.typ == exports.EnumToken.NumberTokenType && typeof chi.val == 'number') {
+                        chi.val = toPrecisionValue(getNumber(chi));
+                    }
+                }
+                return token;
+            }
+        }
+        if (to == exports.ColorType.HSL) {
+            switch (token.kin) {
+                case exports.ColorType.RGB:
+                case exports.ColorType.RGBA:
+                    return rgb2HslToken(token);
+                case exports.ColorType.HEX:
+                case exports.ColorType.LIT:
+                    return hex2HslToken(token);
+                case exports.ColorType.HWB:
+                    return hwb2HslToken(token);
+                case exports.ColorType.DEVICE_CMYK:
+                    return cmyk2HslToken(token);
+                case exports.ColorType.OKLAB:
+                    return oklab2HslToken(token);
+                case exports.ColorType.OKLCH:
+                    return oklch2HslToken(token);
+                case exports.ColorType.LAB:
+                    return lab2HslToken(token);
+                case exports.ColorType.LCH:
+                    return lch2HslToken(token);
+                case exports.ColorType.COLOR:
+                    return color2HslToken(token);
+            }
+        }
+        else if (to == exports.ColorType.HWB) {
+            switch (token.kin) {
+                case exports.ColorType.RGB:
+                case exports.ColorType.RGBA:
+                    return rgb2hwbToken(token);
+                case exports.ColorType.HEX:
+                case exports.ColorType.LIT:
+                    return rgb2hwbToken(token);
+                case exports.ColorType.HSL:
+                case exports.ColorType.HSLA:
+                    return hsl2hwbToken(token);
+                case exports.ColorType.OKLAB:
+                    return oklab2hwbToken(token);
+                case exports.ColorType.OKLCH:
+                    return oklch2hwbToken(token);
+                case exports.ColorType.LAB:
+                    return lab2hwbToken(token);
+                case exports.ColorType.LCH:
+                    return lch2hwbToken(token);
+                case exports.ColorType.DEVICE_CMYK:
+                    return cmyk2hwbToken(token);
+                case exports.ColorType.COLOR:
+                    return color2hwbToken(token);
+            }
+        }
+        else if (to == exports.ColorType.DEVICE_CMYK) {
+            switch (token.kin) {
+                case exports.ColorType.RGB:
+                case exports.ColorType.RGBA:
+                    return rgb2cmykToken(token);
+                case exports.ColorType.HEX:
+                case exports.ColorType.LIT:
+                    return rgb2cmykToken(token);
+                case exports.ColorType.HSL:
+                case exports.ColorType.HSLA:
+                    return hsl2cmykToken(token);
+                case exports.ColorType.HWB:
+                    return hwb2cmykToken(token);
+                case exports.ColorType.OKLAB:
+                    return oklab2cmyk(token);
+                case exports.ColorType.OKLCH:
+                    return oklch2cmykToken(token);
+                case exports.ColorType.LAB:
+                    return lab2cmykToken(token);
+                //
+                case exports.ColorType.LCH:
+                    return lch2cmykToken(token);
+                case exports.ColorType.COLOR:
+                    return color2cmykToken(token);
+            }
         }
         else if (to == exports.ColorType.HEX || to == exports.ColorType.LIT) {
             switch (token.kin) {
@@ -4606,9 +4852,9 @@
     function values2colortoken(values, to) {
         values = srgb2srgbcolorspace(values, to);
         const chi = [
-            { typ: exports.EnumToken.NumberTokenType, val: values[0] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[1] },
-            { typ: exports.EnumToken.NumberTokenType, val: values[2] },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[0]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[1]) },
+            { typ: exports.EnumToken.NumberTokenType, val: toPrecisionValue(values[2]) },
         ];
         if (values.length == 4) {
             chi.push({ typ: exports.EnumToken.LiteralTokenType, val: "/" }, {
@@ -4633,8 +4879,17 @@
         if (token.typ == exports.EnumToken.IdenTokenType && token.val == 'none') {
             return 0;
         }
+        let val;
+        // @ts-ignore
+        if (typeof token.val != 'number' && token.val?.typ == exports.EnumToken.FractionTokenType) {
+            // @ts-ignore
+            val = token.val.l.val / token.val.r.val;
+        }
+        else {
+            val = token.val;
+        }
         // @ts-ignore
-        return token.typ == exports.EnumToken.PercentageTokenType ? token.val / 100 : token.val;
+        return token.typ == exports.EnumToken.PercentageTokenType ? val / 100 : val;
     }
     /**
      * convert angle to turn
@@ -4665,6 +4920,10 @@
         // @ts-ignore
         return token.val / 360;
     }
+    function toPrecisionValue(value) {
+        value = +value.toFixed(colorPrecision);
+        return Math.abs(value) < epsilon ? 0 : value;
+    }
     function toPrecisionAngle(angle) {
         angle = +angle.toPrecision(colorPrecision);
         if (Math.abs(angle) >= 360) {
@@ -5199,7 +5458,7 @@
         }
         if (token.typ == exports.EnumToken.IdenTokenType) {
             // named color
-            return token.val.toLowerCase() in COLORS_NAMES;
+            return token.val.toLowerCase() in COLORS_NAMES || 'currentcolor' === token.val.toLowerCase() || 'transparent' === token.val.toLowerCase();
         }
         let isLegacySyntax = false;
         if (token.typ == exports.EnumToken.FunctionTokenType) {
@@ -5252,8 +5511,13 @@
                                 return false;
                             }
                         }
-                        if (children[i].typ == exports.EnumToken.FunctionTokenType && !mathFuncs.includes(children[i].val)) {
-                            return false;
+                        if (children[i].typ == exports.EnumToken.FunctionTokenType) {
+                            if ('var' == children[i].val.toLowerCase()) {
+                                continue;
+                            }
+                            if (!mathFuncs.includes(children[i].val)) {
+                                return false;
+                            }
                         }
                     }
                     if (children.length == 4 || (isRelative && children.length == 6)) {
@@ -5540,23 +5804,29 @@
         }
         return true;
     }
-    function isDimension(name) {
-        let index = name.length;
-        while (index--) {
-            if (isLetter(name.charCodeAt(index))) {
-                continue;
-            }
-            index++;
-            break;
-        }
-        const number = name.slice(0, index);
-        return number.length > 0 && isIdentStart(name.charCodeAt(index)) && isNumber(number);
-    }
+    // export function isDimension(name: string) {
+    //
+    //     let index: number = name.length;
+    //
+    //     while (index--) {
+    //
+    //         if (isLetter(<number>name.charCodeAt(index))) {
+    //
+    //             continue
+    //         }
+    //
+    //         index++;
+    //         break;
+    //     }
+    //
+    //     const number: string = name.slice(0, index);
+    //     return number.length > 0 && isIdentStart(name.charCodeAt(index)) && isNumber(number);
+    // }
     function isPercentage(name) {
         return name.endsWith('%') && isNumber(name.slice(0, -1));
     }
-    function isFlex(name) {
-        return name.endsWith('fr') && isNumber(name.slice(0, -2));
+    function isFlex(dimension) {
+        return 'unit' in dimension && 'fr' == dimension.unit.toLowerCase();
     }
     function parseDimension(name) {
         let index = name.length;
@@ -5572,6 +5842,9 @@
             val: +name.slice(0, index),
             unit: name.slice(index)
         };
+        if (index < 0 || Number.isNaN(dimension.val)) {
+            return null;
+        }
         if (isAngle(dimension)) {
             // @ts-ignore
             dimension.typ = exports.EnumToken.AngleTokenType;
@@ -5595,6 +5868,10 @@
             // @ts-ignore
             dimension.typ = exports.EnumToken.FrequencyTokenType;
         }
+        else if (isFlex(dimension)) {
+            // @ts-ignore
+            dimension.typ = exports.EnumToken.FlexTokenType;
+        }
         return dimension;
     }
     function isHexColor(name) {
@@ -7435,7 +7712,7 @@
         const sourcemap = options.sourcemap ? new SourceMap : null;
         const cache = Object.create(null);
         const result = {
-            code: renderAstNode(options.expandNestingRules ? expand(data) : data, options, sourcemap, {
+            code: renderAstNode(options.expandNestingRules && [exports.EnumToken.StyleSheetNodeType, exports.EnumToken.AtRuleNodeType, exports.EnumToken.RuleNodeType].includes(data.typ) && 'chi' in data ? expand(data) : data, options, sourcemap, {
                 ind: 0,
                 lin: 1,
                 col: 1
@@ -7477,7 +7754,7 @@
     function updateSourceMap(node, options, cache, sourcemap, position, str) {
         if ([
             exports.EnumToken.RuleNodeType, exports.EnumToken.AtRuleNodeType,
-            exports.EnumToken.KeyFrameRuleNodeType, exports.EnumToken.KeyframeAtRuleNodeType
+            exports.EnumToken.KeyFramesRuleNodeType, exports.EnumToken.KeyframesAtRuleNodeType
         ].includes(node.typ)) {
             let src = node.loc?.src ?? '';
             let output = options.output ?? '';
@@ -7551,9 +7828,9 @@
                 }, '');
             case exports.EnumToken.AtRuleNodeType:
             case exports.EnumToken.RuleNodeType:
-            case exports.EnumToken.KeyFrameRuleNodeType:
-            case exports.EnumToken.KeyframeAtRuleNodeType:
-                if ([exports.EnumToken.AtRuleNodeType, exports.EnumToken.KeyframeAtRuleNodeType].includes(data.typ) && !('chi' in data)) {
+            case exports.EnumToken.KeyFramesRuleNodeType:
+            case exports.EnumToken.KeyframesAtRuleNodeType:
+                if ([exports.EnumToken.AtRuleNodeType, exports.EnumToken.KeyframesAtRuleNodeType].includes(data.typ) && !('chi' in data)) {
                     return `${indent}@${data.nam}${data.val === '' ? '' : options.indent || ' '}${data.val};`;
                 }
                 // @ts-ignore
@@ -7575,7 +7852,7 @@
                         str = `${node.nam}:${options.indent}${(options.minify ? filterValues(node.val) : node.val).reduce(reducer, '').trimEnd()};`;
                     }
                     else if (node.typ == exports.EnumToken.AtRuleNodeType && !('chi' in node)) {
-                        str = `${data.val === '' ? '' : options.indent || ' '}${data.val};`;
+                        str = `${node.val === '' ? '' : options.indent || ' '}${node.val};`;
                     }
                     else {
                         str = renderAstNode(node, options, sourcemap, { ...position }, errors, reducer, cache, level + 1, indents);
@@ -7594,7 +7871,7 @@
                 if (children.endsWith(';')) {
                     children = children.slice(0, -1);
                 }
-                if ([exports.EnumToken.AtRuleNodeType, exports.EnumToken.KeyframeAtRuleNodeType].includes(data.typ)) {
+                if ([exports.EnumToken.AtRuleNodeType, exports.EnumToken.KeyframesAtRuleNodeType].includes(data.typ)) {
                     return `@${data.nam}${data.val === '' ? '' : options.indent || ' '}${data.val}${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
                 }
                 return data.sel + `${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
@@ -8166,13 +8443,15 @@
                     yield pushToken(buffer, parseInfo);
                     buffer = '';
                 }
+                buffer += value;
                 while (value = next(parseInfo)) {
                     charCode = value.charCodeAt(0);
                     if (!isWhiteSpace(charCode)) {
                         break;
                     }
+                    buffer += value;
                 }
-                yield pushToken('', parseInfo, exports.EnumToken.WhitespaceTokenType);
+                yield pushToken(buffer, parseInfo, exports.EnumToken.WhitespaceTokenType);
                 buffer = '';
             }
             switch (charCode) {
@@ -8220,8 +8499,7 @@
                         buffer = '';
                     }
                     if (match$1(parseInfo, '=')) {
-                        yield pushToken('', parseInfo, exports.EnumToken.LteTokenType);
-                        next(parseInfo);
+                        yield pushToken(value + next(parseInfo), parseInfo, exports.EnumToken.LteTokenType);
                         break;
                     }
                     buffer += value;
@@ -8276,8 +8554,7 @@
                     }
                     if (charCode == 124 /* TokenMap.PIPE */) {
                         if (match$1(parseInfo, '|')) {
-                            next(parseInfo);
-                            yield pushToken('', parseInfo, exports.EnumToken.ColumnCombinatorTokenType);
+                            yield pushToken(value + next(parseInfo), parseInfo, exports.EnumToken.ColumnCombinatorTokenType);
                         }
                         else if (match$1(parseInfo, '=')) {
                             buffer += next(parseInfo);
@@ -8331,11 +8608,10 @@
                         buffer = '';
                     }
                     if (match$1(parseInfo, '=')) {
-                        yield pushToken('', parseInfo, exports.EnumToken.GteTokenType);
-                        next(parseInfo);
+                        yield pushToken(value + next(parseInfo), parseInfo, exports.EnumToken.GteTokenType);
                     }
                     else {
-                        yield pushToken('', parseInfo, exports.EnumToken.GtTokenType);
+                        yield pushToken(value, parseInfo, exports.EnumToken.GtTokenType);
                     }
                     consumeWhiteSpace(parseInfo);
                     break;
@@ -8386,7 +8662,7 @@
                         yield pushToken(buffer, parseInfo);
                         buffer = '';
                     }
-                    yield pushToken('', parseInfo, exports.EnumToken.EndParensTokenType);
+                    yield pushToken(value, parseInfo, exports.EnumToken.EndParensTokenType);
                     break;
                 case 40 /* TokenMap.OPEN_PAREN */:
                     if (buffer.length == 0) {
@@ -8452,7 +8728,7 @@
                                     // ')'
                                     if (charCode == 0x29) {
                                         yield pushToken(buffer, parseInfo, hasNewLine ? exports.EnumToken.BadStringTokenType : exports.EnumToken.StringTokenType);
-                                        yield pushToken('', parseInfo, exports.EnumToken.EndParensTokenType);
+                                        yield pushToken(value, parseInfo, exports.EnumToken.EndParensTokenType);
                                         buffer = '';
                                         break;
                                     }
@@ -8476,7 +8752,7 @@
                                 charCode = value.charCodeAt(0);
                                 if (charCode == 0x29) { // ')'
                                     yield pushToken(buffer, parseInfo, exports.EnumToken.UrlTokenTokenType);
-                                    yield pushToken('', parseInfo, exports.EnumToken.EndParensTokenType);
+                                    yield pushToken(value, parseInfo, exports.EnumToken.EndParensTokenType);
                                     buffer = '';
                                     break;
                                 }
@@ -8510,8 +8786,7 @@
                         buffer = '';
                     }
                     if (match$1(parseInfo, 'important')) {
-                        yield pushToken('', parseInfo, exports.EnumToken.ImportantTokenType);
-                        next(parseInfo, 9);
+                        yield pushToken(value + next(parseInfo, 9), parseInfo, exports.EnumToken.ImportantTokenType);
                         buffer = '';
                         break;
                     }
@@ -8563,7 +8838,7 @@
         const reader = input.getReader();
         while (true) {
             const { done, value } = await reader.read();
-            parseInfo.stream += decoder.decode(value, { stream: true });
+            parseInfo.stream += ArrayBuffer.isView(value) ? decoder.decode(value, { stream: true }) : value;
             yield* tokenize$1(parseInfo, done);
             if (done) {
                 break;
@@ -10192,6 +10467,9 @@
     	"text-anchor": {
     		syntax: "start | middle | end"
     	},
+    	"text-autospace": {
+    		syntax: "normal | <autospace> | auto"
+    	},
     	"text-box": {
     		syntax: "normal | <'text-box-trim'> || <'text-box-edge'>"
     	},
@@ -12759,19 +13037,28 @@
     			}
     		}
     	},
-    	charset: {
-    		syntax: "<string>"
+    	"@nest": {
     	},
-    	container: {
-    		syntax: "[ <container-name> ]? <container-condition>"
+    	"@stylistic": {
+    		syntax: " @stylistic { <feature-value-declaration-list> } "
     	},
-    	nest: {
-    		syntax: "<complex-selector-list>"
+    	"@historical-forms": {
+    		syntax: " @historical-forms { <feature-value-declaration-list> } "
     	},
-    	scope: {
-    		syntax: "[ ( <scope-start> ) ]? [ to ( <scope-end> ) ]?"
+    	"@styleset": {
+    		syntax: " @styleset { <feature-value-declaration-list> } "
     	},
-    	"position-try": {
+    	"@character-variant": {
+    		syntax: " @character-variant { <feature-value-declaration-list> } "
+    	},
+    	"@swash": {
+    		syntax: " @swash { <feature-value-declaration-list> } "
+    	},
+    	"@ornaments": {
+    		syntax: " @ornaments { <feature-value-declaration-list> } "
+    	},
+    	"@annotation": {
+    		syntax: " @annotation { <feature-value-declaration-list> } "
     	}
     };
     var config$3 = {
@@ -12834,7 +13121,6 @@
         ValidationSyntaxGroupEnum["Selectors"] = "selectors";
         ValidationSyntaxGroupEnum["AtRules"] = "atRules";
     })(ValidationSyntaxGroupEnum || (ValidationSyntaxGroupEnum = {}));
-
     const skipped = [
         ValidationTokenEnum.Star,
         ValidationTokenEnum.HashMark,
@@ -13915,7 +14201,6 @@
         const index = group + '.' + keys.join('.');
         // @ts-ignore
         if (!parsedSyntaxes.has(index)) {
-            // @ts-ignore
             const syntax = parseSyntax(obj.syntax);
             // @ts-ignore
             parsedSyntaxes.set(index, syntax.chi);
@@ -14366,6 +14651,116 @@
     const config$2 = getSyntaxConfig();
     // @ts-ignore
     const allValues = getSyntaxConfig()["declarations" /* ValidationSyntaxGroupEnum.Declarations */].all.syntax.trim().split(/[\s|]+/g);
+    /**
+     * Check if a node is allowed as child in a given context
+     * @param node
+     * @param context
+     */
+    function isNodeAllowedInContext(node, context) {
+        if (node.typ == exports.EnumToken.CommentNodeType || context == null) {
+            return true;
+        }
+        switch (context?.typ) {
+            case exports.EnumToken.StyleSheetNodeType:
+            case exports.EnumToken.RuleNodeType:
+                return node.typ == exports.EnumToken.RuleNodeType ||
+                    node.typ == exports.EnumToken.AtRuleNodeType ||
+                    node.typ == exports.EnumToken.KeyframesAtRuleNodeType ||
+                    (node.typ == exports.EnumToken.DeclarationNodeType && context.typ == exports.EnumToken.RuleNodeType) ||
+                    (node.typ == exports.EnumToken.CDOCOMMNodeType && context.typ == exports.EnumToken.StyleSheetNodeType);
+            case exports.EnumToken.KeyframesAtRuleNodeType:
+                return node.typ == exports.EnumToken.KeyFramesRuleNodeType;
+            case exports.EnumToken.KeyFramesRuleNodeType:
+                return node.typ == exports.EnumToken.DeclarationNodeType;
+            case exports.EnumToken.AtRuleNodeType:
+                // @ts-ignore
+                const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, '@' + context.nam)?.[0].chi ?? null;
+                //
+                if (syntax == null) {
+                    // console.error(`syntax: Not found ${ValidationSyntaxGroupEnum.AtRules}@${(context as AstAtRule).nam}`);
+                    return true;
+                }
+                const stack = syntax.slice();
+                for (const child of stack) {
+                    if (Array.isArray(child)) {
+                        stack.push(...child);
+                        continue;
+                    }
+                    if ('chi' in child && Array.isArray(child.chi)) {
+                        stack.push(...child.chi);
+                        continue;
+                    }
+                    // @ts-ignore
+                    if (child.l != null) {
+                        // @ts-ignore
+                        stack.push(child.l);
+                        // @ts-ignore
+                        if (child.r != null) {
+                            // @ts-ignore
+                            stack.push(...(Array.isArray(child.r) ? child.r : [child.r]));
+                        }
+                        continue;
+                    }
+                    if (node.typ == exports.EnumToken.DeclarationNodeType) {
+                        if (child.typ == ValidationTokenEnum.DeclarationDefinitionToken) {
+                            if (node.nam == child.nam) {
+                                return true;
+                            }
+                        }
+                    }
+                    if (child.typ == ValidationTokenEnum.PropertyType) {
+                        if (['group-rule-body', 'block-contents', 'rule-list', 'stylesheet'].includes(child.val)) {
+                            if ((node.typ == exports.EnumToken.RuleNodeType ||
+                                node.typ == exports.EnumToken.AtRuleNodeType ||
+                                node.typ == exports.EnumToken.KeyframesAtRuleNodeType)) {
+                                return true;
+                            }
+                            if (node.typ == exports.EnumToken.DeclarationNodeType) {
+                                let parent = node.parent;
+                                while (parent != null) {
+                                    if (parent.parent?.typ == exports.EnumToken.RuleNodeType) {
+                                        return true;
+                                    }
+                                    parent = parent.parent;
+                                }
+                            }
+                        }
+                        if (['declaration-list', 'feature-value-declaration'].includes(child.val) && node.typ == exports.EnumToken.DeclarationNodeType) {
+                            return true;
+                        }
+                        if (child.val == 'page-body' && (node.typ == exports.EnumToken.DeclarationNodeType || (node.typ == exports.EnumToken.AtRuleNodeType && [
+                            'top-left-corner', 'top-left', 'top-center', 'top-right', 'top-right-corner',
+                            'bottom-left-corner', 'bottom-left', 'bottom-center', 'bottom-right', 'bottom-right-corner',
+                            'left-top', 'left-middle', 'left-bottom', 'right-top', 'right-middle', 'right-bottom'
+                        ].includes(node.nam)))) {
+                            return true;
+                        }
+                        if (child.val == 'feature-value-block-list' &&
+                            (node.typ == exports.EnumToken.AtRuleNodeType && ['stylistic', 'historical-forms', 'styleset', 'character-variant', 'swash', 'ornaments', 'annotation'].includes(node.nam))) {
+                            return true;
+                        }
+                        if (['feature-value-declaration-list', 'feature-value-declaration'].includes(child.val) && node.typ == exports.EnumToken.DeclarationNodeType) {
+                            return true;
+                        }
+                        if (child.val == 'page-body') {
+                            if (node.typ == exports.EnumToken.DeclarationNodeType) {
+                                return true;
+                            }
+                        }
+                        // console.error(`isNodeAllowedInContext: Not found ${(child as ValidationPropertyToken).val}`, {
+                        //     child,
+                        //     node
+                        // });
+                    }
+                }
+                break;
+        }
+        return false;
+    }
+    /**
+     * Create a syntax validation context from a list of tokens
+     * @param input
+     */
     function createContext(input) {
         const values = input.slice();
         const result = values.filter(token => token.typ != exports.EnumToken.CommentTokenType).slice();
@@ -14426,7 +14821,22 @@
             }
         };
     }
-    function evaluateSyntax(node, options) {
+    /**
+     * Evaluate the validity of the syntax of a node
+     * @param node
+     * @param parent
+     * @param options
+     */
+    function evaluateSyntax(node, parent, options) {
+        if (node.validSyntax) {
+            return {
+                valid: SyntaxValidationResult.Valid,
+                node,
+                syntax: null,
+                error: '',
+                context: []
+            };
+        }
         let ast;
         let result;
         switch (node.typ) {
@@ -14434,25 +14844,34 @@
                 if (node.nam.startsWith('--')) {
                     break;
                 }
+                let token = null;
+                let values = node.val.slice();
                 ast = getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, node.nam);
-                if (ast != null) {
-                    let token = null;
-                    const values = node.val.slice();
-                    while (values.length > 0) {
-                        token = values.at(-1);
-                        if (token.typ == exports.EnumToken.WhitespaceTokenType || token.typ == exports.EnumToken.CommentTokenType) {
+                while (values.length > 0) {
+                    token = values.at(-1);
+                    if (token.typ == exports.EnumToken.WhitespaceTokenType || token.typ == exports.EnumToken.CommentTokenType) {
+                        values.pop();
+                    }
+                    else {
+                        if (token.typ == exports.EnumToken.ImportantTokenType) {
                             values.pop();
-                        }
-                        else {
-                            if (token.typ == exports.EnumToken.ImportantTokenType) {
+                            if (values.at(-1)?.typ == exports.EnumToken.WhitespaceTokenType) {
                                 values.pop();
-                                if (values.at(-1)?.typ == exports.EnumToken.WhitespaceTokenType) {
-                                    values.pop();
-                                }
                             }
-                            break;
+                        }
+                        break;
+                    }
+                }
+                if (ast == null) {
+                    if (parent?.typ == exports.EnumToken.AtRuleNodeType) {
+                        ast = (getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, ['@' + parent.nam, 'descriptors', node.nam]));
+                        if (ast == null) {
+                            ast = (getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, ['@' + parent.nam, 'descriptors', node.nam]) ?? getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, '@' + parent.nam))?.[0]?.chi;
+                            values = [{ ...node, val: values }];
                         }
                     }
+                }
+                if (ast != null) {
                     result = doEvaluateSyntax(ast, createContext(values), { ...options, visited: new WeakMap() });
                     if (result.valid == SyntaxValidationResult.Valid && !result.context.done()) {
                         let token = null;
@@ -14544,7 +14963,7 @@
                     continue;
                 }
             }
-            else if (options.occurence !== false && syntax.occurence != null) {
+            else if (options.occurrence !== false && syntax.occurence != null) {
                 result = matchOccurence(syntax, context, options);
             }
             else if (options.atLeastOnce !== false && syntax.atLeastOnce) {
@@ -14633,7 +15052,7 @@
             result = doEvaluateSyntax([syntax], createContext(tokens), {
                 ...options,
                 isList: false,
-                occurence: false
+                occurrence: false
             });
             if (result.valid == SyntaxValidationResult.Valid) {
                 context = con.clone();
@@ -14668,7 +15087,7 @@
         let counter = 0;
         let result;
         do {
-            result = match(syntax, context.clone(), { ...options, occurence: false });
+            result = match(syntax, context.clone(), { ...options, occurrence: false });
             if (result.valid == SyntaxValidationResult.Drop) {
                 break;
             }
@@ -14719,7 +15138,7 @@
                 ...options,
                 isRepeatable: null,
                 isList: null,
-                occurence: null,
+                occurrence: null,
                 atLeastOnce: null
             });
             if (result.valid == SyntaxValidationResult.Valid) {
@@ -14731,7 +15150,7 @@
             case ValidationTokenEnum.Keyword:
                 success = (token.typ == exports.EnumToken.IdenTokenType || token.typ == exports.EnumToken.DashedIdenTokenType || isIdentColor(token)) &&
                     (token.val == syntax.val ||
-                        syntax.val === token.val?.toLowerCase?.() ||
+                        syntax.val.toLowerCase() === token.val?.toLowerCase?.() ||
                         // config.declarations.all
                         allValues.includes(token.val.toLowerCase()));
                 if (success) {
@@ -14770,7 +15189,7 @@
                     ...options,
                     isRepeatable: null,
                     isList: null,
-                    occurence: null,
+                    occurrence: null,
                     atLeastOnce: null
                 });
             case ValidationTokenEnum.Comma:
@@ -14805,7 +15224,7 @@
                         ...options,
                         isRepeatable: null,
                         isList: null,
-                        occurence: null,
+                        occurrence: null,
                         atLeastOnce: null
                     }).valid == SyntaxValidationResult.Valid;
                     if (success) {
@@ -14828,18 +15247,19 @@
     }
     function matchPropertyType(syntax, context, options) {
         if (![
-            'bg-position',
+            'color',
             'integer',
+            'bg-position',
             'length-percentage', 'flex', 'calc-sum', 'color',
             'color-base', 'system-color', 'deprecated-system-color',
-            'pseudo-class-selector', 'pseudo-element-selector'
+            'pseudo-class-selector', 'pseudo-element-selector', 'feature-value-declaration'
         ].includes(syntax.val)) {
             if (syntax.val in config$2["syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */]) {
                 return doEvaluateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val), context, {
                     ...options,
                     isRepeatable: null,
                     isList: null,
-                    occurence: null,
+                    occurrence: null,
                     atLeastOnce: null
                 });
             }
@@ -14851,7 +15271,7 @@
                 ...options,
                 isRepeatable: null,
                 isList: null,
-                occurence: null,
+                occurrence: null,
                 atLeastOnce: null
             });
             if (result.valid == SyntaxValidationResult.Valid) {
@@ -14956,6 +15376,14 @@
                     (token.typ == exports.EnumToken.IdenTokenType && typeof Math[token.val.toUpperCase()] == 'number') ||
                     [exports.EnumToken.BinaryExpressionTokenType, exports.EnumToken.NumberTokenType, exports.EnumToken.PercentageTokenType, exports.EnumToken.DimensionTokenType, exports.EnumToken.LengthTokenType, exports.EnumToken.AngleTokenType, exports.EnumToken.TimeTokenType, exports.EnumToken.ResolutionTokenType, exports.EnumToken.FrequencyTokenType].includes(token.typ);
                 break;
+            case 'declaration':
+                {
+                    success = token.typ == exports.EnumToken.DeclarationNodeType;
+                    if (success) {
+                        success = evaluateSyntax(token, null, options).valid == SyntaxValidationResult.Valid;
+                    }
+                }
+                break;
             case 'declaration-value':
                 while (!context.done()) {
                     context.next();
@@ -14982,13 +15410,17 @@
                 break;
             case 'color':
             case 'color-base':
-                success = token.typ == exports.EnumToken.ColorTokenType || (token.typ == exports.EnumToken.IdenTokenType && 'currentcolor' === token.val.toLowerCase()) || (token.typ == exports.EnumToken.IdenTokenType && 'transparent' === token.val.toLowerCase()) || (token.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
+                success = token.typ == exports.EnumToken.ColorTokenType ||
+                    (token.typ == exports.EnumToken.IdenTokenType && 'currentcolor' === token.val.toLowerCase()) ||
+                    (token.typ == exports.EnumToken.IdenTokenType && 'transparent' === token.val.toLowerCase()) ||
+                    (token.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val) ||
+                        isColor(token));
                 if (!success && token.typ == exports.EnumToken.FunctionTokenType && colorsFunc.includes(token.val)) {
                     success = doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, token.val)?.[0]?.chi, createContext(token.chi), {
                         ...options,
                         isRepeatable: null,
                         isList: null,
-                        occurence: null,
+                        occurrence: null,
                         atLeastOnce: null
                     }).valid == SyntaxValidationResult.Valid;
                 }
@@ -14996,8 +15428,26 @@
             case 'hex-color':
                 success = (token.typ == exports.EnumToken.ColorTokenType && token.kin == exports.ColorType.HEX) || (token.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
                 break;
+            case 'feature-value-declaration':
+                {
+                    let hasNumber = false;
+                    success = token.typ == exports.EnumToken.DeclarationNodeType && token.val.length > 0 && token.val.every((val) => {
+                        if (val.typ == exports.EnumToken.WhitespaceTokenType || val.typ == exports.EnumToken.CommentTokenType) {
+                            return true;
+                        }
+                        const success = (val.typ == exports.EnumToken.NumberTokenType && Number.isInteger(+val.val) && val.val > 0) || (val.typ == exports.EnumToken.FunctionTokenType && mathFuncs.includes(val.val.toLowerCase()) || (val.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(val.val)));
+                        if (success) {
+                            hasNumber = true;
+                        }
+                        if ('range' in syntax) {
+                            return success && +val.val >= +syntax.range[0] && +val.val <= +syntax.range[1];
+                        }
+                        return success;
+                    }) && hasNumber;
+                }
+                break;
             case 'integer':
-                success = (token.typ == exports.EnumToken.NumberTokenType && Number.isInteger(+(token.val))) || (token.typ == exports.EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
+                success = (token.typ == exports.EnumToken.NumberTokenType && Number.isInteger(+token.val) && token.val > 0) || (token.typ == exports.EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
                 if ('range' in syntax) {
                     success = success && +token.val >= +syntax.range[0] && +token.val <= +syntax.range[1];
                 }
@@ -15061,7 +15511,7 @@
                             ...options,
                             isRepeatable: null,
                             isList: null,
-                            occurence: null,
+                            occurrence: null,
                             atLeastOnce: null
                         }).valid == SyntaxValidationResult.Valid;
                     }
@@ -15077,7 +15527,7 @@
                         ...options,
                         isRepeatable: null,
                         isList: null,
-                        occurence: null,
+                        occurrence: null,
                         atLeastOnce: null
                     }).valid == SyntaxValidationResult.Valid;
             }
@@ -15224,7 +15674,6 @@
                 i = -1;
             }
         }
-        // console.error()
         const success = syntax.length == 0;
         return {
             valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
@@ -15304,6 +15753,17 @@
     }
 
     function validateAtRuleMedia(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         // media-query-list
         if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             // @ts-ignore
@@ -15536,6 +15996,17 @@
     }
 
     function validateAtRuleCounterStyle(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         // media-query-list
         if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             // @ts-ignore
@@ -15605,6 +16076,17 @@
     }
 
     function validateAtRulePage(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         // media-query-list
         if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             // @ts-ignore
@@ -15683,6 +16165,17 @@
     }
 
     function validateAtRulePageMarginBox(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         if (Array.isArray(atRule.tokens) && atRule.tokens.length > 0) {
             // @ts-ignore
             return {
@@ -15738,6 +16231,17 @@
                 tokens: []
             };
         }
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         const result = validateAtRuleSupportsConditions(atRule, atRule.tokens);
         if (result) {
             if (result.node == null) {
@@ -16130,6 +16634,17 @@
     }
 
     function validateAtRuleLayer(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         // media-query-list
         if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             // @ts-ignore
@@ -16146,6 +16661,17 @@
     }
 
     function validateAtRuleFontFeatureValues(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             // @ts-ignore
             return {
@@ -16329,6 +16855,17 @@
     }
 
     function validateAtRuleKeyframes(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             // @ts-ignore
             return {
@@ -16374,6 +16911,17 @@
     }
 
     function validateAtRuleWhen(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         const slice = Array.isArray(atRule.tokens) ? atRule.tokens.slice() : [];
         consumeWhitespace(slice);
         if (slice.length == 0) {
@@ -16537,6 +17085,17 @@
 
     const validateContainerScrollStateFeature = validateContainerSizeFeature;
     function validateAtRuleContainer(atRule, options, root) {
+        if (!Array.isArray(atRule.chi)) {
+            // @ts-ignore
+            return {
+                valid: SyntaxValidationResult.Drop,
+                matches: [],
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected supports body',
+                tokens: []
+            };
+        }
         // media-query-list
         if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
             // @ts-ignore
@@ -17069,6 +17628,36 @@
     function reject(reason) {
         throw new Error(reason ?? 'Parsing aborted');
     }
+    function normalizeVisitorKeyName(keyName) {
+        return keyName.replace(/-([a-z])/g, (all, one) => one.toUpperCase());
+    }
+    function replaceToken(parent, value, replacement) {
+        for (const node of (Array.isArray(replacement) ? replacement : [replacement])) {
+            if ('parent' in value && value.parent != node.parent) {
+                Object.defineProperty(node, 'parent', {
+                    ...definedPropertySettings,
+                    value: value.parent
+                });
+            }
+        }
+        if (parent.typ == exports.EnumToken.BinaryExpressionTokenType) {
+            if (parent.l == value) {
+                parent.l = replacement;
+            }
+            else {
+                parent.r = replacement;
+            }
+        }
+        else {
+            const target = 'val' in parent && Array.isArray(parent.val) ? parent.val : parent.chi;
+            // @ts-ignore
+            const index = target.indexOf(value);
+            if (index == -1) {
+                return;
+            }
+            target.splice(index, 1, ...(Array.isArray(replacement) ? replacement : [replacement]));
+        }
+    }
     /**
      * parse css string
      * @param iter
@@ -17118,6 +17707,8 @@
         const stats = {
             src: options.src ?? '',
             bytesIn: 0,
+            nodesCount: 0,
+            tokensCount: 0,
             importedBytesIn: 0,
             parse: `0ms`,
             minify: `0ms`,
@@ -17146,14 +17737,107 @@
                 src: ''
             };
         }
-        let item;
-        let node;
+        let valuesHandlers;
+        let preValuesHandlers;
+        let postValuesHandlers;
+        let preVisitorsHandlersMap;
+        let visitorsHandlersMap;
+        let postVisitorsHandlersMap;
         const rawTokens = [];
         const imports = [];
+        let item;
+        let node;
         // @ts-ignore ignore error
-        const isAsync = typeof iter[Symbol.asyncIterator] === 'function';
+        let isAsync = typeof iter[Symbol.asyncIterator] === 'function';
+        if (options.visitor != null) {
+            valuesHandlers = new Map;
+            preValuesHandlers = new Map;
+            postValuesHandlers = new Map;
+            preVisitorsHandlersMap = new Map;
+            visitorsHandlersMap = new Map;
+            postVisitorsHandlersMap = new Map;
+            const visitors = Object.entries(options.visitor);
+            let key;
+            let value;
+            let i;
+            for (i = 0; i < visitors.length; i++) {
+                key = visitors[i][0];
+                value = visitors[i][1];
+                if (Number.isInteger(+key)) {
+                    visitors.splice(i + 1, 0, ...Object.entries(value));
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    // @ts-ignore
+                    visitors.splice(i + 1, 0, ...value.map((item) => [key, item]));
+                    continue;
+                }
+                if (key in exports.EnumToken) {
+                    if (typeof value == 'function') {
+                        if (!valuesHandlers.has(exports.EnumToken[key])) {
+                            valuesHandlers.set(exports.EnumToken[key], []);
+                        }
+                        valuesHandlers.get(exports.EnumToken[key]).push(value);
+                    }
+                    else if (typeof value == 'object' && 'type' in value && 'handler' in value && value.type in exports.WalkerEvent) {
+                        if (value.type == exports.WalkerEvent.Enter) {
+                            if (!preValuesHandlers.has(exports.EnumToken[key])) {
+                                preValuesHandlers.set(exports.EnumToken[key], []);
+                            }
+                            preValuesHandlers.get(exports.EnumToken[key]).push(value.handler);
+                        }
+                        else if (value.type == exports.WalkerEvent.Leave) {
+                            if (!postValuesHandlers.has(exports.EnumToken[key])) {
+                                postValuesHandlers.set(exports.EnumToken[key], []);
+                            }
+                            postValuesHandlers.get(exports.EnumToken[key]).push(value.handler);
+                        }
+                    }
+                    else {
+                        errors.push({ action: 'ignore', message: `doParse: visitor.${key} is not a valid key name` });
+                    }
+                }
+                else if (['Declaration', 'Rule', 'AtRule', 'KeyframesRule', 'KeyframesAtRule'].includes(key)) {
+                    if (typeof value == 'function') {
+                        if (!visitorsHandlersMap.has(key)) {
+                            visitorsHandlersMap.set(key, []);
+                        }
+                        visitorsHandlersMap.get(key).push(value);
+                    }
+                    else if (typeof value == 'object') {
+                        if ('type' in value && 'handler' in value && value.type in exports.WalkerEvent) {
+                            if (value.type == exports.WalkerEvent.Enter) {
+                                if (!preVisitorsHandlersMap.has(key)) {
+                                    preVisitorsHandlersMap.set(key, []);
+                                }
+                                preVisitorsHandlersMap.get(key).push(value.handler);
+                            }
+                            else if (value.type == exports.WalkerEvent.Leave) {
+                                if (!postVisitorsHandlersMap.has(key)) {
+                                    postVisitorsHandlersMap.set(key, []);
+                                }
+                                postVisitorsHandlersMap.get(key).push(value.handler);
+                            }
+                        }
+                        else {
+                            if (!visitorsHandlersMap.has(key)) {
+                                visitorsHandlersMap.set(key, []);
+                            }
+                            visitorsHandlersMap.get(key).push(value);
+                        }
+                    }
+                    else {
+                        errors.push({ action: 'ignore', message: `doParse: visitor.${key} is not a valid key name` });
+                    }
+                }
+                else {
+                    errors.push({ action: 'ignore', message: `doParse: visitor.${key} is not a valid key name` });
+                }
+            }
+        }
         while (item = isAsync ? (await iter.next()).value : iter.next().value) {
             stats.bytesIn = item.bytesIn;
+            stats.tokensCount++;
             rawTokens.push(item);
             if (item.hint != null && BadTokensTypes.includes(item.hint)) {
                 const node = getTokenType(item.token, item.hint);
@@ -17181,7 +17865,7 @@
                 ast.loc.end = item.end;
             }
             if (item.token == ';' || item.token == '{') {
-                node = parseNode(tokens, context, options, errors, src, map, rawTokens);
+                node = parseNode(tokens, context, options, errors, src, map, rawTokens, stats);
                 rawTokens.length = 0;
                 if (node != null) {
                     if ('chi' in node) {
@@ -17225,7 +17909,7 @@
                 map = new Map;
             }
             else if (item.token == '}') {
-                parseNode(tokens, context, options, errors, src, map, rawTokens);
+                parseNode(tokens, context, options, errors, src, map, rawTokens, stats);
                 rawTokens.length = 0;
                 if (context.loc != null) {
                     context.loc.end = item.end;
@@ -17246,7 +17930,7 @@
             }
         }
         if (tokens.length > 0) {
-            node = parseNode(tokens, context, options, errors, src, map, rawTokens);
+            node = parseNode(tokens, context, options, errors, src, map, rawTokens, stats);
             rawTokens.length = 0;
             if (node != null) {
                 if (node.typ == exports.EnumToken.AtRuleNodeType && node.nam == 'import') {
@@ -17270,21 +17954,18 @@
                 const token = node.tokens[0];
                 const url = token.typ == exports.EnumToken.StringTokenType ? token.val.slice(1, -1) : token.val;
                 try {
-                    const root = await options.getStream(url, options.src).then(async (stream) => {
-                        return doParse(tokenizeStream(stream), Object.assign({}, options, {
-                            minify: false,
-                            setParent: false,
-                            src: options.resolve(url, options.src).absolute
-                        })); // )
-                    });
-                    // const root: ParseResult = await options.load!(url, <string>options.src).then((src: string) => {
-                    //
-                    //     return doParse(src, Object.assign({}, options, {
-                    //         minify: false,
-                    //         setParent: false,
-                    //         src: options.resolve!(url, options.src as string).absolute
-                    //     }))
-                    // });
+                    const result = options.load(url, options.src);
+                    const stream = result instanceof Promise || Object.getPrototypeOf(result).constructor.name == 'AsyncFunction' ? await result : result;
+                    const root = await doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize$1({
+                        stream,
+                        buffer: '',
+                        position: { ind: 0, lin: 1, col: 1 },
+                        currentPosition: { ind: -1, lin: 1, col: 0 }
+                    }), Object.assign({}, options, {
+                        minify: false,
+                        setParent: false,
+                        src: options.resolve(url, options.src).absolute
+                    }));
                     stats.importedBytesIn += root.stats.bytesIn;
                     stats.imports.push(root.stats);
                     node.parent.chi.splice(node.parent.chi.indexOf(node), 1, ...root.ast.chi);
@@ -17312,39 +17993,155 @@
         if (options.expandNestingRules) {
             ast = expand(ast);
         }
+        let replacement;
+        let callable;
         if (options.visitor != null) {
             for (const result of walk(ast)) {
-                if (result.node.typ == exports.EnumToken.DeclarationNodeType &&
-                    (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 isAsync = Object.getPrototypeOf(callable).constructor.name == 'AsyncFunction';
-                    const results = isAsync ? await callable(result.node) : callable(result.node);
-                    if (results == null || (Array.isArray(results) && results.length == 0)) {
-                        continue;
+                if (valuesHandlers.size > 0 || preVisitorsHandlersMap.size > 0 || visitorsHandlersMap.size > 0 || postVisitorsHandlersMap.size > 0) {
+                    if ((result.node.typ == exports.EnumToken.DeclarationNodeType &&
+                        (preVisitorsHandlersMap.has('Declaration') || visitorsHandlersMap.has('Declaration') || postVisitorsHandlersMap.has('Declaration'))) ||
+                        (result.node.typ == exports.EnumToken.AtRuleNodeType && (preVisitorsHandlersMap.has('AtRule') || visitorsHandlersMap.has('AtRule') || postVisitorsHandlersMap.has('AtRule'))) ||
+                        (result.node.typ == exports.EnumToken.KeyframesAtRuleNodeType && (preVisitorsHandlersMap.has('KeyframesAtRule') || visitorsHandlersMap.has('KeyframesAtRule') || postVisitorsHandlersMap.has('KeyframesAtRule')))) {
+                        const handlers = [];
+                        const key = result.node.typ == exports.EnumToken.DeclarationNodeType ? 'Declaration' : result.node.typ == exports.EnumToken.AtRuleNodeType ? 'AtRule' : 'KeyframesAtRule';
+                        if (preVisitorsHandlersMap.has(key)) {
+                            // @ts-ignore
+                            handlers.push(...preVisitorsHandlersMap.get(key));
+                        }
+                        if (visitorsHandlersMap.has(key)) {
+                            // @ts-ignore
+                            handlers.push(...visitorsHandlersMap.get(key));
+                        }
+                        if (postVisitorsHandlersMap.has(key)) {
+                            // @ts-ignore
+                            handlers.push(...postVisitorsHandlersMap.get(key));
+                        }
+                        let node = result.node;
+                        for (const handler of handlers) {
+                            callable = typeof handler == 'function' ? handler : handler[normalizeVisitorKeyName(node.typ == exports.EnumToken.DeclarationNodeType || node.typ == exports.EnumToken.AtRuleNodeType ? node.nam : node.val)];
+                            if (callable == null) {
+                                continue;
+                            }
+                            replacement = callable(node, result.parent);
+                            if (replacement == null) {
+                                continue;
+                            }
+                            isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
+                            if (replacement) {
+                                replacement = await replacement;
+                            }
+                            if (replacement == null || replacement == node) {
+                                continue;
+                            }
+                            // @ts-ignore
+                            node = replacement;
+                            //
+                            if (Array.isArray(node)) {
+                                break;
+                            }
+                        }
+                        if (node != result.node) {
+                            // @ts-ignore
+                            replaceToken(result.parent, result.node, node);
+                        }
                     }
-                    // @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 == exports.EnumToken.RuleNodeType) {
-                    const isAsync = Object.getPrototypeOf(options.visitor.Rule).constructor.name == 'AsyncFunction';
-                    const results = isAsync ? await options.visitor.Rule(result.node) : options.visitor.Rule(result.node);
-                    if (results == null || (Array.isArray(results) && results.length == 0)) {
-                        continue;
+                    else if ((result.node.typ == exports.EnumToken.RuleNodeType && (preVisitorsHandlersMap.has('Rule') || visitorsHandlersMap.has('Rule') || postVisitorsHandlersMap.has('Rule'))) ||
+                        (result.node.typ == exports.EnumToken.KeyFramesRuleNodeType && (preVisitorsHandlersMap.has('KeyframesRule') || visitorsHandlersMap.has('KeyframesRule') || postVisitorsHandlersMap.has('KeyframesRule')))) {
+                        const handlers = [];
+                        const key = result.node.typ == exports.EnumToken.RuleNodeType ? 'Rule' : 'KeyframesRule';
+                        if (preVisitorsHandlersMap.has(key)) {
+                            handlers.push(...preVisitorsHandlersMap.get(key));
+                        }
+                        if (visitorsHandlersMap.has(key)) {
+                            handlers.push(...visitorsHandlersMap.get(key));
+                        }
+                        if (postVisitorsHandlersMap.has(key)) {
+                            handlers.push(...postVisitorsHandlersMap.get(key));
+                        }
+                        let node = result.node;
+                        for (const callable of handlers) {
+                            replacement = callable(node, result.parent);
+                            if (replacement == null) {
+                                continue;
+                            }
+                            isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
+                            if (replacement) {
+                                replacement = await replacement;
+                            }
+                            if (replacement == null || replacement == node) {
+                                continue;
+                            }
+                            // @ts-ignore
+                            node = replacement;
+                            //
+                            if (Array.isArray(node)) {
+                                break;
+                            }
+                        }
+                        // @ts-ignore
+                        if (node != result.node) {
+                            // @ts-ignore
+                            replaceToken(result.parent, result.node, node);
+                        }
                     }
-                    // @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 == exports.EnumToken.AtRuleNodeType &&
-                    (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 isAsync = Object.getPrototypeOf(callable).constructor.name == 'AsyncFunction';
-                    const results = isAsync ? await callable(result.node) : callable(result.node);
-                    if (results == null || (Array.isArray(results) && results.length == 0)) {
-                        continue;
+                    else if (valuesHandlers.size > 0) {
+                        let node = null;
+                        node = result.node;
+                        if (valuesHandlers.has(node.typ)) {
+                            for (const valueHandler of valuesHandlers.get(node.typ)) {
+                                callable = valueHandler;
+                                replacement = callable(node, result.parent);
+                                if (replacement == null) {
+                                    continue;
+                                }
+                                isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
+                                if (isAsync) {
+                                    replacement = await replacement;
+                                }
+                                if (replacement != null && replacement != node) {
+                                    node = replacement;
+                                }
+                            }
+                        }
+                        if (node != result.node) {
+                            // @ts-ignore
+                            replaceToken(result.parent, value, node);
+                        }
+                        const tokens = 'tokens' in result.node ? result.node.tokens : [];
+                        if ('val' in result.node && Array.isArray(result.node.val)) {
+                            tokens.push(...result.node.val);
+                        }
+                        if (tokens.length == 0) {
+                            continue;
+                        }
+                        for (const { value, parent, root } of walkValues(tokens, result.node)) {
+                            node = value;
+                            if (valuesHandlers.has(node.typ)) {
+                                for (const valueHandler of valuesHandlers.get(node.typ)) {
+                                    callable = valueHandler;
+                                    let result = callable(node, parent, root);
+                                    if (result == null) {
+                                        continue;
+                                    }
+                                    isAsync = result instanceof Promise || Object.getPrototypeOf(result).constructor.name == 'AsyncFunction';
+                                    if (isAsync) {
+                                        result = await result;
+                                    }
+                                    if (result != null && result != node) {
+                                        node = result;
+                                    }
+                                    //
+                                    if (Array.isArray(node)) {
+                                        break;
+                                    }
+                                }
+                            }
+                            if (node != value) {
+                                // @ts-ignore
+                                replaceToken(parent, value, node);
+                            }
+                        }
                     }
-                    // @ts-ignore
-                    result.parent.chi.splice(result.parent.chi.indexOf(result.node), 1, ...(Array.isArray(results) ? results : [results]));
                 }
             }
         }
@@ -17382,7 +18179,7 @@
         }
         return null;
     }
-    function parseNode(results, context, options, errors, src, map, rawTokens) {
+    function parseNode(results, context, options, errors, src, map, rawTokens, stats) {
         let tokens = [];
         for (const t of results) {
             const node = getTokenType(t.token, t.hint);
@@ -17404,11 +18201,13 @@
                     continue;
                 }
                 loc = location;
-                // @ts-ignore
                 context.chi.push(tokens[i]);
-                if (options.sourcemap) {
-                    tokens[i].loc = loc;
-                }
+                stats.nodesCount++;
+                Object.defineProperty(tokens[i], 'loc', {
+                    ...definedPropertySettings,
+                    value: loc,
+                    enumerable: options.sourcemap !== false
+                });
             }
             else if (tokens[i].typ != exports.EnumToken.WhitespaceTokenType) {
                 break;
@@ -17438,9 +18237,7 @@
             rawTokens.shift();
             if (atRule.val == 'import') {
                 // only @charset and @layer are accepted before @import
-                // @ts-ignore
                 if (context.chi.length > 0) {
-                    // @ts-ignore
                     let i = context.chi.length;
                     while (i--) {
                         // @ts-ignore
@@ -17449,11 +18246,8 @@
                             continue;
                         }
                         if (type != exports.EnumToken.AtRuleNodeType) {
-                            // @ts-ignore
                             if (!(type == exports.EnumToken.InvalidAtRuleTokenType &&
-                                // @ts-ignore
                                 ['charset', 'layer', 'import'].includes(context.chi[i].nam))) {
-                                // @ts-ignore
                                 errors.push({
                                     action: 'drop',
                                     message: 'invalid @import',
@@ -17464,7 +18258,6 @@
                                 return null;
                             }
                         }
-                        // @ts-ignore
                         const name = context.chi[i].nam;
                         if (name != 'charset' && name != 'import' && name != 'layer') {
                             errors.push({ action: 'drop', message: 'invalid @import', location });
@@ -17555,14 +18348,14 @@
                 }
             }
             const t = parseAtRulePrelude(parseTokens(tokens, { minify: options.minify }), atRule);
-            const raw = t.reduce((acc, curr) => {
-                acc.push(renderToken(curr, { removeComments: true, convertColor: false }));
-                return acc;
-            }, []);
+            const raw = [];
+            for (const curr of t) {
+                raw.push(renderToken(curr, { removeComments: true, convertColor: false }));
+            }
             const nam = renderToken(atRule, { removeComments: true });
             // @ts-ignore
             const node = {
-                typ: /^(-[a-z]+-)?keyframes$/.test(nam) ? exports.EnumToken.KeyframeAtRuleNodeType : exports.EnumToken.AtRuleNodeType,
+                typ: /^(-[a-z]+-)?keyframes$/.test(nam) ? exports.EnumToken.KeyframesAtRuleNodeType : exports.EnumToken.AtRuleNodeType,
                 nam,
                 val: raw.join('')
             };
@@ -17574,10 +18367,12 @@
                 node.chi = [];
             }
             loc = map.get(atRule);
-            if (options.sourcemap) {
-                node.loc = loc;
-                node.loc.end = { ...map.get(delim).end };
-            }
+            Object.defineProperty(node, 'loc', {
+                ...definedPropertySettings,
+                value: loc,
+                enumerable: options.sourcemap !== false
+            });
+            node.loc.end = { ...map.get(delim).end };
             let isValid = true;
             if (node.nam == 'else') {
                 const prev = getLastNode(context);
@@ -17591,20 +18386,31 @@
                 }
             }
             // @ts-ignore
-            const valid = options.validation == exports.ValidationLevel.None ? {
+            const skipValidate = (options.validation & exports.ValidationLevel.AtRule) == 0;
+            const isAllowed = skipValidate || isNodeAllowedInContext(node, context);
+            // @ts-ignore
+            const valid = skipValidate ? {
                 valid: SyntaxValidationResult.Valid,
                 error: '',
                 node,
                 syntax: '@' + node.nam
-            } : isValid ? (node.typ == exports.EnumToken.KeyframeAtRuleNodeType ? validateAtRuleKeyframes(node) : validateAtRule(node, options, context)) : {
+            } : !isAllowed ? {
+                valid: SyntaxValidationResult.Drop,
+                node,
+                syntax: '@' + node.nam,
+                error: `${exports.EnumToken[context.typ]}: child ${exports.EnumToken[node.typ]} not allowed in context${context.typ == exports.EnumToken.AtRuleNodeType ? ` '@${context.nam}'` : context.typ == exports.EnumToken.StyleSheetNodeType ? ` 'stylesheet'` : ''}`} : isValid ? (node.typ == exports.EnumToken.KeyframesAtRuleNodeType ? validateAtRuleKeyframes(node) : validateAtRule(node, options, context)) : {
                 valid: SyntaxValidationResult.Drop,
                 node,
                 syntax: '@' + node.nam,
                 error: '@' + node.nam + ' not allowed here'};
             if (valid.valid == SyntaxValidationResult.Drop) {
+                let message = '';
+                for (const token of tokens) {
+                    message += renderToken(token, { minify: false });
+                }
                 errors.push({
                     action: 'drop',
-                    message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), '') + '"',
+                    message: valid.error + ' - "' + message + '"',
                     node,
                     // @ts-ignore
                     location: { src, ...(map.get(valid.node) ?? location) }
@@ -17613,13 +18419,17 @@
                 node.typ = exports.EnumToken.InvalidAtRuleTokenType;
             }
             else {
-                node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr, {
-                    minify: false,
-                    convertColor: false,
-                    removeComments: true
-                }), '');
+                node.val = '';
+                for (const token of node.tokens) {
+                    node.val += renderToken(token, {
+                        minify: false,
+                        convertColor: false,
+                        removeComments: true
+                    });
+                }
             }
             context.chi.push(node);
+            stats.nodesCount++;
             Object.defineProperties(node, {
                 parent: { ...definedPropertySettings, value: context },
                 validSyntax: { ...definedPropertySettings, value: valid.valid == SyntaxValidationResult.Valid }
@@ -17632,7 +18442,7 @@
                 const location = map.get(tokens[0]);
                 const uniq = new Map;
                 parseTokens(tokens, { minify: true });
-                const ruleType = context.typ == exports.EnumToken.KeyframeAtRuleNodeType ? exports.EnumToken.KeyFrameRuleNodeType : exports.EnumToken.RuleNodeType;
+                const ruleType = context.typ == exports.EnumToken.KeyframesAtRuleNodeType ? exports.EnumToken.KeyFramesRuleNodeType : exports.EnumToken.RuleNodeType;
                 if (ruleType == exports.EnumToken.RuleNodeType) {
                     parseSelector(tokens);
                 }
@@ -17642,6 +18452,34 @@
                             if (curr.typ == exports.EnumToken.CommentTokenType) {
                                 return acc;
                             }
+                            if (options.minify) {
+                                if (curr.typ == exports.EnumToken.PseudoClassFuncTokenType && curr.val == ':nth-child') {
+                                    let i = 0;
+                                    for (; i < curr.chi.length; i++) {
+                                        if (curr.chi[i].typ == exports.EnumToken.IdenTokenType && curr.chi[i].val == 'even') {
+                                            Object.assign(curr.chi[i], {
+                                                typ: exports.EnumToken.Dimension,
+                                                val: 2,
+                                                unit: 'n'
+                                            });
+                                        }
+                                        else if (curr.chi[i].typ == exports.EnumToken.Dimension &&
+                                            curr.chi[i].val == 2 &&
+                                            curr.chi[i].unit == 'n' &&
+                                            curr.chi[i + 1]?.typ == exports.EnumToken.WhitespaceTokenType &&
+                                            curr.chi[i + 2]?.typ == exports.EnumToken.LiteralTokenType &&
+                                            curr.chi[i + 2].val == '+' &&
+                                            curr.chi[i + 3]?.typ == exports.EnumToken.WhitespaceTokenType &&
+                                            curr.chi[i + 4]?.typ == exports.EnumToken.NumberTokenType &&
+                                            curr.chi[i + 4].val == 1) {
+                                            curr.chi.splice(i, 5, Object.assign(curr.chi[i], {
+                                                typ: exports.EnumToken.IdenTokenType,
+                                                val: 'odd'
+                                            }));
+                                        }
+                                    }
+                                }
+                            }
                             if (curr.typ == exports.EnumToken.WhitespaceTokenType) {
                                 if (trimWhiteSpace.includes(array[index - 1]?.typ) ||
                                     trimWhiteSpace.includes(array[index + 1]?.typ) ||
@@ -17650,7 +18488,7 @@
                                     return acc;
                                 }
                             }
-                            if (ruleType == exports.EnumToken.KeyFrameRuleNodeType) {
+                            if (ruleType == exports.EnumToken.KeyFramesRuleNodeType && options.minify) {
                                 if (curr.typ == exports.EnumToken.IdenTokenType && curr.val == 'from') {
                                     Object.assign(curr, { typ: exports.EnumToken.PercentageTokenType, val: '0' });
                                 }
@@ -17689,17 +18527,24 @@
                     value: tokens.slice()
                 });
                 loc = location;
-                if (options.sourcemap) {
-                    node.loc = loc;
-                }
-                // @ts-ignore
+                Object.defineProperty(node, 'loc', {
+                    ...definedPropertySettings,
+                    value: loc,
+                    enumerable: options.sourcemap !== false
+                });
                 context.chi.push(node);
                 Object.defineProperty(node, 'parent', { ...definedPropertySettings, value: context });
                 // @ts-ignore
-                const valid = options.validation == exports.ValidationLevel.None ? {
+                const skipValidate = (options.validation & exports.ValidationLevel.Selector) == 0;
+                const isAllowed = skipValidate || isNodeAllowedInContext(node, context);
+                // @ts-ignore
+                const valid = skipValidate ? {
                     valid: SyntaxValidationResult.Valid,
                     error: null
-                } : ruleType == exports.EnumToken.KeyFrameRuleNodeType ? validateKeyframeSelector(tokens) : validateSelector(tokens, options, context);
+                } : !isAllowed ? {
+                    valid: SyntaxValidationResult.Drop,
+                    error: `${exports.EnumToken[context.typ]}: child ${exports.EnumToken[node.typ]} not allowed in context${context.typ == exports.EnumToken.AtRuleNodeType ? ` '@${context.nam}'` : context.typ == exports.EnumToken.StyleSheetNodeType ? ` 'stylesheet'` : ''}`
+                } : ruleType == exports.EnumToken.KeyFramesRuleNodeType ? validateKeyframeSelector(tokens) : validateSelector(tokens, options, context);
                 if (valid.valid != SyntaxValidationResult.Valid) {
                     // @ts-ignore
                     node.typ = exports.EnumToken.InvalidRuleTokenType;
@@ -17808,11 +18653,13 @@
                             nam,
                             val: []
                         };
-                        if (options.sourcemap) {
-                            node.loc = location;
-                            node.loc.end = { ...map.get(delim).end };
-                        }
+                        Object.defineProperty(node, 'loc', {
+                            ...definedPropertySettings,
+                            value: location,
+                            enumerable: options.sourcemap !== false
+                        });
                         context.chi.push(node);
+                        stats.nodesCount++;
                     }
                     return null;
                 }
@@ -17836,22 +18683,31 @@
                     nam,
                     val: value
                 };
-                if (options.sourcemap) {
-                    node.loc = location;
-                    node.loc.end = { ...map.get(delim).end };
-                }
+                Object.defineProperty(node, 'loc', {
+                    ...definedPropertySettings,
+                    value: location,
+                    enumerable: options.sourcemap !== false
+                });
+                node.loc.end = { ...map.get(delim).end };
                 // do not allow declarations in style sheets
                 if (context.typ == exports.EnumToken.StyleSheetNodeType && options.lenient) {
-                    // @ts-ignore
-                    node.typ = exports.EnumToken.InvalidDeclarationNodeType;
+                    Object.assign(node, { typ: exports.EnumToken.InvalidDeclarationNodeType });
                     context.chi.push(node);
+                    stats.nodesCount++;
                     return null;
                 }
                 const result = parseDeclarationNode(node, errors, location);
                 Object.defineProperty(result, 'parent', { ...definedPropertySettings, value: context });
                 if (result != null) {
-                    if (options.validation == exports.ValidationLevel.All) {
-                        const valid = evaluateSyntax(result, options);
+                    if (options.validation & exports.ValidationLevel.Declaration) {
+                        const isAllowed = isNodeAllowedInContext(node, context);
+                        // @ts-ignore
+                        const valid = !isAllowed ? {
+                            valid: SyntaxValidationResult.Drop,
+                            error: `${exports.EnumToken[node.typ]} not allowed in context${context.typ == exports.EnumToken.AtRuleNodeType ? ` '@${context.nam}'` : context.typ == exports.EnumToken.StyleSheetNodeType ? ` 'stylesheet'` : ''}`,
+                            node,
+                            syntax: null
+                        } : evaluateSyntax(result, context, options);
                         Object.defineProperty(result, 'validSyntax', {
                             ...definedPropertySettings,
                             value: valid.valid == SyntaxValidationResult.Valid
@@ -17867,11 +18723,11 @@
                             if (!options.lenient) {
                                 return null;
                             }
-                            // @ts-ignore
-                            node.typ = exports.EnumToken.InvalidDeclarationNodeType;
+                            Object.assign(node, { typ: exports.EnumToken.InvalidDeclarationNodeType });
                         }
                     }
                     context.chi.push(result);
+                    stats.nodesCount++;
                 }
                 return null;
             }
@@ -17883,7 +18739,6 @@
      * @param atRule
      */
     function parseAtRulePrelude(tokens, atRule) {
-        // @ts-ignore
         for (const { value, parent } of walkValues(tokens, null, null, true)) {
             if (value.typ == exports.EnumToken.CommentTokenType ||
                 value.typ == exports.EnumToken.WhitespaceTokenType ||
@@ -17919,16 +18774,14 @@
             }
             if (atRule.val == 'page' && value.typ == exports.EnumToken.PseudoClassTokenType) {
                 if ([':left', ':right', ':first', ':blank'].includes(value.val)) {
-                    // @ts-ignore
-                    value.typ = exports.EnumToken.PseudoPageTokenType;
+                    Object.assign(value, { typ: exports.EnumToken.PseudoPageTokenType });
                 }
             }
             if (atRule.val == 'layer') {
                 if (parent == null && value.typ == exports.EnumToken.LiteralTokenType) {
                     if (value.val.charAt(0) == '.') {
                         if (isIdent(value.val.slice(1))) {
-                            // @ts-ignore
-                            value.typ = exports.EnumToken.ClassSelectorTokenType;
+                            Object.assign(value, { typ: exports.EnumToken.ClassSelectorTokenType });
                         }
                     }
                 }
@@ -17937,8 +18790,7 @@
             if (value.typ == exports.EnumToken.IdenTokenType) {
                 if (parent == null && mediaTypes.some((t) => {
                     if (val === t) {
-                        // @ts-ignore
-                        value.typ = exports.EnumToken.MediaFeatureTokenType;
+                        Object.assign(value, { typ: exports.EnumToken.MediaFeatureTokenType });
                         return true;
                     }
                     return false;
@@ -17946,18 +18798,15 @@
                     continue;
                 }
                 if (value.typ == exports.EnumToken.IdenTokenType && 'and' === val) {
-                    // @ts-ignore
-                    value.typ = exports.EnumToken.MediaFeatureAndTokenType;
+                    Object.assign(value, { typ: exports.EnumToken.MediaFeatureAndTokenType });
                     continue;
                 }
                 if (value.typ == exports.EnumToken.IdenTokenType && 'or' === val) {
-                    // @ts-ignore
-                    value.typ = exports.EnumToken.MediaFeatureOrTokenType;
+                    Object.assign(value, { typ: exports.EnumToken.MediaFeatureOrTokenType });
                     continue;
                 }
                 if (value.typ == exports.EnumToken.IdenTokenType &&
                     ['not', 'only'].some((t) => val === t)) {
-                    // @ts-ignore
                     const array = parent?.chi ?? tokens;
                     const startIndex = array.indexOf(value);
                     let index = startIndex + 1;
@@ -18002,12 +18851,15 @@
                     if (value.chi[i].typ == exports.EnumToken.CommentTokenType || value.chi[i].typ == exports.EnumToken.WhitespaceTokenType) {
                         continue;
                     }
-                    if (value.chi[i].typ == exports.EnumToken.LiteralTokenType && value.chi[i].val.startsWith(':') && isDimension(value.chi[i].val.slice(1))) {
-                        value.chi.splice(i, 1, {
-                            typ: exports.EnumToken.ColonTokenType,
-                        }, Object.assign(value.chi[i], parseDimension(value.chi[i].val.slice(1))));
-                        i--;
-                        continue;
+                    if (value.chi[i].typ == exports.EnumToken.LiteralTokenType && value.chi[i].val.startsWith(':')) {
+                        const dimension = parseDimension(value.chi[i].val.slice(1));
+                        if (dimension != null) {
+                            value.chi.splice(i, 1, {
+                                typ: exports.EnumToken.ColonTokenType,
+                            }, Object.assign(value.chi[i], dimension));
+                            i--;
+                            continue;
+                        }
                     }
                     if (nameIndex != -1 && value.chi[i].typ == exports.EnumToken.PseudoClassTokenType) {
                         value.chi.splice(i, 1, {
@@ -18034,11 +18886,10 @@
                         const val = value.chi.splice(valueIndex, 1)[0];
                         const node = value.chi.splice(nameIndex, 1)[0];
                         // 'background'
-                        // @ts-ignore
                         if (node.typ == exports.EnumToken.ColorTokenType && node.kin == exports.ColorType.DPSYS) {
+                            Object.assign(node, { typ: exports.EnumToken.IdenTokenType });
                             // @ts-ignore
                             delete node.kin;
-                            node.typ = exports.EnumToken.IdenTokenType;
                         }
                         while (value.chi[0]?.typ == exports.EnumToken.WhitespaceTokenType) {
                             value.chi.shift();
@@ -18075,7 +18926,7 @@
             position: { ind: 0, lin: 1, col: 1 },
             currentPosition: { ind: -1, lin: 1, col: 0 }
         }), { setParent: false, minify: false, validation: false }).then(result => {
-            return result.ast.chi[0].chi.filter(t => t.typ == exports.EnumToken.DeclarationNodeType);
+            return result.ast.chi[0].chi.filter(t => t.typ == exports.EnumToken.DeclarationNodeType || t.typ == exports.EnumToken.CommentNodeType);
         });
     }
     /**
@@ -18093,43 +18944,35 @@
             }
             if (parent == null) {
                 if (value.typ == exports.EnumToken.GtTokenType) {
-                    // @ts-ignore
-                    value.typ = exports.EnumToken.ChildCombinatorTokenType;
+                    Object.assign(value, { typ: exports.EnumToken.ChildCombinatorTokenType });
                 }
                 else if (value.typ == exports.EnumToken.LiteralTokenType) {
                     if (value.val.charAt(0) == '&') {
-                        // @ts-ignore
-                        value.typ = exports.EnumToken.NestingSelectorTokenType;
+                        Object.assign(value, { typ: exports.EnumToken.NestingSelectorTokenType });
                         // @ts-ignore
                         delete value.val;
                     }
                     else if (value.val.charAt(0) == '.') {
                         if (!isIdent(value.val.slice(1))) {
-                            // @ts-ignore
-                            value.typ = exports.EnumToken.InvalidClassSelectorTokenType;
+                            Object.assign(value, { typ: exports.EnumToken.InvalidClassSelectorTokenType });
                         }
                         else {
-                            // @ts-ignore
-                            value.typ = exports.EnumToken.ClassSelectorTokenType;
+                            Object.assign(value, { typ: exports.EnumToken.ClassSelectorTokenType });
                         }
                     }
                     if (['*', '>', '+', '~'].includes(value.val)) {
                         switch (value.val) {
                             case '*':
-                                // @ts-ignore
-                                value.typ = exports.EnumToken.UniversalSelectorTokenType;
+                                Object.assign(value, { typ: exports.EnumToken.UniversalSelectorTokenType });
                                 break;
                             case '>':
-                                // @ts-ignore
-                                value.typ = exports.EnumToken.ChildCombinatorTokenType;
+                                Object.assign(value, { typ: exports.EnumToken.ChildCombinatorTokenType });
                                 break;
                             case '+':
-                                // @ts-ignore
-                                value.typ = exports.EnumToken.NextSiblingCombinatorTokenType;
+                                Object.assign(value, { typ: exports.EnumToken.NextSiblingCombinatorTokenType });
                                 break;
                             case '~':
-                                // @ts-ignore
-                                value.typ = exports.EnumToken.SubsequentSiblingCombinatorTokenType;
+                                Object.assign(value, { typ: exports.EnumToken.SubsequentSiblingCombinatorTokenType });
                                 break;
                         }
                         // @ts-ignore
@@ -18142,12 +18985,10 @@
                             if (!isIdent(value.val.slice(1))) {
                                 continue;
                             }
-                            // @ts-ignore
-                            value.typ = exports.EnumToken.HashTokenType;
+                            Object.assign(value, { typ: exports.EnumToken.HashTokenType });
                         }
                         else {
-                            // @ts-ignore
-                            value.typ = exports.EnumToken.IdenTokenType;
+                            Object.assign(value, { typ: exports.EnumToken.IdenTokenType });
                         }
                         // @ts-ignore
                         delete value.kin;
@@ -18210,15 +19051,17 @@
                 return acc;
             }
             const token = getTokenType(t.token, t.hint);
-            if (options.location) {
-                Object.assign(token, { loc: t.sta });
-            }
+            Object.defineProperty(token, 'loc', {
+                ...definedPropertySettings,
+                value: { sta: t.sta },
+                enumerable: options.location !== false
+            });
             acc.push(token);
             return acc;
         }, []));
     }
     /**
-     * get token type from a string
+     * get the token type from a string
      * @param val
      * @param hint
      */
@@ -18254,7 +19097,7 @@
             case '>':
                 return { typ: exports.EnumToken.GtTokenType };
         }
-        if (isPseudo(val)) {
+        if (val.charAt(0) == ':' && isPseudo(val)) {
             return val.endsWith('(') ? {
                 typ: exports.EnumToken.PseudoClassFuncTokenType,
                 val: val.slice(0, -1),
@@ -18271,13 +19114,13 @@
                         val
                     });
         }
-        if (isAtKeyword(val)) {
+        if (val.charAt(0) == '@' && isAtKeyword(val)) {
             return {
                 typ: exports.EnumToken.AtRuleTokenType,
                 val: val.slice(1)
             };
         }
-        if (isFunction(val)) {
+        if (val.endsWith('(') && isFunction(val)) {
             val = val.slice(0, -1);
             if (val == 'url') {
                 return {
@@ -18325,15 +19168,12 @@
                 val: +val.slice(0, -1)
             };
         }
-        if (isFlex(val)) {
-            return {
-                typ: exports.EnumToken.FlexTokenType,
-                val: +val.slice(0, -2)
-            };
-        }
-        if (isDimension(val)) {
-            return parseDimension(val);
+        // if (isDimension(val)) {
+        const dimension = parseDimension(val);
+        if (dimension != null) {
+            return dimension;
         }
+        // }
         const v = val.toLowerCase();
         if (v == 'currentcolor' || v == 'transparent' || v in COLORS_NAMES) {
             return {
@@ -18728,64 +19568,142 @@
         return true;
     }
 
+    /**
+     * options for the walk function
+     */
     exports.WalkerOptionEnum = void 0;
     (function (WalkerOptionEnum) {
         /**
          * ignore the current node and its children
          */
-        WalkerOptionEnum[WalkerOptionEnum["Ignore"] = 0] = "Ignore";
+        WalkerOptionEnum[WalkerOptionEnum["Ignore"] = 1] = "Ignore";
         /**
          * stop walking the tree
          */
-        WalkerOptionEnum[WalkerOptionEnum["Stop"] = 1] = "Stop";
+        WalkerOptionEnum[WalkerOptionEnum["Stop"] = 2] = "Stop";
         /**
-         * ignore node and process children
+         * ignore the current node and process its children
          */
-        WalkerOptionEnum[WalkerOptionEnum["Children"] = 2] = "Children";
+        WalkerOptionEnum[WalkerOptionEnum["Children"] = 4] = "Children";
         /**
-         * ignore children
+         * ignore the current node children
          */
-        WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 3] = "IgnoreChildren";
+        WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 8] = "IgnoreChildren";
     })(exports.WalkerOptionEnum || (exports.WalkerOptionEnum = {}));
-    exports.WalkerValueEvent = void 0;
-    (function (WalkerValueEvent) {
+    /**
+     * event types for the walkValues function
+     */
+    exports.WalkerEvent = void 0;
+    (function (WalkerEvent) {
         /**
          * enter node
          */
-        WalkerValueEvent[WalkerValueEvent["Enter"] = 0] = "Enter";
+        WalkerEvent[WalkerEvent["Enter"] = 1] = "Enter";
         /**
          * leave node
          */
-        WalkerValueEvent[WalkerValueEvent["Leave"] = 1] = "Leave";
-    })(exports.WalkerValueEvent || (exports.WalkerValueEvent = {}));
+        WalkerEvent[WalkerEvent["Leave"] = 2] = "Leave";
+    })(exports.WalkerEvent || (exports.WalkerEvent = {}));
     /**
      * walk ast nodes
-     * @param node
-     * @param filter
+     * @param node initial node
+     * @param filter control the walk process
+     * @param reverse walk in reverse order
+     *
+     * ```ts
+     *
+     * import {walk} from '@tbela99/css-parser';
+     *
+     * const css = `
+     * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+     *
+     * html,
+     * body {
+     *     line-height: 1.474;
+     * }
+     *
+     * .ruler {
+     *
+     *     height: 10px;
+     * }
+     * `;
+     *
+     * for (const {node, parent, root} of walk(ast)) {
+     *
+     *     // do something with node
+     * }
+     * ```
+     *
+     * Using a {@link filter} function to control the ast traversal.  the filter function returns a value of type {@link WalkerOption}.
+     *
+     * ```ts
+     * import {EnumToken, transform, walk, WalkerOptionEnum} from '@tbela99/css-parser';
+     *
+     * const css = `
+     * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+     *
+     * html,
+     * body {
+     *     line-height: 1.474;
+     * }
+     *
+     * .ruler {
+     *
+     *     height: 10px;
+     * }
+     * `;
+     *
+     * function filter(node) {
+     *
+     *     if (node.typ == EnumToken.AstRule && node.sel.includes('html')) {
+     *
+     *         // skip the children of the current node
+     *         return WalkerOptionEnum.IgnoreChildren;
+     *     }
+     * }
+     *
+     * const result = await transform(css);
+     * for (const {node} of walk(result.ast, filter)) {
+     *
+     *     console.error([EnumToken[node.typ]]);
+     * }
+     *
+     * // [ "StyleSheetNodeType" ]
+     * // [ "RuleNodeType" ]
+     * // [ "DeclarationNodeType" ]
+     * // [ "RuleNodeType" ]
+     * // [ "DeclarationNodeType" ]
+     * // [ "RuleNodeType" ]
+     * // [ "DeclarationNodeType" ]
+     * ```
      */
-    function* walk(node, filter) {
+    function* walk(node, filter, reverse) {
         const parents = [node];
         const root = node;
         const map = new Map;
-        while ((node = parents.shift())) {
+        let isNumeric = false;
+        let i = 0;
+        while ((node = parents[i++])) {
             let option = null;
             if (filter != null) {
                 option = filter(node);
-                if (option === exports.WalkerOptionEnum.Ignore) {
-                    continue;
-                }
-                if (option === exports.WalkerOptionEnum.Stop) {
-                    break;
+                isNumeric = typeof option == 'number';
+                if (isNumeric) {
+                    if ((option & exports.WalkerOptionEnum.Ignore)) {
+                        continue;
+                    }
+                    if ((option & exports.WalkerOptionEnum.Stop)) {
+                        break;
+                    }
                 }
             }
-            // @ts-ignore
-            if (option !== 'children') {
+            if (!isNumeric || (option & exports.WalkerOptionEnum.Children) === 0) {
                 // @ts-ignore
                 yield { node, parent: map.get(node), root };
             }
-            if (option !== exports.WalkerOptionEnum.IgnoreChildren && 'chi' in node) {
-                parents.unshift(...node.chi);
-                for (const child of node.chi.slice()) {
+            if ('chi' in node && (!isNumeric || ((option & exports.WalkerOptionEnum.IgnoreChildren) === 0))) {
+                parents.splice(i, 0, ...node.chi[reverse ? 'reverse' : 'slice']());
+                for (const child of node.chi) {
                     map.set(child, node);
                 }
             }
@@ -18797,39 +19715,80 @@
      * @param root
      * @param filter
      * @param reverse
+     *
+     * Example:
+     *
+     * ```ts
+     *
+     * import {AstDeclaration, EnumToken, transform, walkValues} from '@tbela99/css-parser';
+     *
+     * const css = `
+     * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+     * `;
+     *
+     * const result = await transform(css);
+     * const declaration = result.ast.chi[0].chi[0] as AstDeclaration;
+     *
+     * // walk the node attribute's tokens in reverse order
+     * for (const {value} of walkValues(declaration.val, null, null,true)) {
+     *
+     *     console.error([EnumToken[value.typ], value.val]);
+     * }
+     *
+     * // [ "Color", "color" ]
+     * // [ "FunctionTokenType", "calc" ]
+     * // [ "Number", 0.15 ]
+     * // [ "Add", undefined ]
+     * // [ "Iden", "b" ]
+     * // [ "Whitespace", undefined ]
+     * // [ "FunctionTokenType", "calc" ]
+     * // [ "Number", 0.24 ]
+     * // [ "Add", undefined ]
+     * // [ "Iden", "g" ]
+     * // [ "Whitespace", undefined ]
+     * // [ "Iden", "r" ]
+     * // [ "Whitespace", undefined ]
+     * // [ "Iden", "display-p3" ]
+     * // [ "Whitespace", undefined ]
+     * // [ "FunctionTokenType", "var" ]
+     * // [ "DashedIden", "--base-color" ]
+     * // [ "Whitespace", undefined ]
+     * // [ "Iden", "from" ]
+     * ```
      */
     function* walkValues(values, root = null, filter, reverse) {
         // const set = new Set<Token>();
         const stack = values.slice();
         const map = new Map;
         let previous = null;
-        // let parent: FunctionToken | ParensToken | BinaryExpressionToken | null = null;
         if (filter != null && typeof filter == 'function') {
             filter = {
-                event: exports.WalkerValueEvent.Enter,
+                event: exports.WalkerEvent.Enter,
                 fn: filter
             };
         }
         else if (filter == null) {
             filter = {
-                event: exports.WalkerValueEvent.Enter
+                event: exports.WalkerEvent.Enter
             };
         }
-        const eventType = filter.event ?? exports.WalkerValueEvent.Enter;
+        let isNumeric = false;
+        const eventType = filter.event ?? exports.WalkerEvent.Enter;
         while (stack.length > 0) {
             let value = reverse ? stack.pop() : stack.shift();
             let option = null;
-            if (filter.fn != null && eventType == exports.WalkerValueEvent.Enter) {
+            if (filter.fn != null && (eventType & exports.WalkerEvent.Enter)) {
                 const isValid = filter.type == null || value.typ == filter.type ||
                     (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
                     (typeof filter.type == 'function' && filter.type(value));
                 if (isValid) {
-                    option = filter.fn(value, map.get(value) ?? root);
-                    if (option === exports.WalkerOptionEnum.Ignore) {
-                        continue;
+                    option = filter.fn(value, map.get(value) ?? root, exports.WalkerEvent.Enter);
+                    isNumeric = typeof option == 'number';
+                    if (isNumeric && (option & exports.WalkerOptionEnum.Stop)) {
+                        return;
                     }
-                    if (option === exports.WalkerOptionEnum.Stop) {
-                        break;
+                    if (isNumeric && (option & exports.WalkerOptionEnum.Ignore)) {
+                        continue;
                     }
                     // @ts-ignore
                     if (option != null && typeof option == 'object' && 'typ' in option) {
@@ -18837,38 +19796,31 @@
                     }
                 }
             }
-            if (eventType == exports.WalkerValueEvent.Enter && option !== exports.WalkerOptionEnum.Children) {
-                yield {
-                    value,
-                    parent: map.get(value) ?? root,
-                    previousValue: previous,
-                    nextValue: stack[0] ?? null,
-                    // @ts-ignore
-                    root: root ?? null
-                };
-            }
-            if (option !== exports.WalkerOptionEnum.IgnoreChildren && 'chi' in value) {
+            yield {
+                value,
+                parent: map.get(value) ?? root,
+                previousValue: previous,
+                nextValue: stack[0] ?? null,
+                // @ts-ignore
+                root: root ?? null
+            };
+            if ('chi' in value && (!isNumeric || (option & exports.WalkerOptionEnum.IgnoreChildren) === 0)) {
                 const sliced = value.chi.slice();
                 for (const child of sliced) {
                     map.set(child, value);
                 }
-                if (reverse) {
-                    stack.push(...sliced);
-                }
-                else {
-                    stack.unshift(...sliced);
-                }
+                stack[reverse ? 'push' : 'unshift'](...sliced);
             }
             else {
                 const values = [];
                 if ('l' in value && value.l != null) {
                     // @ts-ignore
-                    values.push(value.l);
+                    values[reverse ? 'push' : 'unshift'](value.l);
                     // @ts-ignore
                     map.set(value.l, value);
                 }
                 if ('op' in value && typeof value.op == 'object') {
-                    values.push(value.op);
+                    values[reverse ? 'push' : 'unshift'](value.op);
                     // @ts-ignore
                     map.set(value.op, value);
                 }
@@ -18876,48 +19828,55 @@
                     if (Array.isArray(value.r)) {
                         for (const r of value.r) {
                             // @ts-ignore
-                            values.push(r);
+                            values[reverse ? 'push' : 'unshift'](r);
                             // @ts-ignore
                             map.set(r, value);
                         }
                     }
                     else {
                         // @ts-ignore
-                        values.push(value.r);
+                        values[reverse ? 'push' : 'unshift'](value.r);
                         // @ts-ignore
                         map.set(value.r, value);
                     }
                 }
                 if (values.length > 0) {
-                    stack.unshift(...values);
+                    stack[reverse ? 'push' : 'unshift'](...values);
                 }
             }
-            if (eventType == exports.WalkerValueEvent.Leave && filter.fn != null) {
+            if ((eventType & exports.WalkerEvent.Leave) && filter.fn != null) {
                 const isValid = filter.type == null || value.typ == filter.type ||
                     (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
                     (typeof filter.type == 'function' && filter.type(value));
                 if (isValid) {
-                    option = filter.fn(value, map.get(value));
+                    option = filter.fn(value, map.get(value), exports.WalkerEvent.Leave);
                     // @ts-ignore
                     if (option != null && 'typ' in option) {
                         map.set(option, map.get(value) ?? root);
                     }
                 }
             }
-            if (eventType == exports.WalkerValueEvent.Leave && option !== exports.WalkerOptionEnum.Children) {
-                yield {
-                    value,
-                    parent: map.get(value) ?? root,
-                    previousValue: previous,
-                    nextValue: stack[0] ?? null,
-                    // @ts-ignore
-                    root: root ?? null
-                };
-            }
             previous = value;
         }
     }
 
+    /**
+     * feature walk mode
+     *
+     * @internal
+     */
+    exports.FeatureWalkMode = void 0;
+    (function (FeatureWalkMode) {
+        /**
+         * pre process
+         */
+        FeatureWalkMode[FeatureWalkMode["Pre"] = 1] = "Pre";
+        /**
+         * post process
+         */
+        FeatureWalkMode[FeatureWalkMode["Post"] = 2] = "Post";
+    })(exports.FeatureWalkMode || (exports.FeatureWalkMode = {}));
+
     const config$1 = getSyntaxConfig();
     function replacePseudo(tokens) {
         return tokens.map((raw) => raw.map(r => {
@@ -18963,11 +19922,8 @@
         get ordering() {
             return 2;
         }
-        get preProcess() {
-            return true;
-        }
-        get postProcess() {
-            return false;
+        get processMode() {
+            return exports.FeatureWalkMode.Pre;
         }
         static register(options) {
             if (options.removePrefix) {
@@ -19027,12 +19983,13 @@
                             }
                         }
                     }
+                    // @ts-ignore
                     if (SyntaxValidationResult.Valid == evaluateSyntax({ ...node, val: nodes }, {}).valid) {
                         node.val = nodes;
                     }
                 }
             }
-            else if (node.typ == exports.EnumToken.AtRuleNodeType || node.typ == exports.EnumToken.KeyframeAtRuleNodeType) {
+            else if (node.typ == exports.EnumToken.AtRuleNodeType || node.typ == exports.EnumToken.KeyframesAtRuleNodeType) {
                 if (node.nam.startsWith('-')) {
                     const match = node.nam.match(/^-([^-]+)-(.+)$/);
                     if (match != null && '@' + match[2] in config$1.atRules) {
@@ -19040,14 +19997,6 @@
                     }
                 }
                 if (node.typ == exports.EnumToken.AtRuleNodeType && node.val !== '') {
-                    // if ((node as AstAtRule).tokens == null) {
-                    //
-                    //     Object.defineProperty(node, 'tokens', {
-                    //         // @ts-ignore
-                    //         ...definedPropertySettings,
-                    //         value: parseAtRulePrelude(parseString((node as AstAtRule).val), node as AstAtRule),
-                    //     })
-                    // }
                     if (replaceAstNodes(node.tokens)) {
                         node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr), '');
                     }
@@ -19100,14 +20049,12 @@
         }
     }
     class InlineCssVariablesFeature {
+        accept = new Set([exports.EnumToken.RuleNodeType, exports.EnumToken.AtRuleNodeType]);
         get ordering() {
             return 0;
         }
-        get preProcess() {
-            return true;
-        }
-        get postProcess() {
-            return false;
+        get processMode() {
+            return exports.FeatureWalkMode.Pre;
         }
         static register(options) {
             if (options.inlineCssVariables) {
@@ -19116,9 +20063,10 @@
             }
         }
         run(ast, options = {}, parent, context) {
-            if (!('chi' in ast)) {
-                return;
-            }
+            // if (!('chi' in ast)) {
+            //
+            //     return null;
+            // }
             if (!('variableScope' in context)) {
                 context.variableScope = new Map;
             }
@@ -19160,6 +20108,7 @@
                     replace(node, variableScope);
                 }
             }
+            return null;
         }
         cleanup(ast, options = {}, context) {
             const variableScope = context.variableScope;
@@ -19999,7 +20948,9 @@
         }
         add(...declarations) {
             for (const declaration of declarations) {
-                if (declaration.typ != exports.EnumToken.DeclarationNodeType || !this.options.removeDuplicateDeclarations) {
+                if (declaration.typ != exports.EnumToken.DeclarationNodeType ||
+                    (typeof this.options.removeDuplicateDeclarations === 'string' && this.options.removeDuplicateDeclarations === declaration.nam.toLowerCase()) ||
+                    (Array.isArray(this.options.removeDuplicateDeclarations) ? this.options.removeDuplicateDeclarations.includes(declaration.nam) : !this.options.removeDuplicateDeclarations)) {
                     this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
                     continue;
                 }
@@ -20084,14 +21035,12 @@
     }
 
     class ComputeShorthandFeature {
+        accept = new Set([exports.EnumToken.RuleNodeType, exports.EnumToken.AtRuleNodeType, exports.EnumToken.KeyFramesRuleNodeType]);
         get ordering() {
             return 3;
         }
-        get preProcess() {
-            return false;
-        }
-        get postProcess() {
-            return true;
+        get processMode() {
+            return exports.FeatureWalkMode.Post;
         }
         static register(options) {
             if (options.computeShorthand) {
@@ -20101,7 +21050,7 @@
         }
         run(ast, options = {}, parent, context) {
             if (!('chi' in ast)) {
-                return ast;
+                return null;
             }
             // @ts-ignore
             const j = ast.chi.length;
@@ -20139,14 +21088,12 @@
     }
 
     class ComputeCalcExpressionFeature {
+        accept = new Set([exports.EnumToken.RuleNodeType, exports.EnumToken.AtRuleNodeType]);
         get ordering() {
             return 1;
         }
-        get preProcess() {
-            return false;
-        }
-        get postProcess() {
-            return true;
+        get processMode() {
+            return exports.FeatureWalkMode.Post;
         }
         static register(options) {
             if (options.computeCalcExpression) {
@@ -20156,7 +21103,7 @@
         }
         run(ast) {
             if (!('chi' in ast)) {
-                return;
+                return null;
             }
             for (const node of ast.chi) {
                 if (node.typ != exports.EnumToken.DeclarationNodeType) {
@@ -20164,7 +21111,7 @@
                 }
                 const set = new Set;
                 for (const { value, parent } of walkValues(node.val, node, {
-                    event: exports.WalkerValueEvent.Enter,
+                    event: exports.WalkerEvent.Enter,
                     // @ts-ignore
                     fn(node, parent) {
                         if (parent != null &&
@@ -20217,279 +21164,31 @@
                                             break;
                                         }
                                     }
-                                }
-                                else {
-                                    for (let i = 0; i < children.length; i++) {
-                                        if (children[i] == value) {
-                                            children.splice(i, 1, {
-                                                typ: exports.EnumToken.FunctionTokenType,
-                                                val: 'calc',
-                                                chi: values
-                                            });
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    const epsilon = 1e-5;
-    function identity() {
-        return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-    }
-    function pLength(point) {
-        return Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
-    }
-    function normalize(point) {
-        const [x, y, z] = point;
-        const norm = Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
-        return norm === 0 ? [0, 0, 0] : [x / norm, y / norm, z / norm];
-    }
-    function dot(point1, point2) {
-        if (point1.length === 4 && point2.length === 4) {
-            return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2] + point1[3] * point2[3];
-        }
-        return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2];
-    }
-    function multiply(matrixA, matrixB) {
-        let result = new Array(16).fill(0);
-        for (let i = 0; i < 4; i++) {
-            for (let j = 0; j < 4; j++) {
-                for (let k = 0; k < 4; k++) {
-                    // Utiliser l'indexation linéaire pour accéder aux éléments
-                    // Pour une matrice 4x4, l'index est (row * 4 + col)
-                    result[j * 4 + i] += matrixA[k * 4 + i] * matrixB[j * 4 + k];
-                }
-            }
-        }
-        return result;
-    }
-    function inverse(matrix) {
-        // Create augmented matrix [matrix | identity]
-        let augmented = [
-            1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
-            1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1
-        ];
-        // Gaussian elimination with partial pivoting
-        for (let col = 0; col < 4; col++) {
-            // Find pivot row with maximum absolute value
-            let maxRow = col;
-            let maxVal = Math.abs(augmented[col * 4 + col]);
-            for (let row = col + 1; row < 4; row++) {
-                let val = Math.abs(augmented[row * 4 + col]);
-                if (val > maxVal) {
-                    maxVal = val;
-                    maxRow = row;
-                }
-            }
-            // Check for singularity
-            if (maxVal < 1e-5) {
-                return null;
-            }
-            // Swap rows if necessary
-            if (maxRow !== col) {
-                [augmented[col], augmented[maxRow]] = [augmented[maxRow], augmented[col]];
-            }
-            // Scale pivot row to make pivot element 1
-            let pivot = augmented[col * 4 + col];
-            for (let j = 0; j < 8; j++) {
-                augmented[col * 4 + j] /= pivot;
-            }
-            // Eliminate column in other rows
-            for (let row = 0; row < 4; row++) {
-                if (row !== col) {
-                    let factor = augmented[row * 4 + col];
-                    for (let j = 0; j < 8; j++) {
-                        augmented[row * 4 + j] -= factor * augmented[col * 4 + j];
-                    }
-                }
-            }
-        }
-        // Extract the inverse from the right side of the augmented matrix
-        return augmented.slice(0, 16);
-    }
-    // function transpose(matrix: Matrix): Matrix {
-    //     // Crée une nouvelle matrice vide 4x4
-    //     // @ts-ignore
-    //     let transposed: Matrix = [[], [], [], []] as Matrix;
-    //
-    //     // Parcourt chaque ligne et colonne pour transposer
-    //     for (let i = 0; i < 4; i++) {
-    //
-    //         for (let j = 0; j < 4; j++) {
-    //
-    //             transposed[j][i] = matrix[i][j];
-    //         }
-    //     }
-    //
-    //     return transposed;
-    // }
-    function round(number) {
-        return Math.abs(number) < epsilon ? 0 : +number.toPrecision(6);
-    }
-    // translate3d(25.9808px, 0, 15px ) rotateY(60deg) skewX(49.9999deg) scale(1, 1.2)
-    // translate → rotate → skew → scale
-    function decompose(original) {
-        const matrix = original.slice();
-        // Normalize last row
-        if (matrix[15] === 0) {
-            return null;
-        }
-        for (let i = 0; i < 16; i++)
-            matrix[i] /= matrix[15];
-        // Perspective extraction
-        const perspective = [0, 0, 0, 1];
-        if (matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0) {
-            const rightHandSide = [matrix[3], matrix[7], matrix[11], matrix[15]];
-            const perspectiveMatrix = matrix.slice();
-            perspectiveMatrix[3] = 0;
-            perspectiveMatrix[7] = 0;
-            perspectiveMatrix[11] = 0;
-            perspectiveMatrix[15] = 1;
-            // @ts-ignore
-            const inverted = inverse(original.slice());
-            if (!inverted) {
-                return null;
-            }
-            const transposedInverse = transposeMatrix4(inverted);
-            perspective[0] = dot(rightHandSide, transposedInverse.slice(0, 4));
-            perspective[1] = dot(rightHandSide, transposedInverse.slice(4, 8));
-            perspective[2] = dot(rightHandSide, transposedInverse.slice(8, 12));
-            perspective[3] = dot(rightHandSide, transposedInverse.slice(12, 16));
-            // Clear perspective from matrix
-            matrix[3] = 0;
-            matrix[7] = 0;
-            matrix[11] = 0;
-            matrix[15] = 1;
-        }
-        // Translation
-        const translate = [matrix[12], matrix[13], matrix[14]];
-        matrix[12] = matrix[13] = matrix[14] = 0;
-        // Build the 3x3 matrix
-        const row0 = [matrix[0], matrix[1], matrix[2]];
-        const row1 = [matrix[4], matrix[5], matrix[6]];
-        const row2 = [matrix[8], matrix[9], matrix[10]];
-        // Compute scale
-        const scaleX = pLength(row0);
-        const row0Norm = normalize(row0);
-        const skewXY = dot(row0Norm, row1);
-        const row1Proj = [
-            row1[0] - skewXY * row0Norm[0],
-            row1[1] - skewXY * row0Norm[1],
-            row1[2] - skewXY * row0Norm[2]
-        ];
-        const scaleY = pLength(row1Proj);
-        const row1Norm = normalize(row1Proj);
-        const skewXZ = dot(row0Norm, row2);
-        const skewYZ = dot(row1Norm, row2);
-        const row2Proj = [
-            row2[0] - skewXZ * row0Norm[0] - skewYZ * row1Norm[0],
-            row2[1] - skewXZ * row0Norm[1] - skewYZ * row1Norm[1],
-            row2[2] - skewXZ * row0Norm[2] - skewYZ * row1Norm[2]
-        ];
-        const scaleZ = pLength(row2Proj);
-        const row2Norm = normalize(row2Proj);
-        // Build rotation matrix from orthonormalized vectors
-        const r00 = row0Norm[0], r01 = row1Norm[0], r02 = row2Norm[0];
-        const r10 = row0Norm[1], r11 = row1Norm[1], r12 = row2Norm[1];
-        const r20 = row0Norm[2], r21 = row1Norm[2], r22 = row2Norm[2];
-        // Convert to quaternion
-        const trace = r00 + r11 + r22;
-        let qw, qx, qy, qz;
-        if (trace > 0) {
-            const s = 0.5 / Math.sqrt(trace + 1.0);
-            qw = 0.25 / s;
-            qx = (r21 - r12) * s;
-            qy = (r02 - r20) * s;
-            qz = (r10 - r01) * s;
-        }
-        else if (r00 > r11 && r00 > r22) {
-            const s = 2.0 * Math.sqrt(1.0 + r00 - r11 - r22);
-            qw = (r21 - r12) / s;
-            qx = 0.25 * s;
-            qy = (r01 + r10) / s;
-            qz = (r02 + r20) / s;
-        }
-        else if (r11 > r22) {
-            const s = 2.0 * Math.sqrt(1.0 + r11 - r00 - r22);
-            qw = (r02 - r20) / s;
-            qx = (r01 + r10) / s;
-            qy = 0.25 * s;
-            qz = (r12 + r21) / s;
-        }
-        else {
-            const s = 2.0 * Math.sqrt(1.0 + r22 - r00 - r11);
-            qw = (r10 - r01) / s;
-            qx = (r02 + r20) / s;
-            qy = (r12 + r21) / s;
-            qz = 0.25 * s;
-        }
-        [qx, qy, qz] = toZero([qx, qy, qz]);
-        // const q = gcd(qx, gcd(qy, qz));
-        let q = [Math.abs(qx), Math.abs(qy), Math.abs(qz)].reduce((acc, curr) => {
-            if (acc == 0 || (curr > 0 && curr < acc)) {
-                acc = curr;
-            }
-            return acc;
-        }, 0);
-        if (q > 0) {
-            qx /= q;
-            qy /= q;
-            qz /= q;
-        }
-        const rotate = [qx, qy, qz, Object.is(qw, 0) ? 0 : 2 * Math.acos(qw) * 180 / Math.PI];
-        const scale = [scaleX, scaleY, scaleZ];
-        const skew = [skewXY, skewXZ, skewYZ];
-        return {
-            translate,
-            scale,
-            rotate,
-            skew,
-            perspective
-        };
-    }
-    function transposeMatrix4(m) {
-        return [
-            m[0], m[4], m[8], m[12],
-            m[1], m[5], m[9], m[13],
-            m[2], m[6], m[10], m[14],
-            m[3], m[7], m[11], m[15],
-        ];
-    }
-    function toZero(v) {
-        for (let i = 0; i < v.length; i++) {
-            if (Math.abs(v[i]) <= epsilon) {
-                v[i] = 0;
-            }
-            else {
-                v[i] = +v[i].toPrecision(6);
+                                }
+                                else {
+                                    for (let i = 0; i < children.length; i++) {
+                                        if (children[i] == value) {
+                                            children.splice(i, 1, {
+                                                typ: exports.EnumToken.FunctionTokenType,
+                                                val: 'calc',
+                                                chi: values
+                                            });
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
+            return null;
         }
-        return v;
-    }
-    // https://drafts.csswg.org/css-transforms-1/#2d-matrix
-    function is2DMatrix(matrix) {
-        // m13,m14,  m23, m24, m31, m32, m34, m43 are all 0
-        return matrix[0 * 4 + 2] === 0 &&
-            matrix[0 * 4 + 3] === 0 &&
-            matrix[1 * 4 + 2] === 0 &&
-            matrix[1 * 4 + 3] === 0 &&
-            matrix[2 * 4 + 0] === 0 &&
-            matrix[2 * 4 + 1] === 0 &&
-            matrix[2 * 4 + 3] === 0 &&
-            matrix[3 * 4 + 2] === 0 &&
-            matrix[2 * 4 + 2] === 1 &&
-            matrix[3 * 4 + 3] === 1;
     }
 
     function translateX(x, from) {
         const matrix = identity();
-        matrix[3 * 4 + 0] = x;
+        matrix[3 * 4] = x;
         return multiply(from, matrix);
     }
     function translateY(y, from) {
@@ -20504,13 +21203,13 @@
     }
     function translate(translate, from) {
         const matrix = identity();
-        matrix[3 * 4 + 0] = translate[0];
+        matrix[3 * 4] = translate[0];
         matrix[3 * 4 + 1] = translate[1] ?? 0;
         return multiply(from, matrix);
     }
     function translate3d(translate, from) {
         const matrix = identity();
-        matrix[3 * 4 + 0] = translate[0];
+        matrix[3 * 4] = translate[0];
         matrix[3 * 4 + 1] = translate[1];
         matrix[3 * 4 + 2] = translate[2];
         return multiply(from, matrix);
@@ -20533,34 +21232,34 @@
         x *= unit;
         y *= unit;
         z *= unit;
-        matrix[0 * 4 + 0] = 1 - 2 * (y * y + z * z) * sq;
-        matrix[0 * 4 + 1] = 2 * (x * y * sq + z * sc);
-        matrix[0 * 4 + 2] = 2 * (x * z * sq - y * sc);
-        matrix[1 * 4 + 0] = 2 * (x * y * sq - z * sc);
-        matrix[1 * 4 + 1] = 1 - 2 * (x * x + z * z) * sq;
-        matrix[1 * 4 + 2] = 2 * (y * z * sq + x * sc);
-        matrix[2 * 4 + 0] = 2 * (x * z * sq + y * sc);
+        matrix[0] = 1 - 2 * (y * y + z * z) * sq;
+        matrix[1] = 2 * (x * y * sq + z * sc);
+        matrix[2] = 2 * (x * z * sq - y * sc);
+        matrix[4] = 2 * (x * y * sq - z * sc);
+        matrix[4 + 1] = 1 - 2 * (x * x + z * z) * sq;
+        matrix[4 + 2] = 2 * (y * z * sq + x * sc);
+        matrix[2 * 4] = 2 * (x * z * sq + y * sc);
         matrix[2 * 4 + 1] = 2 * (y * z * sq - x * sc);
         matrix[2 * 4 + 2] = 1 - 2 * (x * x + y * y) * sq;
         return multiply(from, matrix);
     }
     function rotate(angle, from) {
         const matrix = identity();
-        matrix[0 * 4 + 0] = Math.cos(angle);
-        matrix[0 * 4 + 1] = Math.sin(angle);
-        matrix[1 * 4 + 0] = -Math.sin(angle);
-        matrix[1 * 4 + 1] = Math.cos(angle);
+        matrix[0] = Math.cos(angle);
+        matrix[1] = Math.sin(angle);
+        matrix[4] = -Math.sin(angle);
+        matrix[4 + 1] = Math.cos(angle);
         return multiply(from, matrix);
     }
 
     function scaleX(x, from) {
         const matrix = identity();
-        matrix[0 * 4 + 0] = x;
+        matrix[0] = x;
         return multiply(from, matrix);
     }
     function scaleY(y, from) {
         const matrix = identity();
-        matrix[1 * 4 + 1] = y;
+        matrix[4 + 1] = y;
         return multiply(from, matrix);
     }
     function scaleZ(z, from) {
@@ -20570,14 +21269,14 @@
     }
     function scale(x, y, from) {
         const matrix = identity();
-        matrix[0 * 4 + 0] = x;
-        matrix[1 * 4 + 1] = y;
+        matrix[0] = x;
+        matrix[4 + 1] = y;
         return multiply(from, matrix);
     }
     function scale3d(x, y, z, from) {
         const matrix = identity();
-        matrix[0 * 4 + 0] = x;
-        matrix[1 * 4 + 1] = y;
+        matrix[0] = x;
+        matrix[4 + 1] = y;
         matrix[2 * 4 + 2] = z;
         return multiply(from, matrix);
     }
@@ -20602,27 +21301,27 @@
     function matrix(values) {
         const matrix = identity();
         if (values.length === 6) {
-            matrix[0 * 4 + 0] = values[0];
-            matrix[0 * 4 + 1] = values[1];
-            matrix[1 * 4 + 0] = values[2];
-            matrix[1 * 4 + 1] = values[3];
-            matrix[3 * 4 + 0] = values[4];
+            matrix[0] = values[0];
+            matrix[1] = values[1];
+            matrix[4] = values[2];
+            matrix[4 + 1] = values[3];
+            matrix[3 * 4] = values[4];
             matrix[3 * 4 + 1] = values[5];
         }
         else if (values.length === 16) {
-            matrix[0 * 4 + 0] = values[0];
-            matrix[0 * 4 + 1] = values[1];
-            matrix[0 * 4 + 2] = values[2];
-            matrix[0 * 4 + 3] = values[3];
-            matrix[1 * 4 + 0] = values[4];
-            matrix[1 * 4 + 1] = values[5];
-            matrix[1 * 4 + 2] = values[6];
-            matrix[1 * 4 + 3] = values[7];
-            matrix[2 * 4 + 0] = values[8];
+            matrix[0] = values[0];
+            matrix[1] = values[1];
+            matrix[2] = values[2];
+            matrix[3] = values[3];
+            matrix[4] = values[4];
+            matrix[4 + 1] = values[5];
+            matrix[4 + 2] = values[6];
+            matrix[4 + 3] = values[7];
+            matrix[2 * 4] = values[8];
             matrix[2 * 4 + 1] = values[9];
             matrix[2 * 4 + 2] = values[10];
             matrix[2 * 4 + 3] = values[11];
-            matrix[3 * 4 + 0] = values[12];
+            matrix[3 * 4] = values[12];
             matrix[3 * 4 + 1] = values[13];
             matrix[3 * 4 + 2] = values[14];
             matrix[3 * 4 + 3] = values[15];
@@ -20647,11 +21346,11 @@
                 typ: exports.EnumToken.FunctionTokenType,
                 val: 'matrix',
                 chi: [
-                    matrix[0 * 4 + 0],
-                    matrix[0 * 4 + 1],
-                    matrix[1 * 4 + 0],
-                    matrix[1 * 4 + 1],
-                    matrix[3 * 4 + 0],
+                    matrix[0],
+                    matrix[1],
+                    matrix[4],
+                    matrix[4 + 1],
+                    matrix[3 * 4],
                     matrix[3 * 4 + 1]
                 ].reduce((acc, t) => {
                     if (acc.length > 0) {
@@ -20834,10 +21533,6 @@
             }
         }
         if (transforms.has('skew')) {
-            // if (round(decomposed.skew[0]) == 0) {
-            //
-            //     skew.delete('x');
-            // }
             if (round(decomposed.skew[1]) == 0) {
                 skew.delete('y');
             }
@@ -20877,7 +21572,7 @@
                 scales.delete('x');
             }
             if (scales.size == 1) {
-                let prefix = scales.has('x') ? '' : scales.has('y') ? 'Y' : 'Z';
+                let prefix = scales.has('x') ? 'X' : scales.has('y') ? 'Y' : 'Z';
                 result.push({
                     typ: exports.EnumToken.FunctionTokenType,
                     val: 'scale' + prefix,
@@ -20920,13 +21615,9 @@
         ] : result;
     }
     function eqMatrix(a, b) {
-        // console.error(JSON.stringify({a, b}, null, 1));
         let mat = identity();
         let tmp = identity();
-        // @ts-ignore
         const data = (Array.isArray(a) ? a : parseMatrix(a));
-        // toZero(data);
-        // console.error({data});
         for (const transform of b) {
             tmp = computeMatrix([transform], identity());
             if (tmp == null) {
@@ -20934,8 +21625,6 @@
             }
             mat = multiply(mat, tmp);
         }
-        // toZero(mat);
-        // console.error({mat});
         if (mat == null) {
             return false;
         }
@@ -20948,23 +21637,126 @@
         }
         return true;
     }
+    function minifyTransformFunctions(transform) {
+        const name = transform.val.toLowerCase();
+        if ('skewx' == name) {
+            transform.val = 'skew';
+            return transform;
+        }
+        if (!['translate', 'translate3d', 'scale', 'scale3d'].includes(name)) {
+            return transform;
+        }
+        const values = [];
+        for (const token of transform.chi) {
+            if (token.typ == exports.EnumToken.CommentTokenType || token.typ == exports.EnumToken.WhitespaceTokenType || token.typ == exports.EnumToken.CommaTokenType) {
+                continue;
+            }
+            if (![exports.EnumToken.NumberTokenType, exports.EnumToken.LengthTokenType, exports.EnumToken.AngleTokenType, exports.EnumToken.PercentageTokenType].includes(token.typ)) {
+                return transform;
+            }
+            if (token.typ == exports.EnumToken.PercentageTokenType && typeof token.val == 'number' && name.startsWith('scale')) {
+                Object.assign(token, { typ: exports.EnumToken.NumberTokenType, val: token.val / 100 });
+            }
+            values.push(token);
+        }
+        if ((name == 'translate' || name == 'scale') && values.length > 2) {
+            return transform;
+        }
+        const ignoredValue = name.startsWith('scale') ? 1 : 0;
+        const t = new Set(['x', 'y', 'z']);
+        let i = 3;
+        while (i--) {
+            if (values.length <= i || values[i].val == ignoredValue) {
+                t.delete(i == 0 ? 'x' : i == 1 ? 'y' : 'z');
+            }
+        }
+        if (name == 'translate3d' || name == 'translate') {
+            if (t.size == 0) {
+                return {
+                    typ: exports.EnumToken.FunctionTokenType,
+                    val: 'translate',
+                    chi: [
+                        { typ: exports.EnumToken.NumberTokenType, val: 0 }
+                    ]
+                };
+            }
+            if (t.size == 1) {
+                return {
+                    typ: exports.EnumToken.FunctionTokenType,
+                    val: 'translate' + (t.has('x') ? '' : t.has('y') ? 'Y' : 'Z'),
+                    chi: [
+                        values[t.has('x') ? 0 : t.has('y') ? 1 : 2]
+                    ]
+                };
+            }
+            if (t.size == 2) {
+                if (t.has('z')) {
+                    return transform;
+                }
+                return {
+                    typ: exports.EnumToken.FunctionTokenType,
+                    val: 'translate',
+                    chi: [
+                        values[0],
+                        { typ: exports.EnumToken.CommaTokenType },
+                        values[1]
+                    ]
+                };
+            }
+        }
+        if (name == 'scale3d' || name == 'scale') {
+            if (t.size == 0) {
+                return {
+                    typ: exports.EnumToken.FunctionTokenType,
+                    val: 'scale',
+                    chi: [
+                        { typ: exports.EnumToken.NumberTokenType, val: 1 }
+                    ]
+                };
+            }
+            if (t.size == 1) {
+                return {
+                    typ: exports.EnumToken.FunctionTokenType,
+                    val: 'scale' + (t.has('x') ? 'X' : t.has('y') ? 'Y' : 'Z'),
+                    chi: [
+                        values[t.has('x') ? 0 : t.has('y') ? 1 : 2]
+                    ]
+                };
+            }
+            if (t.size == 2) {
+                if (t.has('z')) {
+                    return transform;
+                }
+                return {
+                    typ: exports.EnumToken.FunctionTokenType,
+                    val: 'scale',
+                    chi: [
+                        values[0],
+                        { typ: exports.EnumToken.CommaTokenType },
+                        values[1]
+                    ]
+                };
+            }
+        }
+        return transform;
+    }
 
     function skewX(x, from) {
         const matrix = identity();
-        matrix[1 * 4 + 0] = Math.tan(x);
+        matrix[4] = Math.tan(x);
         return multiply(from, matrix);
     }
     function skewY(y, from) {
         const matrix = identity();
-        matrix[0 * 4 + 1] = Math.tan(y);
+        matrix[1] = Math.tan(y);
         return multiply(from, matrix);
     }
     // convert angle to radian
     function skew(values, from) {
         const matrix = identity();
-        matrix[1 * 4 + 0] = Math.tan(values[0]);
+        matrix[4] = Math.tan(values[0]);
         if (values.length > 1) {
-            matrix[0 * 4 + 1] = Math.tan(values[1]);
+            matrix[1] = Math.tan(values[1]);
         }
         return multiply(from, matrix);
     }
@@ -21003,8 +21795,6 @@
                 });
             }
         }
-        // console.error({matrix});
-        // matrix = toZero(matrix) as Matrix;
         return {
             matrix: serialize(toZero(matrix)),
             cumulative,
@@ -21028,7 +21818,7 @@
                     {
                         values.length = 0;
                         const children = stripCommaToken(transformList[i].chi.slice());
-                        const valCount = transformList[i].val == 'translate3d' || transformList[i].val == 'translate' ? 3 : 1;
+                        const valCount = transformList[i].val == 'translate3d' ? 3 : transformList[i].val == 'translate' ? 2 : 1;
                         for (let j = 0; j < children.length; j++) {
                             if (children[j].typ == exports.EnumToken.WhitespaceTokenType) {
                                 continue;
@@ -21115,7 +21905,7 @@
                         const children = stripCommaToken(transformList[i].chi.slice());
                         for (let k = 0; k < children.length; k++) {
                             child = children[k];
-                            if (child.typ != exports.EnumToken.NumberTokenType) {
+                            if (child.typ != exports.EnumToken.NumberTokenType && child.typ != exports.EnumToken.PercentageTokenType) {
                                 return null;
                             }
                             values.push(getNumber(child));
@@ -21269,14 +22059,12 @@
     }
 
     class TransformCssFeature {
+        accept = new Set([exports.EnumToken.RuleNodeType, exports.EnumToken.KeyFramesRuleNodeType]);
         get ordering() {
             return 4;
         }
-        get preProcess() {
-            return false;
-        }
-        get postProcess() {
-            return true;
+        get processMode() {
+            return exports.FeatureWalkMode.Post;
         }
         static register(options) {
             // @ts-ignore
@@ -21287,7 +22075,7 @@
         }
         run(ast) {
             if (!('chi' in ast)) {
-                return;
+                return null;
             }
             let i = 0;
             let node;
@@ -21298,28 +22086,21 @@
                 if (node.typ != exports.EnumToken.DeclarationNodeType || !node.nam.match(/^(-[a-z]+-)?transform$/)) {
                     continue;
                 }
-                const children = node.val.reduce((acc, curr) => {
-                    if (curr.typ == exports.EnumToken.FunctionTokenType && 'skew' == curr.val.toLowerCase()) {
-                        if (curr.chi.length == 3) {
-                            if (curr.chi[2].val == 0) {
-                                curr.chi.length = 1;
-                                curr.val = 'skew';
-                            }
-                            else if (curr.chi[0].val == 0) {
-                                curr.chi = [curr.chi[2]];
-                                curr.val = 'skewY';
-                            }
-                        }
-                    }
-                    acc.push(curr);
-                    return acc;
-                }, []);
+                const children = [];
+                for (const child of node.val) {
+                    children.push(child.typ == exports.EnumToken.FunctionTokenType ? minifyTransformFunctions(child) : child);
+                }
                 consumeWhitespace(children);
-                let { matrix, cumulative, minified } = compute(children) ?? {};
+                let { matrix, cumulative, minified } = compute(children) ?? {
+                    matrix: null,
+                    cumulative: null,
+                    minified: null
+                };
                 if (matrix == null || cumulative == null || minified == null) {
+                    node.val = children;
                     continue;
                 }
-                let r = [filterValues(node.val.slice())];
+                let r = [filterValues(children)];
                 if (eqMatrix(matrix, cumulative)) {
                     r.push(cumulative);
                 }
@@ -21334,6 +22115,7 @@
                     return acc;
                 }, [matrix]);
             }
+            return null;
         }
     }
 
@@ -21346,21 +22128,6 @@
         TransformCssFeature: TransformCssFeature
     });
 
-    /**
-     * feature walk mode
-     */
-    exports.FeatureWalkMode = void 0;
-    (function (FeatureWalkMode) {
-        /**
-         * pre process
-         */
-        FeatureWalkMode[FeatureWalkMode["Pre"] = 0] = "Pre";
-        /**
-         * post process
-         */
-        FeatureWalkMode[FeatureWalkMode["Post"] = 1] = "Post";
-    })(exports.FeatureWalkMode || (exports.FeatureWalkMode = {}));
-
     const combinators = ['+', '>', '~', '||', '|'];
     const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
     const notEndingWith = ['(', '['].concat(combinators);
@@ -21380,6 +22147,7 @@
         let preprocess = false;
         let postprocess = false;
         let parents;
+        let replacement;
         if (!('features' in options)) {
             // @ts-ignore
             options = {
@@ -21389,82 +22157,92 @@
                 removePrefix: false,
                 features: [], ...options
             };
-            // @ts-ignore
             for (const feature of features) {
                 feature.register(options);
             }
             options.features.sort((a, b) => a.ordering - b.ordering);
         }
         for (const feature of options.features) {
-            if (feature.preProcess) {
+            if (feature.processMode & exports.FeatureWalkMode.Pre) {
                 preprocess = true;
             }
-            if (feature.postProcess) {
+            if (feature.processMode & exports.FeatureWalkMode.Post) {
                 postprocess = true;
             }
         }
         if (preprocess) {
-            parents = [ast];
+            parents = new Set([ast]);
             for (const parent of parents) {
                 if (parent.typ == exports.EnumToken.CommentTokenType ||
                     parent.typ == exports.EnumToken.CDOCOMMTokenType) {
-                    Object.defineProperty(parent, 'parent', {
-                        ...definedPropertySettings,
-                        value: parent
-                    });
                     continue;
                 }
+                replacement = parent;
                 for (const feature of options.features) {
-                    if (!feature.preProcess) {
+                    if ((feature.processMode & exports.FeatureWalkMode.Pre) === 0 || (feature.accept != null && !feature.accept.has(parent.typ))) {
                         continue;
                     }
-                    feature.run(parent, options, parent.parent ?? ast, context, exports.FeatureWalkMode.Pre);
+                    const result = feature.run(replacement, options, parent.parent ?? ast, context, exports.FeatureWalkMode.Pre);
+                    if (result != null) {
+                        replacement = result;
+                    }
                 }
-                if (('chi' in parent)) {
+                if (replacement != parent && parent.parent != null) {
                     // @ts-ignore
-                    for (const node of parent.chi) {
-                        parents.push(Object.defineProperty(node, 'parent', {
+                    replaceToken(parent.parent, parent, replacement);
+                }
+                if (('chi' in replacement)) {
+                    // @ts-ignore
+                    for (const node of replacement.chi) {
+                        parents.add(Object.defineProperty(node, 'parent', {
                             ...definedPropertySettings,
-                            value: parent
+                            value: replacement
                         }));
                     }
                 }
             }
             for (const feature of options.features) {
-                if (feature.preProcess && 'cleanup' in feature) {
+                if ((feature.processMode & exports.FeatureWalkMode.Pre) && 'cleanup' in feature) {
                     // @ts-ignore
                     feature.cleanup(ast, options, context, exports.FeatureWalkMode.Pre);
                 }
             }
         }
         doMinify(ast, options, recursive, errors, nestingContent, context);
-        parents = [ast];
+        parents = new Set([ast]);
         for (const parent of parents) {
             if (parent.typ == exports.EnumToken.CommentTokenType ||
                 parent.typ == exports.EnumToken.CDOCOMMTokenType) {
                 continue;
             }
+            replacement = parent;
             if (postprocess) {
                 for (const feature of options.features) {
-                    if (!feature.postProcess) {
+                    if ((feature.processMode & exports.FeatureWalkMode.Post) === 0 || (feature.accept != null && !feature.accept.has(parent.typ))) {
                         continue;
                     }
-                    feature.run(parent, options, parent.parent ?? ast, context, exports.FeatureWalkMode.Post);
+                    const result = feature.run(replacement, options, parent.parent ?? ast, context, exports.FeatureWalkMode.Post);
+                    if (result != null) {
+                        replacement = result;
+                    }
                 }
             }
-            if (('chi' in parent)) {
+            if (replacement != null && replacement != parent && parent.parent != null) {
                 // @ts-ignore
-                for (const node of parent.chi) {
-                    parents.push(Object.defineProperty(node, 'parent', {
+                replaceToken(parent.parent, parent, replacement);
+            }
+            if (('chi' in replacement)) {
+                for (const node of replacement.chi) {
+                    parents.add(Object.defineProperty(node, 'parent', {
                         ...definedPropertySettings,
-                        value: parent
+                        value: replacement
                     }));
                 }
             }
         }
         if (postprocess) {
             for (const feature of options.features) {
-                if (feature.postProcess && 'cleanup' in feature) {
+                if (feature.processMode & exports.FeatureWalkMode.Post && 'cleanup' in feature) {
                     // @ts-ignore
                     feature.cleanup(ast, options, context, exports.FeatureWalkMode.Post);
                 }
@@ -21476,12 +22254,10 @@
      * reduce selectors
      * @param acc
      * @param curr
-     * @param index
-     * @param array
      *
      * @private
      */
-    function reduce(acc, curr, index, array) {
+    function reduce(acc, curr) {
         // trim :is()
         // if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
         //
@@ -21522,21 +22298,18 @@
             }
             let i = 0;
             let previous = null;
-            let node;
+            let node = null;
             let nodeIndex = -1;
-            // @ts-ignore
             for (; i < ast.chi.length; i++) {
-                // @ts-ignore
                 if (ast.chi[i].typ == exports.EnumToken.CommentNodeType) {
                     continue;
                 }
-                // @ts-ignore
                 node = ast.chi[i];
                 if (node.typ == exports.EnumToken.AtRuleNodeType && node.nam == 'font-face') {
                     continue;
                 }
-                if (node.typ == exports.EnumToken.KeyframeAtRuleNodeType) {
-                    if (previous?.typ == exports.EnumToken.KeyframeAtRuleNodeType &&
+                if (node.typ == exports.EnumToken.KeyframesAtRuleNodeType) {
+                    if (previous?.typ == exports.EnumToken.KeyframesAtRuleNodeType &&
                         node.nam == previous.nam &&
                         node.val == previous.val) {
                         ast.chi?.splice(nodeIndex--, 1);
@@ -21544,15 +22317,11 @@
                         i = nodeIndex;
                         continue;
                     }
-                    if (node.chi.length > 0) {
-                        doMinify(node, options, true, errors, nestingContent, context);
-                    }
                 }
-                else if (node.typ == exports.EnumToken.KeyFrameRuleNodeType) {
-                    if (previous?.typ == exports.EnumToken.KeyFrameRuleNodeType &&
+                else if (node.typ == exports.EnumToken.KeyFramesRuleNodeType) {
+                    if (previous?.typ == exports.EnumToken.KeyFramesRuleNodeType &&
                         node.sel == previous.sel) {
                         previous.chi.push(...node.chi);
-                        // @ts-ignore
                         ast.chi.splice(i--, 1);
                         continue;
                     }
@@ -21574,25 +22343,26 @@
                     }
                 }
                 else if (node.typ == exports.EnumToken.AtRuleNodeType) {
-                    // @ts-ignore
                     if (node.nam == 'media' && ['all', '', null].includes(node.val)) {
-                        // @ts-ignore
                         ast.chi?.splice(i, 1, ...node.chi);
                         i--;
                         continue;
                     }
-                    // @ts-ignore
                     if (previous?.typ == exports.EnumToken.AtRuleNodeType &&
+                        node.nam != 'font-face' &&
                         previous.nam == node.nam &&
                         previous.val == node.val) {
                         if ('chi' in node) {
                             // @ts-ignore
                             previous.chi.push(...node.chi);
+                            if (!hasDeclaration(previous)) {
+                                context.nodes.delete(previous);
+                                doMinify(previous, options, recursive, errors, nestingContent, context);
+                            }
                         }
                         ast?.chi?.splice(i--, 1);
                         continue;
                     }
-                    // @ts-ignore
                     if (!hasDeclaration(node)) {
                         doMinify(node, options, recursive, errors, nestingContent, context);
                     }
@@ -21603,47 +22373,33 @@
                 // @ts-ignore
                 else if (node.typ == exports.EnumToken.RuleNodeType) {
                     reduceRuleSelector(node);
-                    let wrapper;
+                    let wrapper = null;
                     let match;
-                    // @ts-ignore
                     if (options.nestingRules) {
-                        // @ts-ignore
                         if (previous?.typ == exports.EnumToken.RuleNodeType) {
-                            // @ts-ignore
                             reduceRuleSelector(previous);
                             // @ts-ignore
                             match = matchSelectors(previous.raw, node.raw, ast.typ);
-                            // @ts-ignore
                             if (match != null) {
-                                // @ts-ignore
                                 wrapper = wrapNodes(previous, node, match, ast, reducer, i, nodeIndex);
                                 nodeIndex = i - 1;
-                                // @ts-ignore
                                 previous = ast.chi[nodeIndex];
                             }
                         }
-                        // @ts-ignore
                         if (wrapper != null) {
-                            // @ts-ignore
                             while (i < ast.chi.length) {
-                                // @ts-ignore
                                 const nextNode = ast.chi[i];
-                                // @ts-ignore
                                 if (nextNode.typ != exports.EnumToken.RuleNodeType) {
                                     break;
                                 }
                                 reduceRuleSelector(nextNode);
-                                // @ts-ignore
-                                match = matchSelectors(wrapper.raw, nextNode.raw, ast.typ);
-                                // @ts-ignore
+                                match = matchSelectors(wrapper.raw, nextNode.raw);
                                 if (match == null) {
                                     break;
                                 }
-                                // @ts-ignore
                                 wrapper = wrapNodes(wrapper, nextNode, match, ast, reducer, i, nodeIndex);
                             }
                             nodeIndex = --i;
-                            // @ts-ignore
                             previous = ast.chi[nodeIndex];
                             doMinify(wrapper, options, recursive, errors, nestingContent, context);
                             continue;
@@ -21690,7 +22446,6 @@
                                 curr.unshift('&');
                                 wrap = false;
                             }
-                            // @ts-ignore
                             acc.push(curr);
                             return acc;
                         }, []);
@@ -21716,82 +22471,67 @@
                             }
                         }
                         if (rule == null) {
-                            rule = selector.map(s => {
+                            rule = selector.map((s) => {
                                 if (s[0] == '&') {
                                     s.splice(0, 1, ...node.optimized.optimized);
                                 }
                                 return s.join('');
                             }).join(',');
                         }
-                        // @ts-ignore
                         let sel = wrap ? node.optimized.optimized.join('') + `:is(${rule})` : rule;
                         if (sel.length < node.sel.length) {
                             node.sel = sel;
                         }
                     }
+                    doMinify(node, options, recursive, errors, nestingContent, context);
                 }
-                // @ts-ignore
                 if (previous != null) {
-                    // @ts-ignore
                     if ('chi' in previous && ('chi' in node)) {
-                        // @ts-ignore
                         if (previous.typ == node.typ) {
                             let shouldMerge = true;
-                            // @ts-ignore
                             let k = previous.chi.length;
                             while (k-- > 0) {
-                                // @ts-ignore
                                 if (previous.chi[k].typ == exports.EnumToken.CommentNodeType) {
                                     continue;
                                 }
-                                // @ts-ignore
                                 shouldMerge = previous.chi[k].typ == exports.EnumToken.DeclarationNodeType;
                                 break;
                             }
                             if (shouldMerge) {
                                 // @ts-ignore
-                                if (((node.typ == exports.EnumToken.RuleNodeType || node.typ == exports.EnumToken.KeyFrameRuleNodeType) && node.sel == previous.sel) ||
+                                if (((node.typ == exports.EnumToken.RuleNodeType || node.typ == exports.EnumToken.KeyFramesRuleNodeType) && node.sel == previous.sel) ||
                                     // @ts-ignore
                                     (node.typ == exports.EnumToken.AtRuleNodeType) && node.val != 'font-face' && node.val == previous.val) {
                                     // @ts-ignore
                                     node.chi.unshift(...previous.chi);
-                                    // @ts-ignore
+                                    doMinify(node, options, recursive, errors, nestingContent, context);
                                     ast.chi.splice(nodeIndex, 1);
-                                    i--;
-                                    previous = node;
+                                    previous = ast.chi[--i];
                                     nodeIndex = i;
                                     continue;
                                 }
-                                else if (node.typ == previous?.typ && [exports.EnumToken.KeyFrameRuleNodeType, exports.EnumToken.RuleNodeType].includes(node.typ)) {
+                                else if (node.typ == previous?.typ && [exports.EnumToken.KeyFramesRuleNodeType, exports.EnumToken.RuleNodeType].includes(node.typ)) {
                                     const intersect = diff(previous, node, reducer, options);
                                     if (intersect != null) {
                                         if (intersect.node1.chi.length == 0) {
-                                            // @ts-ignore
                                             ast.chi.splice(i--, 1);
                                         }
                                         else {
-                                            // @ts-ignore
                                             ast.chi.splice(i--, 1, intersect.node1);
                                         }
                                         if (intersect.node2.chi.length == 0) {
-                                            // @ts-ignore
                                             ast.chi.splice(nodeIndex, 1, intersect.result);
                                             i--;
-                                            // @ts-ignore
                                             if (nodeIndex == i) {
                                                 nodeIndex = i;
                                             }
                                         }
                                         else {
-                                            // @ts-ignore
                                             ast.chi.splice(nodeIndex, 1, intersect.result, intersect.node2);
-                                            // @ts-ignore
                                             i = (nodeIndex ?? 0) + 1;
                                         }
                                         reduceRuleSelector(intersect.result);
-                                        // @ts-ignore
                                         if (node != ast.chi[i]) {
-                                            // @ts-ignore
                                             node = ast.chi[i];
                                         }
                                         previous = intersect.result;
@@ -21800,9 +22540,7 @@
                                 }
                             }
                         }
-                        // @ts-ignore
                         if (recursive && previous != node) {
-                            // @ts-ignore
                             if (!hasDeclaration(previous)) {
                                 doMinify(previous, options, recursive, errors, nestingContent, context);
                             }
@@ -21810,9 +22548,7 @@
                     }
                 }
                 if (!nestingContent &&
-                    // @ts-ignore
                     previous != null &&
-                    // previous.optimized != null &&
                     previous.typ == exports.EnumToken.RuleNodeType &&
                     previous.sel.includes('&')) {
                     fixSelector(previous);
@@ -21820,20 +22556,15 @@
                 previous = node;
                 nodeIndex = i;
             }
-            // @ts-ignore
             if (recursive && node != null && ('chi' in node)) {
-                // @ts-ignore
-                if (node.typ == exports.EnumToken.KeyframeAtRuleNodeType || !node.chi.some(n => n.typ == exports.EnumToken.DeclarationNodeType)) {
-                    // @ts-ignore
+                if (node.typ == exports.EnumToken.KeyframesAtRuleNodeType || !node.chi.some(n => n.typ == exports.EnumToken.DeclarationNodeType)) {
                     if (!(node.typ == exports.EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
                         doMinify(node, options, recursive, errors, nestingContent, context);
                     }
                 }
             }
             if (!nestingContent &&
-                // @ts-ignore
                 node != null &&
-                // previous.optimized != null &&
                 node.typ == exports.EnumToken.RuleNodeType &&
                 node.sel.includes('&')) {
                 fixSelector(node);
@@ -21984,7 +22715,6 @@
             }
             if (chr == ',') {
                 if (str !== '') {
-                    // @ts-ignore
                     result.at(-1).push(str);
                     str = '';
                 }
@@ -21993,7 +22723,6 @@
             }
             if (chr == '.') {
                 if (str !== '') {
-                    // @ts-ignore
                     result.at(-1).push(str);
                     str = '';
                 }
@@ -22002,20 +22731,17 @@
             }
             if (combinators.includes(chr)) {
                 if (str !== '') {
-                    // @ts-ignore
                     result.at(-1).push(str);
                     str = '';
                 }
                 if (chr == '|' && buffer.charAt(i + 1) == '|') {
                     chr += buffer.charAt(++i);
                 }
-                // @ts-ignore
                 result.at(-1).push(chr);
                 continue;
             }
             if (chr == ':') {
                 if (str !== '') {
-                    // @ts-ignore
                     result.at(-1).push(str);
                     str = '';
                 }
@@ -22057,7 +22783,6 @@
             }
         }
         if (str !== '') {
-            // @ts-ignore
             result.at(-1).push(str);
         }
         return result;
@@ -22122,7 +22847,7 @@
      *
      * @private
      */
-    function matchSelectors(selector1, selector2 /*, parentType: EnumToken, errors: ErrorDescription[] */) {
+    function matchSelectors(selector1, selector2) {
         let match = [[]];
         const j = Math.min(selector1.reduce((acc, curr) => Math.min(acc, curr.length), selector1.length > 0 ? selector1[0].length : 0), selector2.reduce((acc, curr) => Math.min(acc, curr.length), selector2.length > 0 ? selector2[0].length : 0));
         let i = 0;
@@ -22197,7 +22922,6 @@
      * @private
      */
     function fixSelector(node) {
-        // @ts-ignore
         if (node.sel.includes('&')) {
             const attributes = parseString(node.sel);
             for (const attr of walkValues(attributes)) {
@@ -22232,40 +22956,27 @@
         let nSel = match.selector2.reduce(reducer, []).join(',');
         // @ts-ignore
         const wrapper = { ...previous, chi: [], sel: match.match.reduce(reducer, []).join(',') };
-        // @ts-ignore
         Object.defineProperty(wrapper, 'raw', {
             ...definedPropertySettings,
-            // @ts-ignore
             value: match.match.map(t => t.slice())
         });
         if (pSel == '&' || pSel === '') {
-            // @ts-ignore
             wrapper.chi.push(...previous.chi);
-            // @ts-ignore
             if ((nSel == '&' || nSel === '')) {
-                // @ts-ignore
                 wrapper.chi.push(...node.chi);
             }
             else {
-                // @ts-ignore
                 wrapper.chi.push(node);
             }
         }
         else {
-            // @ts-ignore
             wrapper.chi.push(previous, node);
         }
-        // @ts-ignore
         ast.chi.splice(i, 1, wrapper);
-        // @ts-ignore
         ast.chi.splice(nodeIndex, 1);
-        // @ts-ignore
         previous.sel = pSel;
-        // @ts-ignore
         previous.raw = match.selector1;
-        // @ts-ignore
         node.sel = nSel;
-        // @ts-ignore
         node.raw = match.selector2;
         reduceRuleSelector(wrapper);
         return wrapper;
@@ -22457,14 +23168,11 @@
      */
     function expand(ast) {
         const result = { ...ast, chi: [] };
-        // @ts-ignore
         for (let i = 0; i < ast.chi.length; i++) {
-            // @ts-ignore
             const node = ast.chi[i];
             if (node.typ == exports.EnumToken.RuleNodeType) {
                 // @ts-ignore
                 result.chi.push(...expandRule(node));
-                // i += expanded.length - 1;
             }
             else if (node.typ == exports.EnumToken.AtRuleNodeType && 'chi' in node) {
                 let hasRule = false;
@@ -22479,6 +23187,10 @@
                 // @ts-ignore
                 result.chi.push({ ...(hasRule ? expand(node) : node) });
             }
+            else {
+                // @ts-ignore
+                result.chi.push(node);
+            }
         }
         return result;
     }
@@ -22661,25 +23373,21 @@
                 return 1;
             }
             return b == '&' ? -1 : 0;
-        }).reduce((acc, curr) => {
-            // if (acc.length > 0 && curr == '&' && (replace.charAt(0) != '.' || replace.includes(' '))) {
-            //
-            //     return acc + ':is(' + replace + ')';
-            // }
-            return acc + (curr == '&' ? replace : curr);
-        }, '');
+        }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
     }
 
     const matchUrl = /^(https?:)?\/\//;
     /**
      * return the directory name of a path
      * @param path
-     * @internal
+     *
+     * @private
      */
     function dirname(path) {
-        if (path == '/' || path === '') {
-            return path;
-        }
+        // if (path == '/' || path === '') {
+        //
+        //     return path;
+        // }
         let i = 0;
         let parts = [''];
         for (; i < path.length; i++) {
@@ -22687,9 +23395,10 @@
             if (chr == '/') {
                 parts.push('');
             }
-            else if (chr == '?' || chr == '#') {
-                break;
-            }
+            // else if (chr == '?' || chr == '#') {
+            //
+            //     break;
+            // }
             else {
                 parts[parts.length - 1] += chr;
             }
@@ -22744,6 +23453,8 @@
                 relative: url
             };
         }
+        cwd ??= '';
+        currentDirectory ??= '';
         if (matchUrl.test(currentDirectory)) {
             const path = new URL(url, currentDirectory).href;
             return {
@@ -22776,17 +23487,14 @@
     }
 
     /**
-     * web module entry point
-     * @module web
-     */
-    /**
-     * load file or url as stream
+     * default file or url loader
      * @param url
      * @param currentFile
      *
+     * @param asStream
      * @private
      */
-    async function getStream(url, currentFile = '.') {
+    async function load(url, currentFile = '.', asStream = false) {
         let t;
         if (matchUrl.test(url)) {
             t = new URL(url);
@@ -22796,25 +23504,45 @@
         }
         else {
             const path = resolve(url, currentFile).absolute;
-            // @ts-ignore
             t = new URL(path, self.origin);
         }
-        // @ts-ignore
-        return fetch(t, t.origin != self.origin ? { mode: 'cors' } : {}).then((response) => {
+        return fetch(t, t.origin != self.origin ? { mode: 'cors' } : {}).then(async (response) => {
             if (!response.ok) {
                 throw new Error(`${response.status} ${response.statusText} ${response.url}`);
             }
-            return response.body;
+            return asStream ? response.body : await response.text();
         });
     }
     /**
-     * render ast node
+     * render the ast tree
      * @param data
      * @param options
+     *
+     * Example:
+     *
+     * ```ts
+     *
+     *  import {render, ColorType} from '@tbela99/css-parser';
+     *
+     *  const css = 'body { color: color(from hsl(0 100% 50%) xyz x y z); }';
+     *  const parseResult = await parse(css);
+     *
+     * let renderResult = render(parseResult.ast);
+     * console.log(result.code);
+     *
+     * // body{color:red}
+     *
+     *
+     * renderResult = render(parseResult.ast, {beautify: true, convertColor: ColorType.SRGB});
+     * console.log(renderResult.code);
+     *
+     * // body {
+     * //  color: color(srgb 1 0 0)
+     * // }
+     * ```
      */
     function render(data, options = {}) {
         return doRender(data, Object.assign(options, {
-            getStream,
             resolve,
             dirname,
             cwd: options.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
@@ -22824,32 +23552,74 @@
      * parse css file
      * @param file url or path
      * @param options
+     * @param asStream load file as stream
+     *
+     * @throws Error file not found
+     *
+     * Example:
+     *
+     * ```ts
+     *
+     *  import {parseFile} from '@tbela99/css-parser/web';
+     *
+     *  // remote file
+     * let result = await parseFile('https://docs.deno.com/styles.css');
+     * console.log(result.ast);
+     *
+     * // local file
+     * result = await parseFile('./css/styles.css');
+     * console.log(result.ast);
+     * ```
      */
-    async function parseFile(file, options = {}) {
-        return getStream(file).then(stream => parse(stream, { src: file, ...options }));
+    async function parseFile(file, options = {}, asStream = false) {
+        return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => parse(stream, { src: file, ...options }));
     }
     /**
      * parse css
      * @param stream
-     * @param opt
+     * @param options
+     *
+     * Example:
+     *
+     * ```ts
+     *
+     * import {parse} from '@tbela99/css-parser/web';
+     *
+     *  // css string
+     *  const result = await parse(css);
+     *  console.log(result.ast);
+     * ```
+     *
+     * Example using fetch and readable stream
+     *
+     * ```ts
+     *
+     *  import {parse} from '@tbela99/css-parser/web';
+     *
+     *  const response = await fetch('https://docs.deno.com/styles.css');
+     *  const result = await parse(response.body, {beautify: true});
+     *
+     *  console.log(result.ast);
+     * ```
      */
-    async function parse(stream, opt = {}) {
+    async function parse(stream, options = {}) {
         return doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize$1({
             stream,
             buffer: '',
             position: { ind: 0, lin: 1, col: 1 },
             currentPosition: { ind: -1, lin: 1, col: 0 }
-        }), Object.assign(opt, {
-            getStream,
+        }), Object.assign(options, {
+            load,
             resolve,
             dirname,
-            cwd: opt.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
+            cwd: options.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
         }));
     }
     /**
      * transform css file
      * @param file url or path
      * @param options
+     * @param asStream load file as stream
      *
      * Example:
      *
@@ -22866,8 +23636,8 @@
      * console.log(result.code);
      * ```
      */
-    async function transformFile(file, options = {}) {
-        return getStream(file).then(stream => transform(stream, { src: file, ...options }));
+    async function transformFile(file, options = {}, asStream = false) {
+        return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => transform(stream, { src: file, ...options }));
     }
     /**
      * transform css
@@ -22895,7 +23665,8 @@
         options = { minify: true, removeEmpty: true, removeCharset: true, ...options };
         const startTime = performance.now();
         return parse(css, options).then((parseResult) => {
-            const rendered = render(parseResult.ast, options);
+            // ast already expanded by parse
+            const rendered = render(parseResult.ast, { ...options, expandNestingRules: false });
             return {
                 ...parseResult,
                 ...rendered,
@@ -22914,8 +23685,8 @@
     exports.convertColor = convertColor;
     exports.dirname = dirname;
     exports.expand = expand;
-    exports.getStream = getStream;
     exports.isOkLabClose = isOkLabClose;
+    exports.load = load;
     exports.minify = minify;
     exports.okLabDistance = okLabDistance;
     exports.parse = parse;