math-exercises 3.0.199 → 3.0.200

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfPowEK.js

@@ -0,0 +1,231 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { facto } from "../../../../tree/nodes/functions/factorialNode.js";
+const randomDiscreteSetIdsAndDescription = () => {
+    return probaLawFlip([
+        [
+            (() => {
+                const nbElements = randint(2, 5);
+                const arrLetter = shuffle(["a", "b", "c", "d"]).slice(0, nbElements);
+                const arrNode = arrLetter.map((letter) => new VariableNode(letter));
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble $${discreteSetNodeToTex(nodeSetE)}$`,
+                };
+            })(),
+            0.3,
+        ],
+        [
+            (() => {
+                const nbElements = randint(2, 6);
+                const arrNumber = randomMany([...Array(9).keys()].map((i) => i + 1), nbElements);
+                const arrNode = shuffle(arrNumber.map((v) => v.toTree()));
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble $${discreteSetNodeToTex(nodeSetE)}$`,
+                };
+            })(),
+            0.3,
+        ],
+        [
+            (() => {
+                const [boundLowRaw, boundHighRaw] = [randint(2, 8), randint(13, 19)];
+                const [isBoundLowIncluded, isBoundHighIncluded] = [0, 1].map(() => coinFlip());
+                const boundLow = boundLowRaw + (isBoundLowIncluded ? 0 : 1);
+                const boundHigh = boundHighRaw + (isBoundHighIncluded ? 0 : -1);
+                const arrNumber = [...Array(boundHigh - boundLow).keys()].map((i) => i + boundLow);
+                const arrNode = arrNumber.map((v) => v.toTree());
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble des entiers compris entre $${boundLow}$ ${isBoundLowIncluded ? "inclus" : "exclu"} et $${boundHigh}$ ${isBoundHighIncluded ? "inclus" : "exclu"}`,
+                };
+            })(),
+            0.2,
+        ],
+        [
+            (() => {
+                const isFilterEven = coinFlip();
+                const [boundLowRaw, boundHighRaw] = [randint(2, 8), randint(13, 19)];
+                const [isBoundLowIncluded, isBoundHighIncluded] = [0, 1].map(() => coinFlip());
+                const boundLow = boundLowRaw + (isBoundLowIncluded ? 0 : 1);
+                const boundHigh = boundHighRaw + (isBoundHighIncluded ? 0 : -1);
+                const arrNumber = [...Array(boundHigh - boundLow).keys()]
+                    .map((i) => i + boundLow)
+                    .filter((v) => (isFilterEven ? v % 2 === 0 : v % 2 === 1));
+                const arrNode = arrNumber.map((v) => v.toTree());
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble des entiers ${isFilterEven ? "pairs" : "impairs"} compris entre $${boundLow}$ ${isBoundLowIncluded ? "inclus" : "exclu"} et $${boundHigh}$ ${isBoundHighIncluded ? "inclus" : "exclu"}`,
+                };
+            })(),
+            0.2,
+        ],
+    ]);
+};
+/*
+  This toTex() function supports discreteSetNodes with variableNodes inside (this won't create unknown command \\lbracem if m is the first element)
+*/
+const discreteSetNodeToTex = (discreteSetNode) => {
+    return `\\lbrace ${discreteSetNode.elements
+        .map((el) => el.toTex())
+        .join(";")} \\rbrace`;
+};
+const getInstruction = (identifiers) => {
+    const { strDescriptionE, k } = identifiers;
+    return `Soit $E$ ${strDescriptionE}.
+Donner le nombre de $${k}$-uplets d'éléments de E.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    return power(nodeSetE.elements.length, k);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { k } = identifiers;
+    return `Pour prendre un $${k}$-uplet au hasard, tu peux effectuer $${k}$ tirages avec remise d'un élement de $E$.
+Combien y a-t-il d'issues pour un tirage ?
+Combien y a-t-il de séquences différentes de $${k}$ tirages ?`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const nbElements = nodeSetE.elements.length;
+    return `
+$$
+E = ${discreteSetNodeToTex(nodeSetE)}
+$$
+
+$E$ comporte $${nbElements}$ éléments.
+
+Si on prend un $${k}$-uplet au hasard,
+il y a $${nbElements}$ possibilités pour la première composante,
+il y a $${nbElements}$ possibilités pour la deuxième composante,
+etc.
+
+Le nombre de $${k}$-uplets d'éléments de $E$ est $${getAnswer(identifiers)}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const nbElements = nodeSetE.elements.length;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: k^card(E)
+    {
+        const node = power(k, nbElements);
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: nb of k-uples of distinct elements of E
+    {
+        if (k <= nbElements) {
+            const node = [...Array(k).keys()]
+                .map((i) => i + (nbElements - k + 1))
+                .toReversed()
+                .map((v) => v.toTree())
+                .reduce((acc, x) => multiply(acc, x));
+            tryToAddWrongProp(propositions, node.toTex());
+        }
+    }
+    //student: k * card(E)
+    {
+        const node = multiply(k, nbElements);
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: (k*card(E))!
+    {
+        const node = facto(multiply(k, nbElements));
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsSetE } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const arrVarNode = nodeSetE.elements.filter((node) => isVariableNode(node));
+    return [
+        "semicolon",
+        "lbrace", //pas gentil
+        "rbrace", //pas gentil
+        ...arrVarNode.map((varNode) => {
+            const tex = varNode.toTex();
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const isAnswerValid = (ans, { answer, ..._identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getFindCardinalOfPowEKQuestion = () => {
+    const k = randint(3, 6);
+    const dict = randomDiscreteSetIdsAndDescription();
+    const nodeSetE = NodeConstructor.fromIdentifiers(dict.nodeIdsSetE);
+    const identifiers = {
+        strDescriptionE: dict.strDescriptionE,
+        nodeIdsSetE: nodeSetE.toIdentifiers(),
+        k,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findCardinalOfPowEK = {
+    id: "findCardinalOfPowEK",
+    connector: "=",
+    isSingleStep: true,
+    label: "Un ensemble $E$ étant donné, donner le nombre de $k$-uplets d'éléments de $E$",
+    generator: (nb) => getDistinctQuestions(getFindCardinalOfPowEKQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/cartesianProduct/findNumberOfPasswordsWithLettersAndNumbers.d.ts

@@ -0,0 +1,19 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Situation = {
+    strInstruction: string;
+    strCorrection: string;
+    arrSets: {
+        cardinal: number;
+        nbSamples: number;
+        strInjected: string;
+        strExplain: string;
+    }[];
+    nodeIdsCardinal: NodeIdentifiers;
+};
+type Identifiers = {
+    situation: Situation;
+};
+export declare const findNumberOfPasswordsWithLettersAndNumbers: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findNumberOfPasswordsWithLettersAndNumbers.d.ts.map

package/lib/exercises/math/sets/cartesianProduct/findNumberOfPasswordsWithLettersAndNumbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findNumberOfPasswordsWithLettersAndNumbers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/findNumberOfPasswordsWithLettersAndNumbers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4E7C,KAAK,SAAS,GAAG;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE;QACP,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;KACpB,EAAE,CAAC;IACJ,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AA+DF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AA2IF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAmB1E,CAAC"}

package/lib/exercises/math/sets/cartesianProduct/findNumberOfPasswordsWithLettersAndNumbers.js

@@ -0,0 +1,187 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+const situationTemplates = [
+    {
+        strInstruction: "Combien existe-t-il de mots de passe constitués de ${req1} puis de ${req2} ?",
+        strCorrection: `\${req1.explain} 
+\${req2.explain}
+Le nombre de mots de passe différents est donc $\${cardinal}$.`,
+        dictFuncs: {
+            letters: (nbSamples) => {
+                const cardinal = 26;
+                return {
+                    cardinal,
+                    nbSamples,
+                    strInjected: `$${nbSamples}$ lettres`,
+                    strExplain: `Il y a $${cardinal}$ lettres possibles.`,
+                };
+            },
+            digits: (nbSamples) => {
+                const cardinal = 10;
+                return {
+                    cardinal,
+                    nbSamples,
+                    strInjected: `$${nbSamples}$ chiffres`,
+                    strExplain: `Il y a $${cardinal}$ chiffres possibles (${joinanded("0123456789".split("").map((str) => `$${str}$`), ", ", " et ")}).`,
+                };
+            },
+            special: (nbSamples) => {
+                const pool = ["!", "@", "*", "&", "?"];
+                const cardinal = randint(3, pool.length + 1);
+                const arrStr = randomMany(pool, cardinal);
+                return {
+                    cardinal,
+                    nbSamples,
+                    strInjected: `$${nbSamples}$ caractères spéciaux (on se limite aux caractères ${joinanded(arrStr, " ", " ")})`,
+                    strExplain: `Il y a $${cardinal}$ caractères spéciaux possibles.`,
+                };
+            },
+        },
+    },
+];
+class SituationConstructor {
+    static randomSituationFromTemplate(situationTemplate) {
+        const arrNb = [randint(3, 8), randint(3, 8)];
+        const arrSets = zip(arrNb, shuffle(Object.values(situationTemplate.dictFuncs)).slice(arrNb.length - 1)).map(([nb, func]) => func(nb));
+        const { strInstruction, strCorrection: strCorrectionIncomplete, nodeCardinal, nodeCardinalExpanded, } = arrSets.reduce((acc, miniDict, i) => {
+            const index = i + 1;
+            acc.strInstruction = acc.strInstruction.replace(`\${req${index}}`, miniDict.strInjected);
+            acc.strCorrection = acc.strCorrection.replace(`\${req${index}.explain}`, miniDict.strExplain);
+            acc.nodeCardinal = acc.nodeCardinal
+                ? multiply(acc.nodeCardinal, power(miniDict.cardinal, miniDict.nbSamples))
+                : power(miniDict.cardinal, miniDict.nbSamples);
+            acc.nodeCardinalExpanded = acc.nodeCardinalExpanded
+                ? multiply(acc.nodeCardinalExpanded, power(miniDict.cardinal, miniDict.nbSamples).toMultiplyNode())
+                : power(miniDict.cardinal, miniDict.nbSamples).toMultiplyNode();
+            return acc;
+        }, {
+            strInstruction: situationTemplate.strInstruction,
+            strCorrection: situationTemplate.strCorrection,
+            nodeCardinal: undefined,
+            nodeCardinalExpanded: undefined,
+        });
+        const strCorrection = strCorrectionIncomplete.replace(`\${cardinal}`, `${nodeCardinalExpanded.toTex()} = ${nodeCardinal.toTex()}`);
+        return {
+            nodeIdsCardinal: nodeCardinal.toIdentifiers(),
+            strInstruction,
+            strCorrection,
+            arrSets,
+        };
+    }
+}
+const getInstruction = (identifiers) => {
+    const { situation: { strInstruction }, } = identifiers;
+    return strInstruction;
+};
+const getAnswerNode = (identifiers) => {
+    const { situation: { nodeIdsCardinal }, } = identifiers;
+    const nodeCardinal = NodeConstructor.fromIdentifiers(nodeIdsCardinal);
+    return nodeCardinal;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers)
+        .simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = () => {
+    return `Voici un exemple avec un mot de passe de longueur $3$ constitué uniquement avec les lettres a, b, c ou d.
+Il y a $4$ possibilités pour le premier caractère.
+Il y a $4$ possibilités pour le deuxième caractère.
+Il y a $4$ possibilités pour le troisième caractère.
+Il y a donc en tout $4 \\times 4 \\times 4 = 4^3$ mots de passe possibles.`;
+};
+const getCorrection = (identifiers) => {
+    const { situation: { strCorrection }, } = identifiers;
+    return strCorrection;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { situation: { arrSets }, } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: multiplies everything
+    {
+        const nodeWrong = arrSets.slice(1).reduce((acc, { cardinal, nbSamples }) => multiply(acc, multiply(cardinal, nbSamples)), (() => {
+            const { cardinal, nbSamples } = arrSets[0];
+            return multiply(cardinal, nbSamples);
+        })());
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: times+times+times
+    {
+        const nodeWrong = arrSets.slice(1).reduce((acc, { cardinal, nbSamples }) => add(acc, multiply(cardinal, nbSamples)), (() => {
+            const { cardinal, nbSamples } = arrSets[0];
+            return multiply(cardinal, nbSamples);
+        })());
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: pow+pow+pow
+    {
+        const nodeWrong = arrSets.slice(1).reduce((acc, { cardinal, nbSamples }) => add(acc, power(cardinal, nbSamples)), (() => {
+            const { cardinal, nbSamples } = arrSets[0];
+            return power(cardinal, nbSamples);
+        })());
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ..._identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaSub(nodeAns, nodeAnswer));
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getFindNumberOfPasswordsWithLettersAndNumbersQuestion = () => {
+    const situationTemplate = random(situationTemplates);
+    const situation = SituationConstructor.randomSituationFromTemplate(situationTemplate);
+    const identifiers = {
+        situation,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findNumberOfPasswordsWithLettersAndNumbers = {
+    id: "findNumberOfPasswordsWithLettersAndNumbers",
+    connector: "=",
+    isSingleStep: true,
+    label: "Déterminer le nombre de mots de passe possibles (avec $2$ types de caractères)",
+    generator: (nb) => getDistinctQuestions(getFindNumberOfPasswordsWithLettersAndNumbersQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/cartesianProduct/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./proposeElementInCartesianProductOfFiniteSets.js";
+export * from "./findCardinalOfCartesianProductOfFiniteSets.js";
+export * from "./findCardinalOfCartesianProductOfFiniteSetsFromSituation.js";
+export * from "./proposeElementInPowEK.js";
+export * from "./findCardinalOfPowEK.js";
+export * from "./findNumberOfPasswordsWithLettersAndNumbers.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sets/cartesianProduct/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC;AAClE,cAAc,iDAAiD,CAAC;AAChE,cAAc,8DAA8D,CAAC;AAC7E,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iDAAiD,CAAC"}

package/lib/exercises/math/sets/cartesianProduct/index.js

@@ -0,0 +1,6 @@
+export * from "./proposeElementInCartesianProductOfFiniteSets.js";
+export * from "./findCardinalOfCartesianProductOfFiniteSets.js";
+export * from "./findCardinalOfCartesianProductOfFiniteSetsFromSituation.js";
+export * from "./proposeElementInPowEK.js";
+export * from "./findCardinalOfPowEK.js";
+export * from "./findNumberOfPasswordsWithLettersAndNumbers.js";

package/lib/exercises/math/sets/cartesianProduct/proposeElementInCartesianProductOfFiniteSets.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Item = {
+    tex: string;
+    isValid: boolean;
+};
+type Identifiers = {
+    nodeIdsSetA: NodeIdentifiers;
+    nodeIdsSetB: NodeIdentifiers;
+    isAskedACrossB: boolean;
+    items: Item[];
+};
+export declare const proposeElementInCartesianProductOfFiniteSets: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=proposeElementInCartesianProductOfFiniteSets.d.ts.map

package/lib/exercises/math/sets/cartesianProduct/proposeElementInCartesianProductOfFiniteSets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposeElementInCartesianProductOfFiniteSets.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/proposeElementInCartesianProductOfFiniteSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA2B7C,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,eAAe,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwUF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAmB5E,CAAC"}