math-exercises 3.0.183 → 3.0.184

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoConsecutiveTerms.js

@@ -4,12 +4,14 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { NodeRewriter } from "../../../../tree/utilities/nodeRewriter.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -122,46 +124,41 @@ const getPropositions = (n, { answer, ..._identifiers }, optsIn) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
     try {
         //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
-        const splitted = ans.split("=");
-        const studentAns = splitted[1] ?? ans;
-        const parsed = parseAlgebraic(studentAns);
-        if (!parsed)
+        const nodeAnswer = getAnswerStuff(identifiers, opts).answerNode;
+        if (!ans.includes("=")) {
+            // return false;
+            ans = nodeAnswer.leftChild.toTex() + "=" + ans;
+        }
+        // const nodeAns = parseAlgebraic(ans);
+        const nodeAns = (() => {
+            const [lhs, rhs] = ans.split("=");
+            const nodeLhs = lhs.toTree();
+            const nodeRhs = parseAlgebraic(rhs);
+            return new EqualNode(nodeLhs, nodeRhs);
+        })();
+        if (!isEqualNode(nodeAns)) {
             return false;
-        return parsed.simplify().toTex() === answer.split("=")[1];
-        //!ROBIN : tout commenté car ne passent pas les tests
-        // const nodeAnswer = getAnswerStuff(identifiers, opts).answerNode;
-        // if (!ans.includes("=")) {
-        //   // return false;
-        //   ans = nodeAnswer.leftChild.toTex() + "=" + ans;
-        // }
-        // // const nodeAns = parseAlgebraic(ans);
-        // const nodeAns = (() => {
-        //   const [lhs, rhs] = ans.split("=");
-        //   const nodeLhs = lhs.toTree();
-        //   const nodeRhs = parseAlgebraic(rhs);
-        //   return new EqualNode(nodeLhs, nodeRhs);
-        // })();
-        // if (!isEqualNode(nodeAns)) {
-        //   return false;
-        // }
-        // const isValidLhs = () =>
-        //   nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
-        // const isValidRhs = () => {
-        //   const nodeAnsRhs = nodeAns.rightChild;
-        //   const nodeAnswerRhs = nodeAnswer.rightChild;
-        //   return [0, 1, 2].every((n) => {
-        //     return (
-        //       substract(
-        //         nodeAnsRhs.evaluate({ n }),
-        //         nodeAnswerRhs.evaluate({ n }),
-        //       ).evaluate() === 0
-        //     );
-        //   });
-        // };
-        // return isValidLhs() && isValidRhs();
+        }
+        const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
+        const isValidRhs = () => {
+            const nodeAnsRhs = nodeAns.rightChild;
+            const nodeAnswerRhs = nodeAnswer.rightChild;
+            const isEquivalentFound = () => {
+                const nodeAns = nodeAnsRhs;
+                const nodeAnswer = nodeAnswerRhs;
+                const arrNodeAnswerEquivalent = NodeRewriter.getArrNodeEquivalent(nodeAnswer);
+                return arrNodeAnswerEquivalent.some((nodeAnswerRefined) => {
+                    const isEqual = NodeComparator.isEqualViaFrac(nodeAns, nodeAnswerRefined);
+                    return isEqual;
+                });
+            };
+            return isEquivalentFound();
+        };
+        return isValidLhs() && isValidRhs();
     }
     catch (e) {
         handleVEAError(e);
@@ -246,7 +243,8 @@ const createRandomIdentifiersCurated = (opts) => {
         counter++;
         const identifiersCandidate = createRandomIdentifiersRaw(opts);
         const answer = getAnswer(identifiersCandidate, opts);
-        isValid = !answer.includes("NaN");
+        const isVEAOk = () => isAnswerValid(answer, { answer, ...identifiersCandidate }, opts);
+        isValid = !answer.includes("NaN") && isVEAOk();
         if (isValid) {
             identifiers = identifiersCandidate;
         }

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormulaFromTwoTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAoB3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAsWF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAC7D,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormulaFromTwoTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAsB3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAiXF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAC7D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.js

@@ -10,6 +10,8 @@ import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { NodeRewriter } from "../../../../tree/utilities/nodeRewriter.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -156,9 +158,16 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
         const isValidRhs = () => {
             const nodeAnsRhs = nodeAns.rightChild;
             const nodeAnswerRhs = nodeAnswer.rightChild;
-            return [0, 1, 2, 10].every((n) => {
-                return (substract(nodeAnsRhs.evaluate({ n }), nodeAnswerRhs.evaluate({ n })).evaluate() === 0);
-            });
+            const isEquivalentFound = () => {
+                const nodeAns = nodeAnsRhs;
+                const nodeAnswer = nodeAnswerRhs;
+                const arrNodeAnswerEquivalent = NodeRewriter.getArrNodeEquivalent(nodeAnswer);
+                return arrNodeAnswerEquivalent.some((nodeAnswerRefined) => {
+                    const isEqual = NodeComparator.isEqualViaFrac(nodeAns, nodeAnswerRefined);
+                    return isEqual;
+                });
+            };
+            return isEquivalentFound();
         };
         return isValidLhs() && isValidRhs();
     }
@@ -245,7 +254,8 @@ const createRandomIdentifiersCurated = (opts) => {
         counter++;
         const identifiersCandidate = createRandomIdentifiersRaw(opts);
         const answer = getAnswer(identifiersCandidate, opts);
-        isValid = !answer.includes("NaN");
+        const isVEAOk = () => isAnswerValid(answer, { answer, ...identifiersCandidate }, opts);
+        isValid = !answer.includes("NaN") && isVEAOk();
         if (isValid) {
             identifiers = identifiersCandidate;
         }

package/lib/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAiBzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;CACrD,CAAC;AAiPF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAmBzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;CACrD,CAAC;AA0PF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.js

@@ -11,6 +11,8 @@ import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { NodeRewriter } from "../../../../../tree/utilities/nodeRewriter.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 const getNodeFactor = (firstRank, varName = "n") => {
     const nodeN = varName.toTree();
@@ -121,9 +123,16 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
         const isValidRhs = () => {
             const nodeAnsRhs = nodeAns.rightChild;
             const nodeAnswerRhs = nodeAnswer.rightChild;
-            return [0, 1, 2, 3].every((n) => {
-                return (substract(nodeAnsRhs.evaluate({ n }), nodeAnswerRhs.evaluate({ n })).evaluate() === 0);
-            });
+            const isEquivalentFound = () => {
+                const nodeAns = nodeAnsRhs;
+                const nodeAnswer = nodeAnswerRhs;
+                const arrNodeAnswerEquivalent = NodeRewriter.getArrNodeEquivalent(nodeAnswer);
+                return arrNodeAnswerEquivalent.some((nodeAnswerRefined) => {
+                    const isEqual = NodeComparator.isEqualViaFrac(nodeAns, nodeAnswerRefined);
+                    return isEqual;
+                });
+            };
+            return isEquivalentFound();
         };
         return isValidLhs() && isValidRhs();
     }

package/lib/exercises/vea/treeTableVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/treeTableVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EAAE,EAAE,EAAE,EAAE,EACnB,aAAa,MAAM,EAAE,EAAE,EAAE,EAAE,YAa5B,CAAC"}
+{"version":3,"file":"treeTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/treeTableVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EAAE,EAAE,EAAE,EAAE,EACnB,aAAa,MAAM,EAAE,EAAE,EAAE,EAAE,YAgB5B,CAAC"}

package/lib/exercises/vea/treeTableVEA.js

@@ -2,6 +2,9 @@ import { rationalVEA } from "./rationalVEA.js";
 // type Options = {
 // }
 export const treeTableVEA = (ans, answerTable) => {
+    //TODO
+    //les branches peuvent commuter au sein d'un block
+    //les blocks peuvent commuter au sein d'un step
     return ans.every((step, i) => step.every((block, j) => block.every((branch, k) => branch.every((value, l) => value === answerTable[i][j][k][l] ||
         rationalVEA(value, answerTable[i][j][k][l])))));
 };

package/lib/index.d.ts

@@ -1636,6 +1636,20 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     k: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    k: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    coeffs: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    k: number;
+    type: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    k: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pm: number;
     a: number;
@@ -2996,6 +3010,8 @@ declare const mathExercises: (Exercise<{
     pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     p_ABIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     p_ABarreBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    percent: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     questionType: string;
     value?: string;
@@ -3255,11 +3271,25 @@ declare const mathExercises: (Exercise<{
     BC: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     BD: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     probaName: string;
+    useContraryNames?: boolean;
 }, {
-    allowApproximate: string;
-    eventTypes: string[];
-    probaType: string;
+    allowApproximate?: string;
+    eventTypes?: string[];
+    probaType?: string;
+    eventsNames?: string;
 }> | Exercise<{
+    initTree: string[][][][];
+    valueDatas: {
+        isComp: boolean;
+        value: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    }[];
+}, {
+    probaType?: string;
+}> | Exercise<{
+    params: import("./exercises/math/probaStat/trees/probaTreeSituations.js").ProbaTreeSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/trees/probaTreeSituations.js").ProbaTreeSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     firstValue: number;
     askedRank: number;
     reason: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/latexTester.js

@@ -153,7 +153,7 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
         }
     }
     if (!isDefaultInMathMode && (inDollarMode || inDoubleDollarMode))
-        throw new Error(`Math mode not finished`);
+        throw new Error(`Math mode not finished ${formated}`);
     if (leftRightCount !== 0)
         throw new Error("Left right not balanced");
     if (commandModeCount !== 0)

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"}