math-exercises 2.0.7 → 2.0.9

package/lib/tree/nodes/functions/sinNode.js

@@ -4,6 +4,7 @@ exports.SinNode = exports.isSinNode = void 0;
 // import { sin } from "mathjs";
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
+const remarkableValues_1 = require("../../../math/trigonometry/remarkableValues");
 function isSinNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.sin;
 }
@@ -13,6 +14,7 @@ class SinNode {
         this.id = functionNode_1.FunctionsIds.opposite;
         this.child = child;
         this.type = node_1.NodeType.function;
+        this.isNumeric = child.isNumeric;
     }
     toMathString() {
         return `sin(${this.child.toMathString()})`;
@@ -35,10 +37,29 @@ class SinNode {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }
     simplify() {
+        const simplifiedChild = this.child.simplify();
+        if (!(0, node_1.hasVariableNode)(simplifiedChild)) {
+            const value = simplifiedChild.evaluate({});
+            const moduled = Math.abs(value % (2 * Math.PI));
+            const trigoPoint = remarkableValues_1.remarkableTrigoValues.find((value) => value.angle.evaluate({}) === moduled);
+            if (!trigoPoint)
+                return this;
+            else
+                return trigoPoint.cos;
+        }
+        else {
+            //écrire les regles albgeiruqe
+            //chaque simplification doit relancer tout le simplify
+            //cos(x+2PI)
+            //cos(-x)
+        }
         return this;
     }
     evaluate(vars) {
         return Math.sin(this.child.evaluate(vars));
     }
+    equals(node) {
+        return isSinNode(node) && node.child.equals(this.child);
+    }
 }
 exports.SinNode = SinNode;

package/lib/tree/nodes/functions/sqrtNode.d.ts

@@ -7,11 +7,14 @@ export declare class SqrtNode implements FunctionNode {
     child: AlgebraicNode;
     type: NodeType;
     opts?: NodeOptions;
+    isNumeric: boolean;
     constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toTex(): string;
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(): string[];
     evaluate(vars: Record<string, number>): number;
+    simplify(): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=sqrtNode.d.ts.map

package/lib/tree/nodes/functions/sqrtNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AACD,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpD,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGtC"}
+{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AACD,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ;IAmCR,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGrC"}

package/lib/tree/nodes/functions/sqrtNode.js

@@ -8,6 +8,7 @@ const real_1 = require("../../../math/numbers/reals/real");
 const numberNode_1 = require("../numbers/numberNode");
 const multiplyNode_1 = require("../operators/multiplyNode");
 const isInt_1 = require("../../../utils/isInt");
+const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
 function isSqrtNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.sqrt;
 }
@@ -18,6 +19,7 @@ class SqrtNode {
         this.child = child;
         this.type = node_1.NodeType.function;
         this.opts = opts;
+        this.isNumeric = child.isNumeric;
     }
     toMathString() {
         return `sqr(${this.child.toMathString()})`;
@@ -53,5 +55,44 @@ class SqrtNode {
     evaluate(vars) {
         return Math.sqrt(this.child.evaluate(vars));
     }
+    simplify() {
+        const simplifiedChild = this.child.simplify();
+        const copy = new SqrtNode(simplifiedChild, this.opts);
+        const externals = [];
+        //ex [3, x^2] pour sqrt(3x^2)
+        //TODO fractions
+        const recursive = (node) => {
+            if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+                recursive(node.leftChild);
+                recursive(node.rightChild);
+            }
+            else {
+                externals.push(node);
+            }
+        };
+        recursive(copy.child);
+        const simplifyExternalNodes = (a) => {
+            if ((0, numberNode_1.isNumberNode)(a)) {
+                const sqrt = new real_1.SquareRoot(a.value);
+                return sqrt.simplify().toTree();
+            }
+            //TODO diviser par 2 les puissances (dont exp)
+            return new SqrtNode(a);
+        };
+        const simplifyIteration = () => {
+            for (let i = 0; i < externals.length; i++) {
+                const simplified = simplifyExternalNodes(externals[i]);
+                externals[i] = simplified;
+                return;
+            }
+        };
+        simplifyIteration();
+        if (externals.length === 1)
+            return externals[0];
+        return (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externals).simplify();
+    }
+    equals(node) {
+        return isSqrtNode(node) && node.child.equals(this.child);
+    }
 }
 exports.SqrtNode = SqrtNode;

package/lib/tree/nodes/geometry/lengthNode.d.ts

@@ -1,9 +1,11 @@
 import { AlgebraicNode } from "../algebraicNode";
-import { NodeOptions, NodeType } from "../node";
+import { Node, NodeOptions, NodeType } from "../node";
+export declare function isLengthNode(a: Node): a is LengthNode;
 export declare class LengthNode implements AlgebraicNode {
     opts?: NodeOptions | undefined;
     segmentName: string;
     type: NodeType;
+    isNumeric: boolean;
     constructor(segmentName: string, opts?: NodeOptions);
     toAllValidTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions): LengthNode[];
@@ -11,5 +13,7 @@ export declare class LengthNode implements AlgebraicNode {
     toMathjs(): string;
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
+    simplify(): this;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=lengthNode.d.ts.map

package/lib/tree/nodes/geometry/lengthNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lengthNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/geometry/lengthNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhD,qBAAa,UAAW,YAAW,aAAa;IAC9C,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;gBAEH,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW;IASnD,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAOpC,YAAY;IAGZ,QAAQ;IAIR,KAAK;IAIL,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAQtC"}
+{"version":3,"file":"lengthNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/geometry/lengthNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW;IAUnD,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAOpC,YAAY;IAGZ,QAAQ;IAIR,KAAK;IAIL,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

package/lib/tree/nodes/geometry/lengthNode.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LengthNode = void 0;
+exports.LengthNode = exports.isLengthNode = void 0;
 const node_1 = require("../node");
+function isLengthNode(a) {
+    return a.type === node_1.NodeType.mesure;
+}
+exports.isLengthNode = isLengthNode;
 class LengthNode {
     constructor(segmentName, opts) {
         this.type = node_1.NodeType.mesure;
         this.opts = opts;
         this.segmentName = segmentName;
+        this.isNumeric = false;
     }
     //   toAllTexs() {
     //     return [this.segmentName, this.segmentName.split("").reverse().join()];
@@ -36,5 +41,11 @@ class LengthNode {
             throw Error(`Can't evaluate length ${this.segmentName}`);
         return value;
     }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return isLengthNode(node) && node.segmentName === this.segmentName;
+    }
 }
 exports.LengthNode = LengthNode;

package/lib/tree/nodes/node.d.ts

@@ -31,4 +31,5 @@ export interface Node {
     toAllValidTexs: (opts?: NodeOptions) => string[];
     toTex: () => string;
 }
+export declare const hasVariableNode: (n: Node) => boolean;
 //# sourceMappingURL=node.d.ts.map

package/lib/tree/nodes/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,GAAG,IAAA;IACH,UAAU,IAAA;IACV,KAAK,IAAA;IACL,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,KAAA;IACP,MAAM,KAAA;CACP;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AACF,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,EAAE,CAAC;IACjD,KAAK,EAAE,MAAM,MAAM,CAAC;CAGrB"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAIA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,GAAG,IAAA;IACH,UAAU,IAAA;IACV,KAAK,IAAA;IACL,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,KAAA;IACP,MAAM,KAAA;CACP;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AACF,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,EAAE,CAAC;IACjD,KAAK,EAAE,MAAM,MAAM,CAAC;CAGrB;AAED,eAAO,MAAM,eAAe,MAAO,IAAI,KAAG,OAMzC,CAAC"}

package/lib/tree/nodes/node.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeType = void 0;
+exports.hasVariableNode = exports.NodeType = void 0;
+const functionNode_1 = require("./functions/functionNode");
+const operatorNode_1 = require("./operators/operatorNode");
+const variableNode_1 = require("./variables/variableNode");
 var NodeType;
 (function (NodeType) {
     NodeType[NodeType["number"] = 0] = "number";
@@ -16,3 +19,13 @@ var NodeType;
     NodeType[NodeType["belongs"] = 10] = "belongs";
     NodeType[NodeType["vector"] = 11] = "vector";
 })(NodeType || (exports.NodeType = NodeType = {}));
+const hasVariableNode = (n) => {
+    if ((0, variableNode_1.isVariableNode)(n))
+        return true;
+    if ((0, operatorNode_1.isOperatorNode)(n))
+        return (0, exports.hasVariableNode)(n.leftChild) || (0, exports.hasVariableNode)(n.rightChild);
+    if ((0, functionNode_1.isFunctionNode)(n))
+        return (0, exports.hasVariableNode)(n.child);
+    return false;
+};
+exports.hasVariableNode = hasVariableNode;

package/lib/tree/nodes/numbers/constantNode.d.ts

@@ -6,11 +6,14 @@ export declare class ConstantNode implements AlgebraicNode {
     mathString: string;
     value: number;
     type: NodeType;
+    isNumeric: boolean;
     constructor(tex: string, mathString: string, value: number);
     toMathString(): string;
     toTex(): string;
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars: Record<string, number>): number;
+    simplify(): this;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=constantNode.d.ts.map

package/lib/tree/nodes/numbers/constantNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constantNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/constantNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAqB;gBAEvB,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAM1D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAMf,cAAc;IAGd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGtC"}
+{"version":3,"file":"constantNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/constantNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAqB;IACnC,SAAS,EAAE,OAAO,CAAC;gBACP,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAO1D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAMf,cAAc;IAGd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

package/lib/tree/nodes/numbers/constantNode.js

@@ -13,6 +13,7 @@ class ConstantNode {
         this.tex = tex;
         this.mathString = mathString;
         this.value = value;
+        this.isNumeric = true;
     }
     toMathString() {
         return `${this.mathString}`;
@@ -32,5 +33,11 @@ class ConstantNode {
     evaluate(vars) {
         return this.value;
     }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return isConstantNode(node) && node.tex === this.tex;
+    }
 }
 exports.ConstantNode = ConstantNode;

package/lib/tree/nodes/numbers/numberNode.d.ts

@@ -6,6 +6,7 @@ export declare class NumberNode implements AlgebraicNode {
     mathString: string;
     value: number;
     type: NodeType;
+    isNumeric: boolean;
     constructor(value: number, tex?: string, mathString?: string);
     toMathString(): string;
     toTex(): string;
@@ -13,5 +14,7 @@ export declare class NumberNode implements AlgebraicNode {
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars: Record<string, number>): number;
+    simplify(): this;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=numberNode.d.ts.map

package/lib/tree/nodes/numbers/numberNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;gBAErB,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAM5D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGtC"}
+{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAO5D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

package/lib/tree/nodes/numbers/numberNode.js

@@ -12,6 +12,7 @@ class NumberNode {
         this.value = value;
         this.tex = tex || (value + "").replace(".", ",");
         this.mathString = mathString || this.value + "";
+        this.isNumeric = true;
     }
     toMathString() {
         return `${this.mathString}`;
@@ -36,5 +37,11 @@ class NumberNode {
     evaluate(vars) {
         return this.value;
     }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return isNumberNode(node) && node.value === this.value;
+    }
 }
 exports.NumberNode = NumberNode;

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

@@ -8,6 +8,7 @@ export declare class AddNode implements CommutativeOperatorNode {
     rightChild: AlgebraicNode;
     type: NodeType;
     opts?: NodeOptions;
+    isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     shuffle: () => void;
     toMathString(): string;
@@ -16,5 +17,7 @@ export declare class AddNode implements CommutativeOperatorNode {
     toAllValidTexs(opts?: NodeOptions): string[];
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
+    simplify(): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=addNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAMD,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAQpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAMtC"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAOjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAMD,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,IAAI,aAAa;IAwKzB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAUrC"}

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

@@ -8,6 +8,11 @@ const coinFlip_1 = require("../../../utils/coinFlip");
 const permutations_1 = require("../../../utils/permutations");
 const cartesianProducts_1 = require("../../../utils/cartesianProducts");
 const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
+const substractNode_1 = require("./substractNode");
+const oppositeNode_1 = require("../functions/oppositeNode");
+const numberNode_1 = require("../numbers/numberNode");
+const multiplyNode_1 = require("./multiplyNode");
+const fractionNode_1 = require("./fractionNode");
 function isAddNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.add;
 }
@@ -28,6 +33,7 @@ class AddNode {
         this.rightChild = rightChild;
         this.type = node_1.NodeType.operator;
         this.opts = opts;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
     toMathString() {
         return `${this.leftChild.toMathString()} + (${this.rightChild.toMathString()})`;
@@ -78,5 +84,172 @@ class AddNode {
     evaluate(vars) {
         return this.leftChild.evaluate(vars) + this.rightChild.evaluate(vars);
     }
+    // toMathjs() {
+    //   return add(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify() {
+        const leftSimplified = this.leftChild.simplify();
+        const rightSimplified = this.rightChild.simplify();
+        const copy = new AddNode(leftSimplified, rightSimplified, this.opts);
+        /**get externals nodes
+         */
+        let externals = [];
+        const recursive = (node) => {
+            if (isAddNode(node)) {
+                recursive(node.leftChild);
+                recursive(node.rightChild);
+            }
+            else if ((0, substractNode_1.isSubstractNode)(node)) {
+                recursive(node.leftChild);
+                recursive(new oppositeNode_1.OppositeNode(node.rightChild));
+            }
+            else {
+                externals.push(node);
+            }
+        };
+        recursive(copy);
+        externals = externals.filter((node) => !(0, numberNode_1.isNumberNode)(node) || node.value !== 0);
+        if (!externals.length)
+            return new numberNode_1.NumberNode(0);
+        if (externals.length === 1)
+            return externals[0];
+        const simplifyExternalNodes = (a, b) => {
+            if ((0, fractionNode_1.isFractionNode)(a) && (0, fractionNode_1.isFractionNode)(b)) {
+                //c/d + e/f   =  cf+ed / df
+                const c = a.leftChild;
+                const d = a.rightChild;
+                const e = b.leftChild;
+                const f = b.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify();
+            }
+            if ((0, fractionNode_1.isFractionNode)(a)) {
+                //c/d + b
+                const c = a.leftChild;
+                const d = a.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, b)), d).simplify();
+            }
+            if ((0, fractionNode_1.isFractionNode)(b)) {
+                //c/d + a
+                const c = b.leftChild;
+                const d = b.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, a)), d).simplify();
+            }
+            if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
+                return new numberNode_1.NumberNode(a.value + b.value);
+            }
+            if ((0, oppositeNode_1.isOppositeNode)(a) && (0, numberNode_1.isNumberNode)(a.child) && (0, numberNode_1.isNumberNode)(b)) {
+                return new numberNode_1.NumberNode(-a.child.value + b.value);
+            }
+            if ((0, oppositeNode_1.isOppositeNode)(b) && (0, numberNode_1.isNumberNode)(b.child) && (0, numberNode_1.isNumberNode)(a)) {
+                return new numberNode_1.NumberNode(-b.child.value + a.value);
+            }
+            if ((0, oppositeNode_1.isOppositeNode)(a) &&
+                (0, numberNode_1.isNumberNode)(a.child) &&
+                (0, oppositeNode_1.isOppositeNode)(b) &&
+                (0, numberNode_1.isNumberNode)(b.child)) {
+                return new numberNode_1.NumberNode(a.child.value + b.child.value);
+            }
+            //gérer opposites, fractions
+            const aSubExternals = [];
+            const bSubExternals = [];
+            const getAMultiplyExternals = (a) => {
+                if ((0, multiplyNode_1.isMultiplyNode)(a)) {
+                    getAMultiplyExternals(a.leftChild);
+                    getAMultiplyExternals(a.rightChild);
+                }
+                else if ((0, oppositeNode_1.isOppositeNode)(a)) {
+                    //on transofmre les opposites en -1
+                    aSubExternals.push(new numberNode_1.NumberNode(-1));
+                    getAMultiplyExternals(a.child);
+                }
+                else {
+                    aSubExternals.push(a);
+                }
+            };
+            const getBMultiplyExternals = (b) => {
+                if ((0, multiplyNode_1.isMultiplyNode)(b)) {
+                    getBMultiplyExternals(b.leftChild);
+                    getBMultiplyExternals(b.rightChild);
+                }
+                else if ((0, oppositeNode_1.isOppositeNode)(b)) {
+                    //on transofmre les opposites en -1
+                    bSubExternals.push(new numberNode_1.NumberNode(-1));
+                    getBMultiplyExternals(b.child);
+                }
+                else {
+                    bSubExternals.push(b);
+                }
+            };
+            getAMultiplyExternals(a);
+            getBMultiplyExternals(b);
+            const factors = [];
+            for (let i = 0; i < aSubExternals.length; i++) {
+                const left = aSubExternals[i];
+                for (let j = 0; j < bSubExternals.length; j++) {
+                    const right = bSubExternals[j];
+                    if (left.equals(right)) {
+                        factors.push(left);
+                        aSubExternals.splice(i, 1);
+                        bSubExternals.splice(j, 1);
+                        i--;
+                        j--;
+                    }
+                }
+            }
+            //si aucun facteur on return le add node simplifié
+            if (!factors.length)
+                return copy;
+            const factorsNode = factors.length === 1
+                ? factors[0]
+                : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, factors);
+            // if (!aSubExternals.length && !bSubExternals.length) return factorsNode;
+            const aNode = aSubExternals.length === 0
+                ? new numberNode_1.NumberNode(1)
+                : aSubExternals.length === 1
+                    ? aSubExternals[0]
+                    : (0, operatorComposition_1.operatorComposition)(AddNode, aSubExternals);
+            const bNode = bSubExternals.length === 0
+                ? new numberNode_1.NumberNode(1)
+                : bSubExternals.length === 1
+                    ? bSubExternals[0]
+                    : (0, operatorComposition_1.operatorComposition)(AddNode, bSubExternals);
+            const addNode = new AddNode(aNode, bNode);
+            return new multiplyNode_1.MultiplyNode(addNode, factorsNode).simplify();
+        };
+        //pour chaque paire on essaye de simplifier,
+        //chaque simplification déclenche le reboot du process
+        const simplifyIteration = () => {
+            for (let i = 0; i < externals.length - 1; i++) {
+                const left = externals[i];
+                for (let j = i + 1; j < externals.length; j++) {
+                    const right = externals[j];
+                    const simplified = simplifyExternalNodes(left, right);
+                    if (simplified) {
+                        externals[i] = simplified;
+                        externals.splice(j, 1);
+                        if ((0, numberNode_1.isNumberNode)(simplified) && simplified.value === 0) {
+                            externals.splice(i, 1);
+                        }
+                        simplifyIteration();
+                        return;
+                    }
+                }
+            }
+        };
+        simplifyIteration();
+        if (!externals.length)
+            return new numberNode_1.NumberNode(0);
+        if (externals.length === 1)
+            return externals[0];
+        return (0, operatorComposition_1.operatorComposition)(AddNode, externals);
+    }
+    equals(node) {
+        //!incorrect, il faut plutot vérifier qu'ils ont les meme externals
+        return (isAddNode(node) &&
+            ((node.leftChild.equals(this.leftChild) &&
+                node.rightChild.equals(this.rightChild)) ||
+                (node.leftChild.equals(this.rightChild) &&
+                    node.rightChild.equals(this.leftChild))));
+    }
 }
 exports.AddNode = AddNode;

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

@@ -7,6 +7,7 @@ export declare class DivideNode implements OperatorNode {
     leftChild: AlgebraicNode;
     rightChild: AlgebraicNode;
     type: NodeType;
+    isNumeric: boolean;
     /**
      * @param leftChild num
      * @param rightChild denum
@@ -17,5 +18,7 @@ export declare class DivideNode implements OperatorNode {
     toAllValidTexs(): string[];
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
+    simplify(): this;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=divideNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.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;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AA0BD,qBAAa,UAAW,YAAW,YAAY;IAC7C,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAO/D,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAMtC"}
+{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.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;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AA0BD,qBAAa,UAAW,YAAW,YAAY;IAC7C,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAO3B"}

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

@@ -38,6 +38,7 @@ class DivideNode {
         this.leftChild = leftChild;
         this.rightChild = rightChild;
         this.type = node_1.NodeType.operator;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
     toMathString() {
         return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
@@ -62,5 +63,16 @@ class DivideNode {
     evaluate(vars) {
         return this.leftChild.evaluate(vars) / this.rightChild.evaluate(vars);
     }
+    // toMathjs() {
+    //   return divide(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return (isDivideNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
 }
 exports.DivideNode = DivideNode;

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

@@ -12,6 +12,7 @@ export declare class FractionNode implements OperatorNode {
     leftChild: AlgebraicNode;
     rightChild: AlgebraicNode;
     type: NodeType;
+    isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toInversed(): FractionNode;
@@ -19,5 +20,7 @@ export declare class FractionNode implements OperatorNode {
     toAllValidTexs(opts?: NodeOptions): string[];
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
+    simplify(): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=fractionNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.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;AAK3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAMtC"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.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;AAK3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAIjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,IAAI,aAAa;IA6EzB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}