math-exercises 2.0.11 → 2.0.13

package/lib/exercises/sets/intervals/inequalityToInterval.js

@@ -1,145 +1,145 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inequalityToInterval = void 0;
-const exercise_1 = require("../../../exercises/exercise");
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const intervals_1 = require("../../../math/sets/intervals/intervals");
-const inequationNode_1 = require("../../../tree/nodes/inequations/inequationNode");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const belongsNode_1 = require("../../../tree/nodes/sets/belongsNode");
-const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
-const coinFlip_1 = require("../../../utils/coinFlip");
-const shuffle_1 = require("../../../utils/shuffle");
-const getInequalityToIntervalQuestion = () => {
-    const isIntervalToInequality = (0, coinFlip_1.coinFlip)();
-    const interval = intervals_1.IntervalConstructor.random();
-    const inequalityString = interval.toInequality();
-    const answer = isIntervalToInequality
-        ? inequalityString
-        : `x\\in${interval.toTex()}`;
-    const instruction = isIntervalToInequality
-        ? `Soit $x \\in ${interval.toTex()}$. Traduire cette appartenance en une inégalité.`
-        : `Soit $${inequalityString}$. Traduire cette inégalité en appartenance à un intervalle.`;
-    const question = {
-        answer,
-        instruction: instruction,
-        keys: [
-            "x",
-            "belongs",
-            "inf",
-            "sup",
-            "geq",
-            "leq",
-            "lbracket",
-            "rbracket",
-            "semicolon",
-            "infty",
-        ],
-        answerFormat: "tex",
-        identifiers: {
-            isIntervalToInequality: isIntervalToInequality,
-            intervalTex: interval.tex,
-        },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) => {
-    const reverseBracket = (bracket) => {
-        return bracket === "[" ? "]" : "[";
-    };
-    const switchInclusion = (symbol) => {
-        if (symbol === "\\le")
-            return "<";
-        if (symbol === "<")
-            return "\\le";
-        if (symbol === ">")
-            return "\\ge";
-        return ">";
-    };
-    const reverseInequality = (symbol) => {
-        if (symbol === "\\le")
-            return "\\ge";
-        if (symbol === "<")
-            return ">";
-        if (symbol === ">")
-            return "<";
-        return "\\le";
-    };
-    const interval = new intervals_1.Interval(intervalTex);
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    const xNode = new variableNode_1.VariableNode("x");
-    if (isIntervalToInequality) {
-        let wrongIneqs = [];
-        if (interval.min === -Infinity) {
-            wrongIneqs = [
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], switchInclusion(interval.rightInequalitySymbol)),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(switchInclusion(interval.rightInequalitySymbol))),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(interval.rightInequalitySymbol)),
-            ];
-        }
-        else if (interval.max === Infinity) {
-            wrongIneqs = [
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], switchInclusion(interval.leftInequalitySymbol)),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(switchInclusion(interval.leftInequalitySymbol))),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(interval.leftInequalitySymbol)),
-            ];
-        }
-        else {
-            wrongIneqs = [
-                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
-                    switchInclusion(interval.leftInequalitySymbol),
-                    interval.rightInequalitySymbol,
-                ]),
-                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
-                    interval.leftInequalitySymbol,
-                    switchInclusion(interval.rightInequalitySymbol),
-                ]),
-                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
-                    switchInclusion(interval.leftInequalitySymbol),
-                    switchInclusion(interval.rightInequalitySymbol),
-                ]),
-            ];
-        }
-        wrongIneqs.forEach((ineq) => {
-            (0, exercise_1.addWrongProp)(propositions, ineq.toTex());
-        });
-    }
-    else {
-        const wrongStatements = [
-            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${interval.rightBracket}`,
-            `x\\in${interval.leftBracket}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
-            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
-        ];
-        wrongStatements.forEach((ineq) => {
-            (0, exercise_1.addWrongProp)(propositions, ineq);
-        });
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-const isAnswerValid = (ans, { intervalTex, isIntervalToInequality }) => {
-    const interval = new intervals_1.Interval(intervalTex).toTree();
-    console.log(interval.toTex());
-    const inequality = interval.toInequality();
-    const answer = isIntervalToInequality
-        ? inequality
-        : new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
-            allowRawRightChildAsSolution: true,
-        });
-    const texs = answer.toAllValidTexs();
-    console.log(texs);
-    return texs.includes(ans);
-};
-exports.inequalityToInterval = {
-    id: "inequalityToInterval",
-    connector: "=",
-    label: "Traduire une inégalité en intervalle",
-    levels: ["2ndPro", "2nde", "CAP", "1reESM"],
-    isSingleStep: true,
-    sections: ["Ensembles et intervalles"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInequalityToIntervalQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inequalityToInterval = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const intervals_1 = require("../../../math/sets/intervals/intervals");
+const inequationNode_1 = require("../../../tree/nodes/inequations/inequationNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const belongsNode_1 = require("../../../tree/nodes/sets/belongsNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getInequalityToIntervalQuestion = () => {
+    const isIntervalToInequality = (0, coinFlip_1.coinFlip)();
+    const interval = intervals_1.IntervalConstructor.random();
+    const inequalityString = interval.toInequality();
+    const answer = isIntervalToInequality
+        ? inequalityString
+        : `x\\in${interval.toTex()}`;
+    const instruction = isIntervalToInequality
+        ? `Soit $x \\in ${interval.toTex()}$. Traduire cette appartenance en une inégalité.`
+        : `Soit $${inequalityString}$. Traduire cette inégalité en appartenance à un intervalle.`;
+    const question = {
+        answer,
+        instruction: instruction,
+        keys: [
+            "x",
+            "belongs",
+            "inf",
+            "sup",
+            "geq",
+            "leq",
+            "lbracket",
+            "rbracket",
+            "semicolon",
+            "infty",
+        ],
+        answerFormat: "tex",
+        identifiers: {
+            isIntervalToInequality: isIntervalToInequality,
+            intervalTex: interval.tex,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) => {
+    const reverseBracket = (bracket) => {
+        return bracket === "[" ? "]" : "[";
+    };
+    const switchInclusion = (symbol) => {
+        if (symbol === "\\le")
+            return "<";
+        if (symbol === "<")
+            return "\\le";
+        if (symbol === ">")
+            return "\\ge";
+        return ">";
+    };
+    const reverseInequality = (symbol) => {
+        if (symbol === "\\le")
+            return "\\ge";
+        if (symbol === "<")
+            return ">";
+        if (symbol === ">")
+            return "<";
+        return "\\le";
+    };
+    const interval = new intervals_1.Interval(intervalTex);
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const xNode = new variableNode_1.VariableNode("x");
+    if (isIntervalToInequality) {
+        let wrongIneqs = [];
+        if (interval.min === -Infinity) {
+            wrongIneqs = [
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], switchInclusion(interval.rightInequalitySymbol)),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(switchInclusion(interval.rightInequalitySymbol))),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(interval.rightInequalitySymbol)),
+            ];
+        }
+        else if (interval.max === Infinity) {
+            wrongIneqs = [
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], switchInclusion(interval.leftInequalitySymbol)),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(switchInclusion(interval.leftInequalitySymbol))),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(interval.leftInequalitySymbol)),
+            ];
+        }
+        else {
+            wrongIneqs = [
+                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                    switchInclusion(interval.leftInequalitySymbol),
+                    interval.rightInequalitySymbol,
+                ]),
+                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                    interval.leftInequalitySymbol,
+                    switchInclusion(interval.rightInequalitySymbol),
+                ]),
+                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                    switchInclusion(interval.leftInequalitySymbol),
+                    switchInclusion(interval.rightInequalitySymbol),
+                ]),
+            ];
+        }
+        wrongIneqs.forEach((ineq) => {
+            (0, exercise_1.addWrongProp)(propositions, ineq.toTex());
+        });
+    }
+    else {
+        const wrongStatements = [
+            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${interval.rightBracket}`,
+            `x\\in${interval.leftBracket}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
+            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
+        ];
+        wrongStatements.forEach((ineq) => {
+            (0, exercise_1.addWrongProp)(propositions, ineq);
+        });
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { intervalTex, isIntervalToInequality }) => {
+    const interval = new intervals_1.Interval(intervalTex).toTree();
+    console.log(interval.toTex());
+    const inequality = interval.toInequality();
+    const answer = isIntervalToInequality
+        ? inequality
+        : new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
+            allowRawRightChildAsSolution: true,
+        });
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.inequalityToInterval = {
+    id: "inequalityToInterval",
+    connector: "=",
+    label: "Traduire une inégalité en intervalle",
+    levels: ["2ndPro", "2nde", "CAP", "1reESM"],
+    isSingleStep: true,
+    sections: ["Ensembles et intervalles"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInequalityToIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/sets/intervals/intervalBelonging.d.ts

@@ -1 +1,4 @@
+import { MathExercise, Question } from '../../../exercises/exercise';
+export declare const intervalBelonging: MathExercise;
+export declare function getIntervalBelongingQuestion(): Question;
 //# sourceMappingURL=intervalBelonging.d.ts.map

package/lib/exercises/sets/intervals/intervalBelonging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalBelonging.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalBelonging.ts"],"names":[],"mappings":""}
+{"version":3,"file":"intervalBelonging.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalBelonging.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAO/E,eAAO,MAAM,iBAAiB,EAAE,YAW/B,CAAC;AAEF,wBAAgB,4BAA4B,IAAI,QAAQ,CAuDvD"}

package/lib/exercises/sets/intervals/intervalBelonging.js

@@ -1,65 +1,69 @@
 "use strict";
-// import { MathExercise, Proposition, Question } from '../../../exercises/exercise';
-// import { getDistinctQuestions } from '../../../exercises/utils/getDistinctQuestions';
-// import { IntervalConstructor } from '../../../math/sets/intervals/intervals';
-// import { coinFlip } from '../../../utils/coinFlip';
-// import { shuffle } from '../../../utils/shuffle';
-// import { v4 } from 'uuid';
-// e getIntervalBelongingQuestion(): Question {
-//   const interval = IntervalConstructor.random();
-//   const isIn = coinFlip();
-//   let nb = '';
-//   let answer = '';
-//   if (isIn) {
-//     answer = '\\in';
-//     nb = interval.getRandomElement().toTree().toTex();
-//   } else {
-//     answer = '\\notin';
-//     nb = '2';
-//   }
-//   const getPropositions = (n: number) => {
-//     const res: Proposition[] = [];
-//     res.push({
-//       id: v4(),
-//       statement: ``,
-//       isRightAnswer: true,
-//       format: 'tex',
-//     });
-//     const missing = n - res.length;
-//     for (let i = 0; i < missing; i++) {
-//       let isDuplicate: boolean;
-//       let proposition: Proposition;
-//       do {
-//         const wrongAnswer = '';
-//         proposition = {
-//           id: v4() + ``,
-//           statement: wrongAnswer,
-//           isRightAnswer: false,
-//           format: 'tex',
-//         };
-//         isDuplicate = res.some((p) => p.statement === proposition.statement);
-//       } while (isDuplicate);
-//       res.push(proposition);
-//     }
-//     return shuffle(res);
-//   };
-//   const question: Question = {
-//     answer,
-//     instruction: `Compléter par $\\in$ ou $\\notin$ : $\\ ${nb} \\ldots ${interval.toTex()}$`,
-//     keys: ['belongs', 'notin'],
-//     getPropositions,
-//     answerFormat: 'tex',
-//   };
-//   return question;
-// }
-// export const intervalBelonging: MathExercise<QCMProps, VEAProps> = {
-//   id: 'intervalBelonging',
-//   connector: '=',
-//   label: '=',
-//   levels: ['2nde', '2ndPro', '1reESM'],
-//   isSingleStep: true,
-//   sections: ['Ensembles et intervalles'],
-//   generator: (nb: number) => getDistinctQuestions(getIntervalBelongingQuestion, nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-// };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIntervalBelongingQuestion = exports.intervalBelonging = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const intervals_1 = require("../../../math/sets/intervals/intervals");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const uuid_1 = require("uuid");
+exports.intervalBelonging = {
+    id: 'intervalBelonging',
+    connector: '=',
+    instruction: '',
+    label: '=',
+    levels: ['2nde', '2ndPro', '1reESM'],
+    isSingleStep: true,
+    sections: ['Ensembles et intervalles'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIntervalBelongingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+};
+function getIntervalBelongingQuestion() {
+    const interval = intervals_1.IntervalConstructor.random();
+    const isIn = (0, coinFlip_1.coinFlip)();
+    let nb = '';
+    let answer = '';
+    if (isIn) {
+        answer = '\\in';
+        nb = interval.getRandomElement().toTree().toTex();
+    }
+    else {
+        answer = '\\notin';
+        nb = '2';
+    }
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: ``,
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        const missing = n - res.length;
+        for (let i = 0; i < missing; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                const wrongAnswer = '';
+                proposition = {
+                    id: (0, uuid_1.v4)() + ``,
+                    statement: wrongAnswer,
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
+    const question = {
+        answer,
+        instruction: `Compléter par $\\in$ ou $\\notin$ : $\\ ${nb} \\ldots ${interval.toTex()}$`,
+        keys: ['belongs', 'notin'],
+        getPropositions,
+        answerFormat: 'tex',
+    };
+    return question;
+}
+exports.getIntervalBelongingQuestion = getIntervalBelongingQuestion;

package/lib/exercises/sets/intervals/intervalsIntersection.d.ts

@@ -1,8 +1,8 @@
-import { MathExercise } from "../../../exercises/exercise";
-type Identifiers = {
-    int1Tex: string;
-    int2Tex: string;
-};
-export declare const intervalsIntersection: MathExercise<Identifiers>;
-export {};
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    int1Tex: string;
+    int2Tex: string;
+};
+export declare const intervalsIntersection: MathExercise<Identifiers>;
+export {};
 //# sourceMappingURL=intervalsIntersection.d.ts.map

package/lib/exercises/sets/intervals/intervalsIntersection.js

@@ -1,56 +1,56 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.intervalsIntersection = void 0;
-const exercise_1 = require("../../../exercises/exercise");
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const intervals_1 = require("../../../math/sets/intervals/intervals");
-const shuffle_1 = require("../../../utils/shuffle");
-const getIntervalsIntersectionQuestion = () => {
-    const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
-    const inter = int1.intersection(int2);
-    const answer = inter.tex;
-    const question = {
-        answer,
-        instruction: `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. Déterminer $I\\cap J$.`,
-        keys: [
-            "infty",
-            "emptyset",
-            "lbracket",
-            "rbracket",
-            "semicolon",
-            "cup",
-            "cap",
-        ],
-        answerFormat: "tex",
-        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Tex);
-    const int2 = new intervals_1.Interval(int2Tex);
-    (0, exercise_1.tryToAddWrongProp)(propositions, int1.union(int2).tex);
-    while (propositions.length < n) {
-        const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
-        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
-exports.intervalsIntersection = {
-    id: "intervalsIntersection",
-    connector: "=",
-    label: "Déterminer l'intersection de deux intervalles",
-    levels: ["2nde", "1reESM"],
-    isSingleStep: true,
-    sections: ["Ensembles et intervalles"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIntervalsIntersectionQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intervalsIntersection = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const intervals_1 = require("../../../math/sets/intervals/intervals");
+const shuffle_1 = require("../../../utils/shuffle");
+const getIntervalsIntersectionQuestion = () => {
+    const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
+    const inter = int1.intersection(int2);
+    const answer = inter.tex;
+    const question = {
+        answer,
+        instruction: `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. Déterminer $I\\cap J$.`,
+        keys: [
+            "infty",
+            "emptyset",
+            "lbracket",
+            "rbracket",
+            "semicolon",
+            "cup",
+            "cap",
+        ],
+        answerFormat: "tex",
+        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const int1 = new intervals_1.Interval(int1Tex);
+    const int2 = new intervals_1.Interval(int2Tex);
+    (0, exercise_1.tryToAddWrongProp)(propositions, int1.union(int2).tex);
+    while (propositions.length < n) {
+        const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.intervalsIntersection = {
+    id: "intervalsIntersection",
+    connector: "=",
+    label: "Déterminer l'intersection de deux intervalles",
+    levels: ["2nde", "1reESM"],
+    isSingleStep: true,
+    sections: ["Ensembles et intervalles"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIntervalsIntersectionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/sets/intervals/intervalsUnion.d.ts

@@ -1,8 +1,8 @@
-import { MathExercise } from "../../../exercises/exercise";
-type Identifiers = {
-    int1Tex: string;
-    int2Tex: string;
-};
-export declare const intervalsUnion: MathExercise<Identifiers>;
-export {};
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    int1Tex: string;
+    int2Tex: string;
+};
+export declare const intervalsUnion: MathExercise<Identifiers>;
+export {};
 //# sourceMappingURL=intervalsUnion.d.ts.map