math-exercises 3.0.200 → 3.0.201

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YAgMrE,CAAC"}
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YA6LrE,CAAC"}

package/lib/latexTester.js

@@ -3,7 +3,8 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
     let inDoubleDollarMode = isDefaultInMathMode ?? false;
     let commandModeCount = 0;
     let leftRightCount = 0;
-    let inArray = false;
+    // let inArray = false;
+    let nbOpenArrays = 0;
     let inPython = false;
     let inInlinePython = false;
     const formated = latex
@@ -128,9 +129,7 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
                     }
                     else if (substring.startsWith("\\begin{array}") ||
                         substring.startsWith("\\begin{tabular}")) {
-                        if (inArray)
-                            throw new Error("Array not closed" + " char " + char + " latex " + latex);
-                        inArray = true;
+                        nbOpenArrays += 1;
                     }
                 }
                 if (cmd === "\\end") {
@@ -141,9 +140,9 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
                     }
                     else if (substring.startsWith("\\end{array}") ||
                         substring.startsWith("\\end{tabular}")) {
-                        if (!inArray)
+                        if (nbOpenArrays === 0)
                             throw new Error("Array not opened");
-                        inArray = false;
+                        nbOpenArrays -= 1;
                     }
                 }
             }
@@ -158,7 +157,7 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
         throw new Error("Left right not balanced");
     if (commandModeCount !== 0)
         throw new Error(`Command not closed : ${latex}`);
-    if (inArray)
+    if (nbOpenArrays !== 0)
         throw new Error("Array not closed");
     if (inPython)
         throw new Error("Python not closed");
@@ -202,6 +201,8 @@ const validCmds = [
     "\\right",
     "\\alpha",
     "\\beta",
+    "\\gamma",
+    "\\Gamma",
     "\\Delta",
     "\\delta",
     "\\theta",
@@ -270,4 +271,5 @@ const validCmds = [
     "\\searrow",
     "\\mapsto",
     "\\color",
+    "\\wedge",
 ];

package/lib/math/geometry/parametricLine.d.ts

@@ -5,7 +5,7 @@ export declare class ParametricLine {
     startPoint: SpacePoint;
     vector: SpaceVector;
     equations: AlgebraicNode[];
-    constructor(startPoint: SpacePoint, vector: SpaceVector);
+    constructor(startPoint: SpacePoint, vector: SpaceVector, varName?: string);
     toDetailedEvaluation(t: AlgebraicNode): AlgebraicNode[];
     getPointCoords(t: AlgebraicNode): AlgebraicNode[];
     getPoint(t: AlgebraicNode): SpacePoint;

package/lib/math/geometry/parametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametricLine.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAIlE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAA0B,MAAM,kBAAkB,CAAC;AAEvE,qBAAa,cAAc;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,aAAa,EAAE,CAAC;gBACf,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW;IAavD,oBAAoB,CAAC,CAAC,EAAE,aAAa;IAIrC,cAAc,CAAC,CAAC,EAAE,aAAa;IAG/B,QAAQ,CAAC,CAAC,EAAE,aAAa;IAKzB,QAAQ,CAAC,CAAC,EAAE,UAAU;IAYtB,KAAK;CAQN"}
+{"version":3,"file":"parametricLine.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAIlE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAA0B,MAAM,kBAAkB,CAAC;AAEvE,qBAAa,cAAc;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,aAAa,EAAE,CAAC;gBAEzB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,MAAY;IAcvB,oBAAoB,CAAC,CAAC,EAAE,aAAa;IAIrC,cAAc,CAAC,CAAC,EAAE,aAAa;IAG/B,QAAQ,CAAC,CAAC,EAAE,aAAa;IAKzB,QAAQ,CAAC,CAAC,EAAE,UAAU;IAYtB,KAAK;CAQN"}

package/lib/math/geometry/parametricLine.js

@@ -7,12 +7,12 @@ export class ParametricLine {
     startPoint;
     vector;
     equations;
-    constructor(startPoint, vector) {
+    constructor(startPoint, vector, varName = "t") {
         this.startPoint = startPoint;
         this.vector = vector;
         const pointCoords = this.startPoint.getCoords();
         const vectorCoords = this.vector.getCoords();
-        this.equations = [0, 1, 2].map((i) => new AddNode(pointCoords[i], new MultiplyNode(vectorCoords[i], new VariableNode("t"))).simplify({ forbidFactorize: true }));
+        this.equations = [0, 1, 2].map((i) => new AddNode(pointCoords[i], new MultiplyNode(vectorCoords[i], new VariableNode(varName))).simplify({ forbidFactorize: true }));
     }
     toDetailedEvaluation(t) {
         return this.equations.map((e) => e.toDetailedEvaluation({ t: t }));

package/lib/math/geometry/spaceVector.d.ts

@@ -1,6 +1,15 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
 import { SpacePoint } from "./spacePoint.js";
+export type SpaceVectorIdentifiers = {
+    id: "spaceVector";
+    name: string;
+    x: NodeIdentifiers;
+    y: NodeIdentifiers;
+    z: NodeIdentifiers;
+};
 export declare abstract class SpaceVectorConstructor {
+    static fromIdentifiers(identifiers: SpaceVectorIdentifiers): SpaceVector;
     static fromPoints(origin: SpacePoint, end: SpacePoint): SpaceVector;
     static random(name: string, allowNull?: boolean): SpaceVector;
     static randomDifferents(names: string[], allowNull?: boolean): SpaceVector[];
@@ -13,6 +22,7 @@ export declare class SpaceVector {
     y: AlgebraicNode;
     z: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toIdentifiers(): SpaceVectorIdentifiers;
     getCoords(): AlgebraicNode[];
     getEvaluatedCoords(): number[];
     toTex(): string;
@@ -24,7 +34,7 @@ export declare class SpaceVector {
     isCoplanar(): boolean;
     determinant(): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): SpaceVector;
-    scalarProduct(): AlgebraicNode;
+    scalarProduct(v2: SpaceVector): AlgebraicNode;
     add(v: SpaceVector): SpaceVector;
     getNorm(): AlgebraicNode;
     getEndPoint(startPoint: SpacePoint, name?: string): SpacePoint;

package/lib/math/geometry/spaceVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAQlE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW;IAe3D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAQ,GAAG,WAAW,EAAE;IAc1E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;CAWhD;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,SAAS;IAGT,kBAAkB;IAGlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAiB5C,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAMnC,UAAU,IAAI,OAAO;IAGrB,WAAW,IAAI,aAAa;IAI5B,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,IAAI,aAAa;IAI9B,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}
+{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,aAAa,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,sBAAsB;IAS1D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW;IAe3D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAQ,GAAG,WAAW,EAAE;IAc1E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;CAWhD;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,aAAa,IAAI,sBAAsB;IAUvC,SAAS;IAGT,kBAAkB;IAGlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAiB5C,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAMnC,UAAU,IAAI,OAAO;IAGrB,WAAW,IAAI,aAAa;IAI5B,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,EAAE,EAAE,WAAW,GAAG,aAAa;IAQ7C,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}

package/lib/math/geometry/spaceVector.js

@@ -1,12 +1,17 @@
 import { SqrtNode } from "../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../tree/nodes/nodeConstructor.js";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
-import { AddNode } from "../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode.js";
+import { add, AddNode } from "../../tree/nodes/operators/addNode.js";
+import { multiply, MultiplyNode, } from "../../tree/nodes/operators/multiplyNode.js";
 import { SquareNode } from "../../tree/nodes/operators/powerNode.js";
 import { SubstractNode } from "../../tree/nodes/operators/substractNode.js";
+import { zip } from "../../utils/arrays/arrayZip.js";
 import { randint } from "../utils/random/randint.js";
 import { SpacePoint } from "./spacePoint.js";
 export class SpaceVectorConstructor {
+    static fromIdentifiers(identifiers) {
+        return new SpaceVector(identifiers.name, NodeConstructor.fromIdentifiers(identifiers.x), NodeConstructor.fromIdentifiers(identifiers.y), NodeConstructor.fromIdentifiers(identifiers.z));
+    }
     static fromPoints(origin, end) {
         return new SpaceVector(`${origin.name}${end.name}`, new SubstractNode(end.x, origin.x).simplify(), new SubstractNode(end.y, origin.y).simplify(), new SubstractNode(end.z, origin.z).simplify());
     }
@@ -60,6 +65,15 @@ export class SpaceVector {
         this.y = y;
         this.z = z;
     }
+    toIdentifiers() {
+        return {
+            id: "spaceVector",
+            name: this.name,
+            x: this.x.toIdentifiers(),
+            y: this.y.toIdentifiers(),
+            z: this.z.toIdentifiers(),
+        };
+    }
     getCoords() {
         return [this.x, this.y, this.z];
     }
@@ -96,8 +110,8 @@ export class SpaceVector {
     times(k, name) {
         return new SpaceVector(name ?? "v", new MultiplyNode(this.x, k).simplify(), new MultiplyNode(this.y, k).simplify(), new MultiplyNode(this.z, k).simplify());
     }
-    scalarProduct() {
-        throw Error("unimplemented");
+    scalarProduct(v2) {
+        return zip([this.y, this.z], [v2.y, v2.z]).reduce((acc, [node1, node2]) => add(acc, multiply(node1, node2)), multiply(this.x, v2.x));
     }
     add(v) {
         return new SpaceVector(`${this.name}+${v.name}`, new AddNode(this.x, v.x).simplify(), new AddNode(this.y, v.y).simplify(), new AddNode(this.z, v.z).simplify());

package/lib/math/probability/randomVariable.d.ts

@@ -1,12 +1,13 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { AddNode } from "../../tree/nodes/operators/addNode.js";
 export declare abstract class RandomVariableConstructor {
-    static random(): RandomVariable;
+    static random(name?: string, nbIssues?: number): RandomVariable;
 }
 export declare class RandomVariable {
     xValues: AlgebraicNode[];
     yValues: AlgebraicNode[];
-    constructor(xValues: (AlgebraicNode | number)[], yValues: (AlgebraicNode | number)[]);
+    name: string;
+    constructor(xValues: (AlgebraicNode | number)[], yValues: (AlgebraicNode | number)[], name?: string);
     getLawMdTable(): string;
     getLawTable(): string[][];
     getAverage(): AddNode;

package/lib/math/probability/randomVariable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomVariable.d.ts","sourceRoot":"","sources":["../../../src/math/probability/randomVariable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAWhE,8BAAsB,yBAAyB;IAC7C,MAAM,CAAC,MAAM;CA0Bd;AACD,qBAAa,cAAc;IACzB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,OAAO,EAAE,aAAa,EAAE,CAAC;gBAGvB,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EACnC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE;IAMrC,aAAa;IAMb,WAAW;IAMX,UAAU;IAOV,WAAW;IAUX,oBAAoB;CAGrB"}
+{"version":3,"file":"randomVariable.d.ts","sourceRoot":"","sources":["../../../src/math/probability/randomVariable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAWhE,8BAAsB,yBAAyB;IAC7C,MAAM,CAAC,MAAM,CAAC,IAAI,GAAE,MAAY,EAAE,QAAQ,CAAC,EAAE,MAAM;CA0BpD;AACD,qBAAa,cAAc;IACzB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;gBAGX,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EACnC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EACnC,IAAI,GAAE,MAAY;IAOpB,aAAa;IAQb,WAAW;IAQX,UAAU;IAOV,WAAW;IAUX,oBAAoB;CAGrB"}

package/lib/math/probability/randomVariable.js

@@ -10,8 +10,8 @@ import { mdTable } from "../../utils/markdown/mdTable.js";
 import { randint } from "../utils/random/randint.js";
 import { round } from "../utils/round.js";
 export class RandomVariableConstructor {
-    static random() {
-        const nb = randint(4, 6);
+    static random(name = "X", nbIssues) {
+        const nb = nbIssues ?? randint(4, 6);
         const xis = [];
         for (let i = -4; i < 10; i++) {
             xis.push(i);
@@ -31,26 +31,32 @@ export class RandomVariableConstructor {
             yValues[index] = round(yValues[index] + (sum > 1 ? -1 : 1) * 0.05, 2);
             sum = yValues.reduce((acc, curr) => acc + curr);
         }
-        return new RandomVariable(xValues, yValues);
+        return new RandomVariable(xValues, yValues, name);
     }
 }
 export class RandomVariable {
     xValues;
     yValues;
-    constructor(xValues, yValues) {
+    name;
+    constructor(xValues, yValues, name = "X") {
         this.xValues = xValues.map((x) => (typeof x === "number" ? x.toTree() : x));
         this.yValues = yValues.map((x) => (typeof x === "number" ? x.toTree() : x));
+        this.name = name;
     }
     getLawMdTable() {
+        const x = this.name.toLocaleLowerCase();
+        const X = this.name.toLocaleUpperCase();
         return mdTable([
-            ["$x_i$", ...this.xValues.map((x) => `$${x.toTex()}$`)],
-            ["$P(X = x_i)$", ...this.yValues.map((x) => `$${x.toTex()}$`)],
+            [`$${x}_i$`, ...this.xValues.map((x) => `$${x.toTex()}$`)],
+            [`$P(${X} = ${x}_i)$`, ...this.yValues.map((x) => `$${x.toTex()}$`)],
         ]);
     }
     getLawTable() {
+        const x = this.name.toLocaleLowerCase();
+        const X = this.name.toLocaleUpperCase();
         return [
-            ["x_i", ...this.xValues.map((x) => `${x.toTex()}`)],
-            ["P(X = x_i)", ...this.yValues.map((x) => `${x.toTex()}`)],
+            [`${x}_i`, ...this.xValues.map((x) => `${x.toTex()}`)],
+            [`P(${X} = ${x}_i)`, ...this.yValues.map((x) => `${x.toTex()}`)],
         ];
     }
     getAverage() {

package/lib/math/systems/generalSystem.d.ts

@@ -14,14 +14,14 @@ export declare class GeneralSystem {
     constructor(coeffs: (AlgebraicNode | number)[][]);
     toIdentifiers(): GeneralSystemIdentifiers;
     simplify(opts?: SimplifyOptions): GeneralSystem;
-    getEqualNodes(): EqualNode[];
+    getEqualNodes(varNames?: string[]): EqualNode[];
     checkCouple(x: AlgebraicNode, y: AlgebraicNode): boolean;
     multiplyEquation(nodes: AlgebraicNode[]): GeneralSystem;
     solve(): {
         x: AlgebraicNode;
         y: AlgebraicNode;
     };
-    toTex(): string;
-    toCorrectionTex(): string;
+    toTex(varNames?: string[]): string;
+    toCorrectionTex(varNames?: string[], isTrySolveBySub?: boolean): string;
 }
 //# sourceMappingURL=generalSystem.d.ts.map

package/lib/math/systems/generalSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generalSystem.d.ts","sourceRoot":"","sources":["../../../src/math/systems/generalSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,MAAM;IAeb,MAAM,CAAC,UAAU;IAiBjB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,wBAAwB;CAKrD;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAChC,CAAC;AAEF,qBAAa,aAAa;IACxB,MAAM,EAAE,aAAa,EAAE,EAAE,CAAC;gBAId,MAAM,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EAAE;IAKhD,aAAa,IAAI,wBAAwB;IAKzC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,aAAa;IAQb,WAAW,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAQ9C,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE;IAUvC,KAAK;;;;IAoDL,KAAK;IAaL,eAAe;CAgIhB"}
+{"version":3,"file":"generalSystem.d.ts","sourceRoot":"","sources":["../../../src/math/systems/generalSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,MAAM;IAeb,MAAM,CAAC,UAAU;IAiBjB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,wBAAwB;CAKrD;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAChC,CAAC;AAEF,qBAAa,aAAa;IACxB,MAAM,EAAE,aAAa,EAAE,EAAE,CAAC;gBAId,MAAM,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EAAE;IAKhD,aAAa,IAAI,wBAAwB;IAKzC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,aAAa,CAAC,QAAQ,GAAE,MAAM,EAAe;IAU7C,WAAW,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAQ9C,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE;IAUvC,KAAK;;;;IAoDL,KAAK,CAAC,QAAQ,GAAE,MAAM,EAAe;IAerC,eAAe,CACb,QAAQ,GAAE,MAAM,EAAe,EAC/B,eAAe,GAAE,OAAc;CAqIlC"}

package/lib/math/systems/generalSystem.js

@@ -55,12 +55,13 @@ export class GeneralSystem {
         const simpCoeffs = this.coeffs.map((row) => row.map((c) => c.simplify(opts)));
         return new GeneralSystem(simpCoeffs);
     }
-    getEqualNodes() {
+    getEqualNodes(varNames = ["x", "y"]) {
+        const [varNameX, varNameY] = varNames;
         const [a, b, c] = this.coeffs[0];
         const [d, e, f] = this.coeffs[1];
         return [
-            new EqualNode(add(multiply(a, "x"), multiply(b, "y")), c),
-            new EqualNode(add(multiply(d, "x"), multiply(e, "y")), f),
+            new EqualNode(add(multiply(a, varNameX), multiply(b, varNameY)), c),
+            new EqualNode(add(multiply(d, varNameX), multiply(e, varNameY)), f),
         ];
     }
     checkCouple(x, y) {
@@ -129,14 +130,16 @@ export class GeneralSystem {
         //   y,
         // };
     }
-    toTex() {
+    toTex(varNames = ["x", "y"]) {
+        const [varNameX, varNameY] = varNames;
         return `\\left\\{\\begin{matrix}
-${add(multiply(this.coeffs[0][0], "x"), multiply(this.coeffs[0][1], "y")).toTex()}=${this.coeffs[0][2].toTex()} \\\\
-${new AddNode(multiply(this.coeffs[1][0], "x"), multiply(this.coeffs[1][1], "y")).toTex()}=${this.coeffs[1][2].toTex()}
+${add(multiply(this.coeffs[0][0], varNameX), multiply(this.coeffs[0][1], varNameY)).toTex()}=${this.coeffs[0][2].toTex()} \\\\
+${new AddNode(multiply(this.coeffs[1][0], varNameX), multiply(this.coeffs[1][1], varNameY)).toTex()}=${this.coeffs[1][2].toTex()}
 \\end{matrix}\\right.`;
     }
-    toCorrectionTex() {
-        const [equa1, equa2] = this.getEqualNodes();
+    toCorrectionTex(varNames = ["x", "y"], isTrySolveBySub = true) {
+        const [varNameX, varNameY] = varNames;
+        const [equa1, equa2] = this.getEqualNodes(varNames);
         const coeffs1 = this.coeffs[0];
         const coeffs2 = this.coeffs[1];
         let corr = "";
@@ -148,12 +151,12 @@ ${new AddNode(multiply(this.coeffs[1][0], "x"), multiply(this.coeffs[1][1], "y")
         ].findIndex((e) => Math.abs(e.evaluate()) === 1);
         //si une var est à coeff |1|, substitution
         //sinon, cl :
-        const solveBySub = unitCoeffIndex > -1;
+        const solveBySub = isTrySolveBySub && unitCoeffIndex > -1;
         if (solveBySub) {
             const isFirstEqua = unitCoeffIndex < 2;
             const isX = unitCoeffIndex % 2 === 0;
-            const varName = isX ? "x" : "y";
-            const varName2 = isX ? "y" : "x";
+            const varName = isX ? varNameX : varNameY;
+            const varName2 = isX ? varNameY : varNameX;
             const isolated = isFirstEqua
                 ? equa1.isolate(varName)
                 : equa2.isolate(varName);
@@ -171,14 +174,14 @@ $$`;
                 towardsDistribute: true,
                 forbidFactorize: true,
             });
-            const isolated2 = subSimp.isolate(isX ? "y" : "x");
+            const isolated2 = subSimp.isolate(isX ? varNameY : varNameX);
             const varFinal = isolated.toDetailedEvaluation({
                 [varName2]: isolated2.rightChild,
             });
             const varFinalSimp = varFinal.simplify();
             corr += `
     
-On peut alors remplacer $${varName}$ dans la ${isFirstEqua ? "seconde" : "première"} équation, pour en déduire $${isX ? "y" : "x"}$ : 
+On peut alors remplacer $${varName}$ dans la ${isFirstEqua ? "seconde" : "première"} équation, pour en déduire $${isX ? varNameY : varNameX}$ : 
 
 ${alignTex([[substituted.toTex()], [subSimp.toTex()], [isolated2.toTex()]])}
 
@@ -217,14 +220,14 @@ On multiplie la ${shouldHandleFirst
                     : ""} :
 
 $$
-${sysMultiplied.toTex()}
+${sysMultiplied.toTex(varNames)}
 $$
 
 `;
             }
-            const equaMul = sysMultiplied.getEqualNodes();
+            const equaMul = sysMultiplied.getEqualNodes(varNames);
             const added = equal(add(equaMul[0].leftChild, equaMul[1].leftChild), add(equaMul[0].rightChild, equaMul[1].rightChild)).simplify();
-            const varName = isX ? "y" : "x";
+            const varName = isX ? varNameY : varNameX;
             const isolated = added.isolate(varName);
             const sub = equa1.toDetailedEvaluation({
                 [varName]: isolated.rightChild,
@@ -235,7 +238,7 @@ $$
                 towardsDistribute: true,
             });
             const subSimpToIsolateButWeShouldnt = sub.simplify({});
-            const isolated2 = subSimpToIsolateButWeShouldnt.isolate(isX ? "x" : "y");
+            const isolated2 = subSimpToIsolateButWeShouldnt.isolate(isX ? varNameX : varNameY);
             corr += `On peut alors additionner les deux équations pour éliminer une des variables et isoler l'autre : 
 
 ${alignTex([[added.toTex()], [isolated.toTex()]])}

package/lib/math/utils/functions/functionComparison.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionComparison.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAqElE,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,OAAO,aAAa,YAarB,CAAC"}
+{"version":3,"file":"functionComparison.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAIlE,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,OAAO,aAAa,YAarB,CAAC"}

package/lib/math/utils/functions/functionComparison.js

@@ -1,48 +1,5 @@
-import { isInfiniteNode } from "../../../tree/nodes/numbers/constantNode.js";
 import { substract } from "../../../tree/nodes/operators/substractNode.js";
-import { randfloat } from "../random/randfloat.js";
-const getSafeEvaluationDictForEqualityCheck = (node1, node2, nbSafeX = 4) => {
-    const dict = {};
-    let counter = -1;
-    while (Object.keys(dict).length < nbSafeX && counter < 1000) {
-        counter++;
-        const x = randfloat(-20, 100, 3);
-        let value1;
-        let value2;
-        try {
-            value1 = node1.evaluate({ x });
-        }
-        catch (_) {
-            continue;
-        }
-        try {
-            value2 = node2.evaluate({ x });
-        }
-        catch (_) {
-            continue;
-        }
-        const [isValidValue1, isValidValue2] = [value1, value2].map((value) => value !== undefined && !isNaN(value) && !isInfiniteNode(value.toTree()));
-        if (isValidValue1 && isValidValue2) {
-            dict[x] = [value1, value2].map((value) => {
-                return {
-                    x,
-                    value,
-                };
-            });
-        }
-    }
-    return dict;
-};
-const isEqualFromRandomEvaluations = (node1, node2) => {
-    const safeEvalDict = getSafeEvaluationDictForEqualityCheck(node1, node2);
-    const arrArrSafeEval = Object.values(safeEvalDict);
-    return (arrArrSafeEval.length > 0 &&
-        arrArrSafeEval.every((arrSafeEval) => {
-            return arrSafeEval
-                .slice(1)
-                .every((safeEval) => substract(arrSafeEval[0].value, safeEval.value).evaluate() === 0);
-        }));
-};
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
 export const isEquivalentNodes = (node1, node2) => {
     let isEqualFromAlgebraicSimplification = false;
     try {
@@ -53,5 +10,5 @@ export const isEquivalentNodes = (node1, node2) => {
         (() => { })();
     }
     return (isEqualFromAlgebraicSimplification ||
-        isEqualFromRandomEvaluations(node1, node2));
+        NodeComparator.isEqualViaRandomEvaluations(node1, node2, 4));
 };

package/lib/math/utils/functions/functionComposition.d.ts

@@ -1,5 +1,7 @@
 import { AlgebraicNode, SimplifyOptions } from "../../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { Node } from "../../../tree/nodes/node.js";
 export declare const nodeBySubstitutingVar: (nodeCarrier: AlgebraicNode, nodeInjected: AlgebraicNode, variableNode?: VariableNode) => AlgebraicNode;
 export type NodePathWithNodes = {
     arrNode: AlgebraicNode[];
@@ -9,5 +11,5 @@ export declare const getAllNodePaths: (node: AlgebraicNode) => NodePathWithNodes
 export type NodePath = {
     keys: ("leftChild" | "rightChild" | "child")[];
 };
-export declare function nodeByReplacingNodeAtPath(nodeCarrier: AlgebraicNode, path: NodePath, nodeInjected: AlgebraicNode, simplifyUpToLevel?: number, simplifyOptions?: SimplifyOptions): AlgebraicNode;
+export declare function nodeByReplacingNodeAtPath(nodeCarrier: AlgebraicNode, path: NodePath, nodeInjected: AlgebraicNode, simplifyUpToLevel?: number, simplifyOptions?: SimplifyOptions, fromIdentifiersFunc?: (identifiers: NodeIdentifiers) => Node): AlgebraicNode;
 //# sourceMappingURL=functionComposition.d.ts.map

package/lib/math/utils/functions/functionComposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAc3C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA+CF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,iBA0DtC"}
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAS3C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAEhD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA8DF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,EACrC,mBAAmB,GAAE,CAAC,WAAW,EAAE,eAAe,KAAK,IAEN,iBAwElD"}

package/lib/math/utils/functions/functionComposition.js

@@ -1,6 +1,6 @@
 import { isEqualNode, } from "../../../tree/nodes/equations/equalNode.js";
 import { isFunctionNode, } from "../../../tree/nodes/functions/functionNode.js";
-import { NodeConstructor } from "../../../tree/nodes/nodeConstructor.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
 import { isOperatorNode, } from "../../../tree/nodes/operators/operatorNode.js";
 import { isVariableNode, } from "../../../tree/nodes/variables/variableNode.js";
 export const nodeBySubstitutingVar = (nodeCarrier, nodeInjected, variableNode = "x".toTree()) => {
@@ -50,32 +50,32 @@ export const getAllNodePaths = (node) => {
     }
     return arrNodePaths;
 };
-function functionNodeByReplacingChild(fNode, nodeChildNew) {
+function functionNodeByReplacingChild(fNode, nodeChildNew, fromIdentifiersFunc = (identifiers) => NodeConstructor.fromIdentifiers(identifiers)) {
     const nodeIds = fNode.toIdentifiers();
     nodeIds.child = nodeChildNew.toIdentifiers();
-    return NodeConstructor.fromIdentifiers(nodeIds);
+    return fromIdentifiersFunc(nodeIds);
 }
-function operatorNodeByReplacingLeftChild(opNode, nodeLeftChildNew) {
+function operatorNodeByReplacingLeftChild(opNode, nodeLeftChildNew, fromIdentifiersFunc = (identifiers) => NodeConstructor.fromIdentifiers(identifiers)) {
     const nodeIds = opNode.toIdentifiers();
     nodeIds.leftChild = nodeLeftChildNew.toIdentifiers();
-    return NodeConstructor.fromIdentifiers(nodeIds);
+    return fromIdentifiersFunc(nodeIds);
 }
-function operatorNodeByReplacingRightChild(opNode, nodeRightChildNew) {
+function operatorNodeByReplacingRightChild(opNode, nodeRightChildNew, fromIdentifiersFunc = (identifiers) => NodeConstructor.fromIdentifiers(identifiers)) {
     const nodeIds = opNode.toIdentifiers();
     nodeIds.rightChild = nodeRightChildNew.toIdentifiers();
-    return NodeConstructor.fromIdentifiers(nodeIds);
+    return fromIdentifiersFunc(nodeIds);
 }
-function equalNodeByReplacingLeftChild(equalNode, nodeLeftChildNew) {
+function equalNodeByReplacingLeftChild(equalNode, nodeLeftChildNew, fromIdentifiersFunc = (identifiers) => NodeConstructor.fromIdentifiers(identifiers)) {
     const nodeIds = equalNode.toIdentifiers();
     nodeIds.leftChild = nodeLeftChildNew.toIdentifiers();
-    return NodeConstructor.fromIdentifiers(nodeIds);
+    return fromIdentifiersFunc(nodeIds);
 }
-function equalNodeByReplacingRightChild(equalNode, nodeRightChildNew) {
+function equalNodeByReplacingRightChild(equalNode, nodeRightChildNew, fromIdentifiersFunc = (identifiers) => NodeConstructor.fromIdentifiers(identifiers)) {
     const nodeIds = equalNode.toIdentifiers();
     nodeIds.rightChild = nodeRightChildNew.toIdentifiers();
-    return NodeConstructor.fromIdentifiers(nodeIds);
+    return fromIdentifiersFunc(nodeIds);
 }
-export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simplifyUpToLevel = -1, simplifyOptions = {}) {
+export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simplifyUpToLevel = -1, simplifyOptions = {}, fromIdentifiersFunc = (identifiers) => NodeConstructor.fromIdentifiers(identifiers)) {
     function getNodeForKey(node, key) {
         if (key === "leftChild" || key === "rightChild") {
             return node[key];
@@ -89,19 +89,19 @@ export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simpl
     }
     function nodeByReplacingChildAtKey(node, key, nodeInjected) {
         if (key === "leftChild" && isOperatorNode(node)) {
-            return operatorNodeByReplacingLeftChild(node, nodeInjected);
+            return operatorNodeByReplacingLeftChild(node, nodeInjected, fromIdentifiersFunc);
         }
         else if (key === "rightChild" && isOperatorNode(node)) {
-            return operatorNodeByReplacingRightChild(node, nodeInjected);
+            return operatorNodeByReplacingRightChild(node, nodeInjected, fromIdentifiersFunc);
         }
         else if (key === "leftChild" && isEqualNode(node)) {
-            return equalNodeByReplacingLeftChild(node, nodeInjected);
+            return equalNodeByReplacingLeftChild(node, nodeInjected, fromIdentifiersFunc);
         }
         else if (key === "rightChild" && isEqualNode(node)) {
-            return equalNodeByReplacingRightChild(node, nodeInjected);
+            return equalNodeByReplacingRightChild(node, nodeInjected, fromIdentifiersFunc);
         }
         else if (key === "child" && isFunctionNode(node)) {
-            return functionNodeByReplacingChild(node, nodeInjected);
+            return functionNodeByReplacingChild(node, nodeInjected, fromIdentifiersFunc);
         }
         else {
             throw new Error("Either key and node type are incompatible or Unsupported key: " + key);

package/lib/math/utils/integration/rectanglesMethod.d.ts

@@ -0,0 +1,6 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+export declare const lowerSum: (nodeF: AlgebraicNode, nodeIntegralBoundLow: AlgebraicNode, nodeIntegralBoundHigh: AlgebraicNode, nbRectangles: number, isShouldSimplifyAbscissa: boolean) => AlgebraicNode;
+export declare const upperSum: (nodeF: AlgebraicNode, nodeIntegralBoundLow: AlgebraicNode, nodeIntegralBoundHigh: AlgebraicNode, nbRectangles: number, isShouldSimplifyAbscissa: boolean) => AlgebraicNode;
+export declare const lowerSumSameAsGGB: (nodeF: AlgebraicNode, nodeIntegralBoundLow: AlgebraicNode, nodeIntegralBoundHigh: AlgebraicNode, nbRectangles: number) => number;
+export declare const upperSumSameAsGGB: (nodeF: AlgebraicNode, nodeIntegralBoundLow: AlgebraicNode, nodeIntegralBoundHigh: AlgebraicNode, nbRectangles: number) => number;
+//# sourceMappingURL=rectanglesMethod.d.ts.map

package/lib/math/utils/integration/rectanglesMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectanglesMethod.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/integration/rectanglesMethod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAkElE,eAAO,MAAM,QAAQ,GACnB,OAAO,aAAa,EACpB,sBAAsB,aAAa,EACnC,uBAAuB,aAAa,EACpC,cAAc,MAAM,EACpB,0BAA0B,OAAO,kBAelC,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,OAAO,aAAa,EACpB,sBAAsB,aAAa,EACnC,uBAAuB,aAAa,EACpC,cAAc,MAAM,EACpB,0BAA0B,OAAO,kBAelC,CAAC;AA4CF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,sBAAsB,aAAa,EACnC,uBAAuB,aAAa,EACpC,cAAc,MAAM,WAcrB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,sBAAsB,aAAa,EACnC,uBAAuB,aAAa,EACpC,cAAc,MAAM,WAcrB,CAAC"}