@mojir/lits 2.1.31 → 2.1.32

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.1.31";
+var version = "2.1.32";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -9239,7 +9239,7 @@ var collatzSequence = {
     'noNth': true,
 };
 
-function isPrime$1(num) {
+function isPrime(num) {
     if (num <= 1) {
         return false;
     }
@@ -9261,18 +9261,18 @@ var primeSequence = {
         var primes = [];
         var num = 2;
         while (primes.length < length) {
-            if (isPrime$1(num)) {
+            if (isPrime(num)) {
                 primes.push(num);
             }
             num += 1;
         }
         return primes;
     },
-    'nth:prime?': function (n) { return isPrime$1(n); },
+    'nth:prime?': function (n) { return isPrime(n); },
     'nth:prime-take-while': function (takeWhile) {
         var primes = [];
         for (var i = 2;; i += 1) {
-            if (!isPrime$1(i)) {
+            if (!isPrime(i)) {
                 continue;
             }
             if (!takeWhile(i, primes.length)) {
@@ -9288,7 +9288,7 @@ function isComposite(num) {
     if (num <= 1) {
         return false;
     }
-    return !isPrime$1(num);
+    return !isPrime(num);
 }
 var compositeSequence = {
     'nth:composite-seq': function (length) {
@@ -31444,1382 +31444,6 @@ function isAbstractLitsError(error) {
     return error instanceof LitsError;
 }
 
-const defaultConfig = {
-    spaceSeparation: false,
-    precision: 8,
-    epsilon: 1e-10,
-};
-const CONFIG = {
-    spaceSeparation: false,
-    precision: 8,
-    epsilon: 1e-10,
-};
-function setConfig(newConfig) {
-    CONFIG.spaceSeparation = newConfig.spaceSeparation ?? defaultConfig.spaceSeparation;
-    CONFIG.precision = newConfig.precision ?? defaultConfig.precision;
-    CONFIG.epsilon = newConfig.epsilon ?? defaultConfig.epsilon;
-}
-/**
- * Mathematical constants used for symbolic representation
- */
-const CONSTANTS = [
-    { getSymbol: () => 'π', value: Math.PI },
-    { getSymbol: () => 'e', value: Math.E },
-    { getSymbol: () => 'φ', value: (1 + Math.sqrt(5)) / 2 },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(2)' : '√2', value: Math.sqrt(2) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(3)' : '√3', value: Math.sqrt(3) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(5)' : '√5', value: Math.sqrt(5) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(7)' : '√7', value: Math.sqrt(7) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(11)' : '√11', value: Math.sqrt(11) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(13)' : '√13', value: Math.sqrt(13) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(17)' : '√17', value: Math.sqrt(17) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(19)' : '√19', value: Math.sqrt(19) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(π)' : '√π', value: Math.sqrt(Math.PI) },
-    { getSymbol: () => 'ln(2)', value: Math.LN2 },
-    { getSymbol: () => 'ln(10)', value: Math.LN10 },
-    { getSymbol: () => 'log₂(e)', value: Math.LOG2E },
-    { getSymbol: () => 'log₁₀(e)', value: Math.LOG10E },
-];
-/**
- * Trigonometric values with their exact symbolic representations
- */
-const TRIG_VALUES = [
-    // sin values
-    { value: Math.sin(Math.PI / 6), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 6)' : 'sin(π/6)', getExactForm: () => CONFIG.spaceSeparation ? '1 / 2' : '1/2' },
-    { value: Math.sin(Math.PI / 4), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 4)' : 'sin(π/4)', getExactForm: () => CONFIG.spaceSeparation ? '√2 / 2' : '√2/2' },
-    { value: Math.sin(Math.PI / 3), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 3)' : 'sin(π/3)', getExactForm: () => CONFIG.spaceSeparation ? '√3 / 2' : '√3/2' },
-    { value: Math.sin(Math.PI / 2), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 2)' : 'sin(π/2)', getExactForm: () => '1' },
-    // cos values
-    { value: Math.cos(0), getSymbol: () => 'cos(0)', getExactForm: () => '1' },
-    { value: Math.cos(Math.PI / 6), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 6)' : 'cos(π/6)', getExactForm: () => CONFIG.spaceSeparation ? '√(3) / 2' : '√3/2' },
-    { value: Math.cos(Math.PI / 4), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 4)' : 'cos(π/4)', getExactForm: () => CONFIG.spaceSeparation ? '√(2) / 2' : '√2/2' },
-    { value: Math.cos(Math.PI / 3), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 3)' : 'cos(π/3)', getExactForm: () => CONFIG.spaceSeparation ? '1 / 2' : '1/2' },
-    { value: Math.cos(Math.PI / 2), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 2)' : 'cos(π/2)', getExactForm: () => '0' },
-    // tan values
-    { value: Math.tan(Math.PI / 6), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'tan(π / 6)' : 'tan(π/6)', getExactForm: () => CONFIG.spaceSeparation ? '1 / √(3)' : '1/√3' },
-    { value: Math.tan(Math.PI / 4), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'tan(π / 4)' : 'tan(π/4)', getExactForm: () => '1' },
-    { value: Math.tan(Math.PI / 3), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'tan(π / 3)' : 'tan(π/3)', getExactForm: () => CONFIG.spaceSeparation ? '√(3)' : '√3' },
-];
-
-/**
- * Factorizes a number under a radical to extract perfect square factors
- * @param n The number to factorize
- * @returns Object containing the coefficient and remaining radicand
- */
-function factorizeRadicand(n) {
-    // Find largest perfect square factor
-    let coefficient = 1;
-    let i = 2;
-    while (i * i <= n) {
-        // Check if i² is a factor of n
-        if (n % (i * i) === 0) {
-            coefficient *= i;
-            n /= (i * i);
-            // Continue with the same i to check for multiple powers
-            continue;
-        }
-        i++;
-    }
-    return { coefficient, radicand: n };
-}
-/**
- * Finds the greatest common divisor of two numbers
- * @param a First number
- * @param b Second number
- * @returns The GCD of a and b
- */
-function findGCD(a, b) {
-    a = Math.abs(a);
-    b = Math.abs(b);
-    while (b !== 0) {
-        const temp = b;
-        b = a % b;
-        a = temp;
-    }
-    return a;
-}
-/**
- * Checks if a number is prime
- * @param n The number to check
- * @returns True if n is prime, false otherwise
- */
-function isPrime(n) {
-    if (n <= 1)
-        return false;
-    if (n <= 3)
-        return true;
-    if (n % 2 === 0 || n % 3 === 0)
-        return false;
-    let i = 5;
-    while (i * i <= n) {
-        if (n % i === 0 || n % (i + 2) === 0)
-            return false;
-        i += 6;
-    }
-    return true;
-}
-/**
- * Determines if a number's square root should be preserved in direct form
- * @param n The number to check
- * @returns True if the square root should be kept in direct form
- */
-function shouldPreserveDirectRadical(n) {
-    // Always preserve direct form for prime numbers
-    if (isPrime(n))
-        return true;
-    // Always preserve direct form for small integers
-    if (n <= 30)
-        return true;
-    // Check if n has any perfect square factors
-    const factorized = factorizeRadicand(n);
-    // If no perfect square factors were found, preserve direct form
-    return factorized.coefficient === 1;
-}
-
-function isNumberNode(node) {
-    return node.type === 'Number';
-}
-function isUnaryOpNode(node) {
-    return node.type === 'UnaryOp';
-}
-function isBinaryOpNode(node) {
-    return node.type === 'BinaryOp';
-}
-function isRootNode(node) {
-    return node.type === 'Root';
-}
-function isConstantNode(node) {
-    return node.type === 'Constant';
-}
-function isPowerNode(node) {
-    return node.type === 'Power';
-}
-
-/**
- * Helper function to determine expression type priority for ordering
- * @returns A priority number (lower number = higher priority)
- */
-function getExpressionPriority(node) {
-    // Priority order: Number < Root/Power < Constant < Other
-    if (isNumberNode(node))
-        return 1;
-    if (isRootNode(node))
-        return 2;
-    // Handle other node types here
-    return 6; // Default for other types
-}
-/**
- * Determines if two expressions should be swapped in multiplication
- * @returns true if expressions should be swapped
- */
-function shouldSwapInMultiplication(left, right) {
-    const leftPriority = getExpressionPriority(left);
-    const rightPriority = getExpressionPriority(right);
-    // Lower priority number should come first
-    return leftPriority > rightPriority;
-}
-
-/**
- * Base abstract class for all expression nodes
- */
-class ExprNode {
-}
-
-/**
- * Checks if a node represents exactly zero within epsilon tolerance
- */
-function isZero(node) {
-    return isNumberNode(node) && Math.abs(node.evaluate()) < 1e-10;
-}
-/**
- * Checks if a node represents exactly one within epsilon tolerance
- */
-function isOne(node) {
-    return isNumberNode(node) && Math.abs(node.evaluate() - 1) < 1e-10;
-}
-/**
- * Node for numeric constants (integers, simple fractions, etc.)
- */
-class NumberNode extends ExprNode {
-    constructor(value) {
-        super();
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: value
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Number'
-        });
-    }
-    evaluate() {
-        return this.value;
-    }
-    toString() {
-        // Round values extremely close to zero to exactly zero
-        if (Math.abs(this.value) < CONFIG.epsilon) {
-            return "0";
-        }
-        if (this.value === Number.POSITIVE_INFINITY) {
-            return "∞";
-        }
-        if (this.value === Number.NEGATIVE_INFINITY) {
-            return "-∞";
-        }
-        if (Number.isInteger(this.value)) {
-            return this.value.toString();
-        }
-        // Handle fractions if it's a "nice" fraction
-        const MAX_DENOMINATOR = 1000;
-        for (let denominator = 2; denominator <= MAX_DENOMINATOR; denominator++) {
-            const numerator = Math.round(this.value * denominator);
-            if (Math.abs(this.value - numerator / denominator) < CONFIG.epsilon) {
-                const gcd = findGCD(Math.abs(numerator), denominator);
-                return CONFIG.spaceSeparation ? `${numerator / gcd} / ${denominator / gcd}` : `${numerator / gcd}/${denominator / gcd}`;
-            }
-        }
-        // Just return the decimal representation
-        const valueStr = this.value.toString();
-        if (valueStr.includes('.')) {
-            const [, decimalPart] = valueStr.split('.');
-            if (decimalPart.length > 8) {
-                return this.value.toFixed(CONFIG.precision);
-            }
-        }
-        return this.value.toString();
-    }
-    simplify() {
-        return this; // Numbers are already in simplest form
-    }
-    equals(other) {
-        if (!(isNumberNode(other)))
-            return false;
-        return Math.abs(this.value - other.evaluate()) < CONFIG.epsilon;
-    }
-}
-
-/**
- * Node for binary operations (+, -, *, /)
- */
-class BinaryOpNode extends ExprNode {
-    constructor(op, left, right) {
-        super();
-        Object.defineProperty(this, "op", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: op
-        });
-        Object.defineProperty(this, "left", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: left
-        });
-        Object.defineProperty(this, "right", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: right
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'BinaryOp'
-        });
-        // Apply automatic ordering for multiplication operations
-        if (this.op === '*' && shouldSwapInMultiplication(left, right)) {
-            // Swap the operands if they're in the wrong order
-            this.left = right;
-            this.right = left;
-        }
-    }
-    evaluate() {
-        const leftVal = this.left.evaluate();
-        const rightVal = this.right.evaluate();
-        switch (this.op) {
-            case '+': return leftVal + rightVal;
-            case '-': return leftVal - rightVal;
-            case '*': return leftVal * rightVal;
-            case '/': return leftVal / rightVal;
-        }
-    }
-    toString() {
-        let leftStr = this.left.toString();
-        let rightStr = this.right.toString();
-        // Add parentheses if needed
-        if ((this.op === '+' || this.op === '-')
-            && (isBinaryOpNode(this.left) && (this.left.getOp() === '+' || this.left.getOp() === '-'))) {
-            leftStr = `(${leftStr})`;
-        }
-        else if ((this.op === '+' || this.op === '-')
-            && (isBinaryOpNode(this.right) && (this.right.getOp() === '+' || this.right.getOp() === '-'))) {
-            rightStr = `(${rightStr})`;
-        }
-        if (this.op === '*') {
-            // Double-check order at display time
-            if (shouldSwapInMultiplication(this.left, this.right)) {
-                return CONFIG.spaceSeparation
-                    ? `${this.right.toString()} · ${this.left.toString()}`
-                    : `${this.right.toString()}·${this.left.toString()}`;
-            }
-            return CONFIG.spaceSeparation
-                ? `${this.left.toString()} · ${this.right.toString()}`
-                : `${this.left.toString()}·${this.right.toString()}`;
-        }
-        else {
-            return CONFIG.spaceSeparation
-                ? `${leftStr} ${this.op} ${rightStr}`
-                : `${leftStr}${this.op}${rightStr}`;
-        }
-    }
-    getOp() {
-        return this.op;
-    }
-    getLeft() {
-        return this.left;
-    }
-    getRight() {
-        return this.right;
-    }
-    simplify() {
-        // First simplify both children
-        const left = this.left.simplify();
-        const right = this.right.simplify();
-        // If both are numbers, perform the operation
-        if (isNumberNode(left) && isNumberNode(right)) {
-            return new NumberNode(this.evaluate());
-        }
-        // Simplification rules for addition
-        if (this.op === '+') {
-            // a + 0 = a
-            if (isNumberNode(right) && right.evaluate() === 0) {
-                return left;
-            }
-            // 0 + a = a
-            if (isNumberNode(left) && left.evaluate() === 0) {
-                return right;
-            }
-        }
-        // Simplification rules for subtraction
-        if (this.op === '-') {
-            // a - 0 = a
-            if (isNumberNode(right) && right.evaluate() === 0) {
-                return left;
-            }
-            // 0 - a = -a
-            if (isNumberNode(left) && left.evaluate() === 0) {
-                return new UnaryOpNode('-', right);
-            }
-            // a - a = 0
-            if (left.equals(right)) {
-                return new NumberNode(0);
-            }
-        }
-        // Simplification rules for multiplication
-        if (this.op === '*') {
-            // a * 0 = 0
-            if (isZero(left) || isZero(right)) {
-                return new NumberNode(0);
-            }
-            // a * 1 = a
-            if (isOne(right)) {
-                return left;
-            }
-            // 1 * a = a
-            if (isOne(left)) {
-                return right;
-            }
-            // Special case for n·√m/2 (12·√3/2 case)
-            if (isNumberNode(left)
-                && isBinaryOpNode(right)
-                && right.getOp() === '/'
-                && isNumberNode(right.getRight())
-                && right.getRight().evaluate() === 2
-                && isRootNode(right.getLeft())) {
-                const n = left.evaluate();
-                const rootNode = right.getLeft();
-                return new BinaryOpNode('*', new NumberNode(n / 2), rootNode);
-            }
-            // Handle multiplications with fractions
-            if (isBinaryOpNode(left) && left.getOp() === '/') {
-                // (a/b) * c = (a*c)/b
-                const fraction = left;
-                const numerator = fraction.getLeft();
-                const denominator = fraction.getRight();
-                return new BinaryOpNode('/', new BinaryOpNode('*', numerator, right), denominator).simplify();
-            }
-            if (isBinaryOpNode(right) && right.getOp() === '/') {
-                // c * (a/b) = (c*a)/b
-                const fraction = right;
-                const numerator = fraction.getLeft();
-                const denominator = fraction.getRight();
-                return new BinaryOpNode('/', new BinaryOpNode('*', left, numerator), denominator).simplify();
-            }
-            // Multiple numeric factors: (2·3)·π = 6·π
-            if (isNumberNode(left)
-                && isBinaryOpNode(right)
-                && right.getOp() === '*'
-                && isNumberNode(right.getLeft())) {
-                const n1 = left.evaluate();
-                const n2 = (right).getLeft().evaluate();
-                const restTerm = right.getRight();
-                return new BinaryOpNode('*', new NumberNode(n1 * n2), restTerm).simplify();
-            }
-            // Consolidate products of square roots: √a·√b = √(a·b)
-            if (isRootNode(left) && isRootNode(right)) {
-                const leftOperand = getRootOperand(left);
-                const rightOperand = getRootOperand(right);
-                // Create √(a·b) instead of √a·√b
-                if (isNumberNode(leftOperand) && isNumberNode(rightOperand)) {
-                    const newRadicand = leftOperand.evaluate() * rightOperand.evaluate();
-                    return new RootNode(new NumberNode(newRadicand)).simplify();
-                }
-            }
-        }
-        // Simplification rules for division
-        if (this.op === '/') {
-            // 0 / a = 0
-            if (isZero(left)) {
-                return new NumberNode(0);
-            }
-            // a / 1 = a
-            if (isOne(right)) {
-                return left;
-            }
-            // a / a = 1
-            if (left.equals(right)) {
-                return new NumberNode(1);
-            }
-            // Simplify numeric fractions
-            if (isNumberNode(left) && isNumberNode(right)) {
-                const num = left.evaluate();
-                const denom = right.evaluate();
-                if (Number.isInteger(num) && Number.isInteger(denom)) {
-                    const gcd = findGCD(Math.abs(num), Math.abs(denom));
-                    if (gcd > 1) {
-                        return new BinaryOpNode('/', new NumberNode(num / gcd), new NumberNode(denom / gcd));
-                    }
-                }
-            }
-            // (a*b) / b = a
-            if (isBinaryOpNode(left) && left.getOp() === '*') {
-                const product = left;
-                // Case for n·something / n = something (6·√3/6 = √3)
-                if (isNumberNode(product.getLeft())
-                    && isNumberNode(right)
-                    && Math.abs(product.getLeft().evaluate() - right.evaluate()) < 1e-10) {
-                    return product.getRight();
-                }
-                if (isNumberNode(product.getRight())
-                    && isNumberNode(right)
-                    && Math.abs(product.getRight().evaluate() - right.evaluate()) < 1e-10) {
-                    return product.getLeft();
-                }
-                // General case
-                if (product.getLeft().equals(right)) {
-                    return product.getRight();
-                }
-                if (product.getRight().equals(right)) {
-                    return product.getLeft();
-                }
-            }
-        }
-        // If no simplification rules apply, return a new node with simplified children
-        return new BinaryOpNode(this.op, left, right);
-    }
-    equals(other) {
-        if (!(isBinaryOpNode(other)))
-            return false;
-        const otherOp = other;
-        return this.op === otherOp.getOp()
-            && this.left.equals(otherOp.getLeft())
-            && this.right.equals(otherOp.getRight());
-    }
-}
-/**
- * Extracts the radicand from a square root expression
- */
-function getRootOperand(node) {
-    if (isRootNode(node)) {
-        return node.getOperand();
-    }
-    if (isUnaryOpNode(node) && node.getOp() === 'sqrt') {
-        return node.getOperand();
-    }
-    throw new Error('Not a root node');
-}
-/**
- * Checks if a node represents a square root expression
- */
-function isRootLikeNode(node) {
-    return isRootNode(node)
-        || (isUnaryOpNode(node) && node.getOp() === 'sqrt');
-}
-/**
- * Specialized node for square roots for nicer formatting
- */
-class RootNode extends ExprNode {
-    constructor(operand) {
-        super();
-        Object.defineProperty(this, "operand", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: operand
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Root'
-        });
-    }
-    evaluate() {
-        return Math.sqrt(this.operand.evaluate());
-    }
-    toString() {
-        if (CONFIG.spaceSeparation) {
-            const operandStr = this.operand.toString();
-            if (!isNumberNode(this.operand) || operandStr.includes('/')) {
-                return `√(${operandStr})`;
-            }
-            else {
-                return `√${operandStr}`;
-            }
-        }
-        else {
-            return `√${this.operand.toString()}`;
-        }
-    }
-    simplify() {
-        const operand = this.operand.simplify();
-        // Simplify sqrt of perfect squares
-        if (isNumberNode(operand)) {
-            const val = operand.evaluate();
-            const sqrtVal = Math.sqrt(val);
-            // If it's a perfect square, return the number
-            if (Number.isInteger(sqrtVal)) {
-                return new NumberNode(sqrtVal);
-            }
-            // Otherwise, check if we can simplify the radicand
-            const factorized = factorizeRadicand(val);
-            if (factorized.coefficient > 1) {
-                // If there's a perfect square factor, extract it
-                return new BinaryOpNode('*', new NumberNode(factorized.coefficient), new RootNode(new NumberNode(factorized.radicand)));
-            }
-        }
-        // Handle product of radicands under a root
-        if (isBinaryOpNode(operand) && operand.getOp() === '*') {
-            const left = operand.getLeft();
-            const right = operand.getRight();
-            // We can't simplify if they aren't both numbers
-            if (isNumberNode(left) && isNumberNode(right)) {
-                const leftVal = left.evaluate();
-                const rightVal = right.evaluate();
-                // Try to factorize the product
-                const factorized = factorizeRadicand(leftVal * rightVal);
-                if (factorized.coefficient > 1) {
-                    // If there's a perfect square factor, extract it
-                    return new BinaryOpNode('*', new NumberNode(factorized.coefficient), new RootNode(new NumberNode(factorized.radicand))).simplify();
-                }
-            }
-        }
-        return new RootNode(operand);
-    }
-    getOperand() {
-        return this.operand;
-    }
-    equals(other) {
-        if (!(isRootLikeNode(other)))
-            return false;
-        return this.operand.equals(other.getOperand());
-    }
-}
-/**
- * Specialized node for power expressions
- */
-class PowerNode extends ExprNode {
-    constructor(base, exponent) {
-        super();
-        Object.defineProperty(this, "base", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: base
-        });
-        Object.defineProperty(this, "exponent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: exponent
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Power'
-        });
-    }
-    evaluate() {
-        return this.base.evaluate() ** this.exponent.evaluate();
-    }
-    toString() {
-        const baseStr = this.base.toString();
-        const expVal = this.exponent.evaluate();
-        // Use superscript for powers 2 and 3
-        if (expVal === 2)
-            return `${baseStr}²`;
-        if (expVal === 3)
-            return `${baseStr}³`;
-        return CONFIG.spaceSeparation ? `${baseStr} ^ ${this.exponent.toString()}` : `${baseStr}^${this.exponent.toString()}`;
-    }
-    simplify() {
-        const base = this.base.simplify();
-        const exponent = this.exponent.simplify();
-        // Anything to the power of 0 is 1
-        if (isNumberNode(exponent) && exponent.evaluate() === 0) {
-            return new NumberNode(1);
-        }
-        // Anything to the power of 1 is itself
-        if (isNumberNode(exponent) && exponent.evaluate() === 1) {
-            return base;
-        }
-        // 0 to any positive power is 0
-        if (isNumberNode(base) && base.evaluate() === 0
-            && isNumberNode(exponent) && exponent.evaluate() > 0) {
-            return new NumberNode(0);
-        }
-        // 1 to any power is 1
-        if (isNumberNode(base) && base.evaluate() === 1) {
-            return new NumberNode(1);
-        }
-        // If both are numbers, compute the power
-        if (isNumberNode(base) && isNumberNode(exponent)) {
-            return new NumberNode(base.evaluate() ** exponent.evaluate());
-        }
-        return new PowerNode(base, exponent);
-    }
-    equals(other) {
-        if (!(isPowerNode(other)))
-            return false;
-        const otherPower = other;
-        return this.base.equals(otherPower.base)
-            && this.exponent.equals(otherPower.exponent);
-    }
-    getBase() {
-        return this.base;
-    }
-    getExponent() {
-        return this.exponent;
-    }
-}
-/**
- * Node for unary operations (-, sqrt, cbrt, etc.)
- */
-class UnaryOpNode extends ExprNode {
-    constructor(op, operand) {
-        super();
-        Object.defineProperty(this, "op", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: op
-        });
-        Object.defineProperty(this, "operand", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: operand
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'UnaryOp'
-        });
-    }
-    evaluate() {
-        const val = this.operand.evaluate();
-        switch (this.op) {
-            case '-': return -val;
-            case 'sqrt': return Math.sqrt(val);
-            case 'cbrt': return Math.cbrt(val);
-        }
-    }
-    toString() {
-        const operandStr = this.operand.toString();
-        if (operandStr === '0') {
-            return '0';
-        }
-        switch (this.op) {
-            case '-': return CONFIG.spaceSeparation && (!isNumberNode(this.operand) || operandStr.includes('/')) ? `-(${operandStr})` : `-${operandStr}`;
-            case 'sqrt': return CONFIG.spaceSeparation ? `√(${operandStr})` : `√${operandStr}`;
-            case 'cbrt': return CONFIG.spaceSeparation ? `∛(${operandStr})` : `∛${operandStr}`;
-        }
-    }
-    simplify() {
-        const operand = this.operand.simplify();
-        // Double negation: --a = a
-        if (this.op === '-' && isUnaryOpNode(operand)
-            && operand.getOp() === '-') {
-            return operand.getOperand();
-        }
-        // Simplify sqrt of perfect squares
-        if (this.op === 'sqrt' && isNumberNode(operand)) {
-            const val = operand.evaluate();
-            const sqrtVal = Math.sqrt(val);
-            if (Number.isInteger(sqrtVal)) {
-                return new NumberNode(sqrtVal);
-            }
-        }
-        // Simplify cbrt of perfect cubes
-        if (this.op === 'cbrt' && isNumberNode(operand)) {
-            const val = operand.evaluate();
-            const cbrtVal = Math.cbrt(val);
-            if (Number.isInteger(cbrtVal)) {
-                return new NumberNode(cbrtVal);
-            }
-        }
-        return new UnaryOpNode(this.op, operand);
-    }
-    getOp() {
-        return this.op;
-    }
-    getOperand() {
-        return this.operand;
-    }
-    equals(other) {
-        if (!(isUnaryOpNode(other)))
-            return false;
-        const otherOp = other;
-        return this.op === otherOp.getOp()
-            && this.operand.equals(otherOp.getOperand());
-    }
-}
-
-/**
- * Node for mathematical constants (π, e, etc.)
- */
-class ConstantNode extends ExprNode {
-    constructor(symbol, value) {
-        super();
-        Object.defineProperty(this, "symbol", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: symbol
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: value
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Constant'
-        });
-    }
-    evaluate() {
-        return this.value;
-    }
-    toString() {
-        return this.symbol;
-    }
-    simplify() {
-        return this; // Constants are already in simplest form
-    }
-    equals(other) {
-        if (!(isConstantNode(other)))
-            return false;
-        return this.symbol === other.symbol;
-    }
-    getSymbol() {
-        return this.symbol;
-    }
-}
-
-/**
- * Converts a number to its continued fraction representation
- * @param x The number to convert
- * @param maxTerms Maximum number of terms to compute
- * @returns Array of continued fraction terms [a0, a1, a2, ...]
- */
-function toContinuedFraction(x, maxTerms = 20) {
-    const terms = [];
-    for (let i = 0; i < maxTerms; i++) {
-        const a = Math.floor(x);
-        terms.push(a);
-        // If we've reached a very small remainder, we're done
-        if (Math.abs(x - a) < CONFIG.epsilon) {
-            break;
-        }
-        // Prevent division by zero and avoid floating point issues
-        const remainder = x - a;
-        if (Math.abs(remainder) < CONFIG.epsilon) {
-            break;
-        }
-        x = 1 / remainder;
-    }
-    return terms;
-}
-/**
- * Converts continued fraction terms to a fraction [numerator, denominator]
- * @param terms Array of continued fraction terms
- * @returns [numerator, denominator]
- */
-function fromContinuedFraction(terms) {
-    if (terms.length === 0)
-        return [0, 1];
-    if (terms.length === 1)
-        return [terms[0], 1];
-    // Start with the last term
-    let numerator = terms[terms.length - 1];
-    let denominator = 1;
-    // Work backwards through the terms
-    for (let i = terms.length - 2; i >= 0; i--) {
-        // For each term, compute the new fraction 
-        // a_i + 1/previous
-        const newNumerator = terms[i] * numerator + denominator;
-        const newDenominator = numerator;
-        // Update for next iteration
-        numerator = newNumerator;
-        denominator = newDenominator;
-    }
-    return [numerator, denominator];
-}
-/**
- * Generates all convergents (approximations) from continued fraction terms
- * @param terms Array of continued fraction terms
- * @returns Array of [numerator, denominator] pairs
- */
-function getConvergents(terms) {
-    const convergents = [];
-    for (let i = 1; i <= terms.length; i++) {
-        convergents.push(fromContinuedFraction(terms.slice(0, i)));
-    }
-    return convergents;
-}
-/**
- * Tries to identify if a number is a simple quadratic irrational
- * @param x The number to check
- * @returns The identified form or null if not recognized
- */
-function identifyQuadraticIrrational(x) {
-    // Direct checks for common values
-    // Check for square roots of integers
-    for (let n = 2; n <= 20; n++) {
-        if (Math.abs(x - Math.sqrt(n)) < CONFIG.epsilon) {
-            return `√${n}`;
-        }
-    }
-    // Check for golden ratio and its conjugate
-    if (Math.abs(x - (1 + Math.sqrt(5)) / 2) < CONFIG.epsilon) {
-        return "φ"; // Already defined as a constant
-    }
-    if (Math.abs(x - (Math.sqrt(5) - 1) / 2) < CONFIG.epsilon) {
-        return "(√5-1)/2";
-    }
-    // Check for expressions of form (√n ± m)/k where n, m, k are small integers
-    for (let n = 2; n <= 30; n++) {
-        const sqrtN = Math.sqrt(n);
-        for (let m = 1; m <= 10; m++) {
-            for (let k = 2; k <= 10; k++) {
-                // Check (√n + m)/k
-                if (Math.abs(x - (sqrtN + m) / k) < CONFIG.epsilon) {
-                    if (m === 1 && k === 2) {
-                        return `(√${n}+1)/2`;
-                    }
-                    else {
-                        return `(√${n}+${m})/${k}`;
-                    }
-                }
-                // Check (√n - m)/k
-                if (Math.abs(x - (sqrtN - m) / k) < CONFIG.epsilon) {
-                    if (m === 1 && k === 2) {
-                        return `(√${n}-1)/2`;
-                    }
-                    else {
-                        return `(√${n}-${m})/${k}`;
-                    }
-                }
-            }
-        }
-    }
-    // Get continued fraction for pattern analysis
-    const terms = toContinuedFraction(x, 30);
-    // Analyze the continued fraction for periodic patterns
-    const period = detectPeriod(terms);
-    if (period) {
-        // For purely periodic CFs (√D): [a0; a1, a2, ..., aN, a1, a2, ...]
-        // where a0 = floor(√D) and the sequence after a0 is periodic
-        // For √2: [1; 2, 2, 2, ...]
-        if (period.length === 1 && period[0] === 2 && terms[0] === 1) {
-            return "√2";
-        }
-        // For √3: [1; 1, 2, 1, 2, ...]
-        if (period.length === 2 && period[0] === 1 && period[1] === 2 && terms[0] === 1) {
-            return "√3";
-        }
-        // For √5: [2; 4, 4, 4, ...]
-        if (period.length === 1 && period[0] === 4 && terms[0] === 2) {
-            return "√5";
-        }
-        // For √6: [2; 2, 4, 2, 4, ...] 
-        if (period.length === 2 && period[0] === 2 && period[1] === 4 && terms[0] === 2) {
-            return "√6";
-        }
-        // For √7: [2; 1, 1, 1, 4, 1, 1, 1, 4, ...] 
-        if (period.length === 4 &&
-            period[0] === 1 && period[1] === 1 &&
-            period[2] === 1 && period[3] === 4 &&
-            terms[0] === 2) {
-            return "√7";
-        }
-        // For √8: [2; 1, 4, 1, 4, ...]
-        if (period.length === 2 && period[0] === 1 && period[1] === 4 && terms[0] === 2) {
-            return "√8";
-        }
-        // Try to reconstruct the quadratic form from the pattern
-        // (Complex algorithm that would determine D from periodic CF)
-        const D = reconstructD(terms[0], period);
-        if (D > 0 && Math.abs(x - Math.sqrt(D)) < CONFIG.epsilon) {
-            return `√${D}`;
-        }
-    }
-    return null; // Could not identify
-}
-// Helper function to detect periodic patterns in continued fractions
-function detectPeriod(terms) {
-    // Need at least a few terms to detect patterns
-    if (terms.length < 6)
-        return null;
-    // Check for single repeating digit (like √2 = [1; 2, 2, 2, ...])
-    const allSameAfterFirst = terms.slice(1).every(t => t === terms[1]);
-    if (allSameAfterFirst) {
-        return [terms[1]];
-    }
-    // For period of length 2
-    const periodLength2 = terms.slice(1, 3).every((val, idx) => {
-        for (let i = 1; i < Math.floor((terms.length - 1) / 2); i++) {
-            if (terms[1 + idx + 2 * i] !== val)
-                return false;
-        }
-        return true;
-    });
-    if (periodLength2) {
-        return terms.slice(1, 3);
-    }
-    // For period of length 4
-    if (terms.length >= 9) {
-        const periodLength4 = terms.slice(1, 5).every((val, idx) => {
-            return terms[1 + idx + 4] === val && (terms.length >= 13 ? terms[1 + idx + 8] === val : true);
-        });
-        if (periodLength4) {
-            return terms.slice(1, 5);
-        }
-    }
-    // Could add more pattern detection logic here
-    return null;
-}
-// Helper function to reconstruct D from continued fraction pattern
-function reconstructD(a0, period) {
-    // Simple cases
-    if (period.length === 1 && period[0] === 2)
-        return 2;
-    if (period.length === 2 && period[0] === 1 && period[1] === 2)
-        return 3;
-    if (period.length === 1 && period[0] === 4)
-        return 5;
-    if (period.length === 2 && period[0] === 2 && period[1] === 4)
-        return 6;
-    if (period.length === 4 &&
-        period[0] === 1 && period[1] === 1 &&
-        period[2] === 1 && period[3] === 4)
-        return 7;
-    if (period.length === 2 && period[0] === 1 && period[1] === 4)
-        return 8;
-    // For purely periodic CFs, D = a0² + P where P depends on the period
-    // This is a simplified heuristic approach
-    if (period.length === 1) {
-        // If period has form [n], then D ≈ a0² + 1/n
-        return Math.round(a0 * a0 + 1 / period[0]);
-    }
-    // Generalized approach for reconstructing D would be more complex
-    // and would involve solving the Pell equation
-    return -1; // Couldn't determine D
-}
-
-/**
- * Parser to convert numeric values to expression trees
- */
-class ExpressionParser {
-    /**
-     * Main parsing function that converts a number to an expression tree
-     */
-    parseNumber(num, depth = 0) {
-        const MAX_DEPTH = 3;
-        // Handle zero
-        if (Math.abs(num) < CONFIG.epsilon) {
-            return new NumberNode(0);
-        }
-        // Handle negative numbers
-        if (num < 0) {
-            return new UnaryOpNode('-', this.parseNumber(-num, depth));
-        }
-        // Handle integers
-        if (Math.abs(num - Math.round(num)) < CONFIG.epsilon) {
-            return new NumberNode(Math.round(num));
-        }
-        const cfTerms = toContinuedFraction(num, 20);
-        const convergents = getConvergents(cfTerms);
-        for (const [numerator, denominator] of convergents) {
-            // Only consider fractions with reasonably-sized components
-            if (denominator <= 1000 && Math.abs(numerator) <= 10000) {
-                // Verify the approximation is within our epsilon
-                if (Math.abs(num - numerator / denominator) < CONFIG.epsilon) {
-                    const gcd = this.findGCD(Math.abs(numerator), denominator);
-                    return new BinaryOpNode('/', new NumberNode(numerator / gcd), new NumberNode(denominator / gcd));
-                }
-            }
-        }
-        // Try direct matches to constants
-        for (const constant of CONSTANTS) {
-            if (Math.abs(num - constant.value) < CONFIG.epsilon) {
-                return new ConstantNode(constant.getSymbol(), constant.value);
-            }
-        }
-        // Try direct matches to trig values
-        for (const trigValue of TRIG_VALUES) {
-            if (Math.abs(num - trigValue.value) < CONFIG.epsilon) {
-                // If it has an exact form, parse that instead
-                if (trigValue.getExactForm) {
-                    return this.parseExactForm(trigValue.getExactForm());
-                }
-                return new ConstantNode(trigValue.getSymbol(), trigValue.value);
-            }
-        }
-        const quadraticForm = identifyQuadraticIrrational(num);
-        if (quadraticForm) {
-            // If we identified something like "√7" or "(√13-3)/2"
-            return this.parseExactForm(quadraticForm);
-        }
-        // Direct check for square roots before other decompositions
-        // This ensures square roots of integers are handled directly
-        for (let i = 2; i <= 100; i++) {
-            if (Math.abs(num - Math.sqrt(i)) < CONFIG.epsilon) {
-                // Use our enhanced check to determine if we should keep direct form
-                if (shouldPreserveDirectRadical(i)) {
-                    return new RootNode(new NumberNode(i));
-                }
-                // Only factorize if appropriate
-                const factorized = factorizeRadicand(i);
-                if (factorized.coefficient > 1) {
-                    return new BinaryOpNode('*', new NumberNode(factorized.coefficient), new RootNode(new NumberNode(factorized.radicand)));
-                }
-                // Default to direct representation
-                return new RootNode(new NumberNode(i));
-            }
-        }
-        // Check for powers
-        for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-            for (let power = 2; power <= 3; power++) {
-                if (Math.abs(num - constant.value ** power) < CONFIG.epsilon) {
-                    const baseNode = constant.getExactForm
-                        ? this.parseExactForm(constant.getExactForm())
-                        : new ConstantNode(constant.getSymbol(), constant.value);
-                    return new PowerNode(baseNode, new NumberNode(power));
-                }
-            }
-        }
-        // Recursive decomposition with extra care for square roots
-        if (depth < MAX_DEPTH) {
-            // Check for π/n pattern
-            for (const constant of CONSTANTS) {
-                for (let denominator = 2; denominator <= 12; denominator++) {
-                    if (Math.abs(num - constant.value / denominator) < CONFIG.epsilon) {
-                        return new BinaryOpNode('/', constant.getExactForm
-                            ? this.parseExactForm(constant.getExactForm())
-                            : new ConstantNode(constant.getSymbol(), constant.value), new NumberNode(denominator));
-                    }
-                }
-            }
-            // Check for products with more careful handling of square roots
-            for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-                if (Math.abs(constant.value) > CONFIG.epsilon) {
-                    const multiplier = num / constant.value;
-                    // Skip square root decomposition attempts for prime square roots
-                    if (constant.getSymbol() && constant.getSymbol().startsWith('√')
-                        && isPrime(Number.parseInt(constant.getSymbol(true).substring(1)))) {
-                        continue;
-                    }
-                    // Skip common fractions that might be misidentified as complex expressions
-                    if ((Math.abs(multiplier - 0.75) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.5) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.25) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.3333333333333333) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.6666666666666666) < CONFIG.epsilon)) {
-                        continue;
-                    }
-                    if (this.isNiceValue(multiplier)) {
-                        const multiplierNode = this.parseNumber(multiplier, depth + 1);
-                        const valueNode = constant.getExactForm
-                            ? this.parseExactForm(constant.getExactForm())
-                            : new ConstantNode(constant.getSymbol(), constant.value);
-                        // If multiplier is 1, just return the constant
-                        if (isNumberNode(multiplierNode)
-                            && Math.abs(multiplierNode.evaluate() - 1) < CONFIG.epsilon) {
-                            return valueNode;
-                        }
-                        // Create the product node with canonical ordering
-                        let productNode;
-                        // Define a priority order for constants
-                        // Lower number = higher priority (should appear first)
-                        const getConstantPriority = (node) => {
-                            if (!(isConstantNode(node)))
-                                return 100;
-                            const symbol = node.getSymbol();
-                            if (symbol === 'e')
-                                return 1;
-                            if (symbol === 'π')
-                                return 2;
-                            if (symbol === 'φ')
-                                return 3;
-                            if (symbol.startsWith('√'))
-                                return 10;
-                            return 50; // Other constants
-                        };
-                        // Apply the priority ordering
-                        if (isConstantNode(multiplierNode) && isConstantNode(valueNode)) {
-                            // When multiplying two constants, order them by priority
-                            const multiplierPriority = getConstantPriority(multiplierNode);
-                            const valuePriority = getConstantPriority(valueNode);
-                            if (multiplierPriority <= valuePriority) {
-                                productNode = new BinaryOpNode('*', multiplierNode, valueNode);
-                            }
-                            else {
-                                productNode = new BinaryOpNode('*', valueNode, multiplierNode);
-                            }
-                        }
-                        else if (isNumberNode(multiplierNode)) {
-                            // Number multiplier always goes first
-                            productNode = new BinaryOpNode('*', multiplierNode, valueNode);
-                        }
-                        else if (getConstantPriority(valueNode) < 50) {
-                            // Special constants (e, π, φ) go before other expressions
-                            productNode = new BinaryOpNode('*', valueNode, multiplierNode);
-                        }
-                        else {
-                            // Default ordering
-                            productNode = new BinaryOpNode('*', multiplierNode, valueNode);
-                        }
-                        // Check if this product is part of a sum
-                        // Try to see if the product plus a nice value equals our number
-                        for (let addend = 1; addend <= 10; addend++) {
-                            const productValue = productNode.evaluate();
-                            const sum = productValue + addend;
-                            if (Math.abs(num - sum) < CONFIG.epsilon) {
-                                return new BinaryOpNode('+', productNode, new NumberNode(addend));
-                            }
-                        }
-                        return productNode;
-                    }
-                }
-            }
-            // Check for sums and differences with base constants
-            for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-                const remainder = num - constant.value;
-                if (this.isNiceValue(remainder)) {
-                    const remainderNode = this.parseNumber(remainder, depth + 1);
-                    const valueNode = constant.getExactForm
-                        ? this.parseExactForm(constant.getExactForm())
-                        : new ConstantNode(constant.getSymbol(), constant.value);
-                    // If remainder is 0, just return the constant
-                    if (isNumberNode(remainderNode)
-                        && Math.abs(remainderNode.evaluate()) < CONFIG.epsilon) {
-                        return valueNode;
-                    }
-                    // If remainder is negative, use subtraction
-                    if (remainder < 0) {
-                        return new BinaryOpNode('-', valueNode, this.parseNumber(-remainder, depth + 1));
-                    }
-                    return new BinaryOpNode('+', valueNode, remainderNode);
-                }
-            }
-            // Check for sums and differences with multiples of constants
-            for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-                for (let multiplier = 2; multiplier <= 5; multiplier++) {
-                    const multipleValue = multiplier * constant.value;
-                    const remainder = num - multipleValue;
-                    if (this.isNiceValue(remainder)) {
-                        // Create the multiple constant node
-                        const constantNode = constant.getExactForm
-                            ? this.parseExactForm(constant.getExactForm())
-                            : new ConstantNode(constant.getSymbol(), constant.value);
-                        const multipleNode = new BinaryOpNode('*', new NumberNode(multiplier), constantNode);
-                        // Create the remainder node
-                        const remainderNode = this.parseNumber(remainder, depth + 1);
-                        // If remainder is 0, just return the multiple
-                        if (isNumberNode(remainderNode)
-                            && Math.abs(remainderNode.evaluate()) < CONFIG.epsilon) {
-                            return multipleNode;
-                        }
-                        // If remainder is negative, use subtraction
-                        if (remainder < 0) {
-                            return new BinaryOpNode('-', multipleNode, this.parseNumber(-remainder, depth + 1));
-                        }
-                        return new BinaryOpNode('+', multipleNode, remainderNode);
-                    }
-                }
-            }
-            // Check for cube roots of integers
-            for (let i = 2; i <= 100; i++) {
-                if (Math.abs(num - Math.cbrt(i)) < CONFIG.epsilon) {
-                    return new UnaryOpNode('cbrt', new NumberNode(i));
-                }
-            }
-        }
-        // Final direct check for square roots before giving up
-        // This ensures we catch any square roots we might have missed
-        const possibleRadicand = Math.round(num * num);
-        if (Math.abs(num - Math.sqrt(possibleRadicand)) < CONFIG.epsilon) {
-            return new RootNode(new NumberNode(possibleRadicand));
-        }
-        // Fallback to decimal representation
-        return new NumberNode(num);
-    }
-    /**
-     * Helper method to parse exact forms like "√2/2"
-     */
-    parseExactForm(exactForm) {
-        // Handle fractions
-        if (exactForm.includes('/')) {
-            const [numerator, denominator] = exactForm.split('/');
-            return new BinaryOpNode('/', this.parseExactForm(numerator), this.parseExactForm(denominator));
-        }
-        // Handle square roots
-        if (exactForm.startsWith('√')) {
-            const argument = exactForm.substring(1);
-            return new RootNode(this.parseExactForm(argument));
-        }
-        // Handle simple numbers
-        if (/^\d+$/.test(exactForm)) {
-            return new NumberNode(Number.parseInt(exactForm));
-        }
-        // Handle known constants
-        for (const constant of CONSTANTS) {
-            if (exactForm === constant.getSymbol()) {
-                return new ConstantNode(constant.getSymbol(), constant.value);
-            }
-        }
-        // If we don't recognize it, treat it as a symbol
-        return new ConstantNode(exactForm, Number.NaN);
-    }
-    /**
-     * Helper to determine if a value is "nice"
-     */
-    isNiceValue(num) {
-        // Check if it's close to an integer
-        if (Math.abs(num - Math.round(num)) < CONFIG.epsilon) {
-            return true;
-        }
-        const cfTerms = toContinuedFraction(num, 10);
-        const convergents = getConvergents(cfTerms);
-        // Check if any convergent is a good approximation and reasonably simple
-        for (const [numerator, denominator] of convergents) {
-            // Only consider "nice" fractions (reasonable size numerator/denominator)
-            if (denominator <= 20 && Math.abs(numerator) <= 50) {
-                if (Math.abs(num - numerator / denominator) < CONFIG.epsilon) {
-                    return true;
-                }
-            }
-        }
-        // Check if it's a square root of a small integer (highest priority)
-        // This helps prefer direct √n forms
-        for (let i = 2; i <= 30; i++) {
-            if (Math.abs(num - Math.sqrt(i)) < CONFIG.epsilon) {
-                // Give very high priority to prime square roots
-                if (isPrime(i)) {
-                    return true;
-                }
-                // Also prioritize other small square roots
-                if (i <= 20) {
-                    return true;
-                }
-            }
-        }
-        // Check if it's close to a common constant
-        for (const constant of CONSTANTS) {
-            if (Math.abs(num - constant.value) < CONFIG.epsilon) {
-                return true;
-            }
-        }
-        // Check trig values
-        for (const value of TRIG_VALUES) {
-            if (Math.abs(num - value.value) < CONFIG.epsilon) {
-                return true;
-            }
-        }
-        // Other common values with lower priority
-        const COMMON_VALUES = [
-            Math.sin(Math.PI / 3),
-            Math.cos(Math.PI / 4),
-        ];
-        for (const value of COMMON_VALUES) {
-            if (Math.abs(num - value) < CONFIG.epsilon) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Find greatest common divisor helper method
-     */
-    findGCD(a, b) {
-        a = Math.abs(a);
-        b = Math.abs(b);
-        while (b !== 0) {
-            const temp = b;
-            b = a % b;
-            a = temp;
-        }
-        return a;
-    }
-}
-
-/**
- * Symbolic Number Printer using Expression Tree Representation
- *
- * This implementation uses a proper expression tree to represent mathematical
- * expressions, enabling more sophisticated simplification and consistent formatting.
- */
-/**
- * Main function to convert a number to its symbolic representation
- * @param num The number to convert to symbolic form
- * @returns A string containing the symbolic representation
- */
-function prettyPi(num, config = {}) {
-    if (!isFinite(num)) {
-        if (isNaN(num)) {
-            return "NaN";
-        }
-        return num > 0 ? "∞" : "-∞";
-    }
-    setConfig(config);
-    const parser = new ExpressionParser();
-    const exprTree = parser.parseNumber(num);
-    const simplified = exprTree.simplify();
-    return simplified.toString();
-}
-
 function stringifyValue(value, html) {
     var _a;
     var gt = '>';
@@ -32837,7 +31461,7 @@ function stringifyValue(value, html) {
     if (typeof value === 'object' && value instanceof RegExp)
         return "".concat(value);
     if (typeof value === 'number') {
-        return prettyPi(value);
+        return "".concat(value);
     }
     if (isRegularExpression(value))
         return "/".concat(value.s, "/").concat(value.f);
@@ -32850,12 +31474,12 @@ function stringifyValue(value, html) {
             return '[]';
         if (value.length > 8) {
             return "[\n  ".concat(value.map(function (cell) {
-                return prettyPi(cell);
+                return cell;
             }).join(',\n  '), "\n]");
         }
         else {
             return "[".concat(value.map(function (cell) {
-                return prettyPi(cell);
+                return cell;
             }).join(', '), "]");
         }
     }
@@ -32891,45 +31515,11 @@ function replaceInfinities(value) {
     }
     return value;
 }
-function prettyIfNumber(value) {
-    if (typeof value === 'number') {
-        return prettyPi(value);
-    }
-    return "".concat(value);
-}
 function stringifyMatrix(matrix) {
-    var padding = matrix.flat().reduce(function (max, cell) { return Math.max(max, prettyIfNumber(cell).length); }, 0) + 1;
-    var rows = matrix.map(function (row) { return "[".concat(row.map(function (cell) { return prettyIfNumber(cell).padStart(padding); }).join(' '), " ]"); });
+    var padding = matrix.flat().reduce(function (max, cell) { return Math.max(max, "".concat(cell).length); }, 0) + 1;
+    var rows = matrix.map(function (row) { return "[".concat(row.map(function (cell) { return "".concat(cell).padStart(padding); }).join(' '), " ]"); });
     return rows.join('\n');
 }
-// function isMatrix(value: unknown): value is (null | number | string | boolean)[][] {
-//   if (!Array.isArray(value)) {
-//     return false
-//   }
-//   if (!value.every(row => Array.isArray(row))) {
-//     return false
-//   }
-//   let cols = -1
-//   for (const row of value) {
-//     if (cols === -1) {
-//       cols = row.length
-//       if (cols === 0) {
-//         return false
-//       }
-//     }
-//     else {
-//       if (row.length !== cols) {
-//         return false
-//       }
-//     }
-//     for (const cell of row) {
-//       if (typeof cell !== 'number' && typeof cell !== 'string' && typeof cell !== 'boolean' && cell !== null) {
-//         return false
-//       }
-//     }
-//   }
-//   return true
-// }
 function findAllOccurrences(input, pattern) {
     var matches = __spreadArray([], __read(input.matchAll(pattern)), false);
     return new Set(matches.map(function (match) { return match[0]; }));