math-exercises 3.0.137 → 3.0.138

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

@@ -15,4 +15,5 @@ export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
 export * from "./equationFromProblem.js";
+export * from "./isEqualityTrue.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
 export * from "./equationFromProblem.js";
+export * from "./isEqualityTrue.js";

package/lib/exercises/math/calculLitteral/equation/isEqualityTrue.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    evaluationDict: Record<string, NodeIdentifiers>;
+    equalNodeIds: NodeIdentifiers;
+    isEqual: boolean;
+};
+type Options = {
+    typeCoeff: "Entier" | "Fraction" | "Décimal";
+    typeTestValue: "Entier" | "Fraction" | "Décimal";
+};
+export declare const isEqualityTrue1: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=isEqualityTrue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isEqualityTrue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/isEqualityTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkB7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAChD,YAAY,EAAE,eAAe,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAkUF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;IAC7C,aAAa,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;CAClD,CAAC;AA6BF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB1D,CAAC"}

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

@@ -0,0 +1,314 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const varNames = ["x", "y", "z", "t", "u", "v"];
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((strYN) => {
+        if (strYN === answer) {
+            addValidProp(propositions, strYN);
+        }
+        else {
+            tryToAddWrongProp(propositions, strYN);
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { isEqual } = identifiers;
+    return isEqual ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { evaluationDict, equalNodeIds } = identifiers;
+    const equalNode = NodeConstructor.fromIdentifiers(equalNodeIds);
+    const strEvaluation = `${joinanded(Object.entries(evaluationDict).map(([varName, nodeIds]) => {
+        const node = NodeConstructor.fromIdentifiers(nodeIds);
+        return `$${varName} = ${node.toTex()}$`;
+    }), ", ", " et ")}`;
+    return `En considérant l'équation ci-dessous, l'égalité est-elle vérifiée pour ${strEvaluation} ? 
+  
+$$
+${equalNode.toTex()}
+$$
+
+`;
+};
+const getHint = () => {
+    return `L'expression $3x$ vaut $3,3$ pour $x = 1,1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { evaluationDict, equalNodeIds, isEqual } = identifiers;
+    const evaluationEntries = Object.entries(evaluationDict).map(([varName, nodeIds]) => [
+        varName,
+        NodeConstructor.fromIdentifiers(nodeIds),
+    ]);
+    const equalNode = NodeConstructor.fromIdentifiers(equalNodeIds);
+    const [lhsNode, rhsNode] = [equalNode.leftChild, equalNode.rightChild];
+    const [evaluatedLhsNode, evaluatedRhsNode] = [lhsNode, rhsNode].map((nodeCarrier) => evaluationEntries.reduce((acc, [varName, nodeInjected]) => nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName)), nodeCarrier));
+    return `Pour tester si l'égalité est vérifiée, on évalue chaque membre de l'équation.
+  
+On évalue le membre de gauche : 
+
+${alignTex([
+        ["", lhsNode.toTex()],
+        ["=", evaluatedLhsNode.toTex()],
+        [
+            "=",
+            (() => {
+                const evLhsAsAddNode = evaluatedLhsNode;
+                return add(evLhsAsAddNode.leftChild.simplify(), evLhsAsAddNode.rightChild);
+            })().toTex(),
+        ],
+        ["=", evaluatedLhsNode.simplify().toTex()],
+    ])}
+
+On évalue le membre de droite : 
+
+${alignTex([
+        ["", rhsNode.toTex()],
+        ["=", evaluatedRhsNode.toTex()],
+        [
+            "=",
+            (() => {
+                const evRhsAsAddNode = evaluatedRhsNode;
+                return add(evRhsAsAddNode.leftChild.simplify(), evRhsAsAddNode.rightChild);
+            })().toTex(),
+        ],
+        ["=", evaluatedRhsNode.simplify().toTex()],
+    ])}
+
+${isEqual
+        ? `Les deux valeurs sont égales donc l'égalité est vérifiée.`
+        : `Les deux valeurs sont différentes. L'égalité n'est pas vérifiée.`}
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const getIsEqualityTrue1Question = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        typeCoeff: random(arrayedOptions.typeCoeff),
+        typeTestValue: random(arrayedOptions.typeTestValue),
+    };
+    const roundDecimalTo = 1;
+    const varName = random(varNames);
+    function getRandomIntNode(excludes = []) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const intExcludes = excludes
+                .filter((node) => isNumberNode(node))
+                .map((node) => node.evaluate())
+                .filter((value) => value % 1 === 0);
+            let n;
+            try {
+                n = randint(-9, 10, intExcludes);
+            }
+            catch (_) {
+                (() => { })();
+            }
+            if (n) {
+                outNode = n.toTree();
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomFractionNode(excludes = []) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const num = randint(-9, 10);
+            const den = randint(0, 10, [0, num]);
+            const fractionNode = frac(num, den);
+            const isExcluded = excludes.some((excludedNode) => substract(excludedNode, fractionNode).evaluate() === 0);
+            if (!isExcluded) {
+                outNode = fractionNode;
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomDecimalNode(excludes = [], roundTo) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const decimalNode = randfloat(-10, 10, roundTo).toTree();
+            const isExcluded = excludes.some((excludedNode) => substract(excludedNode, decimalNode).evaluate() === 0);
+            if (!isExcluded) {
+                outNode = decimalNode;
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomNode(typeCoeff, excludes = []) {
+        switch (typeCoeff) {
+            case "Fraction":
+                return getRandomFractionNode(excludes);
+            case "Décimal": {
+                return getRandomDecimalNode(excludes, roundDecimalTo);
+            }
+            case "Entier":
+            default:
+                return getRandomIntNode(excludes);
+        }
+    }
+    function createRandomIdentifiers() {
+        const [a, b] = [
+            getRandomNode(opts.typeCoeff),
+            getRandomNode(opts.typeCoeff),
+        ];
+        const [c, d] = [
+            getRandomNode(opts.typeCoeff, [a]),
+            getRandomNode(opts.typeCoeff),
+        ];
+        const lhsNode = add(multiply(a, varName.toTree()), b);
+        const rhsNode = add(multiply(c, varName.toTree()), d);
+        const equalNode = new EqualNode(lhsNode, rhsNode);
+        //ax+b=cx+d
+        //x=(d-b)/(a-c)
+        const solutionNode = frac(substract(d, b), substract(a, c)).simplify();
+        const isEqual = coinFlip();
+        const evaluationDict = {};
+        if (isEqual) {
+            let isSalvation = true;
+            switch (opts.typeTestValue) {
+                case "Entier":
+                    {
+                        const value = solutionNode.evaluate();
+                        const isInteger = value % 1 === 0;
+                        if (isInteger) {
+                            evaluationDict[varName] = value.toTree().toIdentifiers();
+                        }
+                        else {
+                            isSalvation = false;
+                        }
+                    }
+                    break;
+                case "Décimal":
+                    {
+                        const value = solutionNode.evaluate();
+                        const strValue = value.toString();
+                        const isDecimalWithNbDigits = strValue.split(".")?.[1]?.length === roundDecimalTo;
+                        if (isDecimalWithNbDigits) {
+                            evaluationDict[varName] = value.toTree().toIdentifiers();
+                        }
+                        else {
+                            isSalvation = false;
+                        }
+                    }
+                    break;
+                case "Fraction": {
+                    if (isFractionNode(solutionNode)) {
+                        evaluationDict[varName] = solutionNode.toIdentifiers();
+                    }
+                    else {
+                        isSalvation = false;
+                    }
+                }
+            }
+            if (!isSalvation) {
+                return null;
+            }
+        }
+        else {
+            const missNode = getRandomNode(opts.typeTestValue, [solutionNode]);
+            evaluationDict[varName] = missNode.toIdentifiers();
+        }
+        const identifiers = {
+            evaluationDict,
+            equalNodeIds: equalNode.toIdentifiers(),
+            isEqual,
+        };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    while (!identifiers && counter < 100) {
+        counter++;
+        identifiers = createRandomIdentifiers();
+    }
+    const defaultIdentifiers = {
+        evaluationDict: { x: (0).toTree().toIdentifiers() },
+        equalNodeIds: parseLatex("3x+4=-5x+4").toIdentifiers(),
+        isEqual: true,
+    };
+    return getQuestionFromIdentifiers(identifiers ?? defaultIdentifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    typeCoeff: ["Entier"],
+    typeTestValue: ["Entier", "Fraction", "Décimal"],
+};
+const options = [
+    {
+        id: "typeCoeff",
+        label: "Type des coefficients",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Fraction", "Décimal"],
+        defaultValue: optsDefault.typeCoeff,
+    },
+    {
+        id: "typeTestValue",
+        label: "Type des valeurs de test",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Fraction", "Décimal"],
+        defaultValue: optsDefault.typeTestValue,
+    },
+];
+export const isEqualityTrue1 = {
+    id: "isEqualityTrue1",
+    label: "Tester une égalité pour une certaine valeur de la variable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsEqualityTrue1Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"compareBoxPlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/compareBoxPlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAKF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAmQF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}
+{"version":3,"file":"compareBoxPlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/compareBoxPlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAKF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA8PF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}

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

@@ -128,10 +128,6 @@ const getGGBOptions = (identifiers) => {
         coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
     });
 };
-const isAnswerValid = (ans, { answer }) => {
-    const ansRefined = ans.split(";").toSorted().join(";");
-    return ansRefined === answer;
-};
 const getBoxPlotReadingQuestion = () => {
     const nbDistri = 2;
     const nbInAnswer = 1;
@@ -183,7 +179,6 @@ export const compareBoxPlot = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getHint,
     getCorrection,
@@ -193,4 +188,5 @@ export const compareBoxPlot = {
     hasGeogebra: true,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/geometry/cartesian/index.d.ts

@@ -11,6 +11,7 @@ export * from "./readAbscissOnLine.js";
 export * from "./readAbscissOnSemiLine.js";
 export * from "./placeAbscissOnLine.js";
 export * from "./placeAbscissOnSemiLine.js";
+export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/cartesian/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAE5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/geometry/cartesian/index.js

@@ -12,6 +12,6 @@ export * from "./readAbscissOnLine.js";
 export * from "./readAbscissOnSemiLine.js";
 export * from "./placeAbscissOnLine.js";
 export * from "./placeAbscissOnSemiLine.js";
-// export * from "./placeAbscissOnSemiLineV2.js";
+export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAiOF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}
+{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.js

@@ -2,7 +2,6 @@ import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercis
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
 import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
 import { Point } from "../../../../math/geometry/point.js";
@@ -81,18 +80,12 @@ const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) =>
 };
 const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
     const [absciss2Node, axisUnitNode] = [absciss2, axisUnit].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const commands = ans;
-    const dictObj = new GeogebraParser(commands).objectDict();
-    const strPointA = dictObj["A"];
-    if (!strPointA) {
-        return false;
-    }
-    const coordsA = ggbPointToCoords(strPointA);
-    const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
-    return (points.length === 3 && //O,I,A
+    const arrCoords = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
+    const coordsA = arrCoords[0];
+    return (arrCoords.length === 1 &&
         Math.abs(coordsA.y) < 0.5 * axisUnitNode.evaluate() &&
         Math.abs(coordsA.x - absciss2Node.evaluate()) <
-            0.1 * axisUnitNode.evaluate());
+            0.2 * axisUnitNode.evaluate());
 };
 const getPlaceAbscissOnSemiLineV2Question = (optsIn) => {
     const arrayedOptions = optsIn ?? optsDefault;

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts

@@ -2,4 +2,6 @@ export * from "./buildMediatriceWithCompass.js";
 export * from "./buildTriangleWithSizes.js";
 export * from "./pointImageFromTranslation.js";
 export * from "./buildPointFromAxialSymetry.js";
+export * from "./pointImageFromHomothety.js";
+export * from "./segmentImageFromHomothety.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/index.js

@@ -2,5 +2,5 @@ export * from "./buildMediatriceWithCompass.js";
 export * from "./buildTriangleWithSizes.js";
 export * from "./pointImageFromTranslation.js";
 export * from "./buildPointFromAxialSymetry.js";
-// export * from "./pointImageFromHomothety.js";
-// export * from "./segmentImageFromHomothety.js";
+export * from "./pointImageFromHomothety.js";
+export * from "./segmentImageFromHomothety.js";

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AA2EF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAuNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}
+{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AA2EF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA6OF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.js

@@ -235,6 +235,26 @@ const getPossibleValuesForProbaQuestion = (optsIn) => {
                 .length === 2;
     }
     arrNode = shuffle(arrNode);
+    //fix prevent everything to be false
+    //{
+    function isPossibleProba(node) {
+        const value = node.evaluate();
+        return 0 <= value && value <= 1;
+    }
+    function isInvalidNode(node) {
+        return (isFilterPossibleProba ? (x) => !x : (x) => x)(isPossibleProba(node));
+    }
+    const isEverythingFalse = arrNode.every(isInvalidNode);
+    if (isEverythingFalse) {
+        arrNode.pop();
+        if (isFilterPossibleProba) {
+            arrNode.push((1).toTree());
+        }
+        else {
+            arrNode.push((-1).toTree());
+        }
+    }
+    //}
     const identifiers = {
         arrayOfNodeIds: arrNode.map((node) => node.toIdentifiers()),
         isFilterPossibleProba,

package/lib/index.d.ts

@@ -490,6 +490,13 @@ declare const mathExercises: (Exercise<{
     shuffleArrays: number[][];
     equalNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    evaluationDict: Record<string, import("./tree/nodes/nodeConstructor.js").NodeIdentifiers>;
+    equalNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isEqual: boolean;
+}, {
+    typeCoeff: "Entier" | "Fraction" | "D\u00E9cimal";
+    typeTestValue: "Entier" | "Fraction" | "D\u00E9cimal";
+}> | Exercise<{
     a: number;
     b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1607,6 +1614,14 @@ declare const mathExercises: (Exercise<{
     abscissTex: string;
     coeff: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    abscissType: import("./math/numbers/nombre.js").NumberType;
+    axisUnit: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    absciss1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    absciss2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    questionType: "standard" | "\u00E9viter le comptage";
+    numberType: "Entiers" | "Rationnels" | "D\u00E9cimaux";
+}> | Exercise<{
     vectorIdentifiers: import("./math/geometry/vector.js").VectorIdentifiers;
     pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1893,6 +1908,22 @@ declare const mathExercises: (Exercise<{
     point: import("./math/geometry/point.js").PointIdentifiers;
     line: import("./math/geometry/line.js").LineIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    pointsDict: Record<string, import("./math/geometry/point.js").PointIdentifiers>;
+    nameTargetPoint: string;
+    nameCenterPoint: string;
+    factor: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    isPositiveFactorOnly: boolean;
+    factorTypes: string[];
+}> | Exercise<{
+    pointsDict: Record<string, import("./math/geometry/point.js").PointIdentifiers>;
+    nameTargetPoints: string[];
+    nameCenterPoint: string;
+    factor: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    isPositiveFactorOnly: boolean;
+    factorTypes: string[];
+}> | Exercise<{
     type: number;
     commands: string[];
 }, Record<string, string | boolean | string[]>> | Exercise<{

package/lib/index.d.ts.map

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

package/package.json

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