math-exercises 3.0.183 → 3.0.185

package/lib/math/utils/sequences/situations/seqArithmeticUtils.d.ts

@@ -6,7 +6,7 @@ export declare const seqArithmeticUtils: {
     getAnswerNodeExplicitFormula: (initial: number, reason: number, firstRank: number) => EqualNode;
     getAnswerNodeRecurrenceFormula: (_initial: number, reason: number, _firstRank: number) => EqualNode;
     getAnswerNodeRandomTerm: (initial: number, reason: number, firstRank: number, rankAsked: number) => import("../../../../tree/nodes/operators/addNode.js").AddNode;
-    getAnswerNodeRandomRank: (initial: number, reason: number, _firstRank: number, valueAsked: number) => import("../../../../tree/nodes/operators/fractionNode.js").FractionNode;
+    getAnswerNodeRandomRank: (initial: number, reason: number, _firstRank: number, valueAsked: number) => import("../../../../tree/nodes/numbers/constantNode.js").ConstantNode | import("../../../../tree/nodes/numbers/numberNode.js").NumberNode;
     getAnswerNodeThresholdRank: (initial: number, reason: number, firstRank: number, valueThreshold: number, inequationSymbol: InequationSymbol) => import("../../../../tree/nodes/numbers/constantNode.js").ConstantNode | import("../../../../tree/nodes/numbers/numberNode.js").NumberNode;
     getAnswerNodeSumThresholdRank: (initial: number, reason: number, firstRank: number, valueThreshold: number, inequationSymbol: InequationSymbol) => import("../../../../tree/nodes/numbers/constantNode.js").ConstantNode | import("../../../../tree/nodes/numbers/numberNode.js").NumberNode;
     randThreshold: (initial: number, reason: number, firstRank: number, roundTo: number) => number;

package/lib/math/utils/sequences/situations/seqArithmeticUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seqArithmeticUtils.d.ts","sourceRoot":"","sources":["../../../../../src/math/utils/sequences/situations/seqArithmeticUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA8MpE,eAAO,MAAM,kBAAkB;4BArMA,MAAM,UAAU,MAAM,QAAQ,MAAM;+BAIjC,MAAM,UAAU,MAAM,QAAQ,MAAM;4CAK3D,MAAM,UACP,MAAM,aACH,MAAM;+CAaP,MAAM,UACR,MAAM,cACF,MAAM;uCAWT,MAAM,UACP,MAAM,aACH,MAAM,aACN,MAAM;uCAUR,MAAM,UACP,MAAM,cACF,MAAM,cACN,MAAM;0CAQT,MAAM,UACP,MAAM,aACH,MAAM,kBACD,MAAM,oBACJ,gBAAgB;6CAwBzB,MAAM,UACP,MAAM,aACH,MAAM,kBACD,MAAM,oBACJ,gBAAgB;6BAmEzB,MAAM,UACP,MAAM,aACH,MAAM,WACR,MAAM;gCAgBN,MAAM,UACP,MAAM,aACH,MAAM,WACR,MAAM;CA0BhB,CAAC"}
+{"version":3,"file":"seqArithmeticUtils.d.ts","sourceRoot":"","sources":["../../../../../src/math/utils/sequences/situations/seqArithmeticUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAiNpE,eAAO,MAAM,kBAAkB;4BAvMA,MAAM,UAAU,MAAM,QAAQ,MAAM;+BAIjC,MAAM,UAAU,MAAM,QAAQ,MAAM;4CAK3D,MAAM,UACP,MAAM,aACH,MAAM;+CAaP,MAAM,UACR,MAAM,cACF,MAAM;uCAWT,MAAM,UACP,MAAM,aACH,MAAM,aACN,MAAM;uCAUR,MAAM,UACP,MAAM,cACF,MAAM,cACN,MAAM;0CAUT,MAAM,UACP,MAAM,aACH,MAAM,kBACD,MAAM,oBACJ,gBAAgB;6CAwBzB,MAAM,UACP,MAAM,aACH,MAAM,kBACD,MAAM,oBACJ,gBAAgB;6BAmEzB,MAAM,UACP,MAAM,aACH,MAAM,WACR,MAAM;gCAgBN,MAAM,UACP,MAAM,aACH,MAAM,WACR,MAAM;CA0BhB,CAAC"}

package/lib/math/utils/sequences/situations/seqArithmeticUtils.js

@@ -7,6 +7,7 @@ import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
 import { randfloat } from "../../random/randfloat.js";
+import { round } from "../../round.js";
 const valueForRank = (initial, reason, rank) => {
     return initial + reason * rank;
 };
@@ -33,7 +34,9 @@ const getAnswerNodeRandomTerm = (initial, reason, firstRank, rankAsked) => {
 const getAnswerNodeRandomRank = (initial, reason, _firstRank, valueAsked) => {
     //u_n = u_0 + r * n
     //n = (u_n - u_0) / r
-    return frac(substract(valueAsked, initial), reason);
+    const nodeRaw = frac(substract(valueAsked, initial), reason);
+    const valueRounded = round(nodeRaw.evaluate(), 0);
+    return valueRounded.toTree();
 };
 const getAnswerNodeThresholdRank = (initial, reason, firstRank, valueThreshold, inequationSymbol) => {
     //u_n = u_0 + r * n >= t

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAuS3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAwS3B,CAAC"}

package/lib/tests/questionTest.js

@@ -36,6 +36,7 @@ export const questionTest = (exo, question) => {
         assertJsonStringifiable(question.identifiers);
     }
     catch (err) {
+        console.log("question.identifiers", question.identifiers);
         throw new Error(`exo ${exo.id} : ${err}`);
     }
     const dotDecimalPattern = /\d+\.\d+/;

package/lib/tests/singleExo.test.js

@@ -1,9 +1,9 @@
 import "../prototypesEnhancement.js";
 import { exoTest } from "./exoTest.js";
-import { arithmeticFindExplicitFormulaFromTwoTerms, } from "../exercises/math/index.js";
+import { geometricFindExplicitFormulaFromSituation, } from "../exercises/math/index.js";
 try {
     for (let i = 0; i < 1000; i++)
-        exoTest(arithmeticFindExplicitFormulaFromTwoTerms);
+        exoTest(geometricFindExplicitFormulaFromSituation);
 }
 catch (err) {
     throw err;

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

@@ -1,7 +1,7 @@
 import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
 import { FunctionNode, FunctionsIds } from "./functionNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
-export declare const exp: (a: AlgebraicNode | number | string) => ExpNode;
+export declare const exp: (a: AlgebraicNode | number | string, opts?: NodeOptions) => ExpNode;
 export declare function isExpNode(a: Node): a is ExpNode;
 export declare class ExpNode implements FunctionNode {
     opts?: NodeOptions;

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

@@ -1 +1 @@
-{"version":3,"file":"expNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/expNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,eAAO,MAAM,GAAG,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,YAIrD,CAAC;AAEF,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,mBAAmB;IAOnB,YAAY,IAAI,MAAM;IAGtB,mBAAmB,IAAI,MAAM;IAG7B,KAAK,IAAI,MAAM;IAmBf,iBAAiB,IAAI,aAAa,EAAE;IAUpC,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IAO7D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"expNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/expNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,eAAO,MAAM,GAAG,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,WAAW,YAIzE,CAAC;AAEF,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,mBAAmB;IAOnB,YAAY,IAAI,MAAM;IAGtB,mBAAmB,IAAI,MAAM;IAG7B,KAAK,IAAI,MAAM;IAiBf,iBAAiB,IAAI,aAAa,EAAE;IAUpC,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IAO7D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

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

@@ -4,9 +4,9 @@ import { FunctionsIds, isFunctionNode } from "./functionNode.js";
 import { isNumberNode } from "../numbers/numberNode.js";
 import { isLogNode } from "./logNode.js";
 import { multiply } from "../operators/multiplyNode.js";
-export const exp = (a) => {
+export const exp = (a, opts) => {
     const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
-    return new ExpNode(nodeA);
+    return new ExpNode(nodeA, opts);
 };
 export function isExpNode(a) {
     return isFunctionNode(a) && a.id === FunctionsIds.exp;
@@ -54,10 +54,7 @@ export class ExpNode {
         if (this.opts?.useExpNotation) {
             return `\\exp\\left(${tex}\\right)`;
         }
-        const needBraces = tex.length > 1;
-        if (needBraces)
-            return `e^{${tex}}`;
-        return `e^${tex}`;
+        return `e^{${tex}}`;
     }
     // toMathjs() {
     //   return exp(this.child.toMathjs());

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

@@ -2,7 +2,7 @@ import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node.js";
 import { CommutativeOperatorNode, OperatorIds } from "./operatorNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isAddNode(a: Node): a is AddNode;
-export declare const add: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => AddNode;
+export declare const add: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string, opts?: NodeOptions) => AddNode;
 export declare class AddNode implements CommutativeOperatorNode {
     id: OperatorIds;
     leftChild: AlgebraicNode;

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,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAerE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,GACd,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,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;IAUpB;;OAEG;IACH,OAAO,gBAIL;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,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,mBAAmB;IAUnB,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IAyJ7D,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAMvD,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;CAK3C"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAerE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,GACd,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,YAOnB,CAAC;AAEF,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;IAUpB;;OAEG;IACH,OAAO,gBAIL;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,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,mBAAmB;IAUnB,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IAyJ7D,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAMvD,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;CAK3C"}

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

@@ -16,10 +16,10 @@ import { shuffle } from "../../../utils/alea/shuffle.js";
 export function isAddNode(a) {
     return isOperatorNode(a) && a.id === OperatorIds.add;
 }
-export const add = (a, b) => {
+export const add = (a, b, opts) => {
     const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
     const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
-    return new AddNode(nodeA, nodeB);
+    return new AddNode(nodeA, nodeB, opts);
 };
 export class AddNode {
     id;

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

@@ -3,7 +3,7 @@ import { OperatorIds, OperatorNode } from "./operatorNode.js";
 import { AddNode } from "./addNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isSubstractNode(a: Node): a is SubstractNode;
-export declare const substract: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => SubstractNode;
+export declare const substract: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string, opts?: NodeOptions) => SubstractNode;
 export declare class SubstractNode implements OperatorNode {
     id: OperatorIds;
     leftChild: AlgebraicNode;

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,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAE9E,OAAO,EAAO,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAIrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AAED,eAAO,MAAM,SAAS,GACpB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,kBAOnC,CAAC;AAEF,qBAAa,aAAc,YAAW,YAAY;IAChD,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,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,mBAAmB;IAOnB,iBAAiB,IAAI,aAAa,EAAE;IAapC,cAAc,IAAI,MAAM,EAAE;IAG1B,kBAAkB;IAIlB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAoBrC,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;IAK1C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAStC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAMvD,OAAO,uBAGL;CACH"}
+{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAE9E,OAAO,EAAO,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAIrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AAED,eAAO,MAAM,SAAS,GACpB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,kBAOnB,CAAC;AAEF,qBAAa,aAAc,YAAW,YAAY;IAChD,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,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,mBAAmB;IAOnB,iBAAiB,IAAI,aAAa,EAAE;IAapC,cAAc,IAAI,MAAM,EAAE;IAG1B,kBAAkB;IAIlB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAoBrC,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;IAK1C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAStC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAMvD,OAAO,uBAGL;CACH"}

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

@@ -9,10 +9,10 @@ import { round } from "../../../math/utils/round.js";
 export function isSubstractNode(a) {
     return isOperatorNode(a) && a.id === OperatorIds.substract;
 }
-export const substract = (a, b) => {
+export const substract = (a, b, opts) => {
     const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
     const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
-    return new SubstractNode(nodeA, nodeB);
+    return new SubstractNode(nodeA, nodeB, opts);
 };
 export class SubstractNode {
     id;

package/lib/tree/utilities/nodeComparator.d.ts

@@ -0,0 +1,7 @@
+import { AlgebraicNode } from "../nodes/algebraicNode.js";
+export declare abstract class NodeComparator {
+    static compareViaSub: <T extends AlgebraicNode>(node1: T, node2: T) => -1 | 0 | 1;
+    static isEqualViaSub: (node1: AlgebraicNode, node2: AlgebraicNode) => boolean;
+    static isEqualViaFrac: (node1: AlgebraicNode, node2: AlgebraicNode) => boolean;
+}
+//# sourceMappingURL=nodeComparator.d.ts.map

package/lib/tree/utilities/nodeComparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeComparator.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeComparator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAM1D,8BAAsB,cAAc;IAGlC,MAAM,CAAC,aAAa,GAAI,CAAC,SAAS,aAAa,EAC7C,OAAO,CAAC,EACR,OAAO,CAAC,KACP,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CA4DX;IAEF,MAAM,CAAC,aAAa,GAClB,OAAO,aAAa,EACpB,OAAO,aAAa,KACnB,OAAO,CAER;IAIF,MAAM,CAAC,cAAc,GACnB,OAAO,aAAa,EACpB,OAAO,aAAa,KACnB,OAAO,CAgBR;CACH"}

package/lib/tree/utilities/nodeComparator.js

@@ -0,0 +1,88 @@
+import { frac } from "../nodes/operators/fractionNode.js";
+import { substract } from "../nodes/operators/substractNode.js";
+import { NodeRewriter } from "./nodeRewriter.js";
+import { NodeSimplifier } from "./nodeSimplifier.js";
+export class NodeComparator {
+    //via sub
+    static compareViaSub = (node1, node2) => {
+        const isSameTex = () => {
+            return node1.toTex() === node2.toTex();
+        };
+        function compareValueSub(valueSub) {
+            if (isNaN(valueSub)) {
+                throw new Error("valueSub is NaN");
+            }
+            else {
+                if (valueSub === 0) {
+                    return 0;
+                }
+                else if (valueSub > 0) {
+                    return 1;
+                }
+                else {
+                    return -1;
+                }
+            }
+        }
+        const compareUsingEvaluate = () => {
+            const valueSub = substract(node1, node2).evaluate();
+            return compareValueSub(valueSub);
+        };
+        const isEquivalent = () => {
+            const [arrNode1, arrNode2] = [node1, node2].map((node) => NodeRewriter.getArrNodeEquivalent(node));
+            return arrNode1.some((node1Equivalent) => {
+                return arrNode2.some((node2Equivalent) => {
+                    try {
+                        const nodeSub = substract(node1Equivalent, node2Equivalent);
+                        const nodeSubSimplified = NodeSimplifier.simplifyByVibrating(nodeSub);
+                        const valueSub = nodeSubSimplified.evaluate();
+                        return compareValueSub(valueSub);
+                    }
+                    catch (_) {
+                        return false;
+                    }
+                });
+            });
+        };
+        try {
+            if (isSameTex()) {
+                return 0;
+            }
+            else {
+                return compareUsingEvaluate();
+            }
+        }
+        catch (_) {
+            try {
+                if (isEquivalent()) {
+                    return 0;
+                }
+                else {
+                    return 1;
+                }
+            }
+            catch (_) {
+                return 1;
+            }
+        }
+    };
+    static isEqualViaSub = (node1, node2) => {
+        return this.compareViaSub(node1, node2) === 0;
+    };
+    //via frac
+    static isEqualViaFrac = (node1, node2) => {
+        const [arrNode1, arrNode2] = [node1, node2].map((node) => NodeRewriter.getArrNodeEquivalent(node));
+        return arrNode1.some((node1Equivalent) => {
+            return arrNode2.some((node2Equivalent) => {
+                try {
+                    const nodeFrac = frac(node1Equivalent, node2Equivalent);
+                    const nodeFracSimplified = NodeSimplifier.simplifyByVibrating(nodeFrac);
+                    return this.isEqualViaSub(nodeFracSimplified, (1).toTree());
+                }
+                catch (_) {
+                    return false;
+                }
+            });
+        });
+    };
+}

package/lib/tree/utilities/nodeInspector.d.ts

@@ -0,0 +1,5 @@
+import { AlgebraicNode } from "../nodes/algebraicNode.js";
+export declare abstract class NodeInspector {
+    static getChildren(algebraicNode: AlgebraicNode): AlgebraicNode[];
+}
+//# sourceMappingURL=nodeInspector.d.ts.map

package/lib/tree/utilities/nodeInspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeInspector.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeInspector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI1D,8BAAsB,aAAa;IACjC,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;CAShD"}

package/lib/tree/utilities/nodeInspector.js

@@ -0,0 +1,15 @@
+import { isFunctionNode } from "../nodes/functions/functionNode.js";
+import { isOperatorNode } from "../nodes/operators/operatorNode.js";
+export class NodeInspector {
+    static getChildren(algebraicNode) {
+        if (isOperatorNode(algebraicNode)) {
+            return [algebraicNode.leftChild, algebraicNode.rightChild];
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            return [algebraicNode.child];
+        }
+        else {
+            return [];
+        }
+    }
+}

package/lib/tree/utilities/nodeRewriter.d.ts

@@ -0,0 +1,9 @@
+import { AlgebraicNode } from "../nodes/algebraicNode.js";
+export declare abstract class NodeRewriter {
+    static rewriteTopLevel: <T extends AlgebraicNode>(algebraicNode: T, indexIn?: number, shuffleArrayIn?: number[]) => AlgebraicNode;
+    static getCreateNodeFromChildrenFunction: <T extends AlgebraicNode>(algebraicNode: T, indexIn?: number) => (children: AlgebraicNode[]) => AlgebraicNode;
+    static getArrCreateNodeFromChildrenFunction: (algebraicNode: AlgebraicNode) => ((children: AlgebraicNode[]) => AlgebraicNode)[];
+    static getArrRewriteTopLevel(algebraicNode: AlgebraicNode): AlgebraicNode[];
+    static getArrNodeEquivalent(algebraicNode: AlgebraicNode, isDistinctTex?: boolean): AlgebraicNode[];
+}
+//# sourceMappingURL=nodeRewriter.d.ts.map

package/lib/tree/utilities/nodeRewriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeRewriter.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeRewriter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAkC1D,8BAAsB,YAAY;IAChC,MAAM,CAAC,eAAe,GAAI,CAAC,SAAS,aAAa,EAC/C,eAAe,CAAC,EAChB,UAAU,MAAM,EAChB,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAUd;IAEF,MAAM,CAAC,iCAAiC,GAAI,CAAC,SAAS,aAAa,EACjE,eAAe,CAAC,EAChB,UAAU,MAAM,gBAgBH,aAAa,EAAE,KAAK,aAAa,CAP9C;IAKF,MAAM,CAAC,oCAAoC,GACzC,eAAe,aAAa,KAC3B,CAAC,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,aAAa,CAAC,EAAE,CA2HjD;IAEF,MAAM,CAAC,qBAAqB,CAAC,aAAa,EAAE,aAAa,GAAG,aAAa,EAAE;IAW3E,MAAM,CAAC,oBAAoB,CACzB,aAAa,EAAE,aAAa,EAC5B,aAAa,GAAE,OAAc,GAC5B,aAAa,EAAE;CAwCnB"}

package/lib/tree/utilities/nodeRewriter.js

@@ -0,0 +1,172 @@
+import { abs } from "../nodes/functions/absNode.js";
+import { arccos } from "../nodes/functions/arccosNode.js";
+import { CosNode } from "../nodes/functions/cosNode.js";
+import { FunctionsIds, isFunctionNode, } from "../nodes/functions/functionNode.js";
+import { AddNode } from "../nodes/operators/addNode.js";
+import { BinomialCoefficientNode } from "../nodes/operators/binomialCoefficientNode.js";
+import { DivideNode } from "../nodes/operators/divideNode.js";
+import { frac } from "../nodes/operators/fractionNode.js";
+import { multiply } from "../nodes/operators/multiplyNode.js";
+import { power } from "../nodes/operators/powerNode.js";
+import { substract } from "../nodes/operators/substractNode.js";
+import { sin } from "../nodes/functions/sinNode.js";
+import { sqrt } from "../nodes/functions/sqrtNode.js";
+import { tan } from "../nodes/functions/tanNode.js";
+import { ArcsinNode } from "../nodes/functions/arcSinNode.js";
+import { ArctanNode } from "../nodes/functions/arctanNode.js";
+import { exp } from "../nodes/functions/expNode.js";
+import { LogNode } from "../nodes/functions/logNode.js";
+import { Log10Node } from "../nodes/functions/log10Node.js";
+import { NodeConstructor } from "../nodes/nodeConstructor.js";
+import { isOperatorNode, OperatorIds, } from "../nodes/operators/operatorNode.js";
+import { opposite } from "../nodes/functions/oppositeNode.js";
+import { facto } from "../nodes/functions/factorialNode.js";
+import { getCartesiansProducts } from "../../utils/arrays/cartesianProducts.js";
+import { randint } from "../../math/utils/random/randint.js";
+import { NodeInspector } from "./nodeInspector.js";
+export class NodeRewriter {
+    static rewriteTopLevel = (algebraicNode, indexIn, shuffleArrayIn) => {
+        const children = NodeInspector.getChildren(algebraicNode);
+        const shuffleArray = shuffleArrayIn ?? [...Array(children.length).keys()];
+        const shuffledChildren = shuffleArray.map((iTo) => children[iTo]);
+        const funcCreateNodeFromChildren = this.getCreateNodeFromChildrenFunction(algebraicNode, indexIn);
+        return funcCreateNodeFromChildren(shuffledChildren);
+    };
+    static getCreateNodeFromChildrenFunction = (algebraicNode, indexIn) => {
+        const arrFuncCreateNodeFromChildren = this.getArrCreateNodeFromChildrenFunction(algebraicNode);
+        const nbRewritings = arrFuncCreateNodeFromChildren.length;
+        const index = indexIn
+            ? Math.max(nbRewritings - 1, indexIn)
+            : randint(0, nbRewritings);
+        return arrFuncCreateNodeFromChildren[index];
+    };
+    /*
+      commutation is managed as any other rewriting
+    */
+    static getArrCreateNodeFromChildrenFunction = (algebraicNode) => {
+        if (isOperatorNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case OperatorIds.binomialCoefficient:
+                    return [
+                        (children) => new BinomialCoefficientNode(children[0], children[1], algebraicNode.opts),
+                    ];
+                case OperatorIds.divide:
+                    return [
+                        (children) => new DivideNode(children[0], children[1]),
+                    ];
+                case OperatorIds.fraction: {
+                    return [
+                        (children) => frac(children[0], children[1], algebraicNode.opts),
+                        (children) => multiply(children[0], frac((1).toTree(), children[1], algebraicNode.opts), algebraicNode.opts),
+                        (children) => multiply(frac((1).toTree(), children[1], algebraicNode.opts), children[0], algebraicNode.opts),
+                    ];
+                }
+                case OperatorIds.integral:
+                    return [
+                        () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers()),
+                    ];
+                case OperatorIds.limit:
+                    return [
+                        () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers()),
+                    ];
+                case OperatorIds.multiply:
+                    return [
+                        (children) => multiply(children[0], children[1], algebraicNode.opts),
+                        (children) => multiply(children[1], children[0], algebraicNode.opts),
+                    ];
+                case OperatorIds.power:
+                case OperatorIds.square: //this is so nice
+                    return [
+                        (children) => power(children[0], children[1], algebraicNode.opts),
+                    ];
+                case OperatorIds.substract:
+                    return [
+                        (children) => substract(children[0], children[1], algebraicNode.opts),
+                    ];
+                case OperatorIds.add:
+                    return [
+                        (children) => new AddNode(children[0], children[1], algebraicNode.opts),
+                        (children) => new AddNode(children[1], children[0], algebraicNode.opts),
+                    ];
+            }
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case FunctionsIds.arccos:
+                    return [(children) => arccos(children[0])];
+                case FunctionsIds.arcsin:
+                    return [(children) => new ArcsinNode(children[0])];
+                case FunctionsIds.arctan:
+                    return [(children) => new ArctanNode(children[0])];
+                case FunctionsIds.cos:
+                    return [(children) => new CosNode(children[0])];
+                case FunctionsIds.exp:
+                    return [
+                        (children) => exp(children[0], algebraicNode.opts),
+                    ];
+                case FunctionsIds.log:
+                    return [
+                        (children) => new LogNode(children[0], algebraicNode.opts),
+                    ];
+                case FunctionsIds.log10:
+                    return [
+                        (children) => new Log10Node(children[0], algebraicNode.opts),
+                    ];
+                case FunctionsIds.opposite:
+                    return [(children) => opposite(children[0])];
+                case FunctionsIds.sin:
+                    return [(children) => sin(children[0])];
+                case FunctionsIds.sqrt:
+                    return [
+                        (children) => sqrt(children[0]),
+                        (children) => power(children[0], frac(1, 2)),
+                    ];
+                case FunctionsIds.tan:
+                    return [(children) => tan(children[0])];
+                case FunctionsIds.abs:
+                    return [(children) => abs(children[0])];
+                case FunctionsIds.factorial:
+                    return [(children) => facto(children[0])];
+            }
+        }
+        else {
+            return [
+                () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers()),
+            ];
+        }
+    };
+    static getArrRewriteTopLevel(algebraicNode) {
+        const children = NodeInspector.getChildren(algebraicNode);
+        if (children.length === 0) {
+            return [algebraicNode];
+        }
+        const arrFunc = this.getArrCreateNodeFromChildrenFunction(algebraicNode);
+        return arrFunc.map((funcCreateNodeFromChildren) => funcCreateNodeFromChildren(children));
+    }
+    static getArrNodeEquivalent(algebraicNode, isDistinctTex = true) {
+        const children = NodeInspector.getChildren(algebraicNode);
+        if (children.length === 0) {
+            return [algebraicNode];
+        }
+        //get all valid combinations of topLevel-equivalent children
+        const arrChildrenRefined = getCartesiansProducts(children.map((nodeChild) => this.getArrNodeEquivalent(nodeChild).flatMap((nodeChild) => this.getArrRewriteTopLevel(nodeChild))));
+        const arrNodeEquivalentRaw = arrChildrenRefined.flatMap((childrenRefined) => {
+            const arrFuncCreateNodeFromChildren = this.getArrCreateNodeFromChildrenFunction(algebraicNode);
+            return arrFuncCreateNodeFromChildren.map((funcCreateNodeFromChildren) => funcCreateNodeFromChildren(childrenRefined));
+        });
+        if (isDistinctTex) {
+            return arrNodeEquivalentRaw
+                .reduce((acc, node) => {
+                const tex = node.toTex();
+                if (!acc.some(({ tex: texExisting }) => tex === texExisting)) {
+                    acc.push({ node, tex });
+                }
+                return acc;
+            }, [])
+                .map(({ node }) => node);
+        }
+        else {
+            return arrNodeEquivalentRaw;
+        }
+    }
+}

package/lib/tree/utilities/nodeShuffler.d.ts

@@ -4,9 +4,7 @@ export type DeepShuffleOpts = {
     nodeTypesNoFurther: string[];
 };
 export declare abstract class NodeShuffler {
-    static shuffle: <T extends AlgebraicNode>(algebraicNode: T, shuffleArrayIn?: number[]) => AlgebraicNode;
-    static deepShuffle: <T extends AlgebraicNode>(algebraicNode: T, deepShuffleOpts?: DeepShuffleOpts, shuffleArrayIn?: number[]) => AlgebraicNode;
-    private static getCreateNodeFromChildrenFunction;
-    static getChildren(algebraicNode: AlgebraicNode): AlgebraicNode[];
+    static shuffle: <T extends AlgebraicNode>(algebraicNode: T, shuffleArrayIn?: number[], indexIn?: number) => AlgebraicNode;
+    static deepShuffle: <T extends AlgebraicNode>(algebraicNode: T, deepShuffleOpts?: DeepShuffleOpts, shuffleArrayIn?: number[], indexIn?: number) => AlgebraicNode;
 }
 //# sourceMappingURL=nodeShuffler.d.ts.map

package/lib/tree/utilities/nodeShuffler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeShuffler.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeShuffler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AA+B1D,MAAM,MAAM,eAAe,GAAG;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,8BAAsB,YAAY;IAChC,MAAM,CAAC,OAAO,GAAI,CAAC,SAAS,aAAa,EACvC,eAAe,CAAC,EAChB,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAQd;IAGF,MAAM,CAAC,WAAW,GAAI,CAAC,SAAS,aAAa,EAC3C,eAAe,CAAC,EAChB,kBAAiB,eAGhB,EACD,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAyBd;IAEF,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAkF9C;IAEF,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;CAShD"}
+{"version":3,"file":"nodeShuffler.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeShuffler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI1D,MAAM,MAAM,eAAe,GAAG;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,8BAAsB,YAAY;IAChC,MAAM,CAAC,OAAO,GAAI,CAAC,SAAS,aAAa,EACvC,eAAe,CAAC,EAChB,iBAAiB,MAAM,EAAE,EACzB,UAAU,MAAM,KACf,aAAa,CAUd;IAGF,MAAM,CAAC,WAAW,GAAI,CAAC,SAAS,aAAa,EAC3C,eAAe,CAAC,EAChB,kBAAiB,eAGhB,EACD,iBAAiB,MAAM,EAAE,EACzB,UAAS,MAAU,KAClB,aAAa,CA0Bd;CACH"}