@flomsstaar/expression-tree 0.1.0

package/build/src/render_expression.js

@@ -0,0 +1,56 @@
+import { NumberNode } from './models/number_node.js';
+import { BinaryNode } from './models/binary_node.js';
+import { BinaryNodeOperator } from './enums/binary_node_operator.js';
+import { UnknownBinaryOperatorError } from './errors/unknown_binary_operator_error.js';
+import { UnaryNode } from './models/unary_node.js';
+import { UnaryNodeOperator } from './enums/unary_node_operator.js';
+import { UnknownUnaryOperatorError } from './errors/unknown_unary_operator_error.js';
+import { UnknownNodeTypeError } from './errors/unknown_node_type_error.js';
+export function renderExpression(node) {
+    if (node instanceof BinaryNode) {
+        const leftNode = renderExpression(node.left);
+        const rightNode = renderExpression(node.right);
+        const operator = {
+            [BinaryNodeOperator.SUM]: '+',
+            [BinaryNodeOperator.SUBTRACT]: '-',
+            [BinaryNodeOperator.MULTIPLY]: '*',
+            [BinaryNodeOperator.DIVIDE]: '/',
+            [BinaryNodeOperator.POWER]: '^',
+        }[node.operator];
+        if (!operator) {
+            throw new UnknownBinaryOperatorError(node.operator);
+        }
+        return `${leftNode} ${operator} ${rightNode}`;
+    }
+    else if (node instanceof UnaryNode) {
+        switch (node.operator) {
+            case UnaryNodeOperator.NEGATE: {
+                if (node.value instanceof NumberNode && node.value.value === 0) {
+                    return '0';
+                }
+                else if (node.value instanceof BinaryNode) {
+                    const valueNode = renderExpression(node.value);
+                    return `-(${valueNode})`;
+                }
+                const valueNode = renderExpression(node.value);
+                return `-${valueNode}`;
+            }
+            case UnaryNodeOperator.ABSOLUTE: {
+                const valueNode = renderExpression(node.value);
+                return `abs(${valueNode})`;
+            }
+            case UnaryNodeOperator.SQUARE_ROOT: {
+                const valueNode = renderExpression(node.value);
+                return `sqrt(${valueNode})`;
+            }
+            default:
+                throw new UnknownUnaryOperatorError(node.operator);
+        }
+    }
+    else if (node instanceof NumberNode) {
+        return node.toString();
+    }
+    else {
+        throw new UnknownNodeTypeError(node.type);
+    }
+}

package/build/tests/expression_cutter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/expression_cutter.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, test } from 'vitest';
+import { ExpressionCutter } from '../src/expression_cutter.js';
+import { expressionCutterInput } from './inputs/expression_cutter_input.js';
+describe('expression cutter', () => {
+    test.each(expressionCutterInput())('expression: %s', (input, expected) => {
+        const expressionCutter = new ExpressionCutter();
+        expect(expressionCutter.cut(input)).toStrictEqual(expected);
+    });
+});

package/build/tests/expression_evaluator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/expression_evaluator.test.js

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it, test } from 'vitest';
+import { UnaryNode } from '../src/models/unary_node.js';
+import { UnaryNodeOperator } from '../src/enums/unary_node_operator.js';
+import { NumberNode } from '../src/models/number_node.js';
+import { ExpressionEvaluator } from '../src/expression_evaluator.js';
+import { BinaryNode } from '../src/models/binary_node.js';
+import { BinaryNodeOperator } from '../src/enums/binary_node_operator.js';
+import { NegativeSquareRootError } from '../src/errors/invalid_square_root_error.js';
+import { DivisionByZeroError } from '../src/errors/division_by_zero_error.js';
+import { UnknownUnaryOperatorError } from '../src/errors/unknown_unary_operator_error.js';
+import { UnknownBinaryOperatorError } from '../src/errors/unknown_binary_operator_error.js';
+import { UnknownNodeTypeError } from '../src/errors/unknown_node_type_error.js';
+describe('evaluate expression', () => {
+    let evaluator;
+    beforeEach(() => {
+        evaluator = new ExpressionEvaluator();
+    });
+    describe('unary node operations', () => {
+        describe('negation operation', () => {
+            it('should negate a number', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(5));
+                const result = evaluator.evaluate(expression);
+                expect(result).toBe(-5);
+            });
+            it('should negate an operation', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.NEGATE, new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(3), new NumberNode(2)));
+                const result = evaluator.evaluate(expression);
+                expect(result).toBe(-5);
+            });
+        });
+        describe('square root operation', () => {
+            it('should calculate square root of a positive number', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.SQUARE_ROOT, new NumberNode(16));
+                const result = evaluator.evaluate(expression);
+                expect(result).toBe(4);
+            });
+        });
+        describe('absolute value operation', () => {
+            it('should return absolute value of a negative number', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.ABSOLUTE, new NumberNode(-10));
+                const result = evaluator.evaluate(expression);
+                expect(result).toBe(10);
+            });
+            it('should return absolute value of a positive number', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.ABSOLUTE, new NumberNode(10));
+                const result = evaluator.evaluate(expression);
+                expect(result).toBe(10);
+            });
+            it('should return absolute value of zero', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.ABSOLUTE, new NumberNode(0));
+                const result = evaluator.evaluate(expression);
+                expect(result).toBe(0);
+            });
+        });
+    });
+    describe('binary node operations', () => {
+        test('sum operation', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(2), new NumberNode(2));
+            const result = evaluator.evaluate(expression);
+            expect(result).toBe(4);
+        });
+        test('subtract operation', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(5), new NumberNode(3));
+            const result = evaluator.evaluate(expression);
+            expect(result).toBe(2);
+        });
+        test('multiply operation', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(3), new NumberNode(4));
+            const result = evaluator.evaluate(expression);
+            expect(result).toBe(12);
+        });
+        test('divide operation', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(8), new NumberNode(2));
+            const result = evaluator.evaluate(expression);
+            expect(result).toBe(4);
+        });
+        test('power operation', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(8), new NumberNode(2));
+            const result = evaluator.evaluate(expression);
+            expect(result).toBe(64);
+        });
+    });
+    describe('unsupported operations', () => {
+        test('unknown unary operator', () => {
+            const expression = new UnaryNode('UNKNOWN_UNARY_OPERATOR', new NumberNode(1));
+            expect(() => evaluator.evaluate(expression)).toThrowError(UnknownUnaryOperatorError);
+        });
+        test('unknown binary operator', () => {
+            const expression = new BinaryNode('UNKNOWN_OPERATOR', new NumberNode(1), new NumberNode(2));
+            expect(() => evaluator.evaluate(expression)).toThrowError(UnknownBinaryOperatorError);
+        });
+        test('unknown node type', () => {
+            const expression = {
+                type: 'UNKNOWN_NODE_TYPE',
+                value: 42,
+            };
+            expect(() => evaluator.evaluate(expression)).toThrowError(UnknownNodeTypeError);
+        });
+    });
+    describe('special cases', () => {
+        test('division by zero', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(10), new NumberNode(0));
+            expect(() => evaluator.evaluate(expression)).toThrowError(DivisionByZeroError);
+        });
+        test('negative square root', () => {
+            const expression = new UnaryNode(UnaryNodeOperator.SQUARE_ROOT, new NumberNode(-4));
+            expect(() => evaluator.evaluate(expression)).toThrowError(NegativeSquareRootError);
+        });
+    });
+});

package/build/tests/expression_parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/expression_parser.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'vitest';
+import { expressionParserInput } from './inputs/expression_parser_input.js';
+import { ExpressionParser } from '../src/expression_parser.js';
+import { InvalidExpressionError } from '../src/errors/invalid_expression_error.js';
+import { UnknownBinaryOperatorError } from '../src/errors/unknown_binary_operator_error.js';
+import { MissingClosingParenthesisError } from '../src/errors/missing_parenthese_error.js';
+import { InvalidNumberError } from '../src/errors/invalid_number_error.js';
+describe('expression parser', () => {
+    test.each(expressionParserInput())('expression: %o', (input, expected) => {
+        const parser = new ExpressionParser();
+        expect(parser.parse(input)).toStrictEqual(expected);
+    });
+    describe('error cases', () => {
+        test('should throw an error if the expression is not complete', () => {
+            const parser = new ExpressionParser();
+            expect(() => parser.parse(['6', '+'])).toThrowError(InvalidExpressionError);
+        });
+        test('should throw an error if the expression is empty', () => {
+            const parser = new ExpressionParser();
+            expect(() => parser.parse([])).toThrowError(InvalidExpressionError);
+        });
+        test('should throw an error if the expression is invalid', () => {
+            const parser = new ExpressionParser();
+            expect(() => parser.parse(['6', '+', '5', 'invalid'])).toThrowError(InvalidExpressionError);
+        });
+        test.each([[['6', '+', '65a']], [['6', '+', 'a65']], [['6', '+', '6a5']]])('should throw an error if the expression has invalid numbers', (input) => {
+            const parser = new ExpressionParser();
+            expect(() => parser.parse(input)).toThrowError(InvalidNumberError);
+        });
+        test('should throw an error if the expression has missing parentheses', () => {
+            const parser = new ExpressionParser();
+            expect(() => parser.parse(['(', '6', '+', '5', '5'])).toThrowError(MissingClosingParenthesisError);
+        });
+        test('should throw an error if the parser can not map an operator', () => {
+            class FakeExpressionParser extends ExpressionParser {
+                test() {
+                    this.mapRowOperator('UNKNOWN_OPERATOR');
+                }
+            }
+            const parser = new FakeExpressionParser();
+            expect(() => parser.test()).toThrowError(UnknownBinaryOperatorError);
+        });
+    });
+});

package/build/tests/expression_tree.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/expression_tree.test.js

@@ -0,0 +1,12 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { ExpressionTree } from '../src/expression_tree.js';
+import { expressionTreeInput } from './inputs/expression_tree_input.js';
+describe('expression tree', () => {
+    let expressionTree;
+    beforeEach(() => {
+        expressionTree = new ExpressionTree();
+    });
+    test.each(expressionTreeInput())('expression: %s = %d', (expression, expectedResult) => {
+        expect(expressionTree.evaluate(expression)).toBe(expectedResult);
+    });
+});

package/build/tests/inputs/expression_cutter_input.d.ts

@@ -0,0 +1 @@
+export declare function expressionCutterInput(): [string, string[]][];

package/build/tests/inputs/expression_cutter_input.js

@@ -0,0 +1,230 @@
+export function expressionCutterInput() {
+    return [
+        // Addition
+        ['6 + 5', ['6', '+', '5']],
+        ['56 + 5', ['56', '+', '5']],
+        ['56 + 15', ['56', '+', '15']],
+        ['6 + 15', ['6', '+', '15']],
+        ['6+5', ['6', '+', '5']],
+        ['56+5', ['56', '+', '5']],
+        ['56+15', ['56', '+', '15']],
+        ['6+15', ['6', '+', '15']],
+        // Subtraction
+        ['6 - 4', ['6', '-', '4']],
+        ['61 - 4', ['61', '-', '4']],
+        ['61 - 14', ['61', '-', '14']],
+        ['6 - 14', ['6', '-', '14']],
+        ['6-4', ['6', '-', '4']],
+        ['61-4', ['61', '-', '4']],
+        ['61-14', ['61', '-', '14']],
+        ['6-14', ['6', '-', '14']],
+        // Multiplication
+        ['6 * 3', ['6', '*', '3']],
+        ['61 * 3', ['61', '*', '3']],
+        ['61 * 15', ['61', '*', '15']],
+        ['6 * 15', ['6', '*', '15']],
+        ['6*3', ['6', '*', '3']],
+        ['61*3', ['61', '*', '3']],
+        ['61*15', ['61', '*', '15']],
+        ['6*15', ['6', '*', '15']],
+        // Division
+        ['6 / 2', ['6', '/', '2']],
+        ['61 / 2', ['61', '/', '2']],
+        ['61 / 15', ['61', '/', '15']],
+        ['6 / 15', ['6', '/', '15']],
+        ['6/2', ['6', '/', '2']],
+        ['61/2', ['61', '/', '2']],
+        ['61/15', ['61', '/', '15']],
+        ['6/15', ['6', '/', '15']],
+        // Power
+        ['6 ^ 2', ['6', '^', '2']],
+        ['61 ^ 2', ['61', '^', '2']],
+        ['61 ^ 15', ['61', '^', '15']],
+        ['6 ^ 15', ['6', '^', '15']],
+        ['6^2', ['6', '^', '2']],
+        ['61^2', ['61', '^', '2']],
+        ['61^15', ['61', '^', '15']],
+        ['6^15', ['6', '^', '15']],
+        // Complex expressions
+        ['6 + 5 - 4 * 3 / 2', ['6', '+', '5', '-', '4', '*', '3', '/', '2']],
+        ['6 + 5 - 4 * 3 / 2 + 15', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15']],
+        ['6 + 5 - 4 * 3 / 2 - 15', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15']],
+        ['-6 + 5 - 4 * 3 / 2 + 15', ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15']],
+        ['-6 + 5 - 4 * 3 / 2 - 15', ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15']],
+        [
+            '6 + 5 - 4 * 3 / 2 + 15 - 10',
+            ['6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', '-', '10'],
+        ],
+        [
+            '6 + 5 - 4 * 3 / 2 - 15 + 10',
+            ['6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', '+', '10'],
+        ],
+        [
+            '6 + 5 - 4 * 3 / 2 + 15 ^ 2',
+            ['6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', '^', '2'],
+        ],
+        [
+            '6 + 5 - 4 * 3 / 2 - 15 ^ 2',
+            ['6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', '^', '2'],
+        ],
+        [
+            '-6 + 5 - 4 * 3 / 2 + 15 ^ 2',
+            ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', '^', '2'],
+        ],
+        [
+            '-6 + 5 - 4 * 3 / 2 - 15 ^ 2',
+            ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', '^', '2'],
+        ],
+        ['6+5-4*3/2', ['6', '+', '5', '-', '4', '*', '3', '/', '2']],
+        ['6+5-4*3/2+15', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15']],
+        ['6+5-4*3/2-15', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15']],
+        ['-6+5-4*3/2+15', ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15']],
+        ['-6+5-4*3/2-15', ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15']],
+        ['6+5-4*3/2+15-10', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', '-', '10']],
+        ['6+5-4*3/2-15+10', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', '+', '10']],
+        ['6+5-4*3/2+15^2', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', '^', '2']],
+        ['6+5-4*3/2-15^2', ['6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', '^', '2']],
+        ['-6+5-4*3/2+15^2', ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', '^', '2']],
+        ['-6+5-4*3/2-15^2', ['-', '6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', '^', '2']],
+        // Negative numbers
+        ['-6 + 5', ['-', '6', '+', '5']],
+        ['6 + -5', ['6', '+', '-', '5']],
+        ['-65 + 4', ['-', '65', '+', '4']],
+        ['6 + -45', ['6', '+', '-', '45']],
+        ['-6 - 5', ['-', '6', '-', '5']],
+        ['-65 - 4', ['-', '65', '-', '4']],
+        ['-6 * 5', ['-', '6', '*', '5']],
+        ['-65 * 4', ['-', '65', '*', '4']],
+        ['-6 / 5', ['-', '6', '/', '5']],
+        ['-65 / 4', ['-', '65', '/', '4']],
+        ['6 ^ -2', ['6', '^', '-', '2']],
+        ['-6 * -5 + 4 / -2', ['-', '6', '*', '-', '5', '+', '4', '/', '-', '2']],
+        ['-6+5', ['-', '6', '+', '5']],
+        ['6+-5', ['6', '+', '-', '5']],
+        ['-65+4', ['-', '65', '+', '4']],
+        ['6+-45', ['6', '+', '-', '45']],
+        ['-6-5', ['-', '6', '-', '5']],
+        ['-65-4', ['-', '65', '-', '4']],
+        ['-6*5', ['-', '6', '*', '5']],
+        ['-65*4', ['-', '65', '*', '4']],
+        ['-6/5', ['-', '6', '/', '5']],
+        ['-65/4', ['-', '65', '/', '4']],
+        ['-6*-5+4/-2', ['-', '6', '*', '-', '5', '+', '4', '/', '-', '2']],
+        // Parentheses
+        ['(3)', ['(', '3', ')']],
+        ['-(3)', ['-', '(', '3', ')']],
+        ['-(2+4)', ['-', '(', '2', '+', '4', ')']],
+        ['-((1+2)*3)', ['-', '(', '(', '1', '+', '2', ')', '*', '3', ')']],
+        ['5 + -(7-2)', ['5', '+', '-', '(', '7', '-', '2', ')']],
+        ['--(8/2)', ['-', '-', '(', '8', '/', '2', ')']],
+        ['(6)-(-3)', ['(', '6', ')', '-', '(', '-', '3', ')']],
+        ['(6 + 5)', ['(', '6', '+', '5', ')']],
+        ['(6 + 5) - 4', ['(', '6', '+', '5', ')', '-', '4']],
+        ['(6 + 5) * 4', ['(', '6', '+', '5', ')', '*', '4']],
+        ['(6 + 5) / 4', ['(', '6', '+', '5', ')', '/', '4']],
+        ['-(6 + 5) / 4', ['-', '(', '6', '+', '5', ')', '/', '4']],
+        ['(6 + 5) - (4 * 3)', ['(', '6', '+', '5', ')', '-', '(', '4', '*', '3', ')']],
+        ['(6 + 5) - (4 * 3 / 2)', ['(', '6', '+', '5', ')', '-', '(', '4', '*', '3', '/', '2', ')']],
+        [
+            '((6 + 5) - (4 * 3)) / 2',
+            ['(', '(', '6', '+', '5', ')', '-', '(', '4', '*', '3', ')', ')', '/', '2'],
+        ],
+        ['(56 + 5)', ['(', '56', '+', '5', ')']],
+        ['(6 + 15)', ['(', '6', '+', '15', ')']],
+        ['(61 - 4)', ['(', '61', '-', '4', ')']],
+        ['(6 - 14)', ['(', '6', '-', '14', ')']],
+        ['(6 * 3)', ['(', '6', '*', '3', ')']],
+        ['(61 * 3)', ['(', '61', '*', '3', ')']],
+        ['(61 / 2)', ['(', '61', '/', '2', ')']],
+        ['(6 / 15)', ['(', '6', '/', '15', ')']],
+        ['(6 ^ 2)', ['(', '6', '^', '2', ')']],
+        ['(61 ^ 2)', ['(', '61', '^', '2', ')']],
+        ['(61 ^ 15)', ['(', '61', '^', '15', ')']],
+        ['(6 ^ 15)', ['(', '6', '^', '15', ')']],
+        ['(6 + 5 - 4 * 3 / 2)', ['(', '6', '+', '5', '-', '4', '*', '3', '/', '2', ')']],
+        [
+            '(6 + 5 - 4 * 3 / 2 + 15)',
+            ['(', '6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', ')'],
+        ],
+        [
+            '(6 + 5 - 4 * 3 / 2 - 15)',
+            ['(', '6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', ')'],
+        ],
+        [
+            '-(6 + 5 - 4 * 3 / 2 + 15)',
+            ['-', '(', '6', '+', '5', '-', '4', '*', '3', '/', '2', '+', '15', ')'],
+        ],
+        [
+            '-(6 + 5 - 4 * 3 / 2 - 15)',
+            ['-', '(', '6', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', ')'],
+        ],
+        [
+            '(6 + 5 - 41 * 3 / 2 + 15 - 10)',
+            ['(', '6', '+', '5', '-', '41', '*', '3', '/', '2', '+', '15', '-', '10', ')'],
+        ],
+        [
+            '(65 + 5 - 4 * 3 / 2 - 15 + 10)',
+            ['(', '65', '+', '5', '-', '4', '*', '3', '/', '2', '-', '15', '+', '10', ')'],
+        ],
+        ['(6 + 5) ^ 2', ['(', '6', '+', '5', ')', '^', '2']],
+        ['(6 + 5) ^ 15', ['(', '6', '+', '5', ')', '^', '15']],
+        ['(6 ^ 2 + 5)', ['(', '6', '^', '2', '+', '5', ')']],
+        ['(6 + 5) ^ (4 * 3)', ['(', '6', '+', '5', ')', '^', '(', '4', '*', '3', ')']],
+        // Float numbers
+        ['6.5 + 5.2', ['6.5', '+', '5.2']],
+        ['-6.5 + 5.2', ['-', '6.5', '+', '5.2']],
+        ['6.5 - 4.3', ['6.5', '-', '4.3']],
+        ['-6.5 - 4.3', ['-', '6.5', '-', '4.3']],
+        ['6.5 * 3.1', ['6.5', '*', '3.1']],
+        ['-6.5 * 3.1', ['-', '6.5', '*', '3.1']],
+        ['6.5 / 2.2', ['6.5', '/', '2.2']],
+        ['-6.5 / 2.2', ['-', '6.5', '/', '2.2']],
+        ['6.5 + 5.2 - 4.3 * 3.1 / 2.2', ['6.5', '+', '5.2', '-', '4.3', '*', '3.1', '/', '2.2']],
+        [
+            '6.5 + 5.2 - 4.3 * 3.1 / 2.2 + 15.0',
+            ['6.5', '+', '5.2', '-', '4.3', '*', '3.1', '/', '2.2', '+', '15.0'],
+        ],
+        [
+            '6.5 + 5.2 - 4.3 * 3.1 / 2.2 - 15.0',
+            ['6.5', '+', '5.2', '-', '4.3', '*', '3.1', '/', '2.2', '-', '15.0'],
+        ],
+        [
+            '-6.5 + 5.2 - 4.3 * 3.1 / 2.2 + 15',
+            ['-', '6.5', '+', '5.2', '-', '4.3', '*', '3.1', '/', '2.2', '+', '15'],
+        ],
+        [
+            '-6.5 + 5.2 - 4.3 * 3.1 / 2.2 - 15',
+            ['-', '6.5', '+', '5.2', '-', '4.3', '*', '3.1', '/', '2.2', '-', '15'],
+        ],
+        // Square root
+        ['sqrt(4)', ['sqrt', '(', '4', ')']],
+        ['sqrt(16 + 9)', ['sqrt', '(', '16', '+', '9', ')']],
+        ['sqrt(25) + 3', ['sqrt', '(', '25', ')', '+', '3']],
+        ['3 + sqrt(36)', ['3', '+', 'sqrt', '(', '36', ')']],
+        ['sqrt(49) - 2', ['sqrt', '(', '49', ')', '-', '2']],
+        ['-sqrt(64)', ['-', 'sqrt', '(', '64', ')']],
+        ['sqrt(81) * 2', ['sqrt', '(', '81', ')', '*', '2']],
+        ['-3 + sqrt(100)', ['-', '3', '+', 'sqrt', '(', '100', ')']],
+        // Absolute value
+        ['abs(5)', ['abs', '(', '5', ')']],
+        ['abs(-5)', ['abs', '(', '-', '5', ')']],
+        ['abs(3 - 7)', ['abs', '(', '3', '-', '7', ')']],
+        ['abs(-3 + 7)', ['abs', '(', '-', '3', '+', '7', ')']],
+        ['-abs(4)', ['-', 'abs', '(', '4', ')']],
+        ['abs(6 * -2)', ['abs', '(', '6', '*', '-', '2', ')']],
+        ['-abs(-8 / 2)', ['-', 'abs', '(', '-', '8', '/', '2', ')']],
+        ['abs(9 + 1)', ['abs', '(', '9', '+', '1', ')']],
+        ['abs(-10 - 5)', ['abs', '(', '-', '10', '-', '5', ')']],
+        ['abs(12 * 3)', ['abs', '(', '12', '*', '3', ')']],
+        ['abs(-15 / 5)', ['abs', '(', '-', '15', '/', '5', ')']],
+        // Mixed operations
+        ['6 + sqrt(4)', ['6', '+', 'sqrt', '(', '4', ')']],
+        ['abs(3) + 5', ['abs', '(', '3', ')', '+', '5']],
+        ['-sqrt(16) - 2', ['-', 'sqrt', '(', '16', ')', '-', '2']],
+        ['(6 + 5) * abs(-3)', ['(', '6', '+', '5', ')', '*', 'abs', '(', '-', '3', ')']],
+        ['sqrt(25) / abs(-5)', ['sqrt', '(', '25', ')', '/', 'abs', '(', '-', '5', ')']],
+        ['abs(6 - 2) + sqrt(9)', ['abs', '(', '6', '-', '2', ')', '+', 'sqrt', '(', '9', ')']],
+        ['-abs(8) * sqrt(4)', ['-', 'abs', '(', '8', ')', '*', 'sqrt', '(', '4', ')']],
+        ['abs(-10) / (2 + 3)', ['abs', '(', '-', '10', ')', '/', '(', '2', '+', '3', ')']],
+    ];
+}

package/build/tests/inputs/expression_parser_input.d.ts

@@ -0,0 +1,2 @@
+import { BaseNode } from '../../src/models/base_node.js';
+export declare function expressionParserInput(): [string[], BaseNode][];