@tbela99/css-parser 0.7.1 → 0.9.0

package/dist/lib/ast/features/calc.js

@@ -1,6 +1,8 @@
 import { EnumToken } from '../types.js';
-import { walkValues } from '../walk.js';
+import { walkValues, WalkerValueEvent } from '../walk.js';
 import { evaluate } from '../math/expression.js';
+import { renderToken } from '../../renderer/render.js';
+import { mathFuncs } from '../../syntax/syntax.js';
 
 class ComputeCalcExpressionFeature {
     static get ordering() {
@@ -27,30 +29,92 @@ class ComputeCalcExpressionFeature {
                 continue;
             }
             const set = new Set;
-            for (const { value, parent } of walkValues(node.val)) {
-                if (value != null && value.typ == EnumToken.FunctionTokenType && value.val == 'calc') {
-                    if (!set.has(parent)) {
+            for (const { value, parent } of walkValues(node.val, node, {
+                event: WalkerValueEvent.Enter,
+                fn(node, parent, event) {
+                    if (parent != null &&
+                        parent.typ == EnumToken.DeclarationNodeType &&
+                        parent.val.length == 1 &&
+                        node.typ == EnumToken.FunctionTokenType &&
+                        mathFuncs.includes(node.val) &&
+                        node.chi.length == 1 &&
+                        node.chi[0].typ == EnumToken.IdenTokenType) {
+                        return 'ignore';
+                    }
+                    if ((node.typ == EnumToken.FunctionTokenType && node.val == 'var') || (!mathFuncs.includes(parent.val) && [EnumToken.ColorTokenType, EnumToken.DeclarationNodeType, EnumToken.RuleNodeType, EnumToken.AtRuleNodeType, EnumToken.StyleSheetNodeType].includes(parent?.typ))) {
+                        return null;
+                    }
+                    // @ts-ignore
+                    const slice = (node.typ == EnumToken.FunctionTokenType ? node.chi : (node.typ == EnumToken.DeclarationNodeType ? node.val : node.chi))?.slice();
+                    if (slice != null && node.typ == EnumToken.FunctionTokenType && mathFuncs.includes(node.val)) {
+                        // @ts-ignore
+                        const cp = (node.typ == EnumToken.FunctionTokenType && mathFuncs.includes(node.val) && node.val != 'calc' ? [node] : (node.typ == EnumToken.DeclarationNodeType ? node.val : node.chi)).slice();
+                        const values = evaluate(cp);
+                        const key = 'chi' in node ? 'chi' : 'val';
+                        const str1 = renderToken({ ...node, [key]: slice });
+                        const str2 = renderToken(node); // values.reduce((acc: string, curr: Token): string => acc + renderToken(curr), '');
+                        if (str1.length <= str2.length) {
+                            // @ts-ignore
+                            node[key] = slice;
+                        }
+                        else {
+                            // @ts-ignore
+                            node[key] = values;
+                        }
+                        return 'ignore';
+                    }
+                    return null;
+                }
+            })) {
+                if (value != null && value.typ == EnumToken.FunctionTokenType && mathFuncs.includes(value.val)) {
+                    if (!set.has(value)) {
                         set.add(value);
-                        value.chi = evaluate(value.chi);
-                        if (value.chi.length == 1 && value.chi[0].typ != EnumToken.BinaryExpressionTokenType) {
-                            if (parent != null) {
+                        if (parent != null) {
+                            // @ts-ignore
+                            const cp = value.typ == EnumToken.FunctionTokenType && mathFuncs.includes(value.val) && value.val != 'calc' ? [value] : (value.typ == EnumToken.DeclarationNodeType ? value.val : value.chi);
+                            const values = evaluate(cp);
+                            // @ts-ignore
+                            const children = parent.typ == EnumToken.DeclarationNodeType ? parent.val : parent.chi;
+                            if (values.length == 1 && values[0].typ != EnumToken.BinaryExpressionTokenType) {
                                 if (parent.typ == EnumToken.BinaryExpressionTokenType) {
                                     if (parent.l == value) {
-                                        parent.l = value.chi[0];
+                                        parent.l = values[0];
                                     }
                                     else {
-                                        parent.r = value.chi[0];
+                                        parent.r = values[0];
                                     }
                                 }
                                 else {
-                                    for (let i = 0; i < parent.chi.length; i++) {
-                                        if (parent.chi[i] == value) {
-                                            parent.chi.splice(i, 1, value.chi[0]);
+                                    for (let i = 0; i < children.length; i++) {
+                                        if (children[i] == value) {
+                                            // @ts-ignore
+                                            children.splice(i, 1, !(parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') && typeof values[0].val != 'string' ? {
+                                                typ: EnumToken.FunctionTokenType,
+                                                val: 'calc',
+                                                chi: values
+                                            } : values[0]);
                                             break;
                                         }
                                     }
                                 }
                             }
+                            else {
+                                for (let i = 0; i < children.length; i++) {
+                                    if (children[i] == value) {
+                                        if (parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') {
+                                            children.splice(i, 1, ...values);
+                                        }
+                                        else {
+                                            children.splice(i, 1, {
+                                                typ: EnumToken.FunctionTokenType,
+                                                val: 'calc',
+                                                chi: values
+                                            });
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
                         }
                     }
                 }

package/dist/lib/ast/features/inlinecssvariables.js

@@ -1,5 +1,6 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
+import { renderToken } from '../../renderer/render.js';
 
 function replace(node, variableScope) {
     for (const { value, parent: parentValue } of walkValues(node.val)) {
@@ -108,7 +109,11 @@ class InlineCssVariablesFeature {
                     i = parent.chi?.length ?? 0;
                     while (i--) {
                         if (parent.chi[i].typ == EnumToken.DeclarationNodeType && parent.chi[i].nam == info.node.nam) {
-                            parent.chi.splice(i, 1);
+                            // @ts-ignore
+                            parent.chi.splice(i++, 1, {
+                                typ: EnumToken.CommentTokenType,
+                                val: `/* ${info.node.nam}: ${info.node.val.reduce((acc, curr) => acc + renderToken(curr), '')} */`
+                            });
                         }
                     }
                     if (parent.chi?.length == 0 && 'parent' in parent) {

package/dist/lib/ast/features/prefix.js

@@ -1,10 +1,16 @@
 import { EnumToken } from '../types.js';
-import { getConfig } from '../../validation/config.js';
-import { walkValues } from '../walk.js';
+import { getSyntaxConfig } from '../../validation/config.js';
 import { ValidationTokenEnum } from '../../validation/parser/types.js';
 import '../../validation/parser/parse.js';
+import '../minify.js';
+import { walkValues } from '../walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+import '../../validation/syntaxes/complex-selector.js';
 
-const config = getConfig();
+const config = getSyntaxConfig();
 class ComputePrefixFeature {
     static get ordering() {
         return 2;
@@ -30,7 +36,7 @@ class ComputePrefixFeature {
             const node = ast.chi[k];
             if (node.typ == EnumToken.DeclarationNodeType) {
                 if (node.nam.charAt(0) == '-') {
-                    const match = node.nam.match(/^-(.*?)-(.*)$/);
+                    const match = node.nam.match(/^-([^-]+)-(.+)$/);
                     if (match != null) {
                         const nam = match[2];
                         if (nam.toLowerCase() in config.declarations) {
@@ -67,7 +73,6 @@ function matchToken(token, matches) {
             case ValidationTokenEnum.Comma:
                 break;
             case ValidationTokenEnum.Keyword:
-                console.error(matches[i], token);
                 if (token.typ == EnumToken.IdenTokenType && token.val == matches[i].val) {
                     return token;
                 }
@@ -90,6 +95,13 @@ function matchToken(token, matches) {
                 }
                 break;
             case ValidationTokenEnum.PipeToken:
+                for (let j = 0; j < matches[i].chi.length; j++) {
+                    result = matchToken(token, matches[i].chi[j]);
+                    if (result != null) {
+                        return result;
+                    }
+                }
+                break;
             case ValidationTokenEnum.ColumnToken:
             case ValidationTokenEnum.AmpersandToken:
                 result = matchToken(token, matches[i].l);
@@ -106,10 +118,6 @@ function matchToken(token, matches) {
                     return result;
                 }
                 break;
-            // default:
-            //
-            //     console.error(token, matches[i]);
-            //     throw new Error('bar bar');
         }
     }
     return null;

package/dist/lib/ast/features/shorthand.js

@@ -1,6 +1,7 @@
 import { PropertyList } from '../../parser/declaration/list.js';
 import { EnumToken } from '../types.js';
 import '../minify.js';
+import '../walk.js';
 import '../../parser/parse.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';

package/dist/lib/ast/math/expression.js

@@ -1,6 +1,7 @@
 import { EnumToken } from '../types.js';
-import { compute } from './math.js';
+import { rem, compute } from './math.js';
 import { reduceNumber } from '../../renderer/render.js';
+import { mathFuncs } from '../../syntax/syntax.js';
 
 /**
  * evaluate an array of tokens
@@ -8,15 +9,45 @@ import { reduceNumber } from '../../renderer/render.js';
  */
 function evaluate(tokens) {
     let nodes;
+    if (tokens.length == 1 && tokens[0].typ == EnumToken.FunctionTokenType && tokens[0].val != 'calc' && mathFuncs.includes(tokens[0].val)) {
+        const chi = tokens[0].chi.reduce((acc, t) => {
+            if (acc.length == 0 || t.typ == EnumToken.CommaTokenType) {
+                acc.push([]);
+            }
+            if ([EnumToken.WhitespaceTokenType, EnumToken.CommaTokenType, EnumToken.CommaTokenType].includes(t.typ)) {
+                return acc;
+            }
+            acc.at(-1).push(t);
+            return acc;
+        }, []);
+        for (let i = 0; i < chi.length; i++) {
+            chi[i] = evaluate(chi[i]);
+        }
+        tokens[0].chi = chi.reduce((acc, t) => {
+            if (acc.length > 0) {
+                acc.push({ typ: EnumToken.CommaTokenType });
+            }
+            acc.push(...t);
+            return acc;
+        });
+        return evaluateFunc(tokens[0]);
+    }
     try {
         nodes = inlineExpression(evaluateExpression(buildExpression(tokens)));
     }
     catch (e) {
-        // console.error({tokens});
-        // console.error(e);
         return tokens;
     }
     if (nodes.length <= 1) {
+        // @ts-ignore
+        if (nodes.length == 1 && nodes[0].typ == EnumToken.IdenTokenType && typeof Math[nodes[0].val.toUpperCase()] == 'number') {
+            return [{
+                    ...nodes[0],
+                    // @ts-ignore
+                    val: '' + Math[nodes[0].val.toUpperCase()],
+                    typ: EnumToken.NumberTokenType
+                }];
+        }
         return nodes;
     }
     const map = new Map;
@@ -71,9 +102,33 @@ function doEvaluate(l, r, op) {
         l,
         r
     };
-    if (!isScalarToken(l) || !isScalarToken(r)) {
+    if (!isScalarToken(l) || !isScalarToken(r) || (l.typ == r.typ && 'unit' in l && 'unit' in r && l.unit != r.unit)) {
         return defaultReturn;
     }
+    if (l.typ == EnumToken.FunctionTokenType) {
+        const val = evaluateFunc(l);
+        if (val.length == 1) {
+            l = val[0];
+        }
+        else {
+            return defaultReturn;
+        }
+    }
+    if (r.typ == EnumToken.FunctionTokenType) {
+        const val = evaluateFunc(r);
+        if (val.length == 1) {
+            r = val[0];
+        }
+        else {
+            return defaultReturn;
+        }
+    }
+    if (l.typ == EnumToken.FunctionTokenType) {
+        const val = evaluateFunc(l);
+        if (val.length == 1) {
+            l = val[0];
+        }
+    }
     if ((op == EnumToken.Add || op == EnumToken.Sub)) {
         // @ts-ignore
         if (l.typ != r.typ) {
@@ -85,11 +140,13 @@ function doEvaluate(l, r, op) {
         ![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(r.typ)) {
         return defaultReturn;
     }
-    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : (r.typ == EnumToken.NumberTokenType ? l.typ : (l.typ == EnumToken.PercentageTokenType ? r.typ : l.typ));
-    // @ts-ignore
-    let v1 = typeof l.val == 'string' ? +l.val : l.val;
+    let typ = l.typ == EnumToken.NumberTokenType ? r.typ : (r.typ == EnumToken.NumberTokenType ? l.typ : (l.typ == EnumToken.PercentageTokenType ? r.typ : l.typ));
     // @ts-ignore
-    let v2 = typeof r.val == 'string' ? +r.val : r.val;
+    let v1 = getValue(l);
+    let v2 = getValue(r);
+    if (v1 == null || v2 == null) {
+        return defaultReturn;
+    }
     if (op == EnumToken.Mul) {
         if (l.typ != EnumToken.NumberTokenType && r.typ != EnumToken.NumberTokenType) {
             if (typeof v1 == 'number' && l.typ == EnumToken.PercentageTokenType) {
@@ -110,11 +167,238 @@ function doEvaluate(l, r, op) {
     }
     // @ts-ignore
     const val = compute(v1, v2, op);
-    return {
+    // typ = typeof val == 'number' ? EnumToken.NumberTokenType : EnumToken.FractionTokenType;
+    const token = {
         ...(l.typ == EnumToken.NumberTokenType ? r : l),
         typ,
         val: typeof val == 'number' ? reduceNumber(val) : val
     };
+    if (token.typ == EnumToken.IdenTokenType) {
+        // @ts-ignore
+        token.typ = EnumToken.NumberTokenType;
+    }
+    return token;
+}
+function getValue(t) {
+    let v1;
+    if (t.typ == EnumToken.FunctionTokenType) {
+        v1 = evaluateFunc(t);
+        if (v1.length != 1 || v1[0].typ == EnumToken.BinaryExpressionTokenType) {
+            return null;
+        }
+        t = v1[0];
+    }
+    if (t.typ == EnumToken.IdenTokenType) {
+        // @ts-ignore
+        return Math[t.val.toUpperCase()];
+    }
+    if (t.val.typ == EnumToken.FractionTokenType) {
+        // @ts-ignore
+        return t.val.l.val / t.val.r.val;
+    }
+    // @ts-ignore
+    return t.typ == EnumToken.FractionTokenType ? t.l.val / t.r.val : +t.val;
+}
+function evaluateFunc(token) {
+    const values = token.chi.slice();
+    switch (token.val) {
+        case 'abs':
+        case 'sin':
+        case 'cos':
+        case 'tan':
+        case 'asin':
+        case 'acos':
+        case 'atan':
+        case 'sign':
+        case 'sqrt':
+        case 'exp': {
+            const value = evaluate(values);
+            if (value.length != 1 || (value[0].typ != EnumToken.NumberTokenType && value[0].typ != EnumToken.FractionTokenType) || (value[0].typ == EnumToken.FractionTokenType && (+value[0].r.val == 0 || !Number.isFinite(+value[0].l.val) || !Number.isFinite(+value[0].r.val)))) {
+                return value;
+            }
+            // @ts-ignore
+            let val = value[0].typ == EnumToken.NumberTokenType ? +value[0].val : value[0].l.val / value[0].r.val;
+            return [{
+                    typ: EnumToken.NumberTokenType,
+                    val: '' + Math[token.val](val)
+                }];
+        }
+        case 'hypot': {
+            const chi = values.filter(t => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType, EnumToken.CommaTokenType].includes(t.typ));
+            let all = [];
+            let ref = chi[0];
+            let value = 0;
+            if (![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(ref.typ) && !('unit' in ref)) {
+                return [token];
+            }
+            for (let i = 0; i < chi.length; i++) {
+                // @ts-ignore
+                if (chi[i].typ != ref.typ || ('unit' in chi[i] && 'unit' in ref && chi[i].unit != ref.unit)) {
+                    return [token];
+                }
+                // @ts-ignore
+                const val = getValue(chi[i]);
+                if (val == null) {
+                    return [token];
+                }
+                all.push(val);
+                value += val * val;
+            }
+            return [
+                {
+                    ...ref,
+                    val: Math.sqrt(value).toFixed(rem(...all))
+                }
+            ];
+        }
+        case 'atan2':
+        case 'pow':
+        case 'rem':
+        case 'mod': {
+            const chi = values.filter(t => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
+            if (chi.length != 3 || chi[1].typ != EnumToken.CommaTokenType) {
+                return [token];
+            }
+            if (token.val == 'pow' && (chi[0].typ != EnumToken.NumberTokenType || chi[2].typ != EnumToken.NumberTokenType)) {
+                return [token];
+            }
+            if (['rem', 'mod'].includes(token.val) &&
+                (chi[0].typ != chi[2].typ) || ('unit' in chi[0] && 'unit' in chi[2] &&
+                chi[0].unit != chi[2].unit)) {
+                return [token];
+            }
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/mod
+            const v1 = evaluate([chi[0]]);
+            const v2 = evaluate([chi[2]]);
+            const types = [EnumToken.PercentageTokenType, EnumToken.DimensionTokenType, EnumToken.AngleTokenType, EnumToken.NumberTokenType, EnumToken.LengthTokenType, EnumToken.TimeTokenType, EnumToken.FrequencyTokenType, EnumToken.ResolutionTokenType];
+            if (v1.length != 1 || v2.length != 1 || !types.includes(v1[0].typ) || !types.includes(v2[0].typ) || v1[0].unit != v2[0].unit) {
+                return [token];
+            }
+            // @ts-ignore
+            const val1 = getValue(v1[0]);
+            // @ts-ignore
+            const val2 = getValue(v2[0]);
+            if (val1 == null || val2 == null || (v1[0].typ != v2[0].typ && val1 != 0 && val2 != 0)) {
+                return [token];
+            }
+            if (token.val == 'rem') {
+                if (val2 == 0) {
+                    return [token];
+                }
+                return [
+                    {
+                        ...v1[0],
+                        val: (val1 % val2).toFixed(rem(val1, val2))
+                    }
+                ];
+            }
+            if (token.val == 'pow') {
+                return [
+                    {
+                        ...v1[0],
+                        val: String(Math.pow(val1, val2))
+                    }
+                ];
+            }
+            if (token.val == 'atan2') {
+                return [
+                    {
+                        ...{}, ...v1[0],
+                        val: String(Math.atan2(val1, val2))
+                    }
+                ];
+            }
+            return [
+                {
+                    ...v1[0],
+                    val: String(val2 == 0 ? val1 : val1 - (Math.floor(val1 / val2) * val2))
+                }
+            ];
+        }
+        case 'clamp':
+            token.chi = values;
+            return [token];
+        case 'log':
+        case 'round':
+        case 'min':
+        case 'max':
+            {
+                const strategy = token.val == 'round' && values[0]?.typ == EnumToken.IdenTokenType ? values.shift().val : null;
+                const valuesMap = new Map;
+                for (const curr of values) {
+                    if (curr.typ == EnumToken.CommaTokenType || curr.typ == EnumToken.WhitespaceTokenType || curr.typ == EnumToken.CommentTokenType) {
+                        continue;
+                    }
+                    const result = evaluate([curr]);
+                    if (result.length != 1 || result[0].typ == EnumToken.FunctionTokenType) {
+                        return [token];
+                    }
+                    const key = result[0].typ + ('unit' in result[0] ? result[0].unit : '');
+                    if (!valuesMap.has(key)) {
+                        valuesMap.set(key, []);
+                    }
+                    valuesMap.get(key).push(result[0]);
+                }
+                if (valuesMap.size == 1) {
+                    const values = valuesMap.values().next().value;
+                    if (token.val == 'log') {
+                        if (values[0].typ != EnumToken.NumberTokenType || values.length > 2) {
+                            return [token];
+                        }
+                        const val1 = getValue(values[0]);
+                        const val2 = values.length == 2 ? getValue(values[1]) : null;
+                        if (values.length == 1) {
+                            return [
+                                {
+                                    ...values[0],
+                                    val: String(Math.log(val1))
+                                }
+                            ];
+                        }
+                        return [
+                            {
+                                ...values[0],
+                                val: String(Math.log(val1) / Math.log(val2))
+                            }
+                        ];
+                    }
+                    if (token.val == 'min' || token.val == 'max') {
+                        let val = getValue(values[0]);
+                        let val2 = val;
+                        let ret = values[0];
+                        for (const curr of values.slice(1)) {
+                            val2 = getValue(curr);
+                            if (val2 < val && token.val == 'min') {
+                                val = val2;
+                                ret = curr;
+                            }
+                            else if (val2 > val && token.val == 'max') {
+                                val = val2;
+                                ret = curr;
+                            }
+                        }
+                        return [ret];
+                    }
+                    if (token.val == 'round') {
+                        let val = getValue(values[0]);
+                        let val2 = getValue(values[1]);
+                        if (Number.isNaN(val) || Number.isNaN(val2)) {
+                            return [token];
+                        }
+                        if (strategy == null || strategy == 'down') {
+                            val = val - (val % val2);
+                        }
+                        else {
+                            val = strategy == 'to-zero' ? Math.trunc(val / val2) * val2 : (strategy == 'nearest' ? Math.round(val / val2) * val2 : Math.ceil(val / val2) * val2);
+                        }
+                        // @ts-ignore
+                        return [{ ...values[0], val: String(val) }];
+                    }
+                }
+            }
+            return [token];
+    }
+    return [token];
 }
 /**
  * convert BinaryExpression into an array
@@ -155,7 +439,11 @@ function evaluateExpression(token) {
     return doEvaluate(token.l, token.r, token.op);
 }
 function isScalarToken(token) {
-    return 'unit' in token || [EnumToken.NumberTokenType, EnumToken.FractionTokenType, EnumToken.PercentageTokenType].includes(token.typ);
+    return 'unit' in token ||
+        (token.typ == EnumToken.FunctionTokenType && mathFuncs.includes(token.val)) ||
+        // @ts-ignore
+        (token.typ == EnumToken.IdenTokenType && typeof Math[token.val.toUpperCase()] == 'number') ||
+        [EnumToken.NumberTokenType, EnumToken.FractionTokenType, EnumToken.PercentageTokenType].includes(token.typ);
 }
 /**
  *
@@ -225,4 +513,4 @@ function factor(tokens, ops) {
     return tokens;
 }
 
-export { evaluate };
+export { evaluate, evaluateFunc };

package/dist/lib/ast/math/math.js

@@ -87,9 +87,15 @@ function compute(a, b, op) {
         r: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[1]) }
     };
 }
+function rem(...a) {
+    if (a.some((i) => !Number.isInteger(i))) {
+        return a.reduce((a, b) => Math.max(a, String(b).split('.')[1]?.length ?? 0), 0);
+    }
+    return 0;
+}
 function simplify(a, b) {
     const g = gcd(a, b);
     return g > 1 ? [a / g, b / g] : [a, b];
 }
 
-export { compute, gcd, simplify };
+export { compute, gcd, rem, simplify };

package/dist/lib/ast/minify.js

@@ -2,10 +2,10 @@ import { parseString } from '../parser/parse.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { replaceCompound } from './expand.js';
-import { isWhiteSpace, isIdent, isFunction, isIdentStart } from '../syntax/syntax.js';
+import { isIdent, isFunction, isWhiteSpace, isIdentStart } from '../syntax/syntax.js';
 import '../parser/utils/config.js';
 import { eq } from '../parser/utils/eq.js';
-import { renderToken, doRender } from '../renderer/render.js';
+import { doRender, renderToken } from '../renderer/render.js';
 import * as index from './features/index.js';
 
 const combinators = ['+', '>', '~', '||', '|'];
@@ -13,6 +13,15 @@ const definedPropertySettings = { configurable: true, enumerable: false, writabl
 const notEndingWith = ['(', '['].concat(combinators);
 // @ts-ignore
 const features = Object.values(index).sort((a, b) => a.ordering - b.ordering);
+/**
+ * minify ast
+ * @param ast
+ * @param options
+ * @param recursive
+ * @param errors
+ * @param nestingContent
+ * @param context
+ */
 function minify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
     if (!('nodes' in context)) {
         context.nodes = new Set;
@@ -82,7 +91,8 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 continue;
             }
             if (node.typ == EnumToken.AtRuleNodeType) {
-                if (node.nam == 'media' && node.val == 'all') {
+                // @ts-ignore
+                if (node.nam == 'media' && ['all', '', null].includes(node.val)) {
                     // @ts-ignore
                     ast.chi?.splice(i, 1, ...node.chi);
                     i--;
@@ -397,6 +407,18 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
     }
     return ast;
 }
+function hasDeclaration(node) {
+    // @ts-ignore
+    for (let i = 0; i < node.chi?.length; i++) {
+        // @ts-ignore
+        if (node.chi[i].typ == EnumToken.CommentNodeType) {
+            continue;
+        }
+        // @ts-ignore
+        return node.chi[i].typ == EnumToken.DeclarationNodeType;
+    }
+    return true;
+}
 function reduceSelector(selector) {
     if (selector.length == 0) {
         return null;
@@ -497,18 +519,10 @@ function reduceSelector(selector) {
         reducible: selector.every((selector) => !['>', '+', '~', '&'].includes(selector[0]))
     };
 }
-function hasDeclaration(node) {
-    // @ts-ignore
-    for (let i = 0; i < node.chi?.length; i++) {
-        // @ts-ignore
-        if (node.chi[i].typ == EnumToken.CommentNodeType) {
-            continue;
-        }
-        // @ts-ignore
-        return node.chi[i].typ == EnumToken.DeclarationNodeType;
-    }
-    return true;
-}
+/**
+ * split selector string
+ * @param buffer
+ */
 function splitRule(buffer) {
     const result = [[]];
     let str = '';
@@ -995,4 +1009,4 @@ function reduceRuleSelector(node) {
     }
 }
 
-export { combinators, definedPropertySettings, hasDeclaration, minify, reduceSelector, splitRule };
+export { combinators, definedPropertySettings, minify, splitRule };