@tbela99/css-parser 1.1.1 → 1.3.0

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

@@ -2,14 +2,14 @@ import { EnumToken, SyntaxValidationResult } from '../types.js';
 import { getSyntaxConfig } from '../../validation/config.js';
 import '../../validation/parser/types.js';
 import '../../validation/parser/parse.js';
-import { splitRule, definedPropertySettings } from '../minify.js';
+import { splitRule } from '../minify.js';
 import { walkValues } from '../walk.js';
-import { parseAtRulePrelude, parseString } from '../../parser/parse.js';
+import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { pseudoAliasMap } from '../../syntax/syntax.js';
 import { renderToken } from '../../renderer/render.js';
-import { funcLike } from '../../renderer/color/utils/constants.js';
+import { funcLike } from '../../syntax/color/utils/constants.js';
 import '../../validation/syntaxes/complex-selector.js';
 import { evaluateSyntax } from '../../validation/syntax.js';
 
@@ -73,12 +73,15 @@ class ComputePrefixFeature {
     run(node) {
         if (node.typ == EnumToken.RuleNodeType) {
             node.sel = replacePseudo(splitRule(node.sel)).reduce((acc, curr, index) => acc + (index > 0 ? ',' : '') + curr.join(''), '');
-            if (node.raw != null) {
-                node.raw = replacePseudo(node.raw);
-            }
-            if (node.optimized != null) {
-                node.optimized.selector = replacePseudo(node.optimized.selector);
-            }
+            // if ((node as AstRule).raw != null) {
+            //
+            //     (node as AstRule).raw = replacePseudo((node as AstRule).raw as string[][]);
+            // }
+            //
+            // if ((node as AstRule).optimized != null) {
+            //
+            //     (node as AstRule).optimized!.selector = replacePseudo((node as AstRule).optimized!.selector as string[][]);
+            // }
             if (node.tokens != null) {
                 replaceAstNodes(node.tokens);
             }
@@ -114,10 +117,9 @@ class ComputePrefixFeature {
                 for (const { value } of walkValues(nodes)) {
                     if ((value.typ == EnumToken.IdenTokenType || funcLike.includes(value.typ))) {
                         const match = value.val.match(/^-([^-]+)-(.+)$/);
-                        if (match == null) {
-                            continue;
+                        if (match != null) {
+                            value.val = match[2];
                         }
-                        value.val = match[2];
                     }
                 }
                 if (SyntaxValidationResult.Valid == evaluateSyntax({ ...node, val: nodes }, {}).valid) {
@@ -133,13 +135,14 @@ class ComputePrefixFeature {
                 }
             }
             if (node.typ == EnumToken.AtRuleNodeType && node.val !== '') {
-                if (node.tokens == null) {
-                    Object.defineProperty(node, 'tokens', {
-                        // @ts-ignore
-                        ...definedPropertySettings,
-                        value: parseAtRulePrelude(parseString(node.val), node),
-                    });
-                }
+                // 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), '');
                 }

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

@@ -5,7 +5,7 @@ import '../walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 class ComputeShorthandFeature {

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

@@ -6,7 +6,7 @@ import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { filterValues, renderToken } from '../../renderer/render.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import { compute } from '../transform/compute.js';
 import { eqMatrix } from '../transform/minify.js';
 
@@ -40,7 +40,22 @@ class TransformCssFeature {
             if (node.typ != EnumToken.DeclarationNodeType || !node.nam.match(/^(-[a-z]+-)?transform$/)) {
                 continue;
             }
-            const children = node.val.slice();
+            const children = node.val.reduce((acc, curr) => {
+                if (curr.typ == 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;
+            }, []);
             consumeWhitespace(children);
             let { matrix, cumulative, minified } = compute(children) ?? {};
             if (matrix == null || cumulative == null || minified == null) {

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

@@ -1,13 +1,13 @@
 import { EnumToken } from '../types.js';
 import { rem, compute } from './math.js';
-import { reduceNumber } from '../../renderer/render.js';
-import '../../renderer/color/utils/constants.js';
+import { mathFuncs } from '../../syntax/syntax.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import { mathFuncs } from '../../syntax/syntax.js';
+import '../../syntax/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
 
 /**
  * evaluate an array of tokens
@@ -38,12 +38,7 @@ function evaluate(tokens) {
         });
         return evaluateFunc(tokens[0]);
     }
-    try {
-        nodes = inlineExpression(evaluateExpression(buildExpression(tokens)));
-    }
-    catch (e) {
-        return tokens;
-    }
+    nodes = inlineExpression(evaluateExpression(buildExpression(tokens)));
     if (nodes.length <= 1) {
         if (nodes.length == 1) {
             if (nodes[0].typ == EnumToken.BinaryExpressionTokenType) {
@@ -54,7 +49,7 @@ function evaluate(tokens) {
                 return [{
                         ...nodes[0],
                         // @ts-ignore
-                        val: '' + Math[nodes[0].val.toUpperCase()],
+                        val: Math[nodes[0].val.toUpperCase()],
                         typ: EnumToken.NumberTokenType
                     }];
             }
@@ -74,7 +69,7 @@ function evaluate(tokens) {
                 token = { typ: EnumToken.ListToken, chi: [nodes[i], nodes[i + 1]] };
             }
             else {
-                token = doEvaluate(nodes[i + 1], { typ: EnumToken.NumberTokenType, val: '-1' }, EnumToken.Mul);
+                token = doEvaluate(nodes[i + 1], { typ: EnumToken.NumberTokenType, val: -1 }, EnumToken.Mul);
             }
             i++;
         }
@@ -89,7 +84,7 @@ function evaluate(tokens) {
         const token = curr[1].reduce((acc, curr) => doEvaluate(acc, curr, EnumToken.Add));
         if (token.typ != EnumToken.BinaryExpressionTokenType) {
             if ('val' in token && +token.val < 0) {
-                acc.push({ typ: EnumToken.Sub }, { ...token, val: String(-token.val) });
+                acc.push({ typ: EnumToken.Sub }, { ...token, val: -token.val });
                 return acc;
             }
         }
@@ -116,29 +111,11 @@ function doEvaluate(l, r, op) {
     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
@@ -146,32 +123,25 @@ function doEvaluate(l, r, op) {
             return defaultReturn;
         }
     }
-    else if (op == EnumToken.Mul &&
-        ![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(l.typ) &&
-        ![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(r.typ)) {
-        return defaultReturn;
-    }
     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 v1 = getValue(l);
-    let v2 = getValue(r);
-    if (v1 == null || v2 == null) {
-        return defaultReturn;
-    }
+    let v1 = l.val?.typ == EnumToken.FractionTokenType ? l.val : getValue(l);
+    // @ts-ignore
+    let v2 = r.val?.typ == EnumToken.FractionTokenType ? r.val : getValue(r);
     if (op == EnumToken.Mul) {
         if (l.typ != EnumToken.NumberTokenType && r.typ != EnumToken.NumberTokenType) {
             if (typeof v1 == 'number' && l.typ == EnumToken.PercentageTokenType) {
                 v1 = {
                     typ: EnumToken.FractionTokenType,
-                    l: { typ: EnumToken.NumberTokenType, val: String(v1) },
-                    r: { typ: EnumToken.NumberTokenType, val: '100' }
+                    l: { typ: EnumToken.NumberTokenType, val: v1 },
+                    r: { typ: EnumToken.NumberTokenType, val: 100 }
                 };
             }
             else if (typeof v2 == 'number' && r.typ == EnumToken.PercentageTokenType) {
                 v2 = {
                     typ: EnumToken.FractionTokenType,
-                    l: { typ: EnumToken.NumberTokenType, val: String(v2) },
-                    r: { typ: EnumToken.NumberTokenType, val: '100' }
+                    l: { typ: EnumToken.NumberTokenType, val: v2 },
+                    r: { typ: EnumToken.NumberTokenType, val: 100 }
                 };
             }
         }
@@ -181,7 +151,7 @@ function doEvaluate(l, r, op) {
     const token = {
         ...(l.typ == EnumToken.NumberTokenType ? r : l),
         typ,
-        val: typeof val == 'number' ? reduceNumber(val) : val
+        val /* : typeof val == 'number' ? minifyNumber(val) : val */
     };
     if (token.typ == EnumToken.IdenTokenType) {
         // @ts-ignore
@@ -190,22 +160,10 @@ function doEvaluate(l, r, op) {
     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;
 }
@@ -223,14 +181,11 @@ function evaluateFunc(token) {
         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)
+                    val: Math[token.val](val)
                 }];
         }
         case 'hypot': {
@@ -238,26 +193,16 @@ function evaluateFunc(token) {
             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))
+                    val: +(Math.sqrt(value).toFixed(rem(...all)))
                 }
             ];
         }
@@ -266,39 +211,18 @@ function evaluateFunc(token) {
         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))
+                        val: +((val1 % val2).toFixed(rem(val1, val2)))
                     }
                 ];
             }
@@ -306,7 +230,7 @@ function evaluateFunc(token) {
                 return [
                     {
                         ...v1[0],
-                        val: String(Math.pow(val1, val2))
+                        val: Math.pow(val1, val2)
                     }
                 ];
             }
@@ -314,14 +238,14 @@ function evaluateFunc(token) {
                 return [
                     {
                         ...{}, ...v1[0],
-                        val: String(Math.atan2(val1, val2))
+                        val: Math.atan2(val1, val2)
                     }
                 ];
             }
             return [
                 {
                     ...v1[0],
-                    val: String(val2 == 0 ? val1 : val1 - (Math.floor(val1 / val2) * val2))
+                    val: val2 == 0 ? val1 : val1 - (Math.floor(val1 / val2) * val2)
                 }
             ];
         }
@@ -331,82 +255,63 @@ function evaluateFunc(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]);
+        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;
                 }
-                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 result = evaluate([curr]);
+                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') {
+                    const val1 = getValue(values[0]);
+                    const val2 = values.length == 2 ? getValue(values[1]) : null;
+                    return [
+                        {
+                            ...values[0],
+                            val: Math.log(val1) / Math.log(val2)
                         }
-                        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))
-                                }
-                            ];
+                    ];
+                }
+                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;
                         }
-                        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;
-                            }
+                        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 [ret];
+                }
+                if (token.val == 'round') {
+                    let val = getValue(values[0]);
+                    let val2 = getValue(values[1]);
+                    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 }];
                 }
             }
-            return [token];
+        }
     }
     return [token];
 }
@@ -416,10 +321,7 @@ function evaluateFunc(token) {
  */
 function inlineExpression(token) {
     const result = [];
-    if (token.typ == EnumToken.ParensTokenType && token.chi.length == 1) {
-        result.push(token.chi[0]);
-    }
-    else if (token.typ == EnumToken.BinaryExpressionTokenType) {
+    if (token.typ == EnumToken.BinaryExpressionTokenType) {
         if ([EnumToken.Mul, EnumToken.Div].includes(token.op)) {
             result.push(token);
         }
@@ -457,7 +359,7 @@ function isScalarToken(token) {
 }
 /**
  *
- * generate binary expression tree
+ * generate a binary expression tree
  * @param tokens
  */
 function buildExpression(tokens) {
@@ -477,7 +379,7 @@ function getArithmeticOperation(op) {
 }
 /**
  *
- * generate binary expression tree
+ * generate a binary expression tree
  * @param token
  */
 function factorToken(token) {
@@ -492,7 +394,7 @@ function factorToken(token) {
     return token;
 }
 /**
- * generate binary expression tree
+ * generate a binary expression tree
  * @param tokens
  * @param ops
  */

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

@@ -1,11 +1,12 @@
 import { EnumToken } from '../types.js';
-import { reduceNumber } from '../../renderer/render.js';
-import '../../renderer/color/utils/constants.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
+import '../../syntax/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import { minifyNumber } from '../../syntax/utils.js';
 
 function gcd(x, y) {
     x = Math.abs(x);
@@ -14,16 +15,17 @@ function gcd(x, y) {
         return x;
     }
     let t;
-    if (x == 0) {
-        return y;
-    }
-    if (y == 0) {
-        return x;
-    }
+    // if (x == 0) {
+    //
+    //     return y;
+    // }
+    //
+    // if (y == 0) {
+    //
+    //     return x;
+    // }
     if (y > x) {
-        t = x;
-        x = y;
-        y = t;
+        [x, y] = [y, x];
     }
     while (y) {
         t = y;
@@ -47,23 +49,23 @@ function compute(a, b, op) {
                     return r[0];
                 }
                 const result = a / b;
-                const r2 = reduceNumber(r[0]) + '/' + reduceNumber(r[1]);
-                return reduceNumber(result).length <= r2.length ? result : {
+                const r2 = minifyNumber(r[0]) + '/' + minifyNumber(r[1]);
+                return minifyNumber(result).length < r2.length ? result : {
                     typ: EnumToken.FractionTokenType,
-                    l: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[0]) },
-                    r: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[1]) }
+                    l: { typ: EnumToken.NumberTokenType, val: r[0] },
+                    r: { typ: EnumToken.NumberTokenType, val: r[1] }
                 };
         }
     }
     let l1 = typeof a == 'number' ? {
         typ: EnumToken.FractionTokenType,
-        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a) },
-        r: { typ: EnumToken.NumberTokenType, val: '1' }
+        l: { typ: EnumToken.NumberTokenType, val: 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' }
+        l: { typ: EnumToken.NumberTokenType, val: b },
+        r: { typ: EnumToken.NumberTokenType, val: 1 }
     } : b;
     let l2;
     let r2;
@@ -99,10 +101,10 @@ function compute(a, b, op) {
         return a2[0];
     }
     const result = a2[0] / a2[1];
-    return reduceNumber(result).length <= reduceNumber(a2[0]).length + 1 + reduceNumber(a2[1]).length ? result : {
+    return minifyNumber(result).length <= minifyNumber(a2[0]).length + 1 + minifyNumber(a2[1]).length ? result : {
         typ: EnumToken.FractionTokenType,
-        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[0]) },
-        r: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[1]) }
+        l: { typ: EnumToken.NumberTokenType, val: a2[0] },
+        r: { typ: EnumToken.NumberTokenType, val: a2[1] }
     };
 }
 function rem(...a) {