math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.js

@@ -0,0 +1,505 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode, createNodeFTrinomFromPoints, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { IntegralNode } from "../../../../tree/nodes/functions/integralNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsG, nodeIdsBounds } = identifiers;
+    const [nodeF, nodeG, nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+        nodeIdsF,
+        nodeIdsG,
+        ...nodeIdsBounds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodePrimitiveOfF, nodePrimitiveOfG] = [nodeF, nodeG].map((node) => createIntegratedPolynomialNode(node, (0).toTree()));
+    const [nodeIntegralF, nodeIntegralG] = [nodeF, nodeG].map((node) => new IntegralNode(node, nodeIntegralBoundLow, nodeIntegralBoundHigh, "x"));
+    const nodeVarX = new VariableNode("x");
+    const [nodeIntegralAsSubF, nodeIntegralAsSubG] = [
+        nodePrimitiveOfF,
+        nodePrimitiveOfG,
+    ].map((nodePrimitive) => substract(nodeBySubstitutingVar(nodePrimitive, nodeIntegralBoundHigh, nodeVarX).simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    }), nodeBySubstitutingVar(nodePrimitive, nodeIntegralBoundLow, nodeVarX).simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    })));
+    const nodeAreaBetweenCurves = substract(nodeIntegralAsSubG, nodeIntegralAsSubF);
+    return {
+        nodeF,
+        nodeG,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        nodePrimitiveOfF,
+        nodePrimitiveOfG,
+        nodeIntegralF,
+        nodeIntegralAsSubF,
+        nodeIntegralG,
+        nodeIntegralAsSubG,
+        nodeAreaBetweenCurves,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF, nodeIdsG } = identifiers;
+    const [nodeF, nodeG] = [nodeIdsF, nodeIdsG].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Sur le graphique ci-dessous on a représenté les fonctions $f$ et $g$ définies sur $\\mathbb{R}$ par :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+$$
+g(x) = ${nodeG.toTex()}
+$$
+
+Donner l'aire du domaine coloré sur la figure ci-dessous.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeAreaBetweenCurves } = getHydrated(identifiers);
+    return nodeAreaBetweenCurves
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    })
+        .toTex();
+};
+const getHint = () => {
+    return `Soit $u$ et $v$ deux fonctions continues sur un intervalle de réels $[a;b]$ et telles que :
+
+Pour tout $x$ dans $[a;b]$ :
+
+$$
+f(x) <= g(x)
+$$
+
+alors l'aire comprise entre les courbes représentatives de $f$ et de $g$, entre les abscisses $a$ et $b$ est :
+
+$$
+\\mathrm{A} = \\int_{a}^{b} g - \\int_{a}^{b} f = \\int_{a}^{b} g-f
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundLow, nodeIntegralBoundHigh, nodePrimitiveOfF, nodePrimitiveOfG, nodeIntegralF, nodeIntegralAsSubF, nodeIntegralG, nodeIntegralAsSubG, nodeAreaBetweenCurves, } = getHydrated(identifiers);
+    return `Les fonctions $f$ et $g$ sont des polynômes. Elles sont continues sur $\\mathbb{R}$.
+$f$ délimite la frontière inférieure du domaine coloré et $g$ la frontière supérieure.
+L'abscisse qui délimite le domaine à gauche est $${nodeIntegralBoundLow.toTex()}$. 
+L'abscisse qui délimite le domaine à droite est $${nodeIntegralBoundHigh.toTex()}$.
+
+On va donc calculer :
+
+${alignTex([
+        ["I_{f}", nodeIntegralF.toTex()],
+        [
+            "=",
+            `\\left[ ${nodePrimitiveOfF.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+        ],
+        [
+            "=",
+            nodeIntegralAsSubF
+                .simplify({
+                towardsDistribute: true,
+                forceAddFractions: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+${alignTex([
+        ["I_{g}", nodeIntegralG.toTex()],
+        [
+            "=",
+            `\\left[ ${nodePrimitiveOfG.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+        ],
+        [
+            "=",
+            nodeIntegralAsSubG
+                .simplify({
+                towardsDistribute: true,
+                forceAddFractions: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+L'aire du domaine coloré est la différence entre les intégrales de $g$ et $f$ sur $[${nodeIntegralBoundLow.toTex()};${nodeIntegralBoundHigh.toTex()}]$ :
+
+$$
+\\mathrm{A} = I_{g} - I_{f} = ${nodeAreaBetweenCurves
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    })
+        .toTex()}
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsF, nodeIdsG, nodeIdsBounds } = identifiers;
+    const [nodeF, nodeG, nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+        nodeIdsF,
+        nodeIdsG,
+        ...nodeIdsBounds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const [yMin, yMax] = (() => {
+        const valueBoundLow = nodeIntegralBoundLow.evaluate();
+        const valueBoundHigh = nodeIntegralBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const [vMin, vMax] = acc;
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageF = nodeF.evaluate({ x: valueAbscissa });
+            const valueImageG = nodeG.evaluate({ x: valueAbscissa });
+            return [Math.min(vMin, valueImageF), Math.max(vMax, valueImageG)];
+        }, [-1.5, 1.5]);
+    })();
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `g(x) = ${nodeG.toMathString()}`,
+        `SetColor(g, "${blueMain}")`,
+        //integrals
+        `integralF = Integral(0*x+${nodeF.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralF, "${greenMain}")`,
+        `SetFilling(integralF, 0.3)`,
+        `ShowLabel(integralF, false)`,
+        `integralG = Integral(0*x+${nodeG.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralG, "${greenMain}")`,
+        `SetFilling(integralG, 0.3)`,
+        `ShowLabel(integralG, false)`,
+        `integralBetw = IntegralBetween(0*x+${nodeF.toMathString()}, 0*x+${nodeG.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralBetw, "${greenMain}")`,
+        `SetFilling(integralBetw, 0.8)`,
+        `ShowLabel(integralBetw, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIdsF, nodeIdsG, nodeIdsBounds } = identifiers;
+    const [nodeF, nodeG, nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+        nodeIdsF,
+        nodeIdsG,
+        ...nodeIdsBounds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const [yMin, yMax] = (() => {
+        const valueBoundLow = nodeIntegralBoundLow.evaluate();
+        const valueBoundHigh = nodeIntegralBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const [vMin, vMax] = acc;
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageF = nodeF.evaluate({ x: valueAbscissa });
+            const valueImageG = nodeG.evaluate({ x: valueAbscissa });
+            return [Math.min(vMin, valueImageF), Math.max(vMax, valueImageG)];
+        }, [-1.5, 1.5]);
+    })();
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `g(x) = ${nodeG.toMathString()}`,
+        `SetColor(g, "${blueMain}")`,
+        `integralBetw = IntegralBetween(0*x+${nodeF.toMathString()}, 0*x+${nodeG.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralBetw, "${greenMain}")`,
+        `SetFilling(integralBetw, 0.5)`,
+        `ShowLabel(integralBetw, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        try {
+            const identifierWrong = createQCPassedIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+        }
+        catch (_) {
+            (() => { })();
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isValid = NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer);
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const generateValuePositive = (function* () {
+        const arrValue = [...Array(10).keys()].map((i) => i + 1);
+        yield* shuffle(arrValue);
+    })();
+    const generateValueNegative = (function* () {
+        const arrValue = [...Array(10).keys()].map((i) => i + 1).map((v) => -v);
+        yield* shuffle(arrValue);
+    })();
+    const valueTotalLengthOfF = randint(5, 11);
+    const [valueBoundLow, valueBoundHigh] = (() => {
+        if (opts.typeSignBoundLow === "Négative" &&
+            opts.typeSignBoundHigh === "Négative") {
+            const valueBoundHigh = generateValueNegative.next().value;
+            const valueBoundLow = valueBoundHigh - valueTotalLengthOfF;
+            return [valueBoundLow, valueBoundHigh];
+        }
+        else if (opts.typeSignBoundLow === "Positive" &&
+            opts.typeSignBoundHigh === "Positive") {
+            const valueBoundLow = generateValuePositive.next().value;
+            const valueBoundHigh = valueBoundLow + valueTotalLengthOfF;
+            return [valueBoundLow, valueBoundHigh];
+        }
+        else {
+            const valueBoundLow = -randint(2, valueTotalLengthOfF - 1);
+            const valueBoundHigh = valueBoundLow + valueTotalLengthOfF;
+            return [valueBoundLow, valueBoundHigh];
+        }
+    })();
+    const [nodeBoundLow, nodeBoundHigh] = [valueBoundLow, valueBoundHigh].map((v) => v.toTree());
+    const [nodePBottom, nodePTop] = (() => {
+        const [point1, point2] = zip(["P1", "P2"], [nodeBoundLow, nodeBoundHigh]).map(([name, nodeAbscissa]) => new Point(name, nodeAbscissa, randint(0, 6)));
+        switch (opts.typeCrossingCurves) {
+            case "Trinôme/Trinôme": {
+                const [nodeABottom, nodeATop] = [
+                    frac(randint(1, 3), 10),
+                    frac(randint(-2, 0), 10),
+                ];
+                const [nodePBottom, nodePTop] = [nodeABottom, nodeATop].map((nodeA) => createNodeFTrinomFromPoints(nodeA, [point1, point2]));
+                return [nodePBottom, nodePTop];
+            }
+            case "Trinôme/Affine": {
+                const [nodeABottom, nodeATop] = [
+                    (0).toTree(),
+                    frac(randint(-2, 0), 10),
+                ];
+                const [nodePBottom, nodePTop] = [nodeABottom, nodeATop].map((nodeA) => createNodeFTrinomFromPoints(nodeA, [point1, point2]));
+                return [nodePBottom, nodePTop];
+            }
+            case "Affine/Trinôme": {
+                const [nodeABottom, nodeATop] = [frac(randint(1, 3), 10), (0).toTree()];
+                const [nodePBottom, nodePTop] = [nodeABottom, nodeATop].map((nodeA) => createNodeFTrinomFromPoints(nodeA, [point1, point2]));
+                return [nodePBottom, nodePTop];
+            }
+            default:
+                throw new Error("Unsupported opts.typeCrossingCurves: " + opts.typeCrossingCurves);
+        }
+    })();
+    const [nodeF, nodeG] = [nodePBottom, nodePTop].map((nodeP) => nodeP
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    })
+        .simplify({
+        towardsDistribute: true,
+        forceDistributeFractions: true,
+        forbidFactorize: true,
+    }));
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsG: nodeG.toIdentifiers(),
+        nodeIdsBounds: [
+            nodeBoundLow.toIdentifiers(),
+            nodeBoundHigh.toIdentifiers(),
+        ],
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getAnswer(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    const isAboveZero = (identifiers) => {
+        const { nodeIdsF, nodeIdsG, nodeIdsBounds } = identifiers;
+        const [nodeF, nodeG, nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+            nodeIdsF,
+            nodeIdsG,
+            ...nodeIdsBounds,
+        ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+        const yMin = (() => {
+            const valueBoundLow = nodeIntegralBoundLow.evaluate();
+            const valueBoundHigh = nodeIntegralBoundHigh.evaluate();
+            const nbSteps = 50;
+            const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+            return [...Array(nbSteps).keys()].reduce((acc, i) => {
+                const vMin = acc;
+                const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+                const valueImageF = nodeF.evaluate({ x: valueAbscissa });
+                const valueImageG = nodeG.evaluate({ x: valueAbscissa });
+                return Math.min(vMin, valueImageF, valueImageG);
+            }, 0.5);
+        })();
+        return yMin >= 0.5;
+    };
+    return !isExploding(identifiers) && isAboveZero(identifiers);
+};
+const createQCPassedIdentifiers = (opts) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(opts);
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = (() => {
+            const nodeVarX = new VariableNode("x");
+            const nodeF = add(multiply(-frac(1, 10), square(nodeVarX)), 5);
+            const nodeG = (2.5).toTree();
+            return {
+                nodeIdsF: nodeF.toIdentifiers(),
+                nodeIdsG: nodeG.toIdentifiers(),
+                nodeIdsBounds: [(-5).toTree(), (5).toTree()].map((node) => node.toIdentifiers()),
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getAreaBetweenCrossingCurvesFixedPosFromExprQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createQCPassedIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    typeCrossingCurves: "Trinôme/Trinôme",
+    typeSignBoundLow: "Positive",
+    typeSignBoundHigh: "Positive",
+};
+const options = [
+    {
+        id: "typeCrossingCurves",
+        label: "Association de courbes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Trinôme/Trinôme", "Trinôme/Affine", "Affine/Trinôme"],
+        defaultValue: optsDefault.typeCrossingCurves,
+    },
+    {
+        id: "typeSignBoundLow",
+        label: "Signe de la borne inférieure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Positive", "Négative"],
+        defaultValue: optsDefault.typeSignBoundLow,
+    },
+    {
+        id: "typeSignBoundHigh",
+        label: "Signe de la borne supérieure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Positive", "Négative"],
+        defaultValue: optsDefault.typeSignBoundHigh,
+    },
+];
+const validateOptions = (opts) => {
+    if (opts.typeSignBoundLow === "Positive" &&
+        opts.typeSignBoundHigh === "Négative")
+        return {
+            valid: false,
+            message: "La borne inférieure doit pouvoir être inférieure à la borne supérieure.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
+export const areaBetweenCrossingCurvesFixedPosFromExpr = {
+    id: "areaBetweenCrossingCurvesFixedPosFromExpr",
+    connector: "=",
+    label: "Calculer l'aire entre deux courbes dont la position relative ne change pas",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getAreaBetweenCrossingCurvesFixedPosFromExprQuestion(opts), nb),
+    options,
+    validateOptions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/integration/fromExpr/boundIntegralByBoundingFunctionWithAffinesFromExpr.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    nodeIdsBounds: NodeIdentifiers[];
+    nodeIdsAffineMinor: NodeIdentifiers;
+    nodeIdsAffineMajor: NodeIdentifiers;
+    nodeIdsVariableForIntegration: NodeIdentifiers[];
+};
+type Options = {
+    typeSignBoundLow: string;
+    typeSignBoundHigh: string;
+};
+export declare const boundIntegralByBoundingFunctionWithAffinesFromExpr: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=boundIntegralByBoundingFunctionWithAffinesFromExpr.d.ts.map

package/lib/exercises/math/integration/fromExpr/boundIntegralByBoundingFunctionWithAffinesFromExpr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundIntegralByBoundingFunctionWithAffinesFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/boundIntegralByBoundingFunctionWithAffinesFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkB7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,kBAAkB,EAAE,eAAe,CAAC;IACpC,kBAAkB,EAAE,eAAe,CAAC;IACpC,6BAA6B,EAAE,eAAe,EAAE,CAAC;CAClD,CAAC;AAyhBF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAyCF,eAAO,MAAM,kDAAkD,EAAE,QAAQ,CACvE,WAAW,EACX,OAAO,CAsBR,CAAC"}