math-exercises 3.0.124 → 3.0.126

package/lib/exercises/pc/optics/lensFormula.js

@@ -0,0 +1,415 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { EqualNode } from "../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { InfinityNode, MinusInfinityNode, } from "../../../tree/nodes/numbers/infiniteNode.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 { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../utils/alea/random.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const optsDefault = {
+    typeDistance: [
+        "distance focale",
+        "distance objet",
+        "distance image",
+    ],
+    typeImage: [
+        "réelle finie",
+        "réelle infinie",
+        "imaginaire finie",
+        "imaginaire infinie",
+    ],
+    unit: ["cm", "m"],
+    roundTo: [0, 1, 2],
+};
+const options = [
+    {
+        id: "typeDistance",
+        label: "Distance à calculer",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.typeDistance,
+        values: ["distance focale", "distance objet", "distance image"],
+    },
+    {
+        id: "typeImage",
+        label: "Type d'image",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.typeImage,
+        values: [
+            "réelle finie",
+            "réelle infinie",
+            "imaginaire finie",
+            "imaginaire infinie",
+        ],
+    },
+    {
+        id: "unit",
+        label: "unité de mesure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.unit,
+        values: ["cm", "m"],
+    },
+    {
+        id: "roundTo",
+        label: "Arrondir à (nombre de décimales)",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.roundTo,
+        values: [0, 1, 2],
+    },
+];
+const getLensFormulaEqualNode = () => {
+    const equation = new EqualNode(frac(1, "\\overline {OA'}"), add(frac(1, "\\overline {OF'}"), frac(1, "\\overline {OA}")));
+    return equation;
+};
+const getInstruction = (identifiers) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    const strRounTo = (() => {
+        switch (opts.roundTo) {
+            case 0:
+                return "à l'unité";
+            case 1:
+                return "au dixième";
+            case 2:
+                return "au centième";
+        }
+    })();
+    let strOAPrime = `$${nodeOAPrime.simplify().toTex()}${opts.unit}$`;
+    let strOA = `$${nodeOA.simplify().toTex()}${opts.unit}$`;
+    const strOFPrime = `$${nodeOFPrime.simplify().toTex()}${opts.unit}$`;
+    if (strOAPrime.includes("\\infty")) {
+        strOAPrime = "à l'infini";
+    }
+    if (strOA.includes("\\infty")) {
+        strOA = "à l'infini";
+    }
+    const strLensType = nodeOFPrime.evaluate() >= 0 ? "convergente" : "divergente";
+    switch (opts.typeDistance) {
+        case "distance focale": {
+            return `Calculer la distance focale algébrique de la lentille, en $${opts.unit}$, arrondie ${strRounTo}, 
+sachant que la position algébrique de l'objet de l'objet $AB$ est ${strOA}, 
+et que la position algébrique de l'image $A'$ est ${strOAPrime}.`;
+        }
+        case "distance image": {
+            return `Calculer la position algébrique de l'image $A'$ de l'objet $AB$, en $${opts.unit}$, arrondie ${strRounTo}, 
+situé algébriquement à ${strOA} 
+d'une lentille ${strLensType} ayant une distance focale de ${strOFPrime}.`;
+        }
+        case "distance objet": {
+            return `Calculer la position algébrique $A$ de l'objet $AB$, en $${opts.unit}$, arrondie ${strRounTo}, 
+sachant que la position algébrique de l'image $A'$ est ${strOAPrime}, 
+et que la distance focale algébrique est ${strOFPrime}.`;
+        }
+    }
+};
+const getHint = () => {
+    return `Relation de conjugaison de Descartes : 
+  
+$$
+${getLensFormulaEqualNode().toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    const answer = getAnswer(identifiers);
+    return `La relation de conjugaison de Descartes s'écrit : 
+  
+$$
+${getLensFormulaEqualNode().toTex()}
+$$
+
+Dans notre cas : 
+
+${(() => {
+        switch (opts.typeDistance) {
+            case "distance focale":
+                return alignTex([
+                    [
+                        `\\frac{1}{\\overline {OF'}}`,
+                        `=`,
+                        `\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OA}}`,
+                    ],
+                    [
+                        `\\overline {OF'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OA}}}`,
+                    ],
+                    [
+                        `\\overline {OF'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{${nodeOAPrime.toTex()}} - \\frac{1}{${nodeOA.toTex()}}}`,
+                    ],
+                    [`\\overline {OF'}`, `=`, answer.replaceAll("$", "")],
+                ]);
+            case "distance image":
+                return alignTex([
+                    [
+                        `\\overline {OA'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{\\overline {OF'}} + \\frac{1}{\\overline {OA}}}`,
+                    ],
+                    [
+                        `\\overline {OA'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{${nodeOFPrime.toTex()}} + \\frac{1}{${nodeOA.toTex()}}}`,
+                    ],
+                    [`\\overline {OA'}`, `=`, answer.replaceAll("$", "")],
+                ]);
+            case "distance objet":
+                return alignTex([
+                    [
+                        `\\frac{1}{\\overline {OA}}`,
+                        `=`,
+                        `\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OF'}}`,
+                    ],
+                    [
+                        `\\overline {OA}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OF'}}}`,
+                    ],
+                    [
+                        `\\overline {OA}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{${nodeOAPrime.toTex()}} - \\frac{1}{${nodeOFPrime.toTex()}}}`,
+                    ],
+                    [`\\overline {OA}`, `=`, answer.replaceAll("$", "")],
+                ]);
+        }
+    })()}`;
+};
+const getAnswer = (identifiers) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    return `${round((() => {
+        switch (opts.typeDistance) {
+            case "distance focale":
+                return nodeOFPrime;
+            case "distance image":
+                return nodeOAPrime;
+            case "distance objet":
+                return nodeOA;
+        }
+    })().evaluate(), opts.roundTo).frenchify()}${opts.unit}`;
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { opts } = identifiers;
+    if (!ans.endsWith(opts.unit))
+        return false;
+    const ansNumber = parseFloat(ans.replace(opts.unit, ""));
+    const answerNumber = parseFloat(answer.replace(opts.unit, ""));
+    return ansNumber === answerNumber;
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    let propositions = [];
+    function toUnitedTex(tex) {
+        return `${tex}${opts.unit}`;
+    }
+    addValidProp(propositions, answer, "tex");
+    switch (opts.typeDistance) {
+        case "distance focale":
+            {
+                function tryToAddWrongProps(roundTo) {
+                    //x = A + B
+                    tryToAddWrongProp(propositions, toUnitedTex(round(add(nodeOAPrime, nodeOA).evaluate(), roundTo).frenchify()));
+                    //erreur d'inverse
+                    tryToAddWrongProp(propositions, toUnitedTex(round(nodeOFPrime.rightChild.evaluate(), roundTo).frenchify()));
+                    //erreur de signe
+                    tryToAddWrongProp(propositions, toUnitedTex(round(frac(1, add(frac(1, nodeOAPrime.evaluate()), frac(1, nodeOA.evaluate()))).evaluate(), roundTo).frenchify()));
+                }
+                //erreurs d'arrondis
+                [0, 1, 2].forEach((roundTo) => {
+                    tryToAddWrongProps(roundTo);
+                });
+            }
+            break;
+        case "distance image":
+            {
+                function tryToAddWrongProps(roundTo) {
+                    //x = A + B
+                    tryToAddWrongProp(propositions, toUnitedTex(round(add(nodeOFPrime, nodeOA).evaluate(), roundTo).frenchify()));
+                    //erreur d'inverse
+                    tryToAddWrongProp(propositions, toUnitedTex(round(frac(1, nodeOAPrime).evaluate(), roundTo).frenchify()));
+                    //erreur de signe
+                    tryToAddWrongProp(propositions, toUnitedTex(round(substract(frac(1, nodeOFPrime.evaluate()), frac(1, nodeOA.evaluate())).evaluate(), roundTo).frenchify()));
+                }
+                //erreurs d'arrondis
+                [0, 1, 2].forEach((roundTo) => {
+                    tryToAddWrongProps(roundTo);
+                });
+            }
+            break;
+        case "distance objet":
+            {
+                function tryToAddWrongProps(roundTo) {
+                    //x = A + B
+                    tryToAddWrongProp(propositions, toUnitedTex(round(add(nodeOAPrime, nodeOFPrime).evaluate(), roundTo).frenchify()));
+                    //erreur d'inverse
+                    tryToAddWrongProp(propositions, toUnitedTex(round(nodeOA.rightChild.evaluate(), roundTo).frenchify()));
+                    //erreur de signe
+                    tryToAddWrongProp(propositions, toUnitedTex(round(frac(1, add(frac(1, nodeOAPrime.evaluate()), frac(1, nodeOFPrime.evaluate()))).evaluate(), roundTo).frenchify()));
+                }
+                //erreurs d'arrondis
+                [0, 1, 2].forEach((roundTo) => {
+                    tryToAddWrongProps(roundTo);
+                });
+            }
+            break;
+    }
+    propositions = propositions.filter((proposition) => !proposition.statement.includes("NaN"));
+    return shuffleProps(propositions, nbProps);
+};
+const getLensFormulaQuestion = (optsIn) => {
+    const optsInRetyped = optsIn
+        ? {
+            typeDistance: optsIn?.typeDistance,
+            typeImage: optsIn?.typeImage,
+            unit: optsIn?.unit,
+            roundTo: (optsIn?.roundTo)
+                .filter((a) => typeof a === "string")
+                .map((str) => +str),
+        }
+        : undefined;
+    console.log("optsIn", optsIn);
+    console.log("optsInRetyped", optsInRetyped);
+    let nodeOFPrime = NaN.toTree();
+    let nodeOA = NaN.toTree();
+    let nodeOAPrime = NaN.toTree();
+    let opts;
+    function getRandomNodes() {
+        opts = optsInRetyped
+            ? {
+                typeDistance: random(optsInRetyped.typeDistance),
+                typeImage: random(optsInRetyped.typeImage),
+                unit: random(optsInRetyped.unit),
+                roundTo: random(optsInRetyped.roundTo),
+            }
+            : {
+                typeDistance: random(optsDefault.typeDistance),
+                typeImage: random(optsDefault.typeImage),
+                unit: random(optsDefault.unit),
+                roundTo: random(optsDefault.roundTo),
+            };
+        console.log("opts", opts);
+        //objet réel:    \\overline {OA}  < 0
+        //image réelle : \\overline {OA'} > 0
+        function factorNodeForTypeImage(typeImage) {
+            let factorNode;
+            switch (typeImage) {
+                case "réelle finie":
+                    factorNode = (+1).toTree();
+                    break;
+                case "réelle infinie":
+                    factorNode = (-1).toTree();
+                    break;
+                case "imaginaire finie":
+                    factorNode = InfinityNode;
+                    break;
+                case "imaginaire infinie":
+                    factorNode = MinusInfinityNode;
+                    break;
+            }
+            return factorNode;
+        }
+        switch (opts.typeDistance) {
+            case "distance focale":
+                {
+                    nodeOA = (-randint(1, 10)).toTree();
+                    nodeOAPrime = multiply(factorNodeForTypeImage(opts.typeImage), randint(1, 10, [-nodeOA.evaluate()]).toTree()).simplify();
+                    const equalNode = getLensFormulaEqualNode();
+                    nodeOFPrime = frac(1, substract(equalNode.leftChild.evaluate({
+                        "\\overline {OA'}": nodeOA.evaluate(),
+                    }), equalNode.rightChild.rightChild.evaluate({
+                        "\\overline {OA}": nodeOAPrime.evaluate(),
+                    })));
+                }
+                break;
+            case "distance image":
+                {
+                    nodeOA = (-randint(1, 10)).toTree();
+                    nodeOFPrime = multiply(factorNodeForTypeImage(opts.typeImage), randint(1, 10, [-nodeOA.evaluate()]).toTree()).simplify();
+                    const equalNode = getLensFormulaEqualNode();
+                    nodeOAPrime = frac(1, equalNode.rightChild.evaluate({
+                        "\\overline {OA}": nodeOA.evaluate(),
+                        "\\overline {OF'}": nodeOFPrime.evaluate(),
+                    }));
+                }
+                break;
+            case "distance objet":
+                {
+                    nodeOAPrime = multiply(factorNodeForTypeImage(opts.typeImage), randint(1, 10).toTree()).simplify();
+                    nodeOFPrime = randint(1, 10, [-nodeOAPrime.evaluate()]).toTree();
+                    const equalNode = getLensFormulaEqualNode();
+                    nodeOA = frac(1, substract(equalNode.leftChild.evaluate({
+                        "\\overline {OA'}": nodeOAPrime.evaluate(),
+                    }), equalNode.rightChild.leftChild.evaluate({
+                        "\\overline {OF'}": nodeOFPrime.evaluate(),
+                    })));
+                }
+                break;
+        }
+    }
+    function checkValidNodes() {
+        const isContainingNaN = [nodeOA, nodeOAPrime, nodeOFPrime].some((node) => isNaN(node.evaluate()));
+        const valueOFPrime = nodeOFPrime.evaluate();
+        const isFocalInfinite = valueOFPrime === -Infinity || valueOFPrime == Infinity;
+        return !isContainingNaN && !isFocalInfinite;
+    }
+    do {
+        getRandomNodes();
+    } while (!checkValidNodes());
+    return getQuestionFromIdentifiers({
+        OFPrime: nodeOFPrime.toIdentifiers(),
+        OA: nodeOA.toIdentifiers(),
+        OAPrime: nodeOAPrime.toIdentifiers(),
+        opts: opts,
+    }, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        answer: getAnswer(identifiers),
+    };
+    return question;
+};
+export const lensFormula = {
+    id: "lensFormula",
+    label: "Exploiter la relation de conjugaison de Descartes",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLensFormulaQuestion(opts), nb, 30, () => false),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.d.ts

@@ -1,8 +1,8 @@
 import { Exercise } from "../../exercises/exercise.js";
 type Identifiers = {
     isAsking: string;
-    enetringLightX: number;
-    enetringLightY: number;
+    enteringLightX: number;
+    enteringLightY: number;
 };
 export declare const recognizeRefractionOrReflectionAngles: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.js

@@ -22,7 +22,7 @@ const getAnswer = (identifiers) => {
     return isAsking;
 };
 const getGGBOptions = (identifiers) => {
-    const { isAsking, enetringLightX, enetringLightY } = identifiers;
+    const { isAsking, enteringLightX, enteringLightY } = identifiers;
     let angle = "";
     switch (isAsking) {
         case IsAsking.RefractionAngle:
@@ -33,24 +33,24 @@ const getGGBOptions = (identifiers) => {
             break;
         case IsAsking.IncidenceAngle:
         default:
-            angle = `Ang = Angle(Line((0,0), (0,5)),Line((0,0),(${enetringLightX},${enetringLightY})))`;
+            angle = `Ang = Angle(Line((0,0), (0,5)),Line((0,0),(${enteringLightX},${enteringLightY})))`;
     }
-    const reflectionLight = { x2: -enetringLightX, y2: enetringLightY };
+    const reflectionLight = { x2: -enteringLightX, y2: enteringLightY };
     const refractingLight = {
         x2: reflectionLight.x2 - randint(5, 10),
         y2: -reflectionLight.y2,
     };
     const commands = [
-        `E = Vector((${enetringLightX},${enetringLightY}), (0,0))`,
+        `E = Vector((${enteringLightX},${enteringLightY}), (0,0))`,
         `R = Vector((0,0), (${reflectionLight.x2},${reflectionLight.y2}))`,
         `I = Vector((0,0), (${refractingLight.x2},${refractingLight.y2}))`,
         angle,
         `DashedLine = Line((0,0),(0,5))`,
         `Y = Line((0,0),(5,0))`,
-        `Text("\\tiny \\text{Surface de séparation}", (-12,0),false,true)`,
-        `Text("\\tiny \\text{Milieu 1}", (9,2.5),false,true)`,
-        `Text("\\tiny \\text{Milieu 2}", (9,0),false,true)`,
-        `YText = Text(RotateText("\\tiny \\text{Rayon incident}",-90°+${angle}), (${enetringLightX / 2 - 1.5},${enetringLightY / 2}),false,true)`,
+        `SSurfaceText = Text("\\tiny \\text{Surface de séparation}", (-12,0),false,true)`,
+        `M1Text = Text("\\tiny \\text{Milieu 1}", (9,2.5),false,true)`,
+        `M2Text= Text("\\tiny \\text{Milieu 2}", (9,0),false,true)`,
+        `YText = Text(RotateText("\\tiny \\text{Rayon incident}",-90°+Ang), (${enteringLightX / 2 - 1.5},${enteringLightY / 2}),false,true)`,
         `SetLineStyle(DashedLine,2)`,
         `ShowLabel(Ang,false)`,
         `SetColor(E,"#F78D04")`,
@@ -62,10 +62,10 @@ const getGGBOptions = (identifiers) => {
         `SetFixed(I,true)`,
         `SetFixed(DashedLine,true)`,
         `SetFixed(Y,true)`,
-        `First = Polygon((15, 0), (15,12), (-15, 12), (-15, 0))`,
-        `Second = Polygon((15, 0), (15,-12), (-15, -12), (-15, 0))`,
-        `SetColor(First,"${blueMain}")`,
-        `SetColor(Second,"#0a6a01")`,
+        `FirstPolygon = Polygon((15, 0), (15,12), (-15, 12), (-15, 0))`,
+        `SecondPolygon = Polygon((15, 0), (15,-12), (-15, -12), (-15, 0))`,
+        `SetColor(FirstPolygon,"${blueMain}")`,
+        `SetColor(SecondPolygon,"#0a6a01")`,
         `SetColor(Ang,"#6a0101")`,
     ];
     const ggb = new GeogebraConstructor({
@@ -90,10 +90,10 @@ const getQuestionFromIdentifiers = (identifiers) => {
     return question;
 };
 const getRecognizeRefractionOrReflectionAnglesQuestion = () => {
-    const enetringLightX = randint(-20, -10);
-    const enetringLightY = randint(15, 21);
+    const enteringLightX = randint(-20, -10);
+    const enteringLightY = randint(15, 21);
     const isAsking = random(questionAngle);
-    const identifiers = { isAsking, enetringLightX, enetringLightY };
+    const identifiers = { isAsking, enteringLightX, enteringLightY };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {

package/lib/exercises/pc/weight/calculateWeight.d.ts

@@ -1,7 +1,14 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     mass: number;
+    optsIdent: Options;
 };
-export declare const calculateWeight: Exercise<Identifiers>;
+type InputType = "decimal" | "sci";
+type NbDigitsType = 0 | 1 | 2;
+type Options = {
+    inputType: InputType;
+    nbDigits: NbDigitsType;
+};
+export declare const calculateWeight: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=calculateWeight.d.ts.map

package/lib/exercises/pc/weight/calculateWeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA+FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,SAAS,GAAG,SAAS,GAAG,KAAK,CAAC;AACnC,KAAK,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE9B,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,YAAY,CAAC;CACxB,CAAC;AAuMF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc1D,CAAC"}