math-exercises 3.0.202 → 3.0.203

package/lib/exercises/math/sequences/proofByInduction/proofByInductionWritePropAtRankKPlus1.js

@@ -0,0 +1,265 @@
+import { tryToAddWrongProp, addValidProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { getArrProofByInductionSituationParams, getHydratedProofByInductionSituation, } from "./proofByInductionSituations.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getHydrated = (identifiers) => {
+    const { situationParams, isValid, indexForNodeProperty, nodeIdsVarStepDefinition, nodeIdsVarStepInduction, } = identifiers;
+    const situation = getHydratedProofByInductionSituation(situationParams);
+    const [nodeVarStepDefinition, nodeVarStepInduction] = [
+        nodeIdsVarStepDefinition,
+        nodeIdsVarStepInduction,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            const nodePropertyWithN = (isValid ? situation.arrNodeValid : situation.arrNodeInvalid)[indexForNodeProperty];
+            function createNodePropertySubstituted(nodeInjected) {
+                return nodeBySubstitutingVar(nodeBySubstitutingVar(nodePropertyWithN, nodeInjected, new VariableNode("n")), new VariableNode(`u_{${nodeInjected.toTex()}}`), new VariableNode("u_{n}"));
+            }
+            const [nodePropertyDefinition, nodePropertyDefinitionPlus1, nodePropertyInduction, nodePropertyInductionPlus1,] = [
+                nodeVarStepDefinition,
+                add(nodeVarStepDefinition, 1),
+                nodeVarStepInduction,
+                add(nodeVarStepInduction, 1),
+            ].map((node) => createNodePropertySubstituted(node));
+            return {
+                situation,
+                isValid,
+                nodeVarStepDefinition,
+                nodePropertyDefinition,
+                nodePropertyDefinitionPlus1,
+                nodeVarStepInduction,
+                nodePropertyInduction,
+                nodePropertyInductionPlus1,
+            };
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { situation, nodePropertyDefinition, nodeVarStepDefinition, nodeVarStepInduction, } = getHydrated(identifiers);
+    const { n0 } = situation;
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `${situation.strContext}
+
+Pour $${nodeVarStepDefinition.toTex()} \\geq ${n0}$, on note $\\mathcal{P}(${nodeVarStepDefinition.toTex()})$ la propriété : 
+
+$$
+\\mathcal{P}(${nodeVarStepDefinition.toTex()}) :\\ \\ ${nodePropertyDefinition.toTex()}  
+$$
+
+Soit $${nodeVarStepInduction.toTex()}$ un entier tel que $${nodeVarStepInduction.toTex()} \\geq ${n0}$.
+On suppose la propriété $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ vraie.
+
+Quelle est l'égalité qui correspond à la propriété $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$ ?
+`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getAnswer = (identifiers) => {
+    const { nodePropertyInductionPlus1 } = getHydrated(identifiers);
+    return nodePropertyInductionPlus1.toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsVarStepInduction } = identifiers;
+    const [nodeVarStepInduction] = [nodeIdsVarStepInduction].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Substitue $${nodeVarStepInduction.toTex()}$ par $${add(nodeVarStepInduction, 1).toTex()}$ dans l'égalité proposée.`;
+};
+const getCorrection = (identifiers) => {
+    const { situation, nodePropertyInductionPlus1, nodeVarStepInduction } = getHydrated(identifiers);
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `Pour vérifier que la propriété est héréditaire, 
+il faut démontrer que si on suppose $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ vraie alors $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$ est vraie.
+
+On s'intéresse donc à $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$,
+autrement dit à l'égalité : 
+
+$$
+${nodePropertyInductionPlus1.toTex()}
+$$
+
+`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodePropertyDefinition, nodePropertyDefinitionPlus1, nodePropertyInduction, nodePropertyInductionPlus1, } = getHydrated(identifiers);
+    tryToAddWrongProp(propositions, nodePropertyDefinitionPlus1.toTex());
+    const [arrLhs, arrRhs] = [0, 1].map((i) => [
+        nodePropertyDefinition,
+        nodePropertyInduction,
+        nodePropertyInductionPlus1,
+        nodePropertyDefinitionPlus1,
+    ].map((equalNode) => i === 0 ? equalNode.leftChild : equalNode.rightChild));
+    const arrEqualNode = shuffle(getCartesiansProducts([arrLhs, arrRhs]).map(([nodeLhs, nodeRhs]) => new EqualNode(nodeLhs, nodeRhs)));
+    propWhile(propositions, n, () => {
+        const equalNodeWrong = arrEqualNode.pop();
+        tryToAddWrongProp(propositions, equalNodeWrong.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsVarStepDefinition, nodeIdsVarStepInduction } = identifiers;
+    const [nodeVarStepDefinition, nodeVarStepInduction] = [
+        nodeIdsVarStepDefinition,
+        nodeIdsVarStepInduction,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrLetter = [nodeVarStepDefinition, nodeVarStepInduction].map((nodeVar) => nodeVar.name);
+    return ["u", ...arrLetter, "underscore", "equal"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
+        const nodeAnswer = getHydrated(identifiers)
+            .nodePropertyInductionPlus1;
+        if (!ans.includes("=")) {
+            // return false;
+            ans = nodeAnswer.leftChild.toTex() + "=" + ans;
+        }
+        // const nodeAns = parseAlgebraic(ans);
+        const nodeAns = (() => {
+            const [lhs, rhs] = ans.split("=");
+            const nodeLhs = lhs.toTree();
+            const nodeRhs = parseAlgebraic(rhs);
+            return new EqualNode(nodeLhs, nodeRhs);
+        })();
+        if (!isEqualNode(nodeAns)) {
+            return false;
+        }
+        const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
+        const isValidRhs = () => {
+            const nodeAnsRhs = nodeAns.rightChild;
+            const nodeAnswerRhs = nodeAnswer.rightChild;
+            const { nodeIdsVarStepInduction } = identifiers;
+            const [nodeVarStepInduction] = [nodeIdsVarStepInduction].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            return NodeComparator.isEqualViaRandomEvaluations(nodeAnsRhs, nodeAnswerRhs, 3, 6, nodeVarStepInduction, () => randint(0, 20));
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = () => {
+    const [situationParams] = getArrProofByInductionSituationParams([
+        "generalFormulaOfArithmeticoGeometricSequence",
+    ]);
+    const situation = getHydratedProofByInductionSituation(situationParams);
+    const [isValid, indexForNodeProperty] = (() => {
+        switch (situation.id) {
+            case "generalFormulaOfArithmeticoGeometricSequence": {
+                const isValid = coinFlip();
+                const indexForNodeProperty = randint(0, isValid
+                    ? situation.arrNodeValid.length
+                    : situation.arrNodeInvalid.length);
+                return [isValid, indexForNodeProperty];
+            }
+            default:
+                throw new Error("Unsupported situation.id: " + situation.id);
+        }
+    })();
+    const [nodeVarStepDefinition, nodeVarStepInduction] = randomMany(["n", "k", "p", "m"], 2).map((letter) => new VariableNode(letter));
+    const identifiers = {
+        situationParams,
+        isValid,
+        indexForNodeProperty,
+        nodeIdsVarStepDefinition: nodeVarStepDefinition.toIdentifiers(),
+        nodeIdsVarStepInduction: nodeVarStepInduction.toIdentifiers(),
+    };
+    return identifiers;
+};
+// const isIdentifiersQCPassed = (identifiers: Identifiers) => {
+//   const isExploding = (identifiers: Identifiers) => {
+//     let isExploding = false;
+//     try {
+//       getAnswer(identifiers);
+//     } catch (_) {
+//       isExploding = true;
+//     }
+//     return isExploding;
+//   };
+//   return !isExploding(identifiers);
+// };
+// const createQCPassedIdentifiers = () => {
+//   let identifiers: Identifiers;
+//   let counter = -1;
+//   let isValid = false;
+//   while (!isValid && counter < 100) {
+//     counter++;
+//     const identifiersCandidate = createRandomIdentifiers();
+//     isValid = isIdentifiersQCPassed(identifiersCandidate);
+//     if (isValid) {
+//       identifiers = identifiersCandidate;
+//     }
+//   }
+//   if (!isValid) {
+//     const [situationParams] = getArrProofByInductionSituationParams([
+//       "generalFormulaOfArithmeticoGeometricSequence",
+//     ]);
+//     const [nodeVarStepDefinition, nodeVarStepInduction] = randomMany(
+//       ["n", "k", "p", "m"],
+//       2,
+//     ).map((letter) => new VariableNode(letter));
+//     const identifiersDefault: Identifiers = (() => {
+//       return {
+//         situationParams,
+//         isValid: true,
+//         indexForNodeProperty: 0,
+//         nodeIdsVarStepDefinition: nodeVarStepDefinition.toIdentifiers(),
+//         nodeIdsVarStepInduction: nodeVarStepInduction.toIdentifiers(),
+//       };
+//     })();
+//     identifiers = identifiersDefault;
+//   }
+//   return identifiers!;
+// };
+const getProofByInductionWritePropAtRankKPlus1Question = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const proofByInductionWritePropAtRankKPlus1 = {
+    id: "proofByInductionWritePropAtRankKPlus1",
+    connector: "=",
+    label: "Hérédité : Écrire au rang $k+1$ une propriété donnée au rang $k$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProofByInductionWritePropAtRankKPlus1Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/vea/polynomialVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/polynomialVEA.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,YAmBxD,CAAC"}
+{"version":3,"file":"polynomialVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/polynomialVEA.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,YAuBxD,CAAC"}

package/lib/exercises/vea/polynomialVEA.js

@@ -1,11 +1,15 @@
 import { getArrNodeCoeffOfPolynomialNode } from "../../math/utils/polynomial/polynomialUtils.js";
 import { substract } from "../../tree/nodes/operators/substractNode.js";
+import { isIDontKnowNode } from "../../tree/nodes/student/iDontKnowNode.js";
 import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
 import { zip } from "../../utils/arrays/arrayZip.js";
 import { handleVEAError } from "../../utils/errors/handleVEAError.js";
 export const polynomialVEA = (ans, answer) => {
     try {
         const nodeAns = parseAlgebraic(ans);
+        if (isIDontKnowNode(nodeAns)) {
+            return false;
+        }
         const nodeAnswer = parseAlgebraic(answer);
         const [arrNodeCoeffAns, arrNodeCoeffAnswer] = [nodeAns, nodeAnswer].map((node) => getArrNodeCoeffOfPolynomialNode(node));
         return (arrNodeCoeffAns.length === arrNodeCoeffAnswer.length &&

package/lib/index.d.ts

@@ -2857,6 +2857,20 @@ declare const mathExercises: (Exercise<{
     doubleAngle: number;
     singleAngle: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    isParallel: boolean;
+    angleType: "alternes-internes" | "correspondants" | "alternes-externes" | "autres";
+    arrIntersectionIds: {
+        center: import("./math/geometry/point.js").PointIdentifiers;
+        lineH: import("./math/geometry/line.js").LineIdentifiers;
+        lineV: import("./math/geometry/line.js").LineIdentifiers;
+    }[];
+    arrAngleIndex: number[];
+    arrAngleForLabel: number[] | undefined;
+}, {
+    angleTypes: ("alternes-internes" | "correspondants" | "alternes-externes" | "autres")[];
+    isFakeDisplay: boolean;
+    nbDigits: "0" | "1" | "2";
+}> | Exercise<{
     lines: {
         pointA: number[];
         pointB: number[];
@@ -3014,19 +3028,6 @@ declare const mathExercises: (Exercise<{
     limitTo: "+\\infty" | "-\\infty";
     numCoeffs: number[];
     denumCoeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    reason: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    firstTerm: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    coeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    coeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    polyNumCoeffs: number[];
-    polyDenumCoeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    numCoeffs: number[];
-    denumCoeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     type: number;
     to: string;
@@ -3048,6 +3049,19 @@ declare const mathExercises: (Exercise<{
     nodeIdsLimitAbscissa: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsP: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isPossible: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    reason: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    firstTerm: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    coeffs: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    coeffs: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    polyNumCoeffs: number[];
+    polyDenumCoeffs: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    numCoeffs: number[];
+    denumCoeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: string;
     b: string;
@@ -4100,6 +4114,28 @@ declare const mathExercises: (Exercise<{
     type: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coeffs: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationParams: import("./exercises/math/sequences/proofByInduction/proofByInductionSituations.js").ProofByInductionSituationParams;
+    isValid: boolean;
+    indexForNodeProperty: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationParams: import("./exercises/math/sequences/proofByInduction/proofByInductionSituations.js").ProofByInductionSituationParams;
+    isValid: boolean;
+    indexForNodeProperty: number;
+    nodeIdsVarStepDefinition: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsVarStepInduction: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationParams: import("./exercises/math/sequences/proofByInduction/proofByInductionSituations.js").ProofByInductionSituationParams;
+    isValid: boolean;
+    indexForNodeProperty: number;
+    nodeIdsVarStepDefinition: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsVarStepInduction: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationParams: import("./exercises/math/sequences/proofByInduction/proofByInductionSituations.js").ProofByInductionSituationParams;
+    isValid: boolean;
+    indexForNodeProperty: number;
+    nodeIdsVarStepDefinition: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsVarStepInduction: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     intervalIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"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"}

package/lib/math/geometry/point.js

@@ -160,7 +160,7 @@ export class Point {
     }
     toGGBCommand({ isFixed = true, isSelectionnable = false, showLabel = true, style, size, color, label, isVisible = true, } = {}) {
         const commands = [
-            `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()})`,
+            `${this.name} = Point({${this.x.toMathString()}, ${this.y.toMathString()}})`,
             `SetFixed(${this.name},${isFixed ? "true" : "false"},${isSelectionnable ? "true" : "false"})`,
             `ShowLabel(${this.name},${showLabel ? "true" : "false"})`,
         ];

package/lib/math/utils/functions/functionDecomposition.d.ts

@@ -4,7 +4,7 @@ export declare const functionDecompositions: (node: AlgebraicNode, variableNode?
     nodeU: AlgebraicNode;
     nodeV: AlgebraicNode;
 }[];
-export declare const nodeBySubstitutingX: (node: AlgebraicNode, strVar: string) => AlgebraicNode;
-export declare function composeNodes(nodeU: AlgebraicNode, nodeV: AlgebraicNode): AlgebraicNode;
+export declare const nodeBySubstitutingX: (node: AlgebraicNode, strVar: string) => AlgebraicNode | import("../../../tree/nodes/student/iDontKnowNode.js").IDontKnowNode;
+export declare function composeNodes(nodeU: AlgebraicNode, nodeV: AlgebraicNode): AlgebraicNode | import("../../../tree/nodes/student/iDontKnowNode.js").IDontKnowNode;
 export declare function isContainingFacetiousFrac(node: AlgebraicNode): boolean;
 //# sourceMappingURL=functionDecomposition.d.ts.map

package/lib/math/utils/functions/functionDecomposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionDecomposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionDecomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAYlE,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAcpD,eAAO,MAAM,sBAAsB,GACjC,MAAM,aAAa,EACnB,eAAc,YAA2C;WAElC,aAAa;WAAS,aAAa;GAyO3D,CAAC;AAqEF,eAAO,MAAM,mBAAmB,GAAI,MAAM,aAAa,EAAE,QAAQ,MAAM,kBAItE,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,iBAMtE;AAMD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAmBtE"}
+{"version":3,"file":"functionDecomposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionDecomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAYlE,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAcpD,eAAO,MAAM,sBAAsB,GACjC,MAAM,aAAa,EACnB,eAAc,YAA2C;WAElC,aAAa;WAAS,aAAa;GAyO3D,CAAC;AAqEF,eAAO,MAAM,mBAAmB,GAAI,MAAM,aAAa,EAAE,QAAQ,MAAM,yFAItE,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,wFAMtE;AAMD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAmBtE"}

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,EAAuB,MAAM,6BAA6B,CAAC;AAI5E,eAAO,MAAM,OAAO,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC;;;;CA+H5C,CAAC"}
+{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAuB,MAAM,6BAA6B,CAAC;AAI5E,eAAO,MAAM,OAAO,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC;;;;CA4H5C,CAAC"}

package/lib/tests/exoTest.js

@@ -32,16 +32,11 @@ export const exoTest = (exo) => {
     const questions = exo.generator(30);
     const after = Date.now();
     generatorTime = after - before;
-    if (exo.answerType !== "free" &&
-        exo.answerType !== "GGB" &&
-        exo.answerType !== "valueTable" &&
-        exo.answerType !== "varTable" &&
-        exo.answerType !== "signTable" &&
-        exo.answerType !== "treeDiagram" &&
-        exo.answerType !== "signVarTable") {
-        if (!exo.getPropositions)
-            throw new Error(`exo ${exo.id} has no getPropositions`);
-    }
+    if ((exo.answerType === "QCU" || exo.answerType === "QCM") &&
+        !exo.getPropositions)
+        throw new Error(`exo ${exo.id} has no getPropositions`);
+    if (exo.answerType === "reorder" && !exo.getOrderedItems)
+        throw new Error(`exo ${exo.id} has no getOrderedItems`);
     if (exo.answerType !== "QCM" &&
         exo.answerType !== "QCU" &&
         exo.answerType !== "GGB" &&
@@ -49,7 +44,8 @@ export const exoTest = (exo) => {
         exo.answerType !== "varTable" &&
         exo.answerType !== "signTable" &&
         exo.answerType !== "treeDiagram" &&
-        exo.answerType !== "signVarTable") {
+        exo.answerType !== "signVarTable" &&
+        exo.answerType !== "reorder") {
         if (!exo.isAnswerValid)
             throw new Error(`exo ${exo.id} has no isAnswerValid`);
     }

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;AA0BjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAuV3B,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;AA0BjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CA6V3B,CAAC"}

package/lib/tests/questionTest.js

@@ -106,7 +106,9 @@ export const questionTest = (exo, question) => {
         if (!question.initTreeTable.some((stage) => stage.some((block) => block.some((branch) => branch.some((cell) => cell === "")))))
             throw new Error(`exo ${exo.id} is answertype treeDiagram but no input in treeTable`);
     }
-    else if (exo.answerType !== "QCU" && exo.answerType !== "QCM") {
+    else if (exo.answerType !== "QCU" &&
+        exo.answerType !== "QCM" &&
+        exo.answerType !== "reorder") {
         if (!question.answer)
             throw new Error(`exo ${exo.id} has no answer`);
     }
@@ -198,7 +200,8 @@ export const questionTest = (exo, question) => {
         exo.answerType !== "signTable" &&
         exo.answerType !== "varTable" &&
         exo.answerType !== "signVarTable" &&
-        exo.answerType !== "treeDiagram") {
+        exo.answerType !== "treeDiagram" &&
+        exo.answerType !== "reorder") {
         if (!question.keys)
             throw new Error(`exo ${exo.id} has no keys`);
         const answer = question.answer;
@@ -219,7 +222,8 @@ export const questionTest = (exo, question) => {
         exo.answerType !== "varTable" &&
         exo.answerType !== "signTable" &&
         exo.answerType !== "signVarTable" &&
-        exo.answerType !== "treeDiagram") {
+        exo.answerType !== "treeDiagram" &&
+        exo.answerType !== "reorder") {
         if (exo.answerType === "QCM" && !exo.isQCM)
             throw new Error("exo " + exo.id + " has answerType QCM but not isQCM");
         const before = Date.now();

package/lib/tests/singleExo.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"singleExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/singleExo.test.ts"],"names":[],"mappings":"AAGA,OAAO,6BAA6B,CAAC"}
+{"version":3,"file":"singleExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/singleExo.test.ts"],"names":[],"mappings":"AAEA,OAAO,6BAA6B,CAAC"}

package/lib/tests/singleExo.test.js

@@ -1,9 +1,9 @@
 import "../prototypesEnhancement.js";
 import { exoTest } from "./exoTest.js";
-import { problemMaximizeProfitFindProduction, } from "../exercises/math/index.js";
+import { proofByInductionCheckInitialization, } from "../exercises/math/index.js";
 try {
     for (let i = 0; i < 1000; i++)
-        exoTest(problemMaximizeProfitFindProduction);
+        exoTest(proofByInductionCheckInitialization);
 }
 catch (err) {
     throw err;

package/lib/tree/nodes/node.d.ts

@@ -14,7 +14,8 @@ export declare enum NodeType {
     trinom = 12,
     monom = 13,
     complex = 14,
-    notequality = 15
+    notequality = 15,
+    iDontKnow = 16
 }
 export type NodeOptions = {
     forceTimesSign?: boolean;

package/lib/tree/nodes/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"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"}

package/lib/tree/nodes/node.js

@@ -18,6 +18,7 @@ export var NodeType;
     NodeType[NodeType["monom"] = 13] = "monom";
     NodeType[NodeType["complex"] = 14] = "complex";
     NodeType[NodeType["notequality"] = 15] = "notequality";
+    NodeType[NodeType["iDontKnow"] = 16] = "iDontKnow";
 })(NodeType || (NodeType = {}));
 //toujours ajouter les ids en fin de liste (youpi c'est vmt hyper bien codé)
 export var NodeIds;

package/lib/tree/nodes/student/iDontKnowNode.d.ts

@@ -0,0 +1,26 @@
+import { Node, NodeIds, NodeType } from "../node.js";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
+export declare function isIDontKnowNode(a: Node): a is IDontKnowNode;
+export declare class IDontKnowNode implements AlgebraicNode {
+    tex: string;
+    type: NodeType;
+    isNumeric: boolean;
+    constructor(tex: string);
+    static keyword(): string;
+    toMathString(): string;
+    toTex(): string;
+    toAllValidTexs(): string[];
+    toIdentifiers(): {
+        id: NodeIds;
+        tex: string;
+    };
+    toEquivalentNodes(): this[];
+    evaluate(): number;
+    simplify(_opts?: SimplifyOptions): this;
+    toSimplificationTex(opts?: SimplifyOptions): string;
+    equals(node: AlgebraicNode): boolean;
+    toDetailedEvaluation(vars: Record<string, AlgebraicNode>): AlgebraicNode;
+    derivative(): this;
+    toSignInequationTex(): string;
+}
+//# sourceMappingURL=iDontKnowNode.d.ts.map

package/lib/tree/nodes/student/iDontKnowNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iDontKnowNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/student/iDontKnowNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAErE,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,qBAAa,aAAc,YAAW,aAAa;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,GAAG,EAAE,MAAM;IAMvB,MAAM,CAAC,OAAO;IAId,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAMf,cAAc;IAGd,aAAa;;;;IAMb,iBAAiB;IAGjB,QAAQ;IAGR,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe;IAGhC,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;IAK1C,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAIxD,UAAU;IAGV,mBAAmB;CAGpB"}