math-exercises 3.0.125 → 3.0.127

package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.js

@@ -1,62 +1,18 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from '../../../../exercises/exercise.js';
-import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
-import { randint } from '../../../../math/utils/random/randint.js';
-import { opposite } from '../../../../tree/nodes/functions/oppositeNode.js';
-import { add } from '../../../../tree/nodes/operators/addNode.js';
-import { divide } from '../../../../tree/nodes/operators/divideNode.js';
-import { frac } from '../../../../tree/nodes/operators/fractionNode.js';
-import { multiply } from '../../../../tree/nodes/operators/multiplyNode.js';
-import { substract } from '../../../../tree/nodes/operators/substractNode.js';
-import { parseAlgebraic } from '../../../../tree/parsers/latexParser.js';
-import { coinFlip } from '../../../../utils/alea/coinFlip.js';
-import { random } from '../../../../utils/alea/random.js';
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { divide } from "../../../../tree/nodes/operators/divideNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const capitalize = (str) => {
-    if (!str)
-        return ''; // Handle empty strings
-    return str.charAt(0).toUpperCase() + str.slice(1);
-};
-const arr_operator = [
-    { outputName: "Opposite", arity: 1 },
-    { outputName: "Inverse", arity: 1 },
-    { outputName: "Sum", arity: 2 },
-    { outputName: "Difference", arity: 2 },
-    { outputName: "Product", arity: 2 },
-    { outputName: "Quotient", arity: 2 },
-];
-const getNodeFromOperation = (operation) => {
-    let outNode;
-    if (!("b" in operation.operands)) {
-        const { a } = operation.operands;
-        switch (operation.operator.outputName) {
-            case "Opposite":
-                outNode = opposite(a);
-                break;
-            case "Inverse":
-                outNode = frac(1, a);
-                break;
-        }
-    }
-    else {
-        const { a, b } = operation.operands;
-        switch (operation.operator.outputName) {
-            case "Sum":
-                outNode = add(a, b);
-                break;
-            case "Difference":
-                outNode = substract(a, b);
-                break;
-            case "Product":
-                outNode = multiply(a, b);
-                break;
-            case "Quotient":
-                outNode = frac(a, b);
-                break;
-        }
-    }
-    return outNode;
-};
-const dict_texFactor_to_frenchFactor = {
+import { capitalize } from "../../../../utils/strings/capitalize.js";
+const dictTexFactorToFrenchFactor = {
     [frac(1, 2).toTex()]: "la moitié",
     [frac(1, 3).toTex()]: "le tiers",
     [frac(1, 4).toTex()]: "le quart",
@@ -69,253 +25,279 @@ const dict_texFactor_to_frenchFactor = {
     [(4).frenchify()]: "le quadruple",
     [(5).frenchify()]: "le quintuple",
 };
-const buildFactorFrenchString = (tex__factor) => {
-    const str__french = dict_texFactor_to_frenchFactor[tex__factor];
-    return str__french;
-};
-const buildFrenchString = (identifiers) => {
-    const { operation, isUsingFrenchFactorNouns } = identifiers;
-    let str__french = "";
-    if (!("b" in operation.operands)) {
-        const { a } = operation.operands;
-        switch (operation.operator.outputName) {
-            case "Opposite":
-                str__french = `L'opposé de $ ${a} $`;
-                break;
-            case "Inverse":
-                str__french = `L'inverse de $ ${a} $`;
-                break;
-        }
-    }
-    else {
-        const { a, b } = operation.operands;
-        switch (operation.operator.outputName) {
-            case "Sum":
-                str__french = `La somme de $ ${a} $ et de $ ${b} $`;
-                break;
-            case "Difference":
-                str__french = `La différence entre $ ${a} $ et $ ${b} $`;
-                break;
-            case "Product":
-                {
-                    str__french = `Le produit de $ ${a} $ par $ ${b} $`;
-                    if (typeof b == 'string' && isUsingFrenchFactorNouns) {
-                        //"le double de x"
-                        const str__a__french = buildFactorFrenchString(a.frenchify());
-                        if (str__a__french) {
-                            str__french = `${str__a__french} de $ ${b} $`;
-                        }
-                    }
-                }
-                break;
-            case "Quotient":
-                {
-                    str__french = `Le quotient de $ ${a} $ par $ ${b} $`;
-                    if (typeof a == 'string' && isUsingFrenchFactorNouns) {
-                        //"le tiers de x"
-                        const oneOverB = frac(1, b);
-                        const str__oneOverB__french = buildFactorFrenchString(oneOverB.toTex());
-                        if (str__oneOverB__french) {
-                            str__french = `${str__oneOverB__french} de $ ${a} $`;
-                        }
-                    }
-                }
-                break;
+const arrOperator = [
+    "opposite",
+    "inverse",
+    "add",
+    "subtract",
+    "multiply",
+    "divide",
+];
+class ExpressionConstructor {
+    static fromIdentifiers(identifiers) {
+        const { operatorName, a, b, isUsingFrenchFactorNouns } = identifiers;
+        switch (operatorName) {
+            case "opposite":
+                return {
+                    node: opposite(a),
+                    strFrench: `L'opposé de $ ${a} $`,
+                };
+            case "inverse":
+                return {
+                    node: frac(1, a),
+                    strFrench: `L'inverse de $ ${a} $`,
+                };
+            case "add":
+                return {
+                    node: add(a, b),
+                    strFrench: `La somme de $ ${a} $ et de $ ${b} $`,
+                };
+            case "subtract":
+                return {
+                    node: substract(a, b),
+                    strFrench: `La différence entre $ ${a} $ et $ ${b} $`,
+                };
+            case "multiply":
+                return {
+                    node: multiply(a, b),
+                    strFrench: typeof b === "string" && isUsingFrenchFactorNouns
+                        ? dictTexFactorToFrenchFactor[a.frenchify()]
+                            ? `${dictTexFactorToFrenchFactor[a.frenchify()]} de $ ${b} $`
+                            : `Le produit de $ ${a} $ par $ ${b} $`
+                        : `Le produit de $ ${a} $ par $ ${b} $`,
+                };
+            case "divide":
+                return {
+                    node: frac(a, b),
+                    strFrench: typeof a === "string" && isUsingFrenchFactorNouns
+                        ? dictTexFactorToFrenchFactor[frac(1, b).toTex()]
+                            ? `${dictTexFactorToFrenchFactor[frac(1, b).toTex()]} de $ ${a} $`
+                            : `Le quotient de $ ${a} $ par $ ${b} $`
+                        : `Le quotient de $ ${a} $ par $ ${b} $`,
+                };
         }
     }
-    return str__french;
-};
-const getPropositions = (n, { answer, operation, isUsingFrenchFactorNouns }) => {
+}
+const getPropositions = (n, { answer, operatorName, a, b }) => {
     const propositions = [];
-    if (!("b" in operation.operands)) {
-        const { a } = operation.operands;
-        switch (operation.operator.outputName) {
-            case "Opposite":
+    switch (operatorName) {
+        case "opposite":
+            addValidProp(propositions, answer);
+            tryToAddWrongProp(propositions, add(a, 1).toTex());
+            tryToAddWrongProp(propositions, frac(1, a).toTex());
+            tryToAddWrongProp(propositions, substract(1, a).toTex());
+            break;
+        case "inverse":
+            if (coinFlip()) {
                 addValidProp(propositions, answer);
-                tryToAddWrongProp(propositions, add(a, 1).toTex());
-                tryToAddWrongProp(propositions, frac(1, a).toTex());
-                tryToAddWrongProp(propositions, substract(1, a).toTex());
-                break;
-            case "Inverse":
-                if (coinFlip()) {
-                    addValidProp(propositions, answer);
-                }
-                else {
-                    addValidProp(propositions, divide(1, a).toTex());
-                }
-                tryToAddWrongProp(propositions, add(a, 1).toTex());
-                tryToAddWrongProp(propositions, opposite(a).toTex());
-                tryToAddWrongProp(propositions, frac(0, a).toTex());
-                break;
-        }
-    }
-    else {
-        const { a, b } = operation.operands;
-        switch (operation.operator.outputName) {
-            case "Sum":
-                if (coinFlip()) {
-                    addValidProp(propositions, answer);
-                }
-                else {
-                    addValidProp(propositions, add(b, a).toTex());
-                }
-                tryToAddWrongProp(propositions, multiply(a, b).toTex());
-                tryToAddWrongProp(propositions, substract(a, b).toTex());
-                tryToAddWrongProp(propositions, frac(a, b).toTex());
-                break;
-            case "Difference":
+            }
+            else {
+                addValidProp(propositions, divide(1, a).toTex());
+            }
+            tryToAddWrongProp(propositions, add(a, 1).toTex());
+            tryToAddWrongProp(propositions, opposite(a).toTex());
+            tryToAddWrongProp(propositions, frac(0, a).toTex());
+            break;
+        case "add":
+            if (coinFlip()) {
                 addValidProp(propositions, answer);
-                tryToAddWrongProp(propositions, substract(b, a).toTex());
-                tryToAddWrongProp(propositions, frac(a, b).toTex());
-                tryToAddWrongProp(propositions, frac(b, a).toTex());
-                break;
-            case "Product":
-                if (coinFlip()) {
-                    addValidProp(propositions, answer);
-                }
-                else {
-                    addValidProp(propositions, multiply(b, a).toTex());
-                }
-                tryToAddWrongProp(propositions, frac(a, b).toTex());
-                tryToAddWrongProp(propositions, substract(a, b).toTex());
-                tryToAddWrongProp(propositions, add(a, b).toTex());
-                break;
-            case "Quotient":
-                if (coinFlip()) {
-                    addValidProp(propositions, answer);
-                }
-                else {
-                    addValidProp(propositions, divide(a, b).toTex());
-                }
-                tryToAddWrongProp(propositions, frac(b, a).toTex());
-                tryToAddWrongProp(propositions, substract(a, b).toTex());
-                tryToAddWrongProp(propositions, multiply(a, b).toTex());
-                break;
-        }
+            }
+            else {
+                addValidProp(propositions, add(b, a).toTex());
+            }
+            tryToAddWrongProp(propositions, multiply(a, b).toTex());
+            tryToAddWrongProp(propositions, substract(a, b).toTex());
+            tryToAddWrongProp(propositions, frac(a, b).toTex());
+            break;
+        case "subtract":
+            addValidProp(propositions, answer);
+            tryToAddWrongProp(propositions, substract(b, a).toTex());
+            tryToAddWrongProp(propositions, frac(a, b).toTex());
+            tryToAddWrongProp(propositions, frac(b, a).toTex());
+            break;
+        case "multiply":
+            if (coinFlip()) {
+                addValidProp(propositions, answer);
+            }
+            else {
+                addValidProp(propositions, multiply(b, a).toTex());
+            }
+            tryToAddWrongProp(propositions, frac(a, b).toTex());
+            tryToAddWrongProp(propositions, substract(a, b).toTex());
+            tryToAddWrongProp(propositions, add(a, b).toTex());
+            break;
+        case "divide":
+            if (coinFlip()) {
+                addValidProp(propositions, answer);
+            }
+            else {
+                addValidProp(propositions, divide(a, b).toTex());
+            }
+            tryToAddWrongProp(propositions, frac(b, a).toTex());
+            tryToAddWrongProp(propositions, substract(a, b).toTex());
+            tryToAddWrongProp(propositions, multiply(a, b).toTex());
+            break;
     }
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    const { operation, isUsingFrenchFactorNouns } = identifiers;
-    const node = getNodeFromOperation(operation).simplify();
+    const node = ExpressionConstructor.fromIdentifiers(identifiers).node.simplify();
     return node.toTex();
 };
 const getInstruction = (identifiers) => {
-    const statementString = buildFrenchString(identifiers);
+    const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
     return `Écrire l'expression littérale pour : 
 
 ${statementString}
 `;
 };
 const getHint = (identifiers) => {
-    const { operation } = identifiers;
-    switch (operation.operator.outputName) {
-        case "Opposite":
-            //return `L'opposé de $ ${"a".toTree().toTex()} $, c'est $ ${(0).frenchify()} $ moins $ ${"a".toTree().toTex()} $ (l'0pposé)`
-            return `L'opposé d'un nombre $x$ est $-x$.`;
-        case "Inverse":
-            //return `L'inverse de $ ${"a".toTree().toTex()} $, c'est $ ${(1).frenchify()} $ sur $ ${"a".toTree().toTex()} $ (l'1verse)`
-            return `L'inverse d'un nombre $x$ (différent de $0$) est $\\frac{1}{x}$.`;
-        case "Sum":
-            return `La somme est le résultat de l'addition de deux nombres ($ + $).`;
-        case "Difference":
-            return `La différence est le résultat de la soustraction d'un nombre à un autre ($ - $).`;
-        case "Product":
-            return `Le produit est le résultat de la multiplication de deux nombres ($ \\times $).`;
-        case "Quotient":
-            return `Le quotient est le résultat de la division d'un nombre par un autre ($ \\div $).`;
+    const { operatorName } = identifiers;
+    switch (operatorName) {
+        case "opposite":
+            return `La somme d'un nombre et de son opposé donne $0$.`;
+        case "inverse":
+            return `L'inverse de $8$ est $0,25$.`;
+        case "add":
+            return `La somme de $8$ et de $6$ est $14$.`;
+        case "subtract":
+            return `La différence entre $8$ et $6$ est $2$.`;
+        case "multiply": {
+            const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
+            if (!statementString.includes("produit")) {
+                const bHint = randint(2, 10, typeof identifiers.b === "number" ? [identifiers.b] : []);
+                const exprHint1 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    b: "" + bHint,
+                }));
+                const exprHint2 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    b: bHint,
+                }));
+                return `${capitalize(exprHint1.strFrench)} est $${exprHint2.node
+                    .simplify()
+                    .toTex()}$.`;
+            }
+            else {
+                return `Le produit de $8$ par $6$ est $48$.`;
+            }
+        }
+        case "divide": {
+            const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
+            if (!statementString.includes("quotient")) {
+                const aHint = randint(2, 10, typeof identifiers.a === "number" ? [identifiers.a] : []);
+                const exprHint1 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    a: "" + aHint,
+                }));
+                const exprHint2 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    a: aHint,
+                }));
+                return `${capitalize(exprHint1.strFrench)} est $${exprHint2.node.toTex()}$.`;
+            }
+            else {
+                return `Le quotient de $200$ par $8$ est $25$.`;
+            }
+        }
     }
 };
 const getCorrection = (identifiers) => {
-    const statementString = buildFrenchString(identifiers);
-    let outString = `${capitalize(statementString)} est $ ${getAnswer(identifiers)} $.`;
+    const { a, operatorName, b } = identifiers;
+    const expression = ExpressionConstructor.fromIdentifiers(identifiers);
+    const statementString = expression.strFrench;
     //explain rewriting if needed
-    const { operation, isUsingFrenchFactorNouns } = identifiers;
-    const node__raw = getNodeFromOperation(operation);
-    const node__refined = node__raw.simplify();
-    const tex__raw = node__raw.toTex({
-        allowDoubleMinus: true,
-        forceTimesSign: true,
-        forceParenthesis: true,
-        forceNoSimplification: true,
-        allowMinusAnywhereInFraction: true,
-    });
-    const tex__refined = node__refined.toTex();
-    if (tex__raw != tex__refined) {
+    const nodeRaw = expression.node;
+    const nodeRefined = nodeRaw.simplify();
+    let texRaw;
+    switch (operatorName) {
+        case "add":
+            {
+                const [texA, texB] = [a, b].map((c) => parseAlgebraic("" + c).toTex());
+                const isWrapWithParenthesis = ("" + b).startsWith("-");
+                texRaw = `${texA}+${isWrapWithParenthesis ? `(${texB})` : `${texB}`}`;
+            }
+            break;
+        default:
+            {
+                texRaw = nodeRaw.toTex({
+                    allowDoubleMinus: true,
+                    forceTimesSign: true,
+                    forceParenthesis: true,
+                    forceNoSimplification: true,
+                    allowMinusAnywhereInFraction: true,
+                });
+            }
+            break;
+    }
+    const texRefined = nodeRefined.toTex();
+    let outString = `${capitalize(statementString)} est $ ${texRefined} $.`;
+    if (texRaw !== texRefined) {
         outString += `
 
 En effet,
+
 $$
-${tex__raw}
+${texRaw}
 $$
+
 peut se réécrire :
+
 $$
-${tex__refined}
+${texRefined}
 $$
     `;
     }
     return outString;
 };
 const getKeys = (identifiers) => {
-    const { operation } = identifiers;
-    const arr_operands = [operation.operands.a];
-    if ("b" in operation.operands) {
-        arr_operands.push(operation.operands.b);
+    const { a, b } = identifiers;
+    const operands = [a];
+    if (b) {
+        operands.push(b);
     }
-    return arr_operands.filter(elt => typeof elt === "string").map(elt => elt);
+    return operands
+        .filter((elt) => typeof elt === "string")
+        .map((elt) => elt);
 };
 const isAnswerValid = (ans, { answer }) => {
     //return LitExpVEA(ans, answer);
     try {
         const parsed = parseAlgebraic(ans);
-        return (parsed
-            .simplify()
-            .toTex() === answer);
+        return parsed.simplify().toTex() === answer;
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
-const getWriteLitExprFromFrenchQuestion = (ops) => {
-    const operator = random(arr_operator);
+const getWriteLitExprFromFrenchQuestion = () => {
+    const operatorName = random(arrOperator);
     const isUsingFrenchFactorNouns = coinFlip();
-    const str__var = random(["x", "y", "z", "t"]);
+    const strVar = random(["x", "y", "z", "t"]);
     let a = "";
     let b = undefined;
     if (coinFlip()) {
-        a = str__var;
-        if (operator.outputName === "Quotient" && isUsingFrenchFactorNouns) {
-            const arr_fr = [2, 3, 4, 5, 10, 100, 1_000];
-            b = random([randint(-10, 21, [-1, 0, 1]), random(arr_fr)]);
+        a = strVar;
+        if (operatorName === "divide" && isUsingFrenchFactorNouns) {
+            const arrFr = [2, 3, 4, 5, 10, 100, 1_000];
+            b = random(arrFr);
         }
         else {
             b = randint(-10, 11, [-1, 0, 1]);
         }
     }
     else {
-        b = str__var;
-        if (operator.outputName === "Product" && isUsingFrenchFactorNouns) {
-            const arr_fr = [2, 3, 4, 5];
-            a = random([randint(-10, 21, [-1, 0, 1]), random(arr_fr)]);
+        b = strVar;
+        if (operatorName === "multiply" && isUsingFrenchFactorNouns) {
+            const arrFr = [2, 3, 4, 5];
+            a = random(arrFr);
         }
         else {
             a = randint(-10, 11, [-1, 0, 1]);
         }
     }
-    let operands;
-    switch (operator.arity) {
-        case 1:
-            operands = { a };
-            break;
-        case 2:
-            operands = { a, b };
-            break;
-    }
-    const operation = {
-        operator: operator,
-        operands: operands,
+    const identifiers = {
+        operatorName,
+        a,
+        b,
+        isUsingFrenchFactorNouns,
     };
-    const identifiers = { operation, isUsingFrenchFactorNouns };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getQuestionFromIdentifiers = (identifiers) => {
@@ -323,15 +305,15 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
-        answerFormat: 'tex',
+        answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
-        correction: getCorrection(identifiers)
+        correction: getCorrection(identifiers),
     };
 };
 export const writeLitExprFromFrench = {
-    id: 'writeLitExprFromFrench',
-    label: "Ecrire une expression littérale à partir d'une expression en français",
+    id: "writeLitExprFromFrench",
+    label: "Écrire une expression littérale à partir d'une expression en français",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getWriteLitExprFromFrenchQuestion(opts), nb),
     qcmTimer: 60,
@@ -344,5 +326,6 @@ export const writeLitExprFromFrench = {
     getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
-    hasHintAndCorrection: true
+    hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/conversion/index.d.ts

@@ -6,4 +6,8 @@ export * from "./volumeCapacityConversion.js";
 export * from "./volumeConversion.js";
 export * from "./hoursToDecimal.js";
 export * from "./hoursToSecond.js";
+export * from "./minutesToHours.js";
+export * from "./kmPerMinToKmPerHourConversion.js";
+export * from "./secondsToHours.js";
+export * from "./prefixToNumber.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

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

@@ -6,3 +6,7 @@ export * from "./volumeCapacityConversion.js";
 export * from "./volumeConversion.js";
 export * from "./hoursToDecimal.js";
 export * from "./hoursToSecond.js";
+export * from "./minutesToHours.js";
+export * from "./kmPerMinToKmPerHourConversion.js";
+export * from "./secondsToHours.js";
+export * from "./prefixToNumber.js";

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    distance: number;
+    minutes: number;
+};
+type Options = {
+    unitTex: string;
+};
+export declare const kmPerMinToKmPerHourConversion: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=kmPerMinToKmPerHourConversion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kmPerMinToKmPerHourConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/kmPerMinToKmPerHourConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA2IF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgBF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqBxE,CAAC"}