math-exercises 3.0.128 → 3.0.130

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/conversion/kmPerMinToKmPerHourConversion.js

@@ -100,7 +100,7 @@ const options = [
 export const kmPerMinToKmPerHourConversion = {
     id: "kmPerMinToKmPerHourConversion",
     connector: "=",
-    label: "Effectuer des conversions de vitesse ( $x$ km en $y$ min donne une vitesse $V$ en \\textrm{km/h})",
+    label: "Effectuer des conversions de vitesse ( $x$ $\\textrm{km}$ en $y$ $\\textrm{min}$ donne une vitesse $V$ en $\\textrm{km/h}$)",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getKmPerMinToKmPerHourConversionQuestion(opts), nb),
     options,

package/lib/exercises/math/conversion/minutesToHours.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"minutesToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/minutesToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA2LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}
+{"version":3,"file":"minutesToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/minutesToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA8LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/conversion/minutesToHours.js

@@ -76,13 +76,16 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     addValidProp(propositions, answer);
     if (isMinutesToHours) {
         const roundedValue = round(hours.evaluate(), 2);
-        const texDecimal = roundedValue.frenchify().split(",")[1];
         tryToAddWrongProp(propositions, `${roundedValue.frenchify()}\\text{h}`);
         tryToAddWrongProp(propositions, `${multiply(minutes.evaluate(), 60).simplify().toTex()}\\text{h}`);
         tryToAddWrongProp(propositions, `${frac(60, minutes).toTex()}\\text{h}`);
         propWhile(propositions, n, () => {
-            tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
-            tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            const texDecimal = roundedValue.frenchify().split(",")[1];
+            if (texDecimal) {
+                tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
+                tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            }
+            tryToAddWrongProp(propositions, `${randint(1, 20)}\\text{h}`);
         });
     }
     else {

package/lib/exercises/math/conversion/secondsToHours.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secondsToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/secondsToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA2LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}
+{"version":3,"file":"secondsToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/secondsToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA8LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}

package/lib/exercises/math/conversion/secondsToHours.js

@@ -76,13 +76,16 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     addValidProp(propositions, answer);
     if (isSecondsToHours) {
         const roundedValue = round(hours.evaluate(), 2);
-        const texDecimal = roundedValue.frenchify().split(",")[1];
         tryToAddWrongProp(propositions, `${roundedValue.frenchify()}\\text{h}`);
         tryToAddWrongProp(propositions, `${multiply(seconds.evaluate(), 3600).simplify().toTex()}\\text{h}`);
         tryToAddWrongProp(propositions, `${frac(3600, seconds).toTex()}\\text{h}`);
         propWhile(propositions, n, () => {
-            tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
-            tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            const texDecimal = roundedValue.frenchify().split(",")[1];
+            if (texDecimal) {
+                tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
+                tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            }
+            tryToAddWrongProp(propositions, `${randint(1, 20)}\\text{h}`);
         });
     }
     else {

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;AAYrC,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;AAotBF,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";
@@ -8,7 +8,6 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { randint } from "../../../math/utils/random/randint.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { capitalize } from "../../../utils/strings/capitalize.js";
-import { shuffle } from "../../../utils/alea/shuffle.js";
 class BarChartConstructor {
     static stylesPools = {
         color: [
@@ -98,7 +97,7 @@ class BarChartConstructor {
     }
     static createRandomCategories(dictIsUsingCategory, categoryPropsPool, styleType) {
         const nbCategUsed = Object.keys(dictIsUsingCategory).length;
-        const styles = shuffle(this.stylesPools[styleType].slice(0, nbCategUsed));
+        const styles = this.stylesPools[styleType].slice(0, nbCategUsed);
         return categoryPropsPool
             .filter((_, i) => dictIsUsingCategory[i])
             .map((props, i) => {
@@ -208,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;
@@ -346,28 +353,32 @@ 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 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 = [
                 `${B} = Polygon((${xRange.min}, ${yRange.min}), (${xRange.min}, ${yRange.max}),(${xRange.max}, ${yRange.max}),(${xRange.max}, ${yRange.min}))`,
                 `ShowLabel(${B},false)`,
                 style.type === "color"
-                    ? `SetColor(${B}, "${barChart.categories[categIndex].style.color}")`
-                    : `SetDecoration(${B}, ${barChart.categories[categIndex].style.fill})`,
+                    ? `SetColor(${B}, "${categ.style.color}")`
+                    : `SetDecoration(${B}, ${categ.style.fill})`,
             ];
             return 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

@@ -275,17 +275,13 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
-    sign: number;
-    a: number;
-    b: number;
-    c: number;
-    dictFakeNameToQuestionParam: Record<string, {
-        fakeName: string;
+    questionParams: {
+        letter: string;
         trueName: string;
         tex: string;
         nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
         explainTex: string;
-    }>;
+    }[];
     items: {
         tex: string;
         isValidAnswer: boolean;
@@ -296,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[];
@@ -313,7 +313,9 @@ declare const mathExercises: (Exercise<{
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     texAnswers: string[];
-}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
+}, {
+    isFracOfSums: boolean;
+}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     a: number;
     b: number;
     isAdd: boolean;

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/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAqP3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CA2P3B,CAAC"}

package/lib/tests/questionTest.js

@@ -191,10 +191,12 @@ export const questionTest = (exo, question) => {
                 throw new Error(`exo ${exo.id} has invalid props`);
         }
         props.forEach((prop) => {
+            if (prop.statement.includes("undefined"))
+                throw new Error(`exo ${exo.id} has invalid prop (undefined) : ${prop.statement}`);
             if (prop.statement.match(dotDecimalPattern))
-                throw new Error(`exo ${exo.id} has invalid prop (dot) : ${prop}`);
+                throw new Error(`exo ${exo.id} has invalid prop (dot) : ${prop.statement}`);
             if (prop.statement.includes("[object Object]"))
-                throw new Error(`exo ${exo.id} has invalid prop (objectObject) : ${prop}`);
+                throw new Error(`exo ${exo.id} has invalid prop (objectObject) : ${prop.statement}`);
             if (!props.every((prop2) => prop2.id === prop.id || prop.statement !== prop2.statement))
                 throw new Error(`exo ${exo.id} has invalid prop (duplicate): ${prop.statement}`);
             if (prop.format !== "raw") {