math-exercises 1.3.52 → 1.3.53

package/lib/tree/nodes/operators/addNode.js

@@ -1,23 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddNode = void 0;
-const mathjs_1 = require("mathjs");
-const operatorNode_1 = require("./operatorNode");
-class AddNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.add, leftChild, rightChild, true, '+');
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-    }
-    toMathString() {
-        return `${this.leftChild.toMathString()} + (${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        const rightTex = this.rightChild.toTex();
-        return `${this.leftChild.toTex()} ${rightTex[0] === '-' ? '' : '+ '}${rightTex}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.add)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.AddNode = AddNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddNode = void 0;
+const mathjs_1 = require("mathjs");
+const operatorNode_1 = require("./operatorNode");
+class AddNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.add, leftChild, rightChild, true, '+');
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()} + (${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        const rightTex = this.rightChild.toTex();
+        return `${this.leftChild.toTex()} ${rightTex[0] === '-' ? '' : '+ '}${rightTex}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.add)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.AddNode = AddNode;

package/lib/tree/nodes/operators/divideNode.d.ts

@@ -1,13 +1,13 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class DivideNode extends OperatorNode implements Node {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): number | import("mathjs").Unit;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class DivideNode extends OperatorNode implements Node {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): number | import("mathjs").Unit;
+}
 //# sourceMappingURL=divideNode.d.ts.map

package/lib/tree/nodes/operators/divideNode.js

@@ -1,38 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DivideNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class DivideNode extends operatorNode_1.OperatorNode {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, '\\div');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        if (this.leftChild.type === node_1.NodeType.operator) {
-            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(this.leftChild.id))
-                leftTex = `(${leftTex})`;
-        }
-        let needBrackets = rightTex[0] === '-';
-        if (this.rightChild.type === node_1.NodeType.operator) {
-            const operatorRightChild = this.rightChild;
-            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(operatorRightChild.id));
-        }
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        return `${leftTex} \\div ${rightTex}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.divide)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.DivideNode = DivideNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DivideNode = void 0;
+const mathjs_1 = require("mathjs");
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class DivideNode extends operatorNode_1.OperatorNode {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, '\\div');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        if (this.leftChild.type === node_1.NodeType.operator) {
+            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(this.leftChild.id))
+                leftTex = `(${leftTex})`;
+        }
+        let needBrackets = rightTex[0] === '-';
+        if (this.rightChild.type === node_1.NodeType.operator) {
+            const operatorRightChild = this.rightChild;
+            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(operatorRightChild.id));
+        }
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        return `${leftTex} \\div ${rightTex}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.divide)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.DivideNode = DivideNode;

package/lib/tree/nodes/operators/equalNode.d.ts

@@ -1,9 +1,9 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class EqualNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): boolean | import("mathjs").MathCollection;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class EqualNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): boolean | import("mathjs").MathCollection;
+}
 //# sourceMappingURL=equalNode.d.ts.map

package/lib/tree/nodes/operators/equalNode.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EqualNode = void 0;
-const mathjs_1 = require("mathjs");
-const operatorNode_1 = require("./operatorNode");
-class EqualNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, '=');
-    }
-    toMathString() {
-        return `${this.leftChild.toMathString()} = ${this.rightChild.toMathString()}`;
-    }
-    toTex() {
-        return `${this.leftChild.toTex()} = ${this.rightChild.toTex()}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.equal)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.EqualNode = EqualNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EqualNode = void 0;
+const mathjs_1 = require("mathjs");
+const operatorNode_1 = require("./operatorNode");
+class EqualNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, '=');
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()} = ${this.rightChild.toMathString()}`;
+    }
+    toTex() {
+        return `${this.leftChild.toTex()} = ${this.rightChild.toTex()}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.equal)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.EqualNode = EqualNode;

package/lib/tree/nodes/operators/fractionNode.d.ts

@@ -1,13 +1,13 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class FractionNode extends OperatorNode implements Node {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): import("mathjs").Fraction;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class FractionNode extends OperatorNode implements Node {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): import("mathjs").Fraction;
+}
 //# sourceMappingURL=fractionNode.d.ts.map

package/lib/tree/nodes/operators/fractionNode.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FractionNode = void 0;
-const mathjs_1 = require("mathjs");
-const operatorNode_1 = require("./operatorNode");
-class FractionNode extends operatorNode_1.OperatorNode {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, '\\frac');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.fraction)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.FractionNode = FractionNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FractionNode = void 0;
+const mathjs_1 = require("mathjs");
+const operatorNode_1 = require("./operatorNode");
+class FractionNode extends operatorNode_1.OperatorNode {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, '\\frac');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.fraction)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.FractionNode = FractionNode;

package/lib/tree/nodes/operators/multiplyNode.d.ts

@@ -1,9 +1,9 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class MultiplyNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): any;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class MultiplyNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): any;
+}
 //# sourceMappingURL=multiplyNode.d.ts.map

package/lib/tree/nodes/operators/multiplyNode.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = void 0;
-const mathjs_1 = require("mathjs");
-const functionNode_1 = require("../functions/functionNode");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class MultiplyNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        let [left, right] = [leftChild, rightChild];
-        const shouldSwitch = (rightChild.type === node_1.NodeType.function && rightChild.id === functionNode_1.FunctionsIds.opposite) ||
-            (leftChild.type === node_1.NodeType.constant && rightChild.type === node_1.NodeType.number);
-        if (shouldSwitch) {
-            [left, right] = [rightChild, leftChild];
-        }
-        super(operatorNode_1.OperatorIds.multiply, left, right, true, '\\times');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let leftTex = this.leftChild.toTex();
-        let rightTex = this.rightChild.toTex();
-        if (this.rightChild.type === node_1.NodeType.variable) {
-            if (leftTex === '1') {
-                return rightTex;
-            }
-        }
-        if (this.leftChild.type === node_1.NodeType.operator) {
-            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))
-                leftTex = `(${leftTex})`;
-        }
-        let needBrackets = rightTex[0] === '-';
-        if (this.rightChild.type === node_1.NodeType.operator) {
-            const operatorRightChild = this.rightChild;
-            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-        }
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        //  permet de gérer le cas 3*2^x par ex
-        let showTimesSign = !isNaN(+rightTex[0]) || this.rightChild.type === node_1.NodeType.number;
-        if (this.rightChild.type === node_1.NodeType.operator) {
-            const operatorRightChild = this.rightChild;
-            showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
-        }
-        return `${leftTex}${showTimesSign ? '\\times ' : ''}${rightTex}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.multiply)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.MultiplyNode = MultiplyNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiplyNode = void 0;
+const mathjs_1 = require("mathjs");
+const functionNode_1 = require("../functions/functionNode");
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class MultiplyNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        let [left, right] = [leftChild, rightChild];
+        const shouldSwitch = (rightChild.type === node_1.NodeType.function && rightChild.id === functionNode_1.FunctionsIds.opposite) ||
+            (leftChild.type === node_1.NodeType.constant && rightChild.type === node_1.NodeType.number);
+        if (shouldSwitch) {
+            [left, right] = [rightChild, leftChild];
+        }
+        super(operatorNode_1.OperatorIds.multiply, left, right, true, '\\times');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let leftTex = this.leftChild.toTex();
+        let rightTex = this.rightChild.toTex();
+        if (this.rightChild.type === node_1.NodeType.variable) {
+            if (leftTex === '1') {
+                return rightTex;
+            }
+        }
+        if (this.leftChild.type === node_1.NodeType.operator) {
+            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))
+                leftTex = `(${leftTex})`;
+        }
+        let needBrackets = rightTex[0] === '-';
+        if (this.rightChild.type === node_1.NodeType.operator) {
+            const operatorRightChild = this.rightChild;
+            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+        }
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        //  permet de gérer le cas 3*2^x par ex
+        let showTimesSign = !isNaN(+rightTex[0]) || this.rightChild.type === node_1.NodeType.number;
+        if (this.rightChild.type === node_1.NodeType.operator) {
+            const operatorRightChild = this.rightChild;
+            showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
+        }
+        return `${leftTex}${showTimesSign ? '\\times ' : ''}${rightTex}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.multiply)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.MultiplyNode = MultiplyNode;

package/lib/tree/nodes/operators/operatorNode.d.ts

@@ -1,22 +1,22 @@
-import { Node, NodeType } from '../node';
-export declare enum OperatorIds {
-    add = 0,
-    substract = 1,
-    multiply = 2,
-    fraction = 3,
-    divide = 4,
-    power = 5,
-    equal = 6
-}
-export declare abstract class OperatorNode {
-    id: OperatorIds;
-    leftChild: Node;
-    rightChild: Node;
-    isCommutative: boolean;
-    type: NodeType;
-    tex: string;
-    constructor(id: OperatorIds, leftChild: Node, rightChild: Node, isCommutative: boolean, tex: string);
-    /**shuffles in place */
-    shuffle(): void;
-}
+import { Node, NodeType } from '../node';
+export declare enum OperatorIds {
+    add = 0,
+    substract = 1,
+    multiply = 2,
+    fraction = 3,
+    divide = 4,
+    power = 5,
+    equal = 6
+}
+export declare abstract class OperatorNode {
+    id: OperatorIds;
+    leftChild: Node;
+    rightChild: Node;
+    isCommutative: boolean;
+    type: NodeType;
+    tex: string;
+    constructor(id: OperatorIds, leftChild: Node, rightChild: Node, isCommutative: boolean, tex: string);
+    /**shuffles in place */
+    shuffle(): void;
+}
 //# sourceMappingURL=operatorNode.d.ts.map

package/lib/tree/nodes/operators/operatorNode.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorNode = exports.OperatorIds = void 0;
-const coinFlip_1 = require("../../../utils/coinFlip");
-const node_1 = require("../node");
-var OperatorIds;
-(function (OperatorIds) {
-    OperatorIds[OperatorIds["add"] = 0] = "add";
-    OperatorIds[OperatorIds["substract"] = 1] = "substract";
-    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
-    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
-    OperatorIds[OperatorIds["divide"] = 4] = "divide";
-    OperatorIds[OperatorIds["power"] = 5] = "power";
-    OperatorIds[OperatorIds["equal"] = 6] = "equal";
-})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
-class OperatorNode {
-    constructor(id, leftChild, rightChild, isCommutative, tex) {
-        this.type = node_1.NodeType.operator;
-        this.id = id;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.isCommutative = isCommutative;
-        this.tex = tex;
-    }
-    /**shuffles in place */
-    shuffle() {
-        if (!this.isCommutative)
-            return;
-        if ((0, coinFlip_1.coinFlip)())
-            return;
-        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
-        return;
-    }
-}
-exports.OperatorNode = OperatorNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorNode = exports.OperatorIds = void 0;
+const coinFlip_1 = require("../../../utils/coinFlip");
+const node_1 = require("../node");
+var OperatorIds;
+(function (OperatorIds) {
+    OperatorIds[OperatorIds["add"] = 0] = "add";
+    OperatorIds[OperatorIds["substract"] = 1] = "substract";
+    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
+    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
+    OperatorIds[OperatorIds["divide"] = 4] = "divide";
+    OperatorIds[OperatorIds["power"] = 5] = "power";
+    OperatorIds[OperatorIds["equal"] = 6] = "equal";
+})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
+class OperatorNode {
+    constructor(id, leftChild, rightChild, isCommutative, tex) {
+        this.type = node_1.NodeType.operator;
+        this.id = id;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.isCommutative = isCommutative;
+        this.tex = tex;
+    }
+    /**shuffles in place */
+    shuffle() {
+        if (!this.isCommutative)
+            return;
+        if ((0, coinFlip_1.coinFlip)())
+            return;
+        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+        return;
+    }
+}
+exports.OperatorNode = OperatorNode;

package/lib/tree/nodes/operators/powerNode.d.ts

@@ -1,9 +1,9 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class PowerNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): import("mathjs").MathType;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class PowerNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): import("mathjs").MathType;
+}
 //# sourceMappingURL=powerNode.d.ts.map

package/lib/tree/nodes/operators/powerNode.js

@@ -1,37 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PowerNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class PowerNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        let needBrackets = leftTex[0] === '-';
-        if (this.leftChild.type === node_1.NodeType.operator) {
-            const childOperator = this.leftChild;
-            needBrackets || (needBrackets = [
-                operatorNode_1.OperatorIds.add,
-                operatorNode_1.OperatorIds.substract,
-                operatorNode_1.OperatorIds.multiply,
-                operatorNode_1.OperatorIds.divide,
-                operatorNode_1.OperatorIds.fraction,
-                operatorNode_1.OperatorIds.power,
-            ].includes(childOperator.id));
-        }
-        if (needBrackets)
-            leftTex = `(${leftTex})`;
-        return `${leftTex}^{${rightTex}}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.pow)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.PowerNode = PowerNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerNode = void 0;
+const mathjs_1 = require("mathjs");
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class PowerNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        let needBrackets = leftTex[0] === '-';
+        if (this.leftChild.type === node_1.NodeType.operator) {
+            const childOperator = this.leftChild;
+            needBrackets || (needBrackets = [
+                operatorNode_1.OperatorIds.add,
+                operatorNode_1.OperatorIds.substract,
+                operatorNode_1.OperatorIds.multiply,
+                operatorNode_1.OperatorIds.divide,
+                operatorNode_1.OperatorIds.fraction,
+                operatorNode_1.OperatorIds.power,
+            ].includes(childOperator.id));
+        }
+        if (needBrackets)
+            leftTex = `(${leftTex})`;
+        return `${leftTex}^{${rightTex}}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.pow)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.PowerNode = PowerNode;

package/lib/tree/nodes/operators/substractNode.d.ts

@@ -1,9 +1,9 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class SubstractNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): any;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class SubstractNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): any;
+}
 //# sourceMappingURL=substractNode.d.ts.map