math-exercises 3.0.129 → 3.0.130

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts

@@ -3,9 +3,14 @@ type A10N = {
     a: number;
     n: number;
 };
+type Item = {
+    tex: string;
+    isValid: boolean;
+};
 type Identifiers = {
     signType: string;
-    items: A10N[];
+    a10Ns: A10N[];
+    items: Item[];
 };
 type Options = {
     signTypes: string[];

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareA10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareA10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,IAAI,GAAG;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwTF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA0CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAetD,CAAC"}
+{"version":3,"file":"compareA10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareA10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,IAAI,GAAG;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AA2TF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAyCF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBtD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareA10N.js

@@ -6,12 +6,11 @@ import { round } from "../../../../math/utils/round.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-import { permute } from "../../../../utils/arrays/permutations.js";
+import { getAllPicks } from "../../../../utils/arrays/getAllPicks.js";
 const getTexForA10N = (a10N) => {
     const { a, n } = a10N;
     return `${a.frenchify()} \\times 10^{${n}}`;
@@ -55,12 +54,14 @@ const compareFuncForA10N = (a10N1, a10N2) => {
     }
 };
 const getInstruction = (identifiers) => {
-    const { items } = identifiers;
-    return `Ranger par ordre croissant les nombres suivants :
+    const { a10Ns } = identifiers;
+    return `Voici une liste de nombres :
 
-$$
-${items.map((item) => getTexForA10N(item)).join(" ; ")}
-$$`;
+${a10Ns.map((a10N) => `- $${getTexForA10N(a10N)}$`).join(`
+  
+`)}
+
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
 };
 const getHint = (identifiers) => {
     const { signType } = identifiers;
@@ -87,15 +88,15 @@ On range les puissances de $10$ en ordre croissant, puis pour chaque puissance d
 `;
 };
 const getCorrection = (identifiers) => {
-    const { signType, items } = identifiers;
+    const { signType, a10Ns } = identifiers;
     return `Même si on a l'impression que les nombres sont écris en écriture scientifique, ce n'est pas le cas. 
 Il faut les convertir en écriture scientifique et utiliser cette écriture pour les ranger dans l'ordre croissant.
 
-${items
-        .map((item) => `
+${a10Ns
+        .map((a10N) => `
   
 $$
-${getTexForA10N(item)} = ${getSciMultNodeForA10N(item).toTex()}
+${getTexForA10N(a10N)} = ${getSciMultNodeForA10N(a10N).toTex()}
 $$
 
 `)
@@ -104,45 +105,45 @@ $$
 ${(() => {
         switch (signType) {
             case "positifs": {
-                const positive = items.toSorted(compareFuncForA10N);
+                const positive = a10Ns.toSorted(compareFuncForA10N);
                 return `Ici, tous les nombres sont positifs, donc
 on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
 C'est un double tri.
 
 $$
-${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${positive.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${positive.map((item) => getTexForA10N(item)).join("<")}
+${positive.map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 
 `;
             }
             case "négatifs": {
-                const negative = items.toSorted(compareFuncForA10N);
+                const negative = a10Ns.toSorted(compareFuncForA10N);
                 return `Ici, tous les nombres sont négatifs, donc
 on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
 C'est un double tri.
 
 $$
-${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${negative.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${negative.map((item) => getTexForA10N(item)).join("<")}
+${negative.map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 `;
             }
             case "mélange": {
-                const positive = items
+                const positive = a10Ns
                     .filter(({ a }) => a >= 0)
                     .toSorted(compareFuncForA10N);
-                const negative = items
+                const negative = a10Ns
                     .filter(({ a }) => a < 0)
                     .toSorted(compareFuncForA10N);
                 return `Ici, il y a des nombres négatifs et des nombres positifs.
@@ -150,20 +151,20 @@ On commence par les négatifs :
 on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
 
 $$
-${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${negative.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Puis on range les positifs :
 on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
 
 $$
-${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${positive.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${[...negative, ...positive].map((item) => getTexForA10N(item)).join("<")}
+${[...negative, ...positive].map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 `;
             }
@@ -174,37 +175,23 @@ $$
 const getPropositions = (n, { answer, ...identifiers }) => {
     const { items } = identifiers;
     const propositions = [];
-    addValidProp(propositions, answer);
-    permute(items)
-        .slice(0, 5)
-        .forEach((permutedItems) => {
-        const arrayOfTex = permutedItems.map((item) => getTexForA10N(item));
-        tryToAddWrongProp(propositions, arrayOfTex.join("<"));
-        tryToAddWrongProp(propositions, arrayOfTex.join(">"));
+    items.forEach((item) => {
+        if (item.isValid) {
+            addValidProp(propositions, item.tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex);
+        }
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
-    const { items } = identifiers;
-    const answer = items
-        .toSorted(compareFuncForA10N)
-        .map((item) => getTexForA10N(item))
-        .join("<");
-    return answer;
-};
-const isAnswerValid = (ans, { answer, items }) => {
-    const nbItems = items.length;
-    const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split("<").map((tex) => parseAlgebraic(tex)));
-    return (ansNodes.length === nbItems &&
-        [...Array(nbItems).keys()].every((i) => ansNodes[i].equals(answerNodes[i])));
-};
 const getKeys = (identifiers) => {
-    const { items } = identifiers;
+    const { a10Ns } = identifiers;
     return [
         "sup",
         "inf",
-        ...items.map((item) => {
-            const tex = getTexForA10N(item);
+        ...a10Ns.map((a10N) => {
+            const tex = getTexForA10N(a10N);
             return {
                 id: "custom",
                 label: tex,
@@ -263,14 +250,34 @@ const getCompareA10NQuestion = (optsIn) => {
         arrayOfN.push(random(subPoolOfN) + random([-2, -1, 0, 1, 2]));
     }
     arrayOfN = shuffle(arrayOfN);
-    const items = [...Array(nbItems).keys()].map((i) => {
+    const a10Ns = [...Array(nbItems).keys()].map((i) => {
         return {
             a: arrayOfA[i],
             n: arrayOfN[i],
         };
     });
+    const nbTotal = 4;
+    const nbValid = randint(1, 4);
+    const ascOrderedA10Ns = a10Ns.toSorted(compareFuncForA10N);
+    const items = shuffle(shuffle(getAllPicks(ascOrderedA10Ns).filter((arr) => arr.length === 2))
+        .slice(0, nbTotal)
+        .map(([a10N1, a10N2], i) => {
+        if (i < nbValid) {
+            return {
+                tex: `${getTexForA10N(a10N1)}<${getTexForA10N(a10N2)}`,
+                isValid: true,
+            };
+        }
+        else {
+            return {
+                tex: `${getTexForA10N(a10N2)}<${getTexForA10N(a10N1)}`,
+                isValid: false,
+            };
+        }
+    }));
     return getQuestionFromIdentifiers({
         signType,
+        a10Ns,
         items,
     });
 };
@@ -298,7 +305,6 @@ const options = [
 ];
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
@@ -318,9 +324,10 @@ export const compareA10N = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
 };

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.js

@@ -10,7 +10,7 @@ const getInstruction = (identifiers) => {
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
     return `Sachant que $\\frac{${B}}{${A}} > 1$,
   
-comparer $${B}$ et $${A}$.;`;
+comparer $${B}$ et $${A}$.`;
 };
 const getHint = (identifiers) => {
     const { orderedNodeIds } = identifiers;

package/lib/exercises/math/calcul/ordering/compareFracAndDec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AA0SF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AAuBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}
+{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AA6RF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AAuBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}

package/lib/exercises/math/calcul/ordering/compareFracAndDec.js

@@ -5,7 +5,6 @@ import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -108,11 +107,6 @@ const getAnswer = (identifiers) => {
     const answer = items.find((item) => item.isValidAnswer).tex;
     return answer;
 };
-const isAnswerValid = (ans, { answer }) => {
-    const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split(">").map((tex) => parseAlgebraic(tex)));
-    return (ansNodes.length === 3 &&
-        [0, 1, 2].every((i) => substract(ansNodes[i], answerNodes[i]).evaluate() === 0));
-};
 const getKeys = (identifiers, optsIn) => {
     const { questionParams } = identifiers;
     const opts = Object.assign(optsDefault, optsIn);
@@ -249,9 +243,9 @@ export const compareFracAndDec = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/ordering/compareWithSquareRoots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareWithSquareRoots.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareWithSquareRoots.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,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA+KF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"compareWithSquareRoots.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareWithSquareRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAsIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareWithSquareRoots.js

@@ -1,12 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
-import { add } from "../../../../tree/nodes/operators/addNode.js";
-import { substract } from "../../../../tree/nodes/operators/substractNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
     const { a, b, isAdd } = identifiers;
     return `Sachant que  $\\sqrt{${a}} < \\sqrt{${a + 1}}$,
@@ -48,44 +43,10 @@ $$
 
 `;
 };
-const getAnswerNodes = (identifiers) => {
-    const { a, b, isAdd } = identifiers;
-    const addSub = isAdd ? add : substract;
-    const nodeWithA = addSub(b, sqrt(a));
-    const nodeWithAPlus1 = addSub(b, sqrt(add(a, 1)));
-    return isAdd ? [nodeWithA, nodeWithAPlus1] : [nodeWithAPlus1, nodeWithA];
-};
 const getAnswer = (identifiers) => {
     const { a, b, isAdd } = identifiers;
     return `${b}${isAdd ? "+" : "-"}\\sqrt{${a}}${isAdd ? "<" : ">"}${b}${isAdd ? "+" : "-"}\\sqrt{${a + 1}}`;
 };
-const isAnswerValid = (ans, { answer, ...identifiers }) => {
-    function getOrderedNodesFromTex(tex, compSymbol) {
-        return tex
-            .split(compSymbol)
-            .map((str) => parseAlgebraic(str))
-            .toSorted(() => (compSymbol === "<" ? +1 : -1));
-    }
-    try {
-        const compSymbol = ans.includes("<")
-            ? "<"
-            : ans.includes(">")
-                ? ">"
-                : undefined;
-        if (compSymbol) {
-            const [ansNode1, ansNode2] = getOrderedNodesFromTex(ans, compSymbol);
-            const [answerNode1, answerNode2] = getAnswerNodes(identifiers);
-            return (substract(ansNode1, answerNode1).simplify().evaluate() === 0 &&
-                substract(ansNode2, answerNode2).simplify().evaluate() === 0);
-        }
-        else {
-            return false;
-        }
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { a, b, isAdd } = identifiers;
     const propositions = [];
@@ -140,10 +101,10 @@ export const compareWithSquareRoots = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"estimateAroundPow10NTimesAroundPow10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+EF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}
+{"version":3,"file":"estimateAroundPow10NTimesAroundPow10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmEF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}

package/lib/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.js

@@ -3,9 +3,7 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { toSeperatedThousands } from "../../../../utils/numberPrototype/toSeparatedThousands.js";
 const toPrettyString = (node) => {
     return toSeperatedThousands("" + node.evaluate().toFixed(0));
@@ -28,18 +26,6 @@ const getAnswer = (identifiers) => {
     const { n } = identifiers;
     return `10^{${2 * n}}`;
 };
-const isAnswerValid = (ans, { answer }) => {
-    try {
-        const ansNode = parseAlgebraic(ans);
-        const answerNode = parseAlgebraic(answer);
-        return ansNode
-            .simplify({ calculatePowers: true })
-            .equals(answerNode.simplify({ calculatePowers: true }));
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { n } = identifiers;
     const propositions = [];
@@ -74,10 +60,10 @@ export const estimateAroundPow10NTimesAroundPow10N = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"estimatePow10NPlusPow10MinusN.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAwFF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}
+{"version":3,"file":"estimatePow10NPlusPow10MinusN.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA8EF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}

package/lib/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.js

@@ -2,9 +2,7 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
     const { n, varName } = identifiers;
     const A = varName;
@@ -34,16 +32,6 @@ const getAnswer = (identifiers) => {
     const { n } = identifiers;
     return `10^{${n}}`;
 };
-const isAnswerValid = (ans, { answer }) => {
-    try {
-        const ansNode = parseAlgebraic(ans);
-        const answerNode = parseAlgebraic(answer);
-        return ansNode.simplify().equals(answerNode.simplify());
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { n } = identifiers;
     const propositions = [];
@@ -80,10 +68,10 @@ export const estimatePow10NPlusPow10MinusN = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

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

@@ -1 +1 @@
-{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAetE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA6qBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AActE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AAmrBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

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

@@ -10,7 +10,6 @@ import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
 import { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
-import { mdTable } from "../../../../utils/markdown/mdTable.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 class ProblemConstructor {
     static byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays) {
@@ -291,7 +290,13 @@ const getInstruction = (identifiers) => {
     const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
     const skeleton = skeletons[problemSkeletonIndex];
     const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
-    return `${mdTable([[""], [problem.frenchStr]])}
+    return `Voici une situation :
+
+$\\ $ 
+
+${problem.frenchStr}
+
+$\\ $
   
 Parmi les équations suivantes, laquelle modélise cette situation ?`;
 };

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAyMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAqMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.js

@@ -66,9 +66,6 @@ const getAnswer = (identifiers) => {
     const { texsAnswer } = identifiers;
     return texsAnswer[0];
 };
-const isAnswerValid = (ans, { texsAnswer }) => {
-    return texsAnswer.includes(ans);
-};
 const getCompareAMinusBQuestion = () => {
     const namesPool = ["a", "b", "c", "d", "r", "s", "t", "u", "v"];
     const names = randomMany(namesPool, 2);
@@ -175,10 +172,10 @@ export const compareAMinusB = {
     generator: (nb, opts) => getDistinctQuestions(() => getCompareAMinusBQuestion(opts), nb, 30),
     qcmTimer: 60,
     freeTimer: 60,
-    isAnswerValid,
     getPropositions,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calculLitteral/simplifying/compareATimes0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareATimes0.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareATimes0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}
+{"version":3,"file":"compareATimes0.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareATimes0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAqGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/compareATimes0.js

@@ -2,11 +2,10 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-import { permute } from "../../../../utils/arrays/permutations.js";
 const getInstruction = () => {
-    return `Soit a un nombre non nul. 
+    return `Soit $a$ un nombre non nul. 
 
-Parmi les propositions suivantes, lesquelles sont vraies ?`;
+Parmi les propositions suivantes, lesquelles sont égales à $0$ ?`;
 };
 const getHint = () => {
     return `$0$ divisé par un nombre non nul donne $0$.
@@ -17,19 +16,7 @@ const getCorrection = () => {
     return `
 
 $$
-0 \\times a = 0
-$$ 
-
-et  
-
-$$
-\\frac{0}{a} = 0
-$$ 
-
-donc 
-
-$$
-0 \\times a = \\frac{0}{a} = 0
+0 = 0 \\times a = a \\times 0 = \\frac{0}{a} = a + (-a)
 $$
 
 `;
@@ -39,10 +26,10 @@ const getPropositions = (_, { answer, ...identifiers }) => {
     const propositions = [];
     items.forEach((item) => {
         if (item.isValidAnswer) {
-            addValidProp(propositions, item.tex, "raw");
+            addValidProp(propositions, item.tex);
         }
         else {
-            tryToAddWrongProp(propositions, item.tex, "raw");
+            tryToAddWrongProp(propositions, item.tex);
         }
     });
     return propositions;
@@ -56,35 +43,29 @@ const getCompareATimes0Question = () => {
         [4, 0.02],
     ]);
     const nbInvalid = nbTotal - nbValid;
-    const arrayOfTex = [`0 \\times a`, `\\frac{0}{a}`, `0`];
-    const permutations = permute(arrayOfTex);
-    const validItems = permutations.flatMap(([tex1, tex2, tex3]) => {
-        return [
-            `$${[tex1, tex2, tex3].join("=")}$`,
-            `$${tex1}=${tex2}$ et $${tex2}=${tex3}$`,
-        ].map((tex) => {
-            return {
-                tex,
-                isValidAnswer: true,
-            };
-        });
+    const validItems = [
+        `0 \\times a`,
+        `a \\times 0`,
+        `\\frac{0}{a}`,
+        `a + (-a)`,
+    ].map((tex) => {
+        return {
+            tex,
+            isValidAnswer: true,
+        };
     });
-    const invalidItems = permutations.flatMap(([tex1, tex2, tex3]) => {
-        return [
-            `$${tex1}>${tex2}$ et $${tex2}=${tex3}$`,
-            `$${tex1}=${tex2}$ et $${tex2}>${tex3}$`,
-            ...(tex3 === `\\frac{0}{a}`
-                ? [`$${tex1}=${tex2}$ et $${tex3}$ n'existe pas`]
-                : []),
-            ...(tex1 === `\\frac{0}{a}`
-                ? [`$${tex1}$ n'existe pas et $${tex2}=${tex3}$`]
-                : []),
-        ].map((tex) => {
-            return {
-                tex,
-                isValidAnswer: false,
-            };
-        });
+    const invalidItems = [
+        `a \\times (-a)`,
+        `(-a) \\times a`,
+        `\\frac{a}{a}`,
+        `\\frac{a}{-a}`,
+        `a - (-a)`,
+        `a + (a)`,
+    ].map((tex) => {
+        return {
+            tex,
+            isValidAnswer: false,
+        };
     });
     const items = shuffle([
         ...shuffle(validItems).slice(0, nbValid),

package/lib/exercises/math/calculLitteral/simplifying/compareMinusA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareMinusA.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareMinusA.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAkHF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}
+{"version":3,"file":"compareMinusA.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareMinusA.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAiGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/compareMinusA.js

@@ -2,11 +2,10 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-import { permute } from "../../../../utils/arrays/permutations.js";
 const getInstruction = () => {
-    return `Soit a un nombre non nul. 
+    return `Soit $a$ un nombre non nul. 
 
-Parmi les propositions suivantes, lesquelles sont vraies ?`;
+Parmi les propositions suivantes, lesquelles sont égales à  $-a$ ?`;
 };
 const getHint = () => {
     return "La règle des signes est la même pour une multiplication et pour une division.";
@@ -15,19 +14,7 @@ const getCorrection = () => {
     return `
 
 $$
-(−1) \\times a = -a
-$$ 
-
-et  
-
-$$
-\\frac{a}{-1} = -a
-$$ 
-
-donc 
-
-$$
-(−1) \\times a = \\frac{a}{-1} = -a
+-a = (−1) \\times a = a \\times (−1) = \\frac{a}{-1} = -\\frac{a}{1}
 $$
 
 `;
@@ -37,10 +24,10 @@ const getPropositions = (_, { answer, ...identifiers }) => {
     const propositions = [];
     items.forEach((item) => {
         if (item.isValidAnswer) {
-            addValidProp(propositions, item.tex, "raw");
+            addValidProp(propositions, item.tex);
         }
         else {
-            tryToAddWrongProp(propositions, item.tex, "raw");
+            tryToAddWrongProp(propositions, item.tex);
         }
     });
     return propositions;
@@ -54,31 +41,27 @@ const getCompareMinusAQuestion = () => {
         [4, 0.02],
     ]);
     const nbInvalid = nbTotal - nbValid;
-    const arrayOfTex = [`(−1) \\times a`, `\\frac{a}{-1}`, `-a`];
-    const permutations = permute(arrayOfTex);
-    const validItems = permutations.flatMap(([tex1, tex2, tex3]) => {
-        return [
-            `$${[tex1, tex2, tex3].join("=")}$`,
-            `$${tex1}=${tex2}$ et $${tex2}=${tex3}$`,
-        ].map((tex) => {
-            return {
-                tex,
-                isValidAnswer: true,
-            };
-        });
+    const validItems = [
+        `(-1) \\times a`,
+        `\\frac{a}{-1}`,
+        `a \\times (-1)`,
+        `-\\frac{a}{1}`,
+    ].map((tex) => {
+        return {
+            tex,
+            isValidAnswer: true,
+        };
     });
-    const invalidItems = permutations.flatMap(([tex1, tex2, tex3]) => {
-        return [
-            `$${tex1}>${tex2}$ et $${tex2}=${tex3}$`,
-            `$${tex1}<${tex2}$ et $${tex2}=${tex3}$`,
-            `$${tex1}=${tex2}$ et $${tex2}>${tex3}$`,
-            `$${tex1}=${tex2}$ et $${tex2}<${tex3}$`,
-        ].map((tex) => {
-            return {
-                tex,
-                isValidAnswer: false,
-            };
-        });
+    const invalidItems = [
+        `(-1) \\times (-a)`,
+        `\\frac{-a}{-1}`,
+        `(-a) \\times (-1)`,
+        `-\\frac{-a}{1}`,
+    ].map((tex) => {
+        return {
+            tex,
+            isValidAnswer: false,
+        };
     });
     const items = shuffle([
         ...shuffle(validItems).slice(0, nbValid),

package/lib/exercises/math/dataRepresentations/barChartInterpreting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barChartInterpreting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,QAAQ,EAKT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5C,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AAktBF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB/D,CAAC"}
+{"version":3,"file":"barChartInterpreting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EAYL,QAAQ,EAKT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5C,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AA8tBF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe/D,CAAC"}

package/lib/exercises/math/dataRepresentations/barChartInterpreting.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
 import { random, randomMany } from "../../../utils/alea/random.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { blueMain, greenMain, orange, red } from "../../../geogebra/colors.js";
@@ -207,28 +207,36 @@ const getAnswer = (identifiers) => {
             return getAnswerBar(barChart, itemAsked).props.label;
     }
 };
-const getPropositions = (n, { answer, ...identifiers }) => {
+const getPropositions = (_, { answer, ...identifiers }) => {
     const { barChart, itemAsked } = identifiers;
     const propositions = [];
     switch (itemAsked.type) {
         case "categoryForX":
             {
-                addValidProp(propositions, answer, "raw");
                 barChart.categories.forEach((categ) => {
-                    tryToAddWrongProp(propositions, categ.props.name, "raw");
+                    if (categ.props.name === answer) {
+                        addValidProp(propositions, categ.props.name, "raw");
+                    }
+                    else {
+                        tryToAddWrongProp(propositions, categ.props.name, "raw");
+                    }
                 });
             }
             break;
         case "xForCategory":
             {
-                addValidProp(propositions, answer, "raw");
                 barChart.bars.forEach((bar) => {
-                    tryToAddWrongProp(propositions, bar.props.label, "raw");
+                    if (bar.props.label === answer) {
+                        addValidProp(propositions, bar.props.label, "raw");
+                    }
+                    else {
+                        tryToAddWrongProp(propositions, bar.props.label, "raw");
+                    }
                 });
             }
             break;
     }
-    return shuffleProps(propositions, n);
+    return propositions;
 };
 const getHint = (identifiers) => {
     const { barChart, itemAsked } = identifiers;
@@ -345,21 +353,24 @@ const getGGBOptionsVertStacked = (identifiers) => {
             max: xMin + barWidth,
         };
     }
-    function getYRangeForCategory(barIndex, categIndex) {
+    function getYRangeForCategory(barIndex, categIndex, isTopToBottom = true) {
         const slice = barChart.bars[barIndex].data.slice(0, categIndex);
         const yMinForCateg = slice.reduce((acc, data) => acc + data, 0);
         const yMaxForCateg = yMinForCateg + barChart.bars[barIndex].data[categIndex];
         return {
-            min: yMinForCateg,
-            max: yMaxForCateg,
+            min: isTopToBottom
+                ? arrayOfBarHeights[barIndex] - yMinForCateg
+                : yMinForCateg,
+            max: isTopToBottom
+                ? arrayOfBarHeights[barIndex] - yMaxForCateg
+                : yMaxForCateg,
         };
     }
     function createCommandsForBar(barChart, barIndex) {
         //const bar = barChart.bars[barIndex];
-        const categoriesReversed = barChart.categories.toReversed();
-        const commands = categoriesReversed.flatMap((categ, categIndex) => {
+        const commands = barChart.categories.flatMap((categ, categIndex) => {
             const xRange = getXRangeForBarIndex(barIndex);
-            const yRange = getYRangeForCategory(barIndex, categIndex);
+            const yRange = getYRangeForCategory(barIndex, categIndex, true);
             const style = categ.style;
             const B = `B_{${barIndex}${categIndex}}`;
             const barChartCommand = [
@@ -528,6 +539,5 @@ export const barChartInterpreting = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasGeogebra: true,
-    answerType: "QCM",
-    isQCM: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/dataRepresentations/scatterPlotCommenting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scatterPlotCommenting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/scatterPlotCommenting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkZF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}
+{"version":3,"file":"scatterPlotCommenting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/scatterPlotCommenting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAmQF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/math/dataRepresentations/scatterPlotCommenting.js

@@ -60,22 +60,6 @@ il y a des pays avec un taux de chômage faible et une croissance forte,
 il y a des pays avec un taux de chômage fort et une croissance faible,
 il y a des pays avec un taux de chômage fort et une croissance forte.
 `;
-            }
-            case "increasingThenDecreasing": {
-                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
-                return `En particulier :
-      
-Le pays ${pointLowX.name} a un faible taux de chômage et une faible croissance du PIB.
-        
-Le pays ${pointHighX.name} a un fort taux de chômage et une faible croissance du PIB.`;
-            }
-            case "decreasingThenIncreasing": {
-                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
-                return `En particulier :
-      
-Le pays ${pointLowX.name} a un faible taux de chômage et une forte croissance du PIB.
-        
-Le pays ${pointHighX.name} a un fort taux de chômage et une forte croissance du PIB.`;
             }
             default:
                 return ``;
@@ -85,25 +69,15 @@ Le pays ${pointHighX.name} a un fort taux de chômage et une forte croissance du
 const propsForEvolutionType = {
     increasing: [
         `Plus le taux de chômage est élevé et plus la croissance du PIB est élevée.`,
-        `Si le taux de chômage est faible alors la croissance du PIB est faible.`,
-        `Si le taux de chômage est élevé alors la croissance du PIB est élevée.`,
     ],
     decreasing: [
         `Plus le taux de chômage est élevé et plus la croissance du PIB est faible.`,
-        `Si le taux de chômage est faible alors la croissance du PIB est élevée.`,
-        `Si le taux de chômage est élevé alors la croissance du PIB est faible.`,
     ],
     unpredictible: [
         `Il n'y a aucun lien entre le taux de chômage et la croissance du PIB.`,
     ],
-    increasingThenDecreasing: [
-        `Si le taux de chômage est faible alors la croissance du PIB est faible.`,
-        `Si le taux de chômage est élevé alors la croissance du PIB est faible.`,
-    ],
-    decreasingThenIncreasing: [
-        `Si le taux de chômage est faible alors la croissance du PIB est élevée.`,
-        `Si le taux de chômage est élevé alors la croissance du PIB est élevée.`,
-    ],
+    increasingThenDecreasing: [],
+    decreasingThenIncreasing: [],
 };
 const getPropositions = (n, { evolutionType }) => {
     const propositions = [];
@@ -114,14 +88,7 @@ const getPropositions = (n, { evolutionType }) => {
     });
     const invalidProps = [
         ...Object.values(propsForEvolutionType).flatMap((props) => props),
-    ]
-        .filter((prop) => !allValidProps.includes(prop))
-        //prevent confusion
-        .filter((prop) => evolutionType === "increasingThenDecreasing" ||
-        evolutionType === "decreasingThenIncreasing"
-        ? prop !==
-            `Il n'y a aucun lien entre le taux de chômage et la croissance du PIB.`
-        : true);
+    ].filter((prop) => !allValidProps.includes(prop));
     invalidProps.forEach((str) => {
         tryToAddWrongProp(propositions, str, "raw");
     });
@@ -170,13 +137,7 @@ const getScatterPlotCommentingQuestion = () => {
     const nbCountries = 6;
     const countriesPicked = randomMany(countries, nbCountries);
     const boxFull = { xMin: 3, xMax: 13, yMin: 0, yMax: 4 };
-    const evolutionType = random([
-        "increasing",
-        "decreasing",
-        "unpredictible",
-        "increasingThenDecreasing",
-        "decreasingThenIncreasing",
-    ]);
+    const evolutionType = random(["increasing", "decreasing", "unpredictible"]);
     let cloudPointsWithEvoBoxed;
     switch (evolutionType) {
         case "increasing":
@@ -210,64 +171,6 @@ const getScatterPlotCommentingQuestion = () => {
                     ]), boxFull);
             }
             break;
-        case "increasingThenDecreasing":
-            {
-                const nbCountriesIncr = Math.floor(nbCountries / 2);
-                const nbCountriesDecr = nbCountries - nbCountriesIncr;
-                const cloudPointsIncr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesIncr, "increasing"), {
-                    xMin: 0,
-                    xMax: 0.5,
-                    yMin: 0,
-                    yMax: 1,
-                });
-                const cloudPointsDecr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesDecr, "decreasing"), {
-                    xMin: 0.5,
-                    xMax: 1,
-                    yMin: 0,
-                    yMax: 1,
-                });
-                const boxLow = {
-                    xMin: boxFull.xMin,
-                    xMax: boxFull.xMax,
-                    yMin: boxFull.yMin,
-                    yMax: ((boxFull.yMin + boxFull.yMax) * 1) / 3,
-                };
-                cloudPointsWithEvoBoxed =
-                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(new CloudPoints([
-                        ...cloudPointsIncr.points,
-                        ...cloudPointsDecr.points,
-                    ]), boxLow);
-            }
-            break;
-        case "decreasingThenIncreasing":
-            {
-                const nbCountriesDecr = Math.floor(nbCountries / 2);
-                const nbCountriesIncr = nbCountries - nbCountriesDecr;
-                const cloudPointsDecr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesDecr, "decreasing"), {
-                    xMin: 0,
-                    xMax: 0.5,
-                    yMin: 0,
-                    yMax: 1,
-                });
-                const cloudPointsIncr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesIncr, "increasing"), {
-                    xMin: 0.5,
-                    xMax: 1,
-                    yMin: 0,
-                    yMax: 1,
-                });
-                const boxHigh = {
-                    xMin: boxFull.xMin,
-                    xMax: boxFull.xMax,
-                    yMin: ((boxFull.yMin + boxFull.yMax) * 2) / 3,
-                    yMax: boxFull.yMax,
-                };
-                cloudPointsWithEvoBoxed =
-                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(new CloudPoints([
-                        ...cloudPointsIncr.points,
-                        ...cloudPointsDecr.points,
-                    ]), boxHigh);
-            }
-            break;
     }
     const namedPoints = cloudPointsWithEvoBoxed.points.map((point, i) => new Point(countriesPicked[i], point.x, point.y));
     const cloudPointsNamed = new CloudPoints(namedPoints);
@@ -303,6 +206,5 @@ export const scatterPlotCommenting = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
-    answerType: "QCM",
-    isQCM: true,
+    answerType: "QCU",
 };

package/lib/index.d.ts

@@ -292,10 +292,14 @@ declare const mathExercises: (Exercise<{
     isAllowingNegativeNumbers: boolean;
 }, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     signType: string;
-    items: {
+    a10Ns: {
         a: number;
         n: number;
     }[];
+    items: {
+        tex: string;
+        isValid: boolean;
+    }[];
 }, {
     signTypes: string[];
     nbCollisions: 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.129",
+  "version": "3.0.130",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [