@tbela99/css-parser 0.1.0 → 0.2.0

package/dist/lib/ast/expand.js

@@ -7,12 +7,12 @@ import { walkValues } from './walk.js';
 
 function expand(ast) {
     //
-    if (![4 /* NodeType.RuleNodeType */, 2 /* NodeType.StyleSheetNodeType */, 3 /* NodeType.AtRuleNodeType */].includes(ast.typ)) {
+    if (![EnumToken.RuleNodeType, EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType].includes(ast.typ)) {
         return ast;
     }
-    if (4 /* NodeType.RuleNodeType */ == ast.typ) {
+    if (EnumToken.RuleNodeType == ast.typ) {
         return {
-            typ: 2 /* NodeType.StyleSheetNodeType */,
+            typ: EnumToken.StyleSheetNodeType,
             chi: expandRule(ast)
         };
     }
@@ -24,16 +24,16 @@ function expand(ast) {
     for (let i = 0; i < ast.chi.length; i++) {
         // @ts-ignore
         const node = ast.chi[i];
-        if (node.typ == 4 /* NodeType.RuleNodeType */) {
+        if (node.typ == EnumToken.RuleNodeType) {
             // @ts-ignore
             result.chi.push(...expandRule(node));
             // i += expanded.length - 1;
         }
-        else if (node.typ == 3 /* NodeType.AtRuleNodeType */ && 'chi' in node) {
+        else if (node.typ == EnumToken.AtRuleNodeType && 'chi' in node) {
             let hasRule = false;
             let j = node.chi.length;
             while (j--) {
-                if (node.chi[j].typ == 4 /* NodeType.RuleNodeType */ || node.chi[j].typ == 3 /* NodeType.AtRuleNodeType */) {
+                if (node.chi[j].typ == EnumToken.RuleNodeType || node.chi[j].typ == EnumToken.AtRuleNodeType) {
                     hasRule = true;
                     break;
                 }
@@ -51,10 +51,10 @@ function expand(ast) {
 function expandRule(node) {
     const ast = { ...node, chi: node.chi.slice() };
     const result = [];
-    if (ast.typ == 4 /* NodeType.RuleNodeType */) {
+    if (ast.typ == EnumToken.RuleNodeType) {
         let i = 0;
         for (; i < ast.chi.length; i++) {
-            if (ast.chi[i].typ == 4 /* NodeType.RuleNodeType */) {
+            if (ast.chi[i].typ == EnumToken.RuleNodeType) {
                 const rule = ast.chi[i];
                 if (!rule.sel.includes('&')) {
                     const selRule = splitRule(rule.sel);
@@ -70,7 +70,7 @@ function expandRule(node) {
                 ast.chi.splice(i--, 1);
                 result.push(...expandRule(rule));
             }
-            else if (ast.chi[i].typ == 3 /* NodeType.AtRuleNodeType */) {
+            else if (ast.chi[i].typ == EnumToken.AtRuleNodeType) {
                 let astAtRule = ast.chi[i];
                 const values = [];
                 if (astAtRule.nam == 'scope') {
@@ -85,7 +85,7 @@ function expandRule(node) {
                     // @ts-ignore
                     astAtRule.chi.length = 0;
                     for (const r of expandRule(clone)) {
-                        if (r.typ == 3 /* NodeType.AtRuleNodeType */ && 'chi' in r) {
+                        if (r.typ == EnumToken.AtRuleNodeType && 'chi' in r) {
                             if (astAtRule.val !== '' && r.val !== '') {
                                 if (astAtRule.nam == 'media' && r.nam == 'media') {
                                     r.val = astAtRule.val + ' and ' + r.val;
@@ -97,7 +97,7 @@ function expandRule(node) {
                             // @ts-ignore
                             values.push(r);
                         }
-                        else if (r.typ == 4 /* NodeType.RuleNodeType */) {
+                        else if (r.typ == EnumToken.RuleNodeType) {
                             // @ts-ignore
                             astAtRule.chi.push(...expandRule(r));
                         }

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

@@ -1,7 +1,9 @@
 import { EnumToken } from '../types.js';
-import { reduceNumber, renderToken } from '../../renderer/render.js';
+import { reduceNumber } from '../../renderer/render.js';
 import { walkValues } from '../walk.js';
-import { MinifyFeature } from '../utiles/minifyfeature.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
+import { compute } from './utils/math.js';
+import { IterableWeakSet } from '../../iterable/set.js';
 
 class ComputeCalcExpression extends MinifyFeature {
     static get ordering() {
@@ -24,10 +26,10 @@ class ComputeCalcExpression extends MinifyFeature {
         }
         // @ts-ignore
         for (const node of ast.chi) {
-            if (node.typ != 5 /* NodeType.DeclarationNodeType */) {
+            if (node.typ != EnumToken.DeclarationNodeType) {
                 continue;
             }
-            const set = new Set;
+            const set = new IterableWeakSet;
             for (const { parent } of walkValues(node.val)) {
                 if (parent != null && parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') {
                     if (!set.has(parent)) {
@@ -58,39 +60,14 @@ function doEvaluate(l, r, op) {
     }
     if ((op == EnumToken.Add || op == EnumToken.Sub)) {
         // @ts-ignore
-        if (l.typ != r.typ || Number.isNaN(+l.val) || Number.isNaN(r.val)) {
+        if (l.typ != r.typ) {
             return defaultReturn;
         }
-        // @ts-ignore
-        return { ...l, val: reduceNumber(+l.val + (op == EnumToken.Add ? +r.val : -1 * r.val)) };
-    }
-    else {
-        // @ts-ignore
-        let val;
-        if (op == EnumToken.Div) {
-            if (r.typ != EnumToken.NumberTokenType || r.val == '0') {
-                return defaultReturn;
-            }
-            // @ts-ignore
-            val = reduceNumber(l.val / r.val);
-        }
-        else {
-            // @ts-ignore
-            val = reduceNumber(r.val * l.val);
-        }
-        let result;
-        if (r.typ == EnumToken.NumberTokenType || op == EnumToken.Div) {
-            result = { ...l, val };
-        }
-        else {
-            // @ts-ignore
-            result = { ...r, val };
-        }
-        if (renderToken(result).length <= renderToken(defaultReturn).length) {
-            return result;
-        }
     }
-    return defaultReturn;
+    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : l.typ;
+    // @ts-ignore
+    const val = compute(typeof l.val == 'string' ? +l.val : l.val, typeof r.val == 'string' ? +r.val : r.val, op);
+    return { ...(l.typ == EnumToken.NumberTokenType ? r : l), typ, val: typeof val == 'number' ? reduceNumber(val) : val };
 }
 /**
  * evaluate an array of tokens
@@ -146,7 +123,10 @@ function evaluate(tokens) {
  */
 function inlineExpression(token) {
     const result = [];
-    if (token.typ == EnumToken.BinaryExpressionTokenType) {
+    if (token.typ == EnumToken.ParensTokenType && token.chi.length == 1) {
+        result.push(token.chi[0]);
+    }
+    else if (token.typ == EnumToken.BinaryExpressionTokenType) {
         if ([EnumToken.Mul, EnumToken.Div].includes(token.op)) {
             result.push(token);
         }
@@ -173,18 +153,7 @@ function evaluateExpression(token) {
     if (token.l.typ == EnumToken.BinaryExpressionTokenType) {
         token.l = evaluateExpression(token.l);
     }
-    const result = doEvaluate(token.l, token.r, token.op);
-    if (result.typ == EnumToken.BinaryExpressionTokenType &&
-        [EnumToken.Mul, EnumToken.Div].includes(result.op)) {
-        // wrap expression
-        if (result.l.typ == EnumToken.BinaryExpressionTokenType && [EnumToken.Sub, EnumToken.Add].includes(result.l.op)) {
-            result.l = { typ: EnumToken.ParensTokenType, chi: [result.l] };
-        }
-        else if (result.r.typ == EnumToken.BinaryExpressionTokenType && [EnumToken.Sub, EnumToken.Add].includes(result.r.op)) {
-            result.r = { typ: EnumToken.ParensTokenType, chi: [result.r] };
-        }
-    }
-    return result;
+    return doEvaluate(token.l, token.r, token.op);
 }
 function isScalarToken(token) {
     return token.typ != EnumToken.BinaryExpressionTokenType && token.typ != EnumToken.ParensTokenType && token.typ != EnumToken.FunctionTokenType;
@@ -232,7 +201,7 @@ function factorToken(token) {
  */
 function factor(tokens, ops) {
     let isOp;
-    const opList = [EnumToken.Add, EnumToken.Sub, EnumToken.Div, EnumToken.Mul];
+    const opList = ops.map(x => getArithmeticOperation(x));
     if (tokens.length == 1) {
         return [factorToken(tokens[0])];
     }

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

@@ -1,7 +1,31 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
-import { MinifyFeature } from '../utiles/minifyfeature.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
+import { IterableWeakSet } from '../../iterable/set.js';
 
+function replace(node, variableScope) {
+    for (const { value, parent: parentValue } of walkValues(node.val)) {
+        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+            if (value.chi.length == 1 && value.chi[0].typ == EnumToken.DashedIdenTokenType) {
+                const info = variableScope.get(value.chi[0].val);
+                if (info?.replaceable) {
+                    if (parentValue != null) {
+                        let i = 0;
+                        for (; i < parentValue.chi.length; i++) {
+                            if (parentValue.chi[i] == value) {
+                                parentValue.chi.splice(i, 1, ...info.node.val);
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        node.val = info.node.val.slice();
+                    }
+                }
+            }
+        }
+    }
+}
 class InlineCssVariables extends MinifyFeature {
     static get ordering() {
         return 0;
@@ -21,14 +45,14 @@ class InlineCssVariables extends MinifyFeature {
         if (!('variableScope' in context)) {
             context.variableScope = new Map;
         }
-        const isRoot = parent.typ == 2 /* NodeType.StyleSheetNodeType */ && ast.typ == 4 /* NodeType.RuleNodeType */ && ast.sel == ':root';
+        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && ast.sel == ':root';
         const variableScope = context.variableScope;
         // @ts-ignore
         for (const node of ast.chi) {
-            if (node.typ == 1 /* NodeType.CDOCOMMNodeType */ || node.typ == 0 /* NodeType.CommentNodeType */) {
+            if (node.typ == EnumToken.CDOCOMMNodeType || node.typ == EnumToken.CommentNodeType) {
                 continue;
             }
-            if (node.typ != 5 /* NodeType.DeclarationNodeType */) {
+            if (node.typ != EnumToken.DeclarationNodeType) {
                 break;
             }
             // css variable
@@ -37,13 +61,23 @@ class InlineCssVariables extends MinifyFeature {
                     const info = {
                         globalScope: isRoot,
                         // @ts-ignore
-                        parent: new Set(),
+                        parent: new IterableWeakSet(),
                         declarationCount: 1,
                         replaceable: isRoot,
                         node: node
                     };
                     info.parent.add(ast);
                     variableScope.set(node.nam, info);
+                    let recursive = false;
+                    for (const { value, parent: parentValue } of walkValues(node.val)) {
+                        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+                            recursive = true;
+                            break;
+                        }
+                    }
+                    if (recursive) {
+                        replace(node, variableScope);
+                    }
                 }
                 else {
                     const info = variableScope.get(node.nam);
@@ -59,27 +93,7 @@ class InlineCssVariables extends MinifyFeature {
                 }
             }
             else {
-                for (const { value, parent: parentValue } of walkValues(node.val)) {
-                    if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
-                        if (value.chi.length == 1 && value.chi[0].typ == EnumToken.IdenTokenType) {
-                            const info = variableScope.get(value.chi[0].val);
-                            if (info?.replaceable) {
-                                if (parentValue != null) {
-                                    let i = 0;
-                                    for (; i < parentValue.chi.length; i++) {
-                                        if (parentValue.chi[i] == value) {
-                                            parentValue.chi.splice(i, 1, ...info.node.val);
-                                            break;
-                                        }
-                                    }
-                                }
-                                else {
-                                    node.val = info.node.val.slice();
-                                }
-                            }
-                        }
-                    }
-                }
+                replace(node, variableScope);
             }
         }
     }
@@ -88,10 +102,11 @@ class InlineCssVariables extends MinifyFeature {
         for (const info of variableScope.values()) {
             if (info.replaceable) {
                 let i;
+                // drop declarations from :root{}
                 for (const parent of info.parent) {
                     i = parent.chi?.length ?? 0;
                     while (i--) {
-                        if (parent.chi[i].typ == 5 /* NodeType.DeclarationNodeType */ && parent.chi[i].nam == info.node.nam) {
+                        if (parent.chi[i].typ == EnumToken.DeclarationNodeType && parent.chi[i].nam == info.node.nam) {
                             parent.chi.splice(i, 1);
                         }
                     }

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

@@ -1,10 +1,11 @@
 import { PropertyList } from '../../parser/declaration/list.js';
 import '../../renderer/utils/color.js';
-import '../types.js';
+import { EnumToken } from '../types.js';
 import '../minify.js';
 import '../../parser/parse.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import { MinifyFeature } from '../utiles/minifyfeature.js';
+import '../../parser/declaration/map.js';
+import { MinifyFeature } from '../utils/minifyfeature.js';
 
 class ComputeShorthand extends MinifyFeature {
     static get ordering() {
@@ -30,7 +31,7 @@ class ComputeShorthand extends MinifyFeature {
         for (; k < j; k++) {
             // @ts-ignore
             const node = ast.chi[k];
-            if (node.typ == 0 /* NodeType.CommentNodeType */ || node.typ == 5 /* NodeType.DeclarationNodeType */) {
+            if (node.typ == EnumToken.CommentNodeType || node.typ == EnumToken.DeclarationNodeType) {
                 properties.add(node);
                 continue;
             }

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

@@ -0,0 +1,95 @@
+import { EnumToken } from '../../types.js';
+import { reduceNumber } from '../../../renderer/render.js';
+
+const gcd = (x, y) => {
+    x = Math.abs(x);
+    y = Math.abs(y);
+    let t;
+    if (x == 0 || y == 0) {
+        return 1;
+    }
+    while (y) {
+        t = y;
+        y = x % y;
+        x = t;
+    }
+    return x;
+};
+function compute(a, b, op) {
+    if (typeof a == 'number' && typeof b == 'number') {
+        switch (op) {
+            case EnumToken.Add:
+                return a + b;
+            case EnumToken.Sub:
+                return a - b;
+            case EnumToken.Mul:
+                return a * b;
+            case EnumToken.Div:
+                const r = simplify(a, b);
+                if (r[1] == 1) {
+                    return r[0];
+                }
+                const result = a / b;
+                const r2 = reduceNumber(r[0]) + '/' + reduceNumber(r[1]);
+                return reduceNumber(result).length <= r2.length ? result : {
+                    typ: EnumToken.FractionTokenType,
+                    l: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[0]) },
+                    r: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[1]) }
+                };
+        }
+    }
+    let l1 = typeof a == 'number' ? {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a) },
+        r: { typ: EnumToken.NumberTokenType, val: '1' }
+    } : a;
+    let r1 = typeof b == 'number' ? {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(b) },
+        r: { typ: EnumToken.NumberTokenType, val: '1' }
+    } : b;
+    let l2;
+    let r2;
+    switch (op) {
+        case EnumToken.Add:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val + l1.r.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Sub:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val - l1.r.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Mul:
+            // @ts-ignore
+            l2 = l1.l.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Div:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.l.val;
+            break;
+    }
+    const a2 = simplify(l2, r2);
+    if (a2[1] == 1) {
+        return a2[0];
+    }
+    const result = a2[0] / a2[1];
+    return reduceNumber(result).length <= reduceNumber(a2[0]).length + 1 + reduceNumber(a2[1]).length ? result : {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[0]) },
+        r: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[1]) }
+    };
+}
+function simplify(a, b) {
+    const g = gcd(a, b);
+    return g > 1 ? [a / g, b / g] : [a, b];
+}
+
+export { compute, gcd, simplify };

package/dist/lib/ast/minify.js

@@ -1,5 +1,5 @@
 import { parseString } from '../parser/parse.js';
-import { isIdentStart, isWhiteSpace, isIdent, isFunction } from '../parser/utils/syntax.js';
+import { isWhiteSpace, isIdent, isFunction, isIdentStart } from '../parser/utils/syntax.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { replaceCompound } from './expand.js';
@@ -7,7 +7,7 @@ import { eq } from '../parser/utils/eq.js';
 import { renderToken, doRender } from '../renderer/render.js';
 import * as index from './features/index.js';
 
-const combinators = ['+', '>', '~'];
+const combinators = ['+', '>', '~', '||'];
 const notEndingWith = ['(', '['].concat(combinators);
 const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
 // @ts-ignore
@@ -23,7 +23,12 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
     context.nodes.add(ast);
     if (!('features' in options)) {
         // @ts-ignore
-        options = { removeDuplicateDeclarations: true, computeShorthand: true, computeCalcExpression: true, features: [], ...options };
+        options = {
+            removeDuplicateDeclarations: true,
+            computeShorthand: true,
+            computeCalcExpression: true,
+            features: [], ...options
+        };
         // @ts-ignore
         for (const feature of features) {
             feature.register(options);
@@ -42,7 +47,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 curr.splice(0, 1);
             }
         }
-        else if (ast.typ == 4 /* NodeType.RuleNodeType */ && (isIdent(curr[0]) || isFunction(curr[0]))) {
+        else if (ast.typ == EnumToken.RuleNodeType && (isIdent(curr[0]) || isFunction(curr[0]))) {
             curr.unshift('&', ' ');
         }
         acc.push(curr.join(''));
@@ -51,7 +56,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
     // @ts-ignore
     if ('chi' in ast && ast.chi.length > 0) {
         if (!nestingContent) {
-            nestingContent = options.nestingRules && ast.typ == 4 /* NodeType.RuleNodeType */;
+            nestingContent = options.nestingRules && ast.typ == EnumToken.RuleNodeType;
         }
         let i = 0;
         let previous;
@@ -60,7 +65,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         // @ts-ignore
         for (; i < ast.chi.length; i++) {
             // @ts-ignore
-            if (ast.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
+            if (ast.chi[i].typ == EnumToken.CommentNodeType) {
                 continue;
             }
             // @ts-ignore
@@ -72,10 +77,10 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 i--;
                 continue;
             }
-            if (node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam == 'font-face') {
+            if (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face') {
                 continue;
             }
-            if (node.typ == 3 /* NodeType.AtRuleNodeType */) {
+            if (node.typ == EnumToken.AtRuleNodeType) {
                 if (node.nam == 'media' && node.val == 'all') {
                     // @ts-ignore
                     ast.chi?.splice(i, 1, ...node.chi);
@@ -83,7 +88,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                     continue;
                 }
                 // @ts-ignore
-                if (previous?.typ == 3 /* NodeType.AtRuleNodeType */ &&
+                if (previous?.typ == EnumToken.AtRuleNodeType &&
                     previous.nam == node.nam &&
                     previous.val == node.val) {
                     if ('chi' in node) {
@@ -102,14 +107,14 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 continue;
             }
             // @ts-ignore
-            if (node.typ == 4 /* NodeType.RuleNodeType */) {
+            if (node.typ == EnumToken.RuleNodeType) {
                 reduceRuleSelector(node);
                 let wrapper;
                 let match;
                 // @ts-ignore
                 if (options.nestingRules) {
                     // @ts-ignore
-                    if (previous?.typ == 4 /* NodeType.RuleNodeType */) {
+                    if (previous?.typ == EnumToken.RuleNodeType) {
                         // @ts-ignore
                         reduceRuleSelector(previous);
                         // @ts-ignore
@@ -130,7 +135,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                             // @ts-ignore
                             const nextNode = ast.chi[i];
                             // @ts-ignore
-                            if (nextNode.typ != 4 /* NodeType.RuleNodeType */) {
+                            if (nextNode.typ != EnumToken.RuleNodeType) {
                                 break;
                             }
                             reduceRuleSelector(nextNode);
@@ -184,7 +189,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                 curr.splice(0, 2);
                             }
                             else {
-                                if (ast.typ != 4 /* NodeType.RuleNodeType */ && combinators.includes(curr[1])) {
+                                if (ast.typ != EnumToken.RuleNodeType && combinators.includes(curr[1])) {
                                     wrap = false;
                                 }
                                 else {
@@ -232,18 +237,18 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                         let k = previous.chi.length;
                         while (k-- > 0) {
                             // @ts-ignore
-                            if (previous.chi[k].typ == 0 /* NodeType.CommentNodeType */) {
+                            if (previous.chi[k].typ == EnumToken.CommentNodeType) {
                                 continue;
                             }
                             // @ts-ignore
-                            shouldMerge = previous.chi[k].typ == 5 /* NodeType.DeclarationNodeType */;
+                            shouldMerge = previous.chi[k].typ == EnumToken.DeclarationNodeType;
                             break;
                         }
                         if (shouldMerge) {
                             // @ts-ignore
-                            if ((node.typ == 4 /* NodeType.RuleNodeType */ && node.sel == previous.sel) ||
+                            if ((node.typ == EnumToken.RuleNodeType && node.sel == previous.sel) ||
                                 // @ts-ignore
-                                (node.typ == 3 /* NodeType.AtRuleNodeType */) && node.val != 'font-face' && node.val == previous.val) {
+                                (node.typ == EnumToken.AtRuleNodeType) && node.val != 'font-face' && node.val == previous.val) {
                                 // @ts-ignore
                                 node.chi.unshift(...previous.chi);
                                 // @ts-ignore
@@ -260,7 +265,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                 nodeIndex = i;
                                 continue;
                             }
-                            else if (node.typ == 4 /* NodeType.RuleNodeType */ && previous?.typ == 4 /* NodeType.RuleNodeType */) {
+                            else if (node.typ == EnumToken.RuleNodeType && previous?.typ == EnumToken.RuleNodeType) {
                                 const intersect = diff(previous, node, reducer, options);
                                 if (intersect != null) {
                                     if (intersect.node1.chi.length == 0) {
@@ -317,7 +322,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 // @ts-ignore
                 previous != null &&
                 // previous.optimized != null &&
-                previous.typ == 4 /* NodeType.RuleNodeType */ &&
+                previous.typ == EnumToken.RuleNodeType &&
                 previous.sel.includes('&')) {
                 fixSelector(previous);
             }
@@ -327,9 +332,9 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         // @ts-ignore
         if (recursive && node != null && ('chi' in node)) {
             // @ts-ignore
-            if (!node.chi.some(n => n.typ == 5 /* NodeType.DeclarationNodeType */)) {
+            if (!node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
                 // @ts-ignore
-                if (!(node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam != 'font-face')) {
+                if (!(node.typ == EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
                     minify(node, options, recursive, errors, nestingContent, context);
                 }
             }
@@ -338,12 +343,12 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             // @ts-ignore
             node != null &&
             // previous.optimized != null &&
-            node.typ == 4 /* NodeType.RuleNodeType */ &&
+            node.typ == EnumToken.RuleNodeType &&
             node.sel.includes('&')) {
             fixSelector(node);
         }
     }
-    if (ast.typ == 2 /* NodeType.StyleSheetNodeType */) {
+    if (ast.typ == EnumToken.StyleSheetNodeType) {
         let parent;
         let parents = [ast];
         while (parents.length > 0) {
@@ -352,7 +357,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             for (let k = 0; k < parent.chi.length; k++) {
                 // @ts-ignore
                 const node = parent.chi[k];
-                if (!('chi' in node) || node.typ == 2 /* NodeType.StyleSheetNodeType */ || (node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam == 'font-face')) {
+                if (!('chi' in node) || node.typ == EnumToken.StyleSheetNodeType || (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face')) {
                     continue;
                 }
                 // @ts-ignore
@@ -463,11 +468,11 @@ function hasDeclaration(node) {
     // @ts-ignore
     for (let i = 0; i < node.chi?.length; i++) {
         // @ts-ignore
-        if (node.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
+        if (node.chi[i].typ == EnumToken.CommentNodeType) {
             continue;
         }
         // @ts-ignore
-        return node.chi[i].typ == 5 /* NodeType.DeclarationNodeType */;
+        return node.chi[i].typ == EnumToken.DeclarationNodeType;
     }
     return true;
 }
@@ -613,7 +618,7 @@ function matchSelectors(selector1, selector2, parentType, errors) {
     if (matchFunction != 0 || inAttr != 0) {
         return null;
     }
-    if (parentType != 4 /* NodeType.RuleNodeType */) {
+    if (parentType != EnumToken.RuleNodeType) {
         for (const part of match) {
             if (part.length > 0 && combinators.includes(part[0].charAt(0))) {
                 return null;
@@ -819,7 +824,7 @@ function diff(n1, n2, reducer, options = {}) {
     }
     const intersect = [];
     while (i--) {
-        if (node1.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
+        if (node1.chi[i].typ == EnumToken.CommentNodeType) {
             continue;
         }
         j = node2.chi.length;
@@ -827,7 +832,7 @@ function diff(n1, n2, reducer, options = {}) {
             break;
         }
         while (j--) {
-            if (node2.chi[j].typ == 0 /* NodeType.CommentNodeType */) {
+            if (node2.chi[j].typ == EnumToken.CommentNodeType) {
                 continue;
             }
             if (node1.chi[i].nam == node2.chi[j].nam) {