math-exercises 3.0.130 → 3.0.131

package/lib/exercises/math/calculLitteral/equation/equationWithDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationWithDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationWithDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+HF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgEF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}
+{"version":3,"file":"equationWithDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationWithDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyIF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgEF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationWithDistributivity.js

@@ -24,16 +24,15 @@ const getPropositions = (n, { answer }, opts) => {
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;
-    const sol = type
-        ? frac(substract(multiply(d, f), multiply(a, c)), substract(multiply(a, b), multiply(d, e)))
-            .simplify()
-            .toTex()
-        : frac(substract(e, multiply(a, c)), substract(multiply(a, b), d))
-            .simplify()
-            .toTex();
-    return `x=${sol}`;
+    return type
+        ? frac(substract(multiply(d, f), multiply(a, c)), substract(multiply(a, b), multiply(d, e))).simplify()
+        : frac(substract(e, multiply(a, c)), substract(multiply(a, b), d)).simplify();
+};
+const getAnswer = (identifiers) => {
+    const answerNode = getAnswerNode(identifiers);
+    return `x=${answerNode.toTex()}`;
 };
 const getInstruction = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;
@@ -100,11 +99,16 @@ $$
 const getKeys = () => {
     return ["x", "equal"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     const parsed = equationSolutionParser(ans);
     if (!parsed)
         return false;
-    return `x=${parsed.toTex()}` === answer;
+    return (`x=${parsed.toTex()}` === answer ||
+        (() => {
+            const ansNode = parsed;
+            const answerNode = getAnswerNode(identifiers);
+            return substract(ansNode, answerNode).simplify().evaluate() === 0;
+        })());
 };
 const getEquationWithDistributivityQuestion = (opts) => {
     const type = random([0, 1]);

package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.js

@@ -8,6 +8,8 @@ import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
 const getStatementNode = (identifiers) => {
     const { a, b, c, d } = identifiers;
     const polynome1 = new Polynomial([b, a]);
@@ -110,14 +112,13 @@ const getPropositions = (n, { answer }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { a, b, c, d }) => {
+    const parsed = discreteSetParser(ans);
+    if (!parsed)
+        return false;
     const sol1 = new Rational(-b, a).simplify().toTree();
     const sol2 = new Rational(-d, c).simplify().toTree();
     const sortedSols = -b / a < -d / c ? [sol1, sol2] : [sol2, sol1];
-    const answer = new EquationSolutionNode(new DiscreteSetNode(sortedSols), {
-        opts: { allowFractionToDecimal: true },
-    });
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+    return SetVEA.isArrayOfNodesValid(parsed.elements, sortedSols);
 };
 export const multiplicationEquation = {
     id: "multiplicationEquation",

package/lib/exercises/math/calculLitteral/factorisation/index.d.ts

@@ -6,5 +6,4 @@ export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";
 export * from "./factoByX.js";
-export * from "./factorizeAX2PlusBX.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/factorisation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/index.js

@@ -6,4 +6,4 @@ export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";
 export * from "./factoByX.js";
-export * from "./factorizeAX2PlusBX.js";
+// export * from "./factorizeAX2PlusBX.js"; //! existe déjà

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.js

@@ -81,7 +81,7 @@ const getHint = () => {
     return `Voici les énoncés des théorèmes de Pythagore et de Thalès, et leurs réciproques :
 
 - **Théorème de Pythagore** : Dans un triangle rectangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés.
-- **Réciproque du théorème de Pythagore** : Si dans un triangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés, alors le triangle est rectangle.
+- **Réciproque du théorème de Pythagore** : Si dans un triangle, le carré du plus grand côté est égal à la somme des carrés des deux autres côtés, alors le triangle est rectangle.
 - **Théorème de Thalès** : Soit un triangle $ABC$, et $D$ un point sur la droite $(AB)$ et $E$ un point sur la droite $(AC)$. Si les droites $(DE)$ et $(BC)$ sont parallèles, alors :
 
 $$
@@ -98,7 +98,7 @@ const getCorrection = (identifiers) => {
 On applique ce théorème dans le triangle $ABD$ rectangle en $D$. En effet, d'après le théorème de Pythagore, on a $AB^2 = AD^2 + DB^2$. Puisqu'on connaît les longueurs $AD$ et $DB$, on peut en déduire la longueur $AB$.`;
         }
         else {
-            return `Il faut utiliser la réciproque du théorème de Pythagore : si dans un triangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés, alors le triangle est rectangle.
+            return `Il faut utiliser la réciproque du théorème de Pythagore : si dans un triangle, le carré du plus grand côté est égal à la somme des carrés des deux autres côtés, alors le triangle est rectangle.
   
 On applique cette réciproque dans le triangle $BCD$. En effet, on connaît les longueurs des trois côtés. Il suffit donc de montrer que $BC^2 = BD^2 + CD^2$.`;
         }

package/lib/exercises/math/percent/evolutions/evolutionRateFromValues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evolutionRateFromValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/evolutionRateFromValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyGF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}
+{"version":3,"file":"evolutionRateFromValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/evolutionRateFromValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}

package/lib/exercises/math/percent/evolutions/evolutionRateFromValues.js

@@ -4,9 +4,11 @@ import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { percentParser } from "../../../../tree/parsers/percentParser.js";
+import { valueParser } from "../../../../tree/parsers/valueParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { doWhile } from "../../../../utils/doWhile.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
 const getPropositions = (n, { answer, vd, vf }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -25,42 +27,53 @@ const getAnswer = (identifiers) => {
     return taux.frenchify() + "\\%";
 };
 const getInstruction = (identifiers) => {
-    return `Un prix passe de $${identifiers.vd.frenchify()}€$ à $${identifiers.vf.frenchify()}€$. Quel est le taux d'évolution du prix, en pourcentage ? Arrondir au centième de pourcentage.`;
+    return `Un prix passe de $${identifiers.vd.frenchify()}€$ à $${identifiers.vf.frenchify()}€$. Quel est le taux d'évolution du prix ? Arrondir au centième de pourcent.`;
 };
 const getHint = () => {
-    return `Si une valeur passe d'une valeur de départ $V_d$ à une valeur d'arrivée $V_a$, alors le taux d'évolution $t$ en pourcentage est donné par la formule : 
+    return `Si une valeur passe d'une valeur de départ $V_d$ à une valeur d'arrivée $V_a$, alors le taux d'évolution $t$ est donné par la formule : 
   
 $$
-t = \\frac{V_a-V_d}{V_d}\\times 100
+t = \\frac{V_a-V_d}{V_d}
 $$`;
 };
 const getCorrection = (identifiers) => {
-    const answer = round(((identifiers.vf - identifiers.vd) / identifiers.vd) * 100, 2).frenchify();
-    return `Si une valeur passe d'une valeur de départ $V_d$ à une valeur d'arrivée $V_a$, alors le taux d'évolution $t$ en pourcentage est donné par la formule : 
+    const { vd, vf } = identifiers;
+    const percentAnswer = round(((identifiers.vf - identifiers.vd) / identifiers.vd) * 100, 2).frenchify();
+    return `Si une valeur passe d'une valeur de départ $V_d$ à une valeur d'arrivée $V_a$, alors le taux d'évolution $t$ est donné par la formule : 
   
 $$
-t = \\frac{V_a-V_d}{V_d}\\times 100
+t = \\frac{V_a-V_d}{V_d}
 $$
 
-Ici, on a $V_d = ${identifiers.vd.frenchify()}$ et $V_a = ${identifiers.vf.frenchify()}$. 
+Ici, on a $V_d = ${vd.frenchify()}$ et $V_a = ${vf.frenchify()}$. 
 
-Donc, le taux d'évolution, en pourcentage, est : 
+Donc, le taux d'évolution est : 
 
 ${alignTex([
-        [
-            "t",
-            "=",
-            `\\frac{${identifiers.vf.frenchify()}-${identifiers.vd.frenchify()}}{${identifiers.vd.frenchify()}}\\times 100`,
-        ],
-        ["", "\\approx", answer],
+        ["t", "=", `\\frac{${vf.frenchify()}-${vd.frenchify()}}{${vd.frenchify()}}`],
+        ["", "=", `\\frac{${round(vf - vd, 4).frenchify()}}{${vd.frenchify()}}`],
+        ["", ...approxOrEqual((vf - vd) / vd, 4)],
     ])}
+
+Sous forme de pourcentage, le taux d'évolution est donc :
+
+$$
+${percentAnswer}\\%
+$$
 `;
 };
 const getKeys = () => {
     return ["percent"];
 };
-const isAnswerValid = (ans, { answer }) => {
-    return percentParser(ans) === answer;
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    if (ans.includes("\\%")) {
+        const value = percentParser(ans);
+        return value === answer;
+    }
+    const refinedAns = ans.replaceAll("\\%", ``);
+    const nodeAns = valueParser(refinedAns);
+    const nodeAnswer = round((identifiers.vf - identifiers.vd) / identifiers.vd, 4);
+    return nodeAns === nodeAnswer;
 };
 const getEvolutionRateFromValuesQuestion = () => {
     const vd = coinFlip() ? randint(1, 100) : randfloat(1, 100, 2);

package/lib/exercises/math/percent/findProportion.d.ts

@@ -3,11 +3,7 @@ type Identifiers = {
     indexSituation: number;
     total: number;
     lefties: number;
-    opts: Options;
 };
-type Options = {
-    isPercentSymbolRequired: boolean;
-};
-export declare const findProportion: Exercise<Identifiers, Options>;
+export declare const findProportion: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=findProportion.d.ts.map

package/lib/exercises/math/percent/findProportion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,uBAAuB,EAAE,OAAO,CAAC;CAClC,CAAC;AAeF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBzD,CAAC"}
+{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgOF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/percent/findProportion.js

@@ -1,26 +1,29 @@
-import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
-import { percentParser } from "../../../tree/parsers/percentParser.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { random } from "../../../utils/alea/random.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
-import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const situations = [
     {
         instruction: (total, lefties) => `${random([
             `Dans un lycée de $${total}$ élèves, $${lefties}$ sont gauchers.`,
             `Dans un lycée, $${lefties}$ élèves sont gauchers sur un total de $${total}$ élèves.`,
         ])}
-Quelle est la proportion de gauchers dans ce lycée, en pourcentage ?`,
-        hint: `La proportion de gauchers en pourcents s'obtient par la formule  :
+Quelle est la proportion de gauchers dans ce lycée ?`,
+        hint: `La proportion de gauchers s'obtient par la formule  :
     
 $$
-\\frac{\\text{nombre de gauchers}}{\\text{nombre total d'élèves}}\\times 100
+\\frac{\\text{nombre de gauchers}}{\\text{nombre total d'élèves}}
 $$
 `,
-        correction: `La proportion de gauchers en pourcentage dans ce lycée est de`,
+        correction: `La proportion de gauchers dans ce lycée est de`,
         randTotal: () => randint(500, 2000),
     },
     {
@@ -28,14 +31,14 @@ $$
             `Dans une casse automobile, il y a $${total}$ voitures dont $${lefties}$ ont le volant à gauche.`,
             `Dans une casse automobile, $${lefties}$ voitures ont le volant à gauche. Il y a au total $${total}$ voitures.`,
         ])}      
-Quelle est la proportion de voitures avec le volant à gauche dans cette casse, en pourcentage ?`,
-        hint: `La proportion, en pourcents, de voitures avec le volant à gauche s'obtient par la formule  :
+Quelle est la proportion de voitures avec le volant à gauche dans cette casse ?`,
+        hint: `La proportion de voitures avec le volant à gauche s'obtient par la formule  :
     
 $$
-\\frac{\\text{nombre de voitures avec volant à gauche}}{\\text{nombre total de voitures}}\\times 100
+\\frac{\\text{nombre de voitures avec volant à gauche}}{\\text{nombre total de voitures}}
 $$
 `,
-        correction: `La proportion, en pourcentage, de voitures avec le volant à gauche est de`,
+        correction: `La proportion de voitures avec le volant à gauche est de`,
         randTotal: () => randint(100, 500),
     },
     {
@@ -43,14 +46,14 @@ $$
             `Dans un restaurant italien, sur un total de $${total}$ clients, $${lefties}$ ont commandé des pâtes.`,
             `Dans un restaurant italien, $${lefties}$ clients ont commandé des pâtes. Il y a au total $${total}$ clients.`,
         ])} 
-Quelle est la proportion de clients qui ont commandé des pâtes, en pourcentage ?`,
-        hint: `La proportion en pourcents de clients qui ont commandé des pâtes s'obtient par la formule  :
+Quelle est la proportion de clients qui ont commandé des pâtes ?`,
+        hint: `La proportion de clients qui ont commandé des pâtes s'obtient par la formule  :
     
 $$
-\\frac{\\text{nombre de clients ayant commandé des pâtes}}{\\text{nombre total de clients}}\\times 100
+\\frac{\\text{nombre de clients ayant commandé des pâtes}}{\\text{nombre total de clients}}
 $$
 `,
-        correction: `La proportion en pourcentage de clients ayant commandé des pâtes est de`,
+        correction: `La proportion de clients ayant commandé des pâtes est de`,
         randTotal: () => randint(30, 200),
     },
     {
@@ -58,14 +61,14 @@ $$
             `Dans une cagette de $${total}$ pommes, $${lefties}$ sont véreuses.`,
             `Dans une cagette de pommes, $${lefties}$ sont véreuses. Il y a au total $${total}$ pommes.`,
         ])}
-Quelle est la proportion de pommes véreuses dans la cagette, en pourcentage ?`,
-        hint: `La proportion, en pourcents, de pommes véreuses s'obtient par la formule  :
+Quelle est la proportion de pommes véreuses dans la cagette ?`,
+        hint: `La proportion de pommes véreuses s'obtient par la formule  :
     
 $$
-\\frac{\\text{nombre de pommes véreuses}}{\\text{nombre total de pommes}}\\times 100
+\\frac{\\text{nombre de pommes véreuses}}{\\text{nombre total de pommes}}
 $$
 `,
-        correction: `La proportion, en pourcentage, de pommes véreuses est de`,
+        correction: `La proportion de pommes véreuses est de`,
         randTotal: () => randint(30, 100),
     },
     {
@@ -73,14 +76,14 @@ $$
             `Dans un car scolaire transportant $${total}$ élèves, $${lefties}$ sont du côté gauche.`,
             `Dans un car scolaire, $${lefties}$ élèves sont du côté gauche. Le car transporte $${total}$ élèves.`,
         ])}    
-Quelle est la proportion d'élèves du côté gauche du car, en pourcentage ?`,
-        hint: `La proportion en pourcents d'élèves du gauche du car s'obtient par la formule  :
+Quelle est la proportion d'élèves du côté gauche du car ?`,
+        hint: `La proportion d'élèves du gauche du car s'obtient par la formule  :
     
 $$
-\\frac{\\text{nombre d'élèves du côté gauche}}{\\text{nombre d'élèves dans le car}}\\times 100
+\\frac{\\text{nombre d'élèves du côté gauche}}{\\text{nombre d'élèves dans le car}}
 $$
 `,
-        correction: `La proportion en pourcentage d'élèves du côté gauche est de`,
+        correction: `La proportion d'élèves du côté gauche est de`,
         randTotal: () => randint(20, 40),
     },
     {
@@ -88,54 +91,67 @@ $$
             `Dans un champ, au mois de septembre, sur $${total}$ champignons, $${lefties}$ sont vénéneux.`,
             `Dans un champ, au mois de septembre, $${lefties}$ champignons sont vénéneux sur un total de $${total}$ champignons.`,
         ])}    
-Quelle est la proportion de champignons vénéneux dans ce champ, en pourcentage ?`,
-        hint: `La proportion de champignons vénéneux dans ce champ, en pourcents, s'obtient par la formule  :
+Quelle est la proportion de champignons vénéneux dans ce champ ?`,
+        hint: `La proportion de champignons vénéneux dans ce champ s'obtient par la formule  :
     
 $$
-\\frac{\\text{nombre de champignons vénéneux}}{\\text{nombre total de champignons}}\\times 100
+\\frac{\\text{nombre de champignons vénéneux}}{\\text{nombre total de champignons}}
 $$
 `,
-        correction: `La proportion en pourcentage de champignons vénéneux dans ce champ est de`,
+        correction: `La proportion de champignons vénéneux dans ce champ est de`,
         randTotal: () => randint(20, 400),
     },
 ];
 const getInstruction = (identifiers) => {
-    const { indexSituation, total, lefties, opts } = identifiers;
+    const { indexSituation, total, lefties } = identifiers;
     const situation = situations[indexSituation];
     return `${situation.instruction(total, lefties)} 
   
-Arrondir au centième de pourcent.
-${opts.isPercentSymbolRequired
-        ? `
-  
-Ne pas oublier le symbole $\\%$ à la fin.`
-        : ``}`;
+Arrondir au centième de pourcent.`;
 };
 const getHint = (identifiers) => {
     const { indexSituation } = identifiers;
     const situation = situations[indexSituation];
-    return situation.hint;
+    return `${situation.hint}
+
+Rappel :
+
+$$
+2\\% = 0,02
+$$
+
+$$
+2,01\\% = 0,0201
+$$
+
+`;
 };
 const getCorrection = (identifiers) => {
-    const { indexSituation, total, lefties, opts } = identifiers;
+    const { indexSituation, total, lefties } = identifiers;
     const situation = situations[indexSituation];
-    const frac = (100 * lefties) / total;
+    const fractionNode = frac(lefties, total);
+    const roundedProportion = round(frac(lefties, total).evaluate(), 4);
+    const isEqual = substract(frac(lefties, total), round(frac(lefties, total).evaluate(), 4).toTree()).evaluate() === 0;
+    const middleSymbol = isEqual ? "=" : "\\approx";
     return `On a : 
 
-$$
-\\frac{${lefties}}{${total}}\\times 100 ${approxOrEqual(frac, 2).join("")}
-$$
+${alignTex([
+        [`${fractionNode.toTex()}`, middleSymbol, `${roundedProportion.frenchify()}`],
+        [
+            "",
+            middleSymbol,
+            `${roundedProportion.frenchify()} \\times 100 \\times \\frac{1}{100}`,
+        ],
+        ["", middleSymbol, `${roundedProportion.frenchify()} \\times 100 \\ \\%`],
+        ["", middleSymbol, `${getAnswer(identifiers)}`],
+    ])}
 
-${situation.correction} $${getAnswer(identifiers)}$.
-${opts.isPercentSymbolRequired
-        ? `
-  
-Attention, ici le symbole "$\\%$" est requis à la fin.`
-        : ``}`;
+${situation.correction} $${getAnswer(identifiers)}$.`;
 };
 const getAnswer = (identifiers) => {
     const { total, lefties } = identifiers;
-    const answer = round((lefties / total) * 100, 2).frenchify() + "\\%";
+    const answer = round(multiply(frac(lefties, total), 100).evaluate(), 2).frenchify() +
+        "\\%";
     return answer;
 };
 const getPropositions = (n, { answer, total, lefties }) => {
@@ -147,34 +163,27 @@ const getPropositions = (n, { answer, total, lefties }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, opts }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { lefties, total } = identifiers;
     try {
-        if (opts.isPercentSymbolRequired) {
-            if (!ans.includes("\\%")) {
-                return false;
-            }
-            else {
-                return percentParser(ans) === answer;
-            }
-        }
-        else {
-            const texs = [answer, answer.replace("\\%", "")];
-            return texs.includes(ans);
-        }
+        const percentNode = frac(1, 100);
+        const refinedAns = ans.replaceAll("\\%", `({${percentNode.toTex()}})`);
+        const nodeAns = parseAlgebraic(refinedAns);
+        const nodeAnswer = round(lefties / total, 4);
+        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
-const getFindProportionQuestion = (optsIn) => {
-    const opts = optsIn ?? optsDefault;
+const getFindProportionQuestion = () => {
     const indexSituation = randint(0, situations.length);
     const situation = situations[indexSituation];
     const total = situation.randTotal();
     const lefties = round(randfloat(0.1, 0.9) * total, 0);
-    return getQuestionFromIdentifiers({ indexSituation, total, lefties, opts });
+    return getQuestionFromIdentifiers({ indexSituation, total, lefties });
 };
-const getQuestionFromIdentifiers = (identifiers, opts) => {
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -183,30 +192,15 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
-        options: opts,
     };
     return question;
 };
-const optsDefault = {
-    isPercentSymbolRequired: false,
-};
-const options = [
-    {
-        id: "isPercentSymbolRequired",
-        label: "Symbole pourcent requis",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.checkbox,
-        values: [false, true],
-        defaultValue: optsDefault.isPercentSymbolRequired,
-    },
-];
 export const findProportion = {
     id: "findProportion",
     connector: "=",
-    label: "Calculer une proportion en pourcentage",
+    label: "Calculer une proportion",
     isSingleStep: true,
-    generator: (nb, opts) => getDistinctQuestions(() => getFindProportionQuestion(opts), nb),
-    options,
+    generator: (nb) => getDistinctQuestions(getFindProportionQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/probaStat/randomVariable/randomVariableAverage.js

@@ -30,7 +30,7 @@ Que vaut l'espérance $E(X)$ de $X$ ?
 `;
 };
 const getHint = () => {
-    return `$V(X)$ est la somme des produits des valeurs de $X$ par leur probabilité. `;
+    return `$E(X)$ est la somme des produits des valeurs de $X$ par leur probabilité. `;
 };
 const getCorrection = (identifiers) => {
     const { xValuesIds, yValuesIds } = identifiers;

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

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+export declare function isNodesEqual(node1: AlgebraicNode, node2: AlgebraicNode): boolean;
+//# sourceMappingURL=isNodesEqual.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isNodesEqual.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/isNodesEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAIlE,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,WAMtE"}

package/lib/exercises/vea/isNodesEqual.js

@@ -0,0 +1,6 @@
+import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../tree/nodes/operators/substractNode.js";
+export function isNodesEqual(node1, node2) {
+    return [1, 1_000, 1_000_000].every((factor) => substract(multiply(factor, node1), multiply(factor, node2)).evaluate() ===
+        0);
+}

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

@@ -0,0 +1,5 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+export declare abstract class SetVEA {
+    static isArrayOfNodesValid: (arrAns: AlgebraicNode[], arrAnswer: AlgebraicNode[]) => boolean;
+}
+//# sourceMappingURL=setVEA.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/setVEA.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,8BAAsB,MAAM;IAC1B,MAAM,CAAC,mBAAmB,GACxB,QAAQ,aAAa,EAAE,EACvB,WAAW,aAAa,EAAE,aA2B1B;CACH"}

package/lib/exercises/vea/setVEA.js

@@ -0,0 +1,25 @@
+import { isNodesEqual } from "./isNodesEqual.js";
+export class SetVEA {
+    static isArrayOfNodesValid = (arrAns, arrAnswer) => {
+        const dictAnswer = Object.fromEntries(arrAnswer.map((node, i) => [i, node]));
+        let isValid = true;
+        for (let i = 0; i < arrAns.length; i++) {
+            const nodeAns = arrAns[i];
+            let isFound = false;
+            const keys = Object.keys(dictAnswer);
+            for (let j = 0; j < keys.length; j++) {
+                const key = keys[j];
+                const answerNode = dictAnswer[key];
+                if (isNodesEqual(nodeAns, answerNode)) {
+                    isFound = true;
+                    delete dictAnswer[key]; //one-to-one correspondence
+                    break;
+                }
+            }
+            isValid = isValid && isFound;
+            if (!isValid)
+                break;
+        }
+        return isValid;
+    };
+}

package/lib/index.d.ts

@@ -503,11 +503,6 @@ declare const mathExercises: (Exercise<{
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     a: number;
     b: number;
-}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
-    a: number;
-    b: number;
-    isAdd: boolean;
-    varName: string;
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     b: number;
     c: number;
@@ -2049,12 +2044,7 @@ declare const mathExercises: (Exercise<{
     indexSituation: number;
     total: number;
     lefties: number;
-    opts: {
-        isPercentSymbolRequired: boolean;
-    };
-}, {
-    isPercentSymbolRequired: boolean;
-}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
+}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     TVA: number;
     ht: number;
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
@@ -3423,12 +3413,7 @@ declare const pcExercises: (Exercise<{
     indexSituation: number;
     total: number;
     lefties: number;
-    opts: {
-        isPercentSymbolRequired: boolean;
-    };
-}, {
-    isPercentSymbolRequired: boolean;
-}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
+}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     decimal: number;
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     a: number;

package/lib/index.d.ts.map

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.130",
+  "version": "3.0.131",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [