math-exercises 3.0.127 → 3.0.129

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeArithmeticFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsGF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAenE,CAAC"}
+{"version":3,"file":"recognizeArithmeticFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmGF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAcnE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.js

@@ -76,9 +76,6 @@ const getPropositions = (_n, { answer, sequences, answerIndex }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const recognizeArithmeticFromFirstTerms = {
     id: "recognizeArithmeticFromFirstTerms",
     label: "Reconnaître une suite arithmétique via ses premiers termes",
@@ -87,7 +84,6 @@ export const recognizeArithmeticFromFirstTerms = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     answerType: "QCU",
     subject: "Mathématiques",
     hasHintAndCorrection: true,

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAoGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}
+{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAiGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.js

@@ -85,9 +85,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "Non", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const recognizeArithmeticFromGraph = {
     id: "recognizeArithmeticFromGraph",
     label: "Reconnaître graphiquement si une suite est arithmétique",
@@ -96,7 +93,6 @@ export const recognizeArithmeticFromGraph = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     answerType: "QCU",
     hasGeogebra: true,
     subject: "Mathématiques",

package/lib/exercises/math/sequences/geometric/geometricVariations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}
+{"version":3,"file":"geometricVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricVariations.js

@@ -68,9 +68,6 @@ Ainsi, la suite $u_n = ${statement.toTex()}$ est ${answer.toLocaleLowerCase()}.
 const getKeys = () => {
     return [];
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 const getGeometricVariationsQuestion = () => {
     const a = randfloat(0.1, 3, 2, [1]) * (coinFlip() ? 1 : -1);
     const qLessThanOne = coinFlip();
@@ -113,7 +110,6 @@ export const geometricVariations = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
     getHint,

package/lib/exercises/math/sets/intervals/isNumberInInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isNumberInInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/isNumberInInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAsLF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}
+{"version":3,"file":"isNumberInInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/isNumberInInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA+KF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

package/lib/exercises/math/sets/intervals/isNumberInInterval.js

@@ -8,7 +8,6 @@ import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
 import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer, "tex");
@@ -91,14 +90,6 @@ ${result
 const getKeys = () => {
     return [];
 };
-const isAnswerValid = (ans, { answer }) => {
-    try {
-        return ans === answer;
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getIsNumberInIntervalQuestion = () => {
     const lowerBound = coinFlip()
         ? randint(-10, 10)
@@ -162,7 +153,6 @@ export const isNumberInInterval = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
     getHint,

package/lib/exercises/math/sets/isNumberDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isNumberDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/isNumberDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE;QACP,CAAC,EAAE,eAAe,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;KACpB,EAAE,CAAC;CACL,CAAC;AAmIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}
+{"version":3,"file":"isNumberDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/isNumberDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE;QACP,CAAC,EAAE,eAAe,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;KACpB,EAAE,CAAC;CACL,CAAC;AA4HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}

package/lib/exercises/math/sets/isNumberDecimal.js

@@ -10,7 +10,6 @@ import { isFractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { random } from "../../../utils/alea/random.js";
 import { doWhile } from "../../../utils/doWhile.js";
-import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { options }) => {
     const propositions = [];
     for (const { a, isDecimal } of options) {
@@ -69,14 +68,6 @@ const getCorrection = (identifiers) => {
 const getKeys = () => {
     return [];
 };
-const isAnswerValid = () => {
-    try {
-        throw Error("VEA not implemented");
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const generateNonDecimalNumber = () => {
     const nonDecimals = [];
     nonDecimals.push(RationalConstructor.randomPureRational().toTree());
@@ -130,7 +121,6 @@ export const isNumberdecimal = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
     getHint,

package/lib/exercises/math/sets/nameOfNumberSets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nameOfNumberSets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/nameOfNumberSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,OAAO,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgJF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}
+{"version":3,"file":"nameOfNumberSets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/nameOfNumberSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,OAAO,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAwIF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}

package/lib/exercises/math/sets/nameOfNumberSets.js

@@ -2,7 +2,6 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
-import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer, isQuestionAboutNotation }) => {
     const propositions = [];
     if (isQuestionAboutNotation) {
@@ -82,14 +81,6 @@ const getInstruction = ({ isQuestionAboutNotation, caseNumber, }) => {
 const getKeys = () => {
     return ["naturals", "integers", "rationals", "decimals", "reals"];
 };
-const isAnswerValid = (ans, { answer }) => {
-    try {
-        return ans === answer;
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getNameOfNumberSetsQuestion = () => {
     const caseNumber = randint(0, 5);
     const isQuestionAboutNotation = coinFlip();
@@ -117,7 +108,6 @@ export const nameOfNumberSets = {
     maxAllowedQuestions: 5,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
     getAnswer,

package/lib/exercises/pc/chemicalElements/atomicStructureOfNucleus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomicStructureOfNucleus.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/atomicStructureOfNucleus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAKnF,KAAK,WAAW,GAAG;IAAE,UAAU,EAAE,WAAW,CAAA;CAAE,CAAC;AA0F/C,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"atomicStructureOfNucleus.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/atomicStructureOfNucleus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAKnF,KAAK,WAAW,GAAG;IAAE,UAAU,EAAE,WAAW,CAAA;CAAE,CAAC;AA0F/C,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAY1D,CAAC"}

package/lib/exercises/pc/chemicalElements/atomicStructureOfNucleus.js

@@ -66,6 +66,5 @@ export const atomicStructureOfNucleus = {
     getPropositions,
     isAnswerValid,
     subject: "Chimie",
-    answerType: "QCU",
     getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/chemicalElements/identifyRightElectronicConfiguration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identifyRightElectronicConfiguration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/identifyRightElectronicConfiguration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAKnF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;CACzB,CAAC;AA8HF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAkBtE,CAAC"}
+{"version":3,"file":"identifyRightElectronicConfiguration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/identifyRightElectronicConfiguration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAKnF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;CACzB,CAAC;AA2HF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAiBtE,CAAC"}

package/lib/exercises/pc/chemicalElements/identifyRightElectronicConfiguration.js

@@ -94,9 +94,6 @@ const getPropositions = (n, { answer, atomSymbol }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const identifyRightElectronicConfiguration = {
     id: "identifyRightElectronicConfiguration",
     label: "Identifier la bonne configuration électronique",
@@ -105,7 +102,6 @@ export const identifyRightElectronicConfiguration = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Chimie",
     answerType: "QCU",
     maxAllowedQuestions: 16,

package/lib/exercises/pc/chemicalReactions/identifyLimitingReagent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identifyLimitingReagent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/identifyLimitingReagent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC,CAAC;AAoGF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"identifyLimitingReagent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/identifyLimitingReagent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC,CAAC;AAgGF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAYzD,CAAC"}

package/lib/exercises/pc/chemicalReactions/identifyLimitingReagent.js

@@ -55,9 +55,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "Le réactif B", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const identifyLimitingReagent = {
     id: "identifyLimitingReagent",
     label: "Identifier un réactif limitant",
@@ -66,7 +63,6 @@ export const identifyLimitingReagent = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Chimie",
     answerType: "QCU",
     getQuestionFromIdentifiers,

package/lib/exercises/pc/chemicalReactions/identifyStoichiometricMixture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identifyStoichiometricMixture.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/identifyStoichiometricMixture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,sBAAsB,EAAE,MAAM,EAAE,CAAC;IACjC,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAAC;AAyGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAa/D,CAAC"}
+{"version":3,"file":"identifyStoichiometricMixture.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/identifyStoichiometricMixture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,sBAAsB,EAAE,MAAM,EAAE,CAAC;IACjC,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAAC;AAsGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAY/D,CAAC"}

package/lib/exercises/pc/chemicalReactions/identifyStoichiometricMixture.js

@@ -62,9 +62,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "Non", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const identifyStoichiometricMixture = {
     id: "identifyStoichiometricMixture",
     label: "Identifier un mélange stœchiométrique",
@@ -73,7 +70,6 @@ export const identifyStoichiometricMixture = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Chimie",
     answerType: "QCU",
     getQuestionFromIdentifiers,

package/lib/exercises/pc/chemicalReactions/stoichiometricReaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stoichiometricReaction.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/stoichiometricReaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IAEX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AA4EF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}
+{"version":3,"file":"stoichiometricReaction.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/stoichiometricReaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IAEX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAwEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAYxD,CAAC"}

package/lib/exercises/pc/chemicalReactions/stoichiometricReaction.js

@@ -64,9 +64,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const stoichiometricReaction = {
     id: "stoichiometricReaction",
     label: "Déterminer si une réaction est stœchiométrique",
@@ -75,7 +72,6 @@ export const stoichiometricReaction = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     answerType: "QCU",
     subject: "Physique",
     getQuestionFromIdentifiers,

package/lib/exercises/pc/electricity/ohmicConductorOrGenerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ohmicConductorOrGenerator.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/ohmicConductorOrGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAiGF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAgB3D,CAAC"}
+{"version":3,"file":"ohmicConductorOrGenerator.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/ohmicConductorOrGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA6FF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/pc/electricity/ohmicConductorOrGenerator.js

@@ -39,9 +39,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 const getGGBOptions = (identifiers) => {
     const { type, end } = identifiers;
     const points = [];
@@ -87,7 +84,6 @@ export const ohmicConductorOrGenerator = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     answerType: "QCU",
     maxAllowedQuestions: 10,
     subject: "Physique",

package/lib/exercises/pc/moleculeNomenclature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moleculeNomenclature.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/moleculeNomenclature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAuEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"moleculeNomenclature.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/moleculeNomenclature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAmEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/pc/moleculeNomenclature.js

@@ -44,9 +44,6 @@ const getPropositions = (n, { answer }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const moleculeNomenclature = {
     id: "moleculeNomenclature",
     connector: "\\iff",
@@ -57,7 +54,6 @@ export const moleculeNomenclature = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     maxAllowedQuestions: 20,
     getQuestionFromIdentifiers,
     answerType: "QCU",

package/lib/exercises/pc/motion/motionReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motionReference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/motionReference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA0NF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"motionReference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/motionReference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAsNF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/pc/motion/motionReference.js

@@ -166,9 +166,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const MotionReferenceExercise = {
     id: "motionReference",
     label: "Déterminer le mouvement relatif entre deux objets",
@@ -178,7 +175,6 @@ export const MotionReferenceExercise = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Physique",
     maxAllowedQuestions: 10,
     hasHintAndCorrection: true,

package/lib/exercises/pc/motion/typeOfAcceleration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CAEd,CAAC;AA2FF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CAEd,CAAC;AAuFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/pc/motion/typeOfAcceleration.js

@@ -79,9 +79,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const typeOfAcceleration = {
     id: "typeOfAcceleration",
     label: "Déterminer le type d'accélération du mouvement d'un objet",
@@ -90,7 +87,6 @@ export const typeOfAcceleration = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     hasGeogebra: true,
     answerType: "QCU",
     subject: "Physique",

package/lib/exercises/pc/sound/frequencyComparison.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frequencyComparison.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/frequencyComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAwEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"frequencyComparison.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/frequencyComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/pc/sound/frequencyComparison.js

@@ -41,9 +41,6 @@ const getPropositions = (n, { answer, soundAsked }) => {
     tryToAddWrongProp(propositions, `Aussi aigu que le son $${soundCompared}$`, "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const frequencyComparison = {
     id: "frequencyComparison",
     label: "Comparer deux fréquences sonores",
@@ -52,7 +49,6 @@ export const frequencyComparison = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Physique",
     answerType: "QCU",
     pdfOptions: { shouldSpreadPropositions: true },

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;
@@ -313,7 +309,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/math/progCalc/progCalc.d.ts

@@ -18,9 +18,9 @@ export type ProgCalcOperationIdentifiers = {
 export declare class ProgCalcOperation {
     operationIds: ProgCalcOperationIdentifiers;
     strFrench: string;
-    func: (node: AlgebraicNode) => AlgebraicNode;
+    func: (node: AlgebraicNode) => AlgebraicNode | undefined;
     inverseOperationIds: ProgCalcOperationIdentifiers;
-    constructor(operationIds: ProgCalcOperationIdentifiers, strFrench: string, func: (node: AlgebraicNode) => AlgebraicNode, inverseOperationIds: ProgCalcOperationIdentifiers);
+    constructor(operationIds: ProgCalcOperationIdentifiers, strFrench: string, func: (node: AlgebraicNode) => AlgebraicNode | undefined, inverseOperationIds: ProgCalcOperationIdentifiers);
     getInverseOperation(): ProgCalcOperation;
     toIdentifiers(): ProgCalcOperationIdentifiers;
 }
@@ -37,7 +37,7 @@ export declare abstract class ProgCalcConstructor {
 export declare class ProgCalc {
     operations: ProgCalcOperation[];
     constructor(arrOperation: ProgCalcOperation[]);
-    apply(node: AlgebraicNode): AlgebraicNode;
+    apply(node: AlgebraicNode): AlgebraicNode | undefined;
     getArrOfFrenchStrings(): string[];
     getInverseProgCalc(): ProgCalc | undefined;
     toTree(nodeVariable: VariableNode): AlgebraicNode;

package/lib/math/progCalc/progCalc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"progCalc.d.ts","sourceRoot":"","sources":["../../../src/math/progCalc/progCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAI1E,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,eAAO,MAAM,qBAAqB,EAAE,iCAAiC,EA2BpE,CAAC;AAEF,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,qBAAqB,CAAC,WAAW,EAAE,iCAAiC;IAS3E,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAwE3D;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,YAAY,EAAE,4BAA4B,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,CAAC;IAC7C,mBAAmB,EAAE,4BAA4B,CAAC;gBAGhD,YAAY,EAAE,4BAA4B,EAC1C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,EAC5C,mBAAmB,EAAE,4BAA4B;IAQnD,mBAAmB,IAAI,iBAAiB;IAMxC,aAAa,IAAI,4BAA4B;CAG9C;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,4BAA4B,EAAE,CAAC;CAC9C,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,oBAAoB,GAAE,OAAc,EACpC,uBAAuB,GAAE,iCAAiC,EAA0B;IAatF,MAAM,CAAC,mBAAmB,CACxB,OAAO,EAAE,MAAM,EACf,oBAAoB,EAAE,OAAO,EAC7B,uBAAuB,EAAE,iCAAiC,EAAE,EAC5D,iBAAiB,EAAE,iCAAiC,EAAE;IAyBxD,MAAM,CAAC,mBAAmB,CACxB,OAAO,GAAE,MAAU,EACnB,oBAAoB,GAAE,OAAc;IA6CtC,MAAM,CAAC,YAAY,CACjB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,aAAa,EACjC,QAAQ,GAAE,MAAU,EACpB,oBAAoB,GAAE,OAAc;IA2EtC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,mBAAmB;CAMlD;AAED,qBAAa,QAAQ;IACnB,UAAU,EAAE,iBAAiB,EAAE,CAAC;gBAEpB,YAAY,EAAE,iBAAiB,EAAE;IAI7C,KAAK,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa;IASzC,qBAAqB,IAAI,MAAM,EAAE;IAIjC,kBAAkB,IAAI,QAAQ,GAAG,SAAS;IAO1C,MAAM,CAAC,YAAY,EAAE,YAAY,GAAG,aAAa;IAIjD,aAAa,IAAI,mBAAmB;CAOrC"}
+{"version":3,"file":"progCalc.d.ts","sourceRoot":"","sources":["../../../src/math/progCalc/progCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAI1E,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,eAAO,MAAM,qBAAqB,EAAE,iCAAiC,EA2BpE,CAAC;AAEF,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,qBAAqB,CAAC,WAAW,EAAE,iCAAiC;IAS3E,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,4BAA4B;CA8E3D;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,YAAY,EAAE,4BAA4B,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,GAAG,SAAS,CAAC;IACzD,mBAAmB,EAAE,4BAA4B,CAAC;gBAGhD,YAAY,EAAE,4BAA4B,EAC1C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,GAAG,SAAS,EACxD,mBAAmB,EAAE,4BAA4B;IAQnD,mBAAmB,IAAI,iBAAiB;IAMxC,aAAa,IAAI,4BAA4B;CAG9C;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,4BAA4B,EAAE,CAAC;CAC9C,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,oBAAoB,GAAE,OAAc,EACpC,uBAAuB,GAAE,iCAAiC,EAA0B;IAatF,MAAM,CAAC,mBAAmB,CACxB,OAAO,EAAE,MAAM,EACf,oBAAoB,EAAE,OAAO,EAC7B,uBAAuB,EAAE,iCAAiC,EAAE,EAC5D,iBAAiB,EAAE,iCAAiC,EAAE;IAyBxD,MAAM,CAAC,mBAAmB,CACxB,OAAO,GAAE,MAAU,EACnB,oBAAoB,GAAE,OAAc;IA6CtC,MAAM,CAAC,YAAY,CACjB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,aAAa,EACjC,QAAQ,GAAE,MAAU,EACpB,oBAAoB,GAAE,OAAc;IA4EtC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,mBAAmB;CAMlD;AAED,qBAAa,QAAQ;IACnB,UAAU,EAAE,iBAAiB,EAAE,CAAC;gBAEpB,YAAY,EAAE,iBAAiB,EAAE;IAI7C,KAAK,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,GAAG,SAAS;IAYrD,qBAAqB,IAAI,MAAM,EAAE;IAIjC,kBAAkB,IAAI,QAAQ,GAAG,SAAS;IAO1C,MAAM,CAAC,YAAY,EAAE,YAAY,GAAG,aAAa;IAIjD,aAAa,IAAI,mBAAmB;CAOrC"}

package/lib/math/progCalc/progCalc.js

@@ -47,7 +47,14 @@ export class ProgCalcOperationConstructor {
             case "opposite":
                 return new ProgCalcOperation(opIds, `Prendre l'opposé`, (node) => opposite(node), { operator: "opposite" });
             case "inverse":
-                return new ProgCalcOperation(opIds, `Prendre l'inverse`, (node) => frac(1, node), { operator: "inverse" });
+                return new ProgCalcOperation(opIds, `Prendre l'inverse`, (node) => {
+                    if (node.simplify().evaluate() === 0) {
+                        return undefined;
+                    }
+                    else {
+                        return frac(1, node);
+                    }
+                }, { operator: "inverse" });
             case "add": {
                 const nodeParam = NodeConstructor.fromIdentifiers(opIds.param);
                 return new ProgCalcOperation(opIds, `Ajouter $ ${nodeParam.toTex()} $`, (nodeX) => add(nodeX, nodeParam), { operator: "subtract", param: opIds.param });
@@ -185,8 +192,8 @@ export class ProgCalcConstructor {
                 operation =
                     ProgCalcOperationConstructor.randomFromOpGenConfig(opGenConfig);
                 const nodeResult = operation.func(nodeCurrent);
-                const numberResult = nodeResult.evaluate();
-                const isValidResult = isInt(numberResult * Math.pow(10, nbDigits));
+                const numberResult = nodeResult && nodeResult.evaluate();
+                const isValidResult = numberResult && isInt(numberResult * Math.pow(10, nbDigits));
                 if (isValidResult) {
                     isOperationValid = true;
                     nodeCurrent = nodeResult;
@@ -216,6 +223,9 @@ export class ProgCalc {
         for (let i = 0; i < this.operations.length; i++) {
             const operation = this.operations[i];
             nodeCurrent = operation.func(nodeCurrent);
+            if (nodeCurrent === undefined) {
+                return undefined;
+            }
         }
         return nodeCurrent;
     }

package/lib/tests/exoTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC;;;;CA+F5C,CAAC"}
+{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC;;;;CA0G5C,CAAC"}

package/lib/tests/exoTest.js

@@ -46,6 +46,13 @@ export const exoTest = (exo) => {
         if (!exo.isAnswerTableValid)
             throw new Error(`exo ${exo.id} has no isAnswerTableValid`);
     }
+    if (exo.answerType === "QCU" || exo.answerType === "QCM") {
+        if (exo.isAnswerValid)
+            throw new Error(`exo ${exo.id} has isAnswerValid but has answer type ${exo.answerType}`);
+        // console.log(
+        //   `exo ${exo.id} has isAnswerValid but has answer type ${exo.answerType}`,
+        // );
+    }
     questions.forEach((question) => {
         const times = questionTest(exo, question);
         qcmTime = times.qcmTime;

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;;;CA0P3B,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

@@ -146,6 +146,7 @@ export const questionTest = (exo, question) => {
             exo.id +
             " has answerFormat raw but answerType is not QCU or QCM");
     }
+    const jsonIds = JSON.stringify(question.identifiers);
     if (exo.answerType !== "QCM" &&
         exo.answerType !== "QCU" &&
         exo.answerType !== "GGB" &&
@@ -158,7 +159,7 @@ export const questionTest = (exo, question) => {
         const before = Date.now();
         console.log("will test vea : ", exo.id);
         if (!exo.isAnswerValid(answer, { answer, ...question.identifiers })) {
-            throw new Error(`exo ${exo.id} has invalid VEA, ids ${JSON.stringify(question.identifiers)}, answer ${question.answer}`);
+            throw new Error(`exo ${exo.id} has invalid VEA, ids ${jsonIds}, answer ${question.answer}`);
         }
         const after = Date.now();
         veaTime = after - before;
@@ -171,7 +172,7 @@ export const questionTest = (exo, question) => {
         if (exo.answerType === "QCM" && !exo.isQCM)
             throw new Error("exo " + exo.id + " has answerType QCM but not isQCM");
         const before = Date.now();
-        console.log("will generate props : ", exo.id, "ids :", question.identifiers);
+        console.log("will generate props : ", exo.id, "ids :", jsonIds);
         const props = exo.getPropositions(4, {
             answer: question.answer,
             ...question.identifiers,
@@ -190,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") {

package/package.json

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