math-exercises 3.0.217 → 3.0.218

package/lib/exercises/pc/energy/energyTransfer.js

@@ -4,6 +4,7 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { round } from "../../../math/utils/round.js";
 import { requiresApostropheBefore } from "../../../utils/strings/requiresApostropheBefore.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 const substances = [
     { name: "eau", latentHeat: 334 }, // kJ/kg for melting ice
     { name: "fer", latentHeat: 276 }, // kJ/kg for melting iron
@@ -56,14 +57,8 @@ const getPropositions = (n, { answer, substance, mass }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { substance, mass }) => {
-    const subst = substances.find((s) => s.name === substance);
-    const energy = round(mass * subst.latentHeat, 2);
-    const validanswer1 = `${energy}\\kJ`;
-    const validanswer2 = energy.toTree().toAllValidTexs();
-    const latexs = [];
-    latexs.push(validanswer1, ...validanswer2);
-    return latexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const energyTransfer = {
     id: "energyTransfer",

package/lib/exercises/pc/energy/thermalEnergyTransferCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thermalEnergyTransferCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/thermalEnergyTransferCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,QAAQ,CAAC;CACzC,CAAC;AAwRF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}
+{"version":3,"file":"thermalEnergyTransferCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/thermalEnergyTransferCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,QAAQ,CAAC;CACzC,CAAC;AAuPF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/pc/energy/thermalEnergyTransferCalculation.js

@@ -4,6 +4,7 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { round } from "../../../math/utils/round.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 const getInstruction = (identifiers) => {
     const { mass, specificHeat, initialTemp, finalTemp, variable } = identifiers;
     const deltaT = finalTemp - initialTemp;
@@ -148,30 +149,8 @@ const getPropositions = (n, { answer, mass, specificHeat, initialTemp, finalTemp
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { mass, specificHeat, initialTemp, finalTemp, variable }) => {
-    let validanswer;
-    const deltaT = finalTemp - initialTemp;
-    switch (variable) {
-        case "E_th":
-            validanswer = round(mass * specificHeat * deltaT, 2);
-            break;
-        case "m":
-            validanswer = round((mass * specificHeat * deltaT) / (specificHeat * deltaT), 2);
-            break;
-        case "c":
-            validanswer = round((mass * specificHeat * deltaT) / (mass * deltaT), 2);
-            break;
-        case "deltaT":
-            validanswer = round((mass * specificHeat * deltaT) / (mass * specificHeat), 2);
-            break;
-    }
-    const latexs = [
-        ...validanswer.toTree().toAllValidTexs(),
-        validanswer.toScientific(2).toTex(),
-        validanswer.toScientific(1).toTex(),
-        validanswer.toScientific(3).toTex(),
-    ];
-    return latexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const thermalEnergyTransferCalculation = {
     id: "thermalEnergyTransferCalculation",

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proportionnalityCoeffFromLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/math/proportionnalityCoeffFromLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0FF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"proportionnalityCoeffFromLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/math/proportionnalityCoeffFromLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0FF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.js

@@ -1,5 +1,6 @@
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../exercises/vea/rationalVEA.js";
 import { randomColor } from "../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { Integer } from "../../../math/numbers/integer/integer.js";
@@ -7,6 +8,7 @@ import { Rational } from "../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getInstruction = () => {
     return "Déterminer le coefficient de proportionnalité entre $y$ et $x$ : ";
 };
@@ -71,12 +73,13 @@ const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
-    const leadingCoeff = new Rational(yB - yA, xB - xA)
-        .simplify()
-        .toTree({ allowFractionToDecimal: true });
-    const texs = leadingCoeff.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const proportionnalityCoeffFromLine = {
     id: "proportionnalityCoeffFromLine",

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

@@ -1 +1 @@
-{"version":3,"file":"equationVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/equationVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,aAAa,MAAM,YAa3D,CAAC"}
+{"version":3,"file":"equationVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/equationVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,aAAa,MAAM,YAgB3D,CAAC"}

package/lib/exercises/vea/equationVEA.js

@@ -4,6 +4,8 @@ import { handleVEAError } from "../../utils/errors/handleVEAError.js";
 import { rationalVEA } from "./rationalVEA.js";
 export const equationVEA = (ans, solutionTex) => {
     try {
+        if (solutionTex === "\\varnothing")
+            return ans === "\\varnothing" || ans === "S=\\varnothing";
         const parsed = equationSolutionParser(ans);
         if (parsed) {
             return rationalVEA(parsed.toTex(), solutionTex);

package/lib/exercises/vea/rationalVEA.d.ts

@@ -1,8 +1,9 @@
 type Opts = {
     allowNonIrreductible?: boolean;
     allowDecimal?: boolean;
+    allowDecimalApprox?: boolean;
     decimalPrecision?: number;
 };
-export declare const rationalVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalPrecision, allowDecimal }?: Opts) => boolean;
+export declare const rationalVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalPrecision, allowDecimal, allowDecimalApprox, }?: Opts) => boolean;
 export {};
 //# sourceMappingURL=rationalVEA.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAOA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,2DAA0D,IAIzD,YAkCF,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAeA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,gFAKG,IAKF,YAsEF,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -1,14 +1,18 @@
 import { round } from "../../math/utils/round.js";
-import { isNumberNode } from "../../tree/nodes/numbers/numberNode.js";
+import { isOppositeNode } from "../../tree/nodes/functions/oppositeNode.js";
+import { isNumberNode, } from "../../tree/nodes/numbers/numberNode.js";
+import { isFractionNode, } from "../../tree/nodes/operators/fractionNode.js";
 import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
 import { rationalParser } from "../../tree/parsers/rationalParser.js";
 import { handleVEAError } from "../../utils/errors/handleVEAError.js";
-export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal } = {
+export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal, allowDecimalApprox, } = {
     allowNonIrreductible: true,
     decimalPrecision: 2,
     allowDecimal: true,
+    allowDecimalApprox: true,
 }) => {
     allowDecimal = allowDecimal ?? true;
+    allowDecimalApprox = allowDecimalApprox ?? true;
     allowNonIrreductible = allowNonIrreductible ?? true;
     decimalPrecision = decimalPrecision ?? undefined;
     const parsed = rationalParser(studentAns);
@@ -19,6 +23,20 @@ export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalP
         if (isNumberNode(parsed)) {
             if (!allowDecimal)
                 return false;
+            if (!allowDecimalApprox) {
+                //si l'answer n'est pas décimable et que c'est un nbNode on renvoit faux dans tous les cas
+                const answerFraced = isFractionNode(parsedAnswer)
+                    ? parsedAnswer
+                    : isOppositeNode(parsedAnswer) && isFractionNode(parsedAnswer.child)
+                        ? parsedAnswer.child
+                        : isNumberNode(parsedAnswer)
+                            ? parsedAnswer.toFrac()
+                            : null;
+                if (!!answerFraced &&
+                    !isNumberNode(answerFraced) &&
+                    !answerFraced.isDecimal())
+                    return false;
+            }
             if (decimalPrecision === undefined)
                 return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001);
             else {
@@ -32,6 +50,22 @@ export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalP
             }
         }
         else if (allowNonIrreductible) {
+            if (!allowDecimalApprox) {
+                if (isNumberNode(parsed)) {
+                    //si l'answer n'est pas décimable et que c'est un nbNode on renvoit faux dans tous les cas
+                    const answerFraced = isFractionNode(parsedAnswer)
+                        ? parsedAnswer
+                        : isOppositeNode(parsedAnswer) && isFractionNode(parsedAnswer.child)
+                            ? parsedAnswer.child
+                            : isNumberNode(parsedAnswer)
+                                ? parsedAnswer.toFrac()
+                                : null;
+                    if (!!answerFraced &&
+                        !isNumberNode(answerFraced) &&
+                        !answerFraced.isDecimal())
+                        return false;
+                }
+            }
             return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
         }
         else {

package/lib/index.d.ts

@@ -119,7 +119,9 @@ declare const mathExercises: (Exercise<{
     denom: number;
     num1: number;
     num2: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    allowNonIrreductible?: boolean;
+}> | Exercise<{
     num1: number;
     num2: number;
     denom1: number;
@@ -681,11 +683,6 @@ declare const mathExercises: (Exercise<{
     d: number;
     k: number;
     isSubstract: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    k1: number;
-    b: number;
-    k2: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     b: number;
     c: number;
@@ -5943,10 +5940,8 @@ declare const mathExercises: (Exercise<{
     graphIds2: import("./math/graphs/graph.js").GraphIdentifiers;
     graphNodes1: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
     graphEdges1: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
-    scale1: number;
     graphNodes2: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
     graphEdges2: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
-    scale2: number;
 }, {
     graphType: string;
 }> | Exercise<{

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/math/utils/graphs/graphRenderer.d.ts

@@ -1,6 +1,4 @@
 import { Graph } from "../../graphs/graph.js";
-import * as TSGraphViz from "ts-graphviz";
-import { Engine } from "@hpcc-js/wasm-graphviz";
 export interface GraphNode {
     label: string;
     x: number;
@@ -10,14 +8,14 @@ export interface GraphEdge {
     from: string;
     to: string;
 }
+export type RandomLayoutOptions = {
+    width?: number;
+    height?: number;
+    minDistance?: number;
+    maxAttempts?: number;
+};
 export declare class GraphRenderer {
-    static convertToGraphVizGraph(graph: Graph): TSGraphViz.Digraph;
-    static renderToSVG(graph: Graph, layoutEngineIn?: Engine): string;
-    static convertSVGToNodesAndEdges(strSVG: string): {
-        nodes: GraphNode[];
-        edges: GraphEdge[];
-    };
-    static renderToNodesAndEdges(graph: Graph, layoutEngineIn?: Engine): {
+    static renderToNodesAndEdges(graph: Graph, { width, height, minDistance, maxAttempts, }?: RandomLayoutOptions): {
         nodes: GraphNode[];
         edges: GraphEdge[];
     };

package/lib/math/utils/graphs/graphRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphRenderer.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/graphs/graphRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C,OAAO,KAAK,UAAU,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAY,MAAM,wBAAwB,CAAC;AAM1D,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,qBAAa,aAAa;IACxB,MAAM,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAAC,OAAO;IAkE/D,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,cAAc,CAAC,EAAE,MAAM;IA0BxD,MAAM,CAAC,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG;QAChD,KAAK,EAAE,SAAS,EAAE,CAAC;QACnB,KAAK,EAAE,SAAS,EAAE,CAAC;KACpB;IAwDD,MAAM,CAAC,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,cAAc,CAAC,EAAE,MAAM;eA1DzD,SAAS,EAAE;eACX,SAAS,EAAE;;CA6DrB"}
+{"version":3,"file":"graphRenderer.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/graphs/graphRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,qBAAa,aAAa;IACxB,MAAM,CAAC,qBAAqB,CAC1B,KAAK,EAAE,KAAK,EACZ,EACE,KAAU,EACV,MAAW,EACX,WAAiB,EACjB,WAAiB,GAClB,GAAE,mBAAwB,GAC1B;QAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAAC,KAAK,EAAE,SAAS,EAAE,CAAA;KAAE;CAoC9C"}

package/lib/math/utils/graphs/graphRenderer.js

@@ -1,123 +1,31 @@
-import * as TSGraphViz from "ts-graphviz";
-import { Graphviz } from "@hpcc-js/wasm-graphviz";
-const graphviz = await Graphviz.load();
-import { JSDOM } from "jsdom";
-import { random } from "../../../utils/alea/random.js";
 export class GraphRenderer {
-    static convertToGraphVizGraph(graph) {
-        const digraph = new TSGraphViz.Digraph();
-        // Create nodes
-        const dictGraphvizNode = Object.fromEntries(graph.vertexNames.map((nameVertex) => {
-            const graphvizNode = new TSGraphViz.Node(nameVertex, {});
-            return [nameVertex, graphvizNode];
-        }));
-        // Create edges between the nodes
-        const arrConnectionNoDuplicate = (() => {
-            const arrConnection = Object.entries(graph.dictConnections()).flatMap(([nameVertexStart, dictConnections]) => {
-                return Object.entries(dictConnections)
-                    .filter(([_, isConnection]) => isConnection)
-                    .map(([nameVertexEnd, _]) => [nameVertexStart, nameVertexEnd]);
-            });
-            if (graph.isDirected) {
-                return arrConnection;
+    static renderToNodesAndEdges(graph, { width = 10, height = 10, minDistance = 1.5, maxAttempts = 100, } = {}) {
+        // 1. Placement aléatoire des sommets, en évitant les chevauchements
+        const nodes = [];
+        for (const label of graph.vertexNames) {
+            let best = { x: 0, y: 0 };
+            let bestDist = -Infinity;
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                const x = Math.random() * width;
+                const y = Math.random() * height;
+                const dist = nodes.reduce((min, node) => Math.min(min, Math.hypot(node.x - x, node.y - y)), Infinity);
+                // on garde le candidat le plus éloigné des autres (repli si la zone est trop petite)
+                if (dist > bestDist) {
+                    best = { x, y };
+                    bestDist = dist;
+                }
+                if (dist >= minDistance)
+                    break;
             }
-            else {
-                return arrConnection
-                    .map(([nameVertexStart, nameVertexEnd]) => [nameVertexStart, nameVertexEnd].join("-"))
-                    .reduce((acc, strEdge) => {
-                    const strEdgeReversed = strEdge.split("").toReversed().join("");
-                    if (acc.includes(strEdgeReversed)) {
-                        //ignore
-                    }
-                    else {
-                        acc = [...acc, strEdge];
-                    }
-                    return acc;
-                }, [])
-                    .map((strEdge) => {
-                    const [nameVertexStart, nameVertexEnd] = strEdge.split("-");
-                    return [nameVertexStart, nameVertexEnd];
-                });
-            }
-        })();
-        const arrEdge = arrConnectionNoDuplicate.map(([nameVertexStart, nameVertexEnd]) => {
-            const [graphvizNodeStart, graphvizNodeEnd] = [
-                nameVertexStart,
-                nameVertexEnd,
-            ].map((nameVertex) => dictGraphvizNode[nameVertex]);
-            const graphvizEdge = new TSGraphViz.Edge([graphvizNodeStart, graphvizNodeEnd], {});
-            return graphvizEdge;
-        });
-        // Add elements to the graph
-        Object.entries(dictGraphvizNode).forEach(([_, graphvizNode]) => digraph.addNode(graphvizNode));
-        arrEdge.forEach((graphvizEdge) => digraph.addEdge(graphvizEdge));
-        return digraph;
-    }
-    static renderToSVG(graph, layoutEngineIn) {
-        const digraph = GraphRenderer.convertToGraphVizGraph(graph);
-        const dot = TSGraphViz.toDot(digraph);
-        // Render DOT to SVG
-        /*
-        const arrLayoutEngine = [
-          "circo",
-          "dot",
-          "fdp",
-          "neato",
-          "nop",
-          "nop2",
-          // "osage",
-          // "patchwork",
-          "sfdp",
-          "twopi",
-        ];
-        */
-        const layoutEngine = layoutEngineIn ?? random(["fdp", "circo"]);
-        const svg = graphviz.layout(dot, "svg", layoutEngine);
-        return svg;
-    }
-    static convertSVGToNodesAndEdges(strSVG) {
-        function parseSvgGraph(svgString) {
-            const domParser = new new JSDOM().window.DOMParser();
-            const doc = domParser.parseFromString(svgString, "image/svg+xml");
-            const svgEl = doc.querySelector("svg");
-            const height = parseFloat(svgEl?.getAttribute("height") ?? "0");
-            // Translation du groupe racine (pattern classique Graphviz)
-            const graphGroup = doc.querySelector("g.graph") ?? doc.querySelector("svg > g");
-            const transform = graphGroup?.getAttribute("transform") ?? "";
-            const match = transform.match(/translate\(([-\d.]+)[ ,]([-\d.]+)\)/);
-            const [tx, ty] = match
-                ? [parseFloat(match[1]), parseFloat(match[2])]
-                : [0, 0];
-            // Sommets
-            const nodes = Array.from(doc.querySelectorAll("g.node")).map((g) => {
-                const ellipse = g.querySelector("ellipse");
-                const text = g.querySelector("text");
-                const label = text?.textContent?.trim() ??
-                    g.querySelector("title")?.textContent?.trim() ??
-                    "";
-                const cx = parseFloat(ellipse?.getAttribute("cx") ?? "0");
-                const cy = parseFloat(ellipse?.getAttribute("cy") ?? "0");
-                return {
-                    label,
-                    x: cx + tx,
-                    y: height - (cy + ty), // flip vertical SVG -> GeoGebra
-                };
-            });
-            // Arêtes : lues directement depuis le <title> de chaque g.edge (ex: "A->B")
-            const edges = Array.from(doc.querySelectorAll("g.edge"))
-                .map((g) => g.querySelector("title")?.textContent?.trim() ?? "")
-                .map((title) => {
-                const [from, to] = title.split(/-&gt;|->/).map((s) => s.trim());
-                return { from, to };
-            })
-                .filter((e) => Boolean(e.from && e.to));
-            return { nodes, edges };
+            nodes.push({ label, ...best });
         }
-        const { nodes, edges } = parseSvgGraph(strSVG);
+        // 2. Arêtes (une seule fois par paire si le graphe n'est pas orienté)
+        const indexOf = new Map(graph.vertexNames.map((name, i) => [name, i]));
+        const edges = graph
+            .arrConnection()
+            .filter(([from, to, isConnection]) => isConnection &&
+            (graph.isDirected || indexOf.get(from) <= indexOf.get(to)))
+            .map(([from, to]) => ({ from, to }));
         return { nodes, edges };
     }
-    static renderToNodesAndEdges(graph, layoutEngineIn) {
-        const strSVG = this.renderToSVG(graph, layoutEngineIn);
-        return this.convertSVGToNodesAndEdges(strSVG);
-    }
 }

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

@@ -21,6 +21,7 @@ export type SimplifyOptions = {
     forbidPowerMultiply?: boolean;
     forbidPowerDivision?: boolean;
     forbidPowerPower?: boolean;
+    forbidLogSimplify?: boolean;
 };
 export type EvaluateOptions = {
     degreeMode?: boolean;
@@ -41,4 +42,5 @@ export declare abstract class CAlgebraicNode {
     private static toString;
 }
 export declare const isAlgebraicNode: (node: Node) => node is AlgebraicNode;
+export declare const isFactorizedNode: (node: Node) => node is AlgebraicNode;
 //# sourceMappingURL=algebraicNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAG5B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IAC5E,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,aAAa,CAAC;IACnE,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;IAChD,mBAAmB,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IACxD,mBAAmB,EAAE,MAAM,MAAM,CAAC;CACnC;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,aACI,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAI9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAG7B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IAC5E,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,aAAa,CAAC;IACnE,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;IAChD,mBAAmB,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IACxD,mBAAmB,EAAE,MAAM,MAAM,CAAC;CACnC;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,aACI,CAAC;AAE1D,eAAO,MAAM,gBAAgB,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,aASrD,CAAC"}

package/lib/tree/nodes/algebraicNode.js

@@ -1,3 +1,6 @@
+import { isOppositeNode } from "./functions/oppositeNode.js";
+import { isMultiplyNode } from "./operators/multiplyNode.js";
+import { isPowerNode, isSquareNode } from "./operators/powerNode.js";
 export class CAlgebraicNode {
     constructor() { }
     static toString() {
@@ -5,3 +8,11 @@ export class CAlgebraicNode {
     }
 }
 export const isAlgebraicNode = (node) => Object.prototype.hasOwnProperty.call(node, "isNumeric");
+export const isFactorizedNode = (node) => {
+    return (isMultiplyNode(node) ||
+        isPowerNode(node) ||
+        isSquareNode(node) ||
+        (isOppositeNode(node) && isMultiplyNode(node.child)) ||
+        (isOppositeNode(node) && isPowerNode(node.child)) ||
+        (isOppositeNode(node) && isSquareNode(node.child)));
+};

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

@@ -1,6 +1,6 @@
 import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
 import { FunctionNode, FunctionsIds } from "./functionNode.js";
-import { AlgebraicNode } from "../algebraicNode.js";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isLog10Node(a: Node): a is Log10Node;
 export declare const log10: (a: AlgebraicNode | number | string) => Log10Node;
 export declare class Log10Node implements FunctionNode {
@@ -22,7 +22,7 @@ export declare class Log10Node implements FunctionNode {
     toEquivalentNodes(): AlgebraicNode[];
     toSignInequationTex(): string;
     toAllValidTexs(): string[];
-    simplify(): AlgebraicNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
     evaluate(vars?: Record<string, number>): number;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): Log10Node;

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

@@ -1 +1 @@
-{"version":3,"file":"log10Node.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/log10Node.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;AAE/E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAMpD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,eAAO,MAAM,KAAK,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,cAIvD,CAAC;AACF,qBAAa,SAAU,YAAW,YAAY;IAC5C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,mBAAmB;IAQnB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IAQpC,mBAAmB;IAOnB,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,aAAa;IAiCzB,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,IAAI,aAAa;CAG5B"}
+{"version":3,"file":"log10Node.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/log10Node.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;AAE/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAMrE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,eAAO,MAAM,KAAK,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,cAIvD,CAAC;AACF,qBAAa,SAAU,YAAW,YAAY;IAC5C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,mBAAmB;IAQnB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IAQpC,mBAAmB;IAOnB,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAkC/C,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,IAAI,aAAa;CAG5B"}

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

@@ -78,9 +78,11 @@ export class Log10Node {
     toAllValidTexs() {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }
-    simplify() {
+    simplify(opts) {
         const simplifiedChild = this.child.simplify();
         const copy = new Log10Node(simplifiedChild, this.opts);
+        if (opts?.forbidLogSimplify)
+            return copy;
         if (isNumberNode(simplifiedChild)) {
             const value = simplifiedChild.value;
             const log10 = Math.log10(value);

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

@@ -1 +1 @@
-{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.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;AAQrE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,IAAI,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,YAItD,CAAC;AAEF,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,mBAAmB;IAQnB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IAQpC,mBAAmB;IAOnB,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAoC/C,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,IAAI,aAAa;CAG5B"}
+{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.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;AAQrE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,IAAI,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,YAItD,CAAC;AAEF,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,mBAAmB;IAQnB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IAQpC,mBAAmB;IAOnB,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqC/C,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,IAAI,aAAa;CAG5B"}

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

@@ -81,6 +81,8 @@ export class LogNode {
     simplify(opts) {
         const simplifiedChild = this.child.simplify(opts);
         const copy = new LogNode(simplifiedChild, this.opts);
+        if (opts?.forbidLogSimplify)
+            return copy; //on autorise la simplification du child mais pas les formules de simpliifications du log en elles memes
         if (isNumberNode(simplifiedChild)) {
             const value = simplifiedChild.value;
             if (value <= 0)

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

@@ -313,7 +313,7 @@ const addSort = (a, b, opts) => {
                 parsedA.variable.localeCompare(parsedB.variable));
         }
     }
-    return 0;
+    return Number(isNumberNode(b)) - Number(isNumberNode(a));
 };
 const addSimplifyFrac = (a, b, opts) => {
     if (isFractionNode(a) &&

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

@@ -102,7 +102,7 @@ export class FractionNode {
         const simp = this.simplify();
         if (isNumberNode(simp))
             return true;
-        let denum = simp.leftChild.evaluate();
+        let denum = simp.rightChild.evaluate();
         let counter = 0;
         while (denum % 2 === 0) {
             counter++;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.217",
+  "version": "3.0.218",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [
@@ -28,22 +28,16 @@
   "author": "Heureux Hasard",
   "license": "ISC",
   "dependencies": {
-    "@flatten-js/core": "^1.6.14",
-    "@hpcc-js/wasm-graphviz": "^1.29.1",
     "d3-node": "^4.0.1",
-    "jsdom": "^29.1.1",
     "katex": "^0.16.21",
     "lodash.isequal": "^4.5.0",
-    "ts-graphviz": "^3.0.7",
     "uuidv4": "^6.2.13"
   },
   "devDependencies": {
     "@eslint/js": "^9.34.0",
     "@types/cors": "^2.8.13",
-    "@types/deasync": "^0.1.5",
     "@types/express": "^4.17.17",
     "@types/jest": "^29.5.6",
-    "@types/jsdom": "^30.0.0",
     "@types/lodash.isequal": "^4.5.8",
     "@types/node": "^20.10.6",
     "body-parser": "^1.20.2",