math-exercises 2.0.2 → 2.0.4

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

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOperatorNode = exports.OperatorIds = void 0;
-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 = exports.OperatorIds || (exports.OperatorIds = {}));
-function isOperatorNode(a) {
-    return a.type === node_1.NodeType.operator;
-}
-exports.isOperatorNode = isOperatorNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOperatorNode = exports.OperatorIds = void 0;
+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 || (exports.OperatorIds = OperatorIds = {}));
+function isOperatorNode(a) {
+    return a.type === node_1.NodeType.operator;
+}
+exports.isOperatorNode = isOperatorNode;

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

@@ -1,21 +1,20 @@
-import { Node, NodeOptions, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
-import { AlgebraicNode } from "../algebraicNode";
-export declare function isPowerNode(a: Node): a is PowerNode;
-export declare class PowerNode implements OperatorNode {
-    opts?: NodeOptions;
-    id: OperatorIds;
-    leftChild: AlgebraicNode;
-    rightChild: AlgebraicNode;
-    type: NodeType;
-    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
-    toMathString(): string;
-    toEquivalentNodes(): Node[];
-    toAllValidTexs(): string[];
-    toTex(): string;
-    toMathjs(): import("mathjs").MathType;
-}
-export declare class SquareNode extends PowerNode {
-    constructor(child: Node, opts?: NodeOptions);
-}
+import { Node, NodeOptions, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isPowerNode(a: Node): a is PowerNode;
+export declare class PowerNode implements OperatorNode {
+    opts?: NodeOptions;
+    id: OperatorIds;
+    leftChild: AlgebraicNode;
+    rightChild: AlgebraicNode;
+    type: NodeType;
+    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
+    toMathString(): string;
+    toEquivalentNodes(): Node[];
+    toAllValidTexs(): string[];
+    toTex(): string;
+}
+export declare class SquareNode extends PowerNode {
+    constructor(child: Node, opts?: NodeOptions);
+}
 //# sourceMappingURL=powerNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;gBAEb,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAoBf,QAAQ;CAGT;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;CAG5C"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;gBAEb,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;CAuBhB;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;CAG5C"}

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

@@ -1,80 +1,77 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SquareNode = exports.PowerNode = exports.isPowerNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const numberNode_1 = require("../numbers/numberNode");
-const multiplyNode_1 = require("./multiplyNode");
-function isPowerNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.power;
-}
-exports.isPowerNode = isPowerNode;
-class PowerNode {
-    constructor(leftChild, rightChild, opts) {
-        this.id = operatorNode_1.OperatorIds.power;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.type = node_1.NodeType.operator;
-        this.opts = opts;
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
-    }
-    toEquivalentNodes() {
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new PowerNode(leftNode, rightNode));
-                if (!this.opts?.forbidPowerToProduct && (0, numberNode_1.isNumberNode)(this.rightChild)) {
-                    const power = this.rightChild.value;
-                    if (Math.floor(power) !== power || power < 2)
-                        return;
-                    let tree = new multiplyNode_1.MultiplyNode(leftNode, leftNode);
-                    for (let i = 2; i < power; i++) {
-                        tree = new multiplyNode_1.MultiplyNode(tree, leftNode);
-                    }
-                    res.push(tree);
-                }
-            });
-        });
-        return res;
-    }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        let needBrackets = leftTex[0] === "-";
-        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
-            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(this.leftChild.id);
-        }
-        if (needBrackets)
-            leftTex = `\\left(${leftTex}\\right)`;
-        const needBrace = rightTex.length > 1;
-        if (needBrace)
-            return `${leftTex}^{${rightTex}}`;
-        else
-            return `${leftTex}^${rightTex}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.pow)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.PowerNode = PowerNode;
-class SquareNode extends PowerNode {
-    constructor(child, opts) {
-        super(child, new numberNode_1.NumberNode(2), opts);
-    }
-}
-exports.SquareNode = SquareNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquareNode = exports.PowerNode = exports.isPowerNode = void 0;
+// import { pow } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+const numberNode_1 = require("../numbers/numberNode");
+const multiplyNode_1 = require("./multiplyNode");
+function isPowerNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.power;
+}
+exports.isPowerNode = isPowerNode;
+class PowerNode {
+    constructor(leftChild, rightChild, opts) {
+        this.id = operatorNode_1.OperatorIds.power;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
+        this.opts = opts;
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new PowerNode(leftNode, rightNode));
+                if (!this.opts?.forbidPowerToProduct && (0, numberNode_1.isNumberNode)(this.rightChild)) {
+                    const power = this.rightChild.value;
+                    if (Math.floor(power) !== power || power < 2)
+                        return;
+                    let tree = new multiplyNode_1.MultiplyNode(leftNode, leftNode);
+                    for (let i = 2; i < power; i++) {
+                        tree = new multiplyNode_1.MultiplyNode(tree, leftNode);
+                    }
+                    res.push(tree);
+                }
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        let needBrackets = leftTex[0] === "-";
+        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
+            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(this.leftChild.id);
+        }
+        if (needBrackets)
+            leftTex = `\\left(${leftTex}\\right)`;
+        const needBrace = rightTex.length > 1;
+        if (needBrace)
+            return `${leftTex}^{${rightTex}}`;
+        else
+            return `${leftTex}^${rightTex}`;
+    }
+}
+exports.PowerNode = PowerNode;
+class SquareNode extends PowerNode {
+    constructor(child, opts) {
+        super(child, new numberNode_1.NumberNode(2), opts);
+    }
+}
+exports.SquareNode = SquareNode;

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

@@ -1,16 +1,15 @@
-import { Node, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
-export declare function isSubstractNode(a: Node): a is SubstractNode;
-export declare class SubstractNode implements OperatorNode {
-    id: OperatorIds;
-    leftChild: Node;
-    rightChild: Node;
-    type: NodeType;
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toEquivalentNodes(): Node[];
-    toAllValidTexs(): string[];
-    toTex(): string;
-    toMathjs(): any;
-}
+import { Node, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+export declare function isSubstractNode(a: Node): a is SubstractNode;
+export declare class SubstractNode implements OperatorNode {
+    id: OperatorIds;
+    leftChild: Node;
+    rightChild: Node;
+    type: NodeType;
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toEquivalentNodes(): Node[];
+    toAllValidTexs(): string[];
+    toTex(): string;
+}
 //# sourceMappingURL=substractNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IAO7C,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAa3B,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;IAef,QAAQ;CAGT"}
+{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IAO7C,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAa3B,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;CAkBhB"}

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

@@ -1,52 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubstractNode = exports.isSubstractNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const oppositeNode_1 = require("../functions/oppositeNode");
-const addNode_1 = require("./addNode");
-function isSubstractNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.substract;
-}
-exports.isSubstractNode = isSubstractNode;
-class SubstractNode {
-    constructor(leftChild, rightChild) {
-        this.id = operatorNode_1.OperatorIds.substract;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.type = node_1.NodeType.operator;
-    }
-    toMathString() {
-        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
-    }
-    toEquivalentNodes() {
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new SubstractNode(leftNode, rightNode));
-                res.push(new addNode_1.AddNode(new oppositeNode_1.OppositeNode(rightNode), leftNode));
-            });
-        });
-        return res;
-    }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        const needBrackets = ((0, operatorNode_1.isOperatorNode)(this.rightChild) &&
-            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
-            rightTex[0] === "-";
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        return `${leftTex}-${rightTex}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.subtract)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.SubstractNode = SubstractNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstractNode = exports.isSubstractNode = void 0;
+// import { subtract } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+const oppositeNode_1 = require("../functions/oppositeNode");
+const addNode_1 = require("./addNode");
+function isSubstractNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.substract;
+}
+exports.isSubstractNode = isSubstractNode;
+class SubstractNode {
+    constructor(leftChild, rightChild) {
+        this.id = operatorNode_1.OperatorIds.substract;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new SubstractNode(leftNode, rightNode));
+                res.push(new addNode_1.AddNode(new oppositeNode_1.OppositeNode(rightNode), leftNode));
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        const needBrackets = ((0, operatorNode_1.isOperatorNode)(this.rightChild) &&
+            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
+            rightTex[0] === "-";
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        return `${leftTex}-${rightTex}`;
+    }
+}
+exports.SubstractNode = SubstractNode;

package/lib/tree/nodes/sets/belongsNode.d.ts

@@ -1,15 +1,15 @@
-import { Node, NodeOptions, NodeType } from "../node";
-import { SetNode } from "./setNode";
-export declare class BelongsNode implements Node {
-    type: NodeType;
-    opts?: NodeOptions | undefined;
-    leftChild: Node;
-    rightChild: SetNode;
-    constructor(leftChild: Node, rightChild: SetNode, opts?: NodeOptions);
-    toAllValidTexs(): string[];
-    toEquivalentNodes(opts?: NodeOptions): Node[];
-    toMathString(): string;
-    toMathjs(): string;
-    toTex(): string;
-}
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare class BelongsNode implements Node {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    leftChild: Node;
+    rightChild: SetNode;
+    constructor(leftChild: Node, rightChild: SetNode, opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): Node[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=belongsNode.d.ts.map

package/lib/tree/nodes/sets/belongsNode.js

@@ -1,36 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BelongsNode = void 0;
-const node_1 = require("../node");
-class BelongsNode {
-    constructor(leftChild, rightChild, opts) {
-        this.type = node_1.NodeType.belongs;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.opts = opts;
-    }
-    toAllValidTexs() {
-        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
-    }
-    toEquivalentNodes(opts) {
-        const options = opts ?? this.opts;
-        const rightEquivs = this.rightChild.toEquivalentNodes(options);
-        if (options?.allowRawRightChildAsSolution)
-            return rightEquivs.flatMap((equiv) => [
-                new BelongsNode(this.leftChild, equiv, options),
-                equiv,
-            ]);
-        else
-            return rightEquivs.map((equiv) => new BelongsNode(this.leftChild, equiv, options));
-    }
-    toMathString() {
-        return this.toTex();
-    }
-    toMathjs() {
-        return this.toTex();
-    }
-    toTex() {
-        return `${this.leftChild.toTex()}\\in${this.rightChild.toTex()}`;
-    }
-}
-exports.BelongsNode = BelongsNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsNode = void 0;
+const node_1 = require("../node");
+class BelongsNode {
+    constructor(leftChild, rightChild, opts) {
+        this.type = node_1.NodeType.belongs;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const rightEquivs = this.rightChild.toEquivalentNodes(options);
+        if (options?.allowRawRightChildAsSolution)
+            return rightEquivs.flatMap((equiv) => [
+                new BelongsNode(this.leftChild, equiv, options),
+                equiv,
+            ]);
+        else
+            return rightEquivs.map((equiv) => new BelongsNode(this.leftChild, equiv, options));
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+    toTex() {
+        return `${this.leftChild.toTex()}\\in${this.rightChild.toTex()}`;
+    }
+}
+exports.BelongsNode = BelongsNode;

package/lib/tree/nodes/sets/discreteSetNode.d.ts

@@ -1,15 +1,15 @@
-import { Node, NodeOptions, NodeType } from "../node";
-import { SetNode } from "./setNode";
-export declare class DiscreteSetNode implements SetNode {
-    type: NodeType;
-    opts?: NodeOptions | undefined;
-    elements: Node[];
-    constructor(elements: Node[], opts?: NodeOptions);
-    toAllValidTexs(): string[];
-    toEquivalentNodes(opts?: NodeOptions): DiscreteSetNode[];
-    toMathString(): string;
-    toMathjs(): string;
-    toTex(): string;
-}
-export declare const EmptySet: DiscreteSetNode;
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare class DiscreteSetNode implements SetNode {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    elements: Node[];
+    constructor(elements: Node[], opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): DiscreteSetNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+export declare const EmptySet: DiscreteSetNode;
 //# sourceMappingURL=discreteSetNode.d.ts.map

package/lib/tree/nodes/sets/discreteSetNode.js

@@ -1,54 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptySet = exports.DiscreteSetNode = void 0;
-const cartesianProducts_1 = require("../../../utils/cartesianProducts");
-const permutations_1 = require("../../../utils/permutations");
-const node_1 = require("../node");
-class DiscreteSetNode {
-    constructor(elements, opts) {
-        this.type = node_1.NodeType.set;
-        this.elements = elements;
-        this.opts = opts;
-    }
-    toAllValidTexs() {
-        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
-    }
-    toEquivalentNodes(opts) {
-        if (this.elements.length === 0)
-            return [this];
-        if (this.elements.length === 1) {
-            return this.elements[0]
-                .toEquivalentNodes(opts ?? this.opts)
-                .map((node) => new DiscreteSetNode([node]));
-        }
-        //produits cartésiens
-        else {
-            const res = [];
-            const equivNodesArr = this.elements.map((node) => node.toEquivalentNodes(opts ?? this.opts));
-            //!pas opti car si [2,3,3] alors les 3 se permutent et donc double sortie [2,3_1,3_2], [2,3_2,3_1]
-            let equivNodesPermutations = (0, permutations_1.permute)(equivNodesArr);
-            equivNodesPermutations.forEach((permutation) => {
-                const cartesiansProducts = (0, cartesianProducts_1.getCartesiansProducts)(permutation);
-                cartesiansProducts.forEach((product) => {
-                    res.push(new DiscreteSetNode(product));
-                });
-            });
-            return res;
-        }
-    }
-    toMathString() {
-        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
-    }
-    toMathjs() {
-        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
-    }
-    toTex() {
-        if (!this.elements.length)
-            return `\\emptyset`;
-        return `\\left\\{${this.elements
-            .map((el) => el.toTex())
-            .join(";")}\\right\\}`;
-    }
-}
-exports.DiscreteSetNode = DiscreteSetNode;
-exports.EmptySet = new DiscreteSetNode([]);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptySet = exports.DiscreteSetNode = void 0;
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const permutations_1 = require("../../../utils/permutations");
+const node_1 = require("../node");
+class DiscreteSetNode {
+    constructor(elements, opts) {
+        this.type = node_1.NodeType.set;
+        this.elements = elements;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        if (this.elements.length === 0)
+            return [this];
+        if (this.elements.length === 1) {
+            return this.elements[0]
+                .toEquivalentNodes(opts ?? this.opts)
+                .map((node) => new DiscreteSetNode([node]));
+        }
+        //produits cartésiens
+        else {
+            const res = [];
+            const equivNodesArr = this.elements.map((node) => node.toEquivalentNodes(opts ?? this.opts));
+            //!pas opti car si [2,3,3] alors les 3 se permutent et donc double sortie [2,3_1,3_2], [2,3_2,3_1]
+            let equivNodesPermutations = (0, permutations_1.permute)(equivNodesArr);
+            equivNodesPermutations.forEach((permutation) => {
+                const cartesiansProducts = (0, cartesianProducts_1.getCartesiansProducts)(permutation);
+                cartesiansProducts.forEach((product) => {
+                    res.push(new DiscreteSetNode(product));
+                });
+            });
+            return res;
+        }
+    }
+    toMathString() {
+        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
+    }
+    toMathjs() {
+        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
+    }
+    toTex() {
+        if (!this.elements.length)
+            return `\\emptyset`;
+        return `\\left\\{${this.elements
+            .map((el) => el.toTex())
+            .join(";")}\\right\\}`;
+    }
+}
+exports.DiscreteSetNode = DiscreteSetNode;
+exports.EmptySet = new DiscreteSetNode([]);