math-exercises 3.0.19 → 3.0.21

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.js

@@ -1,57 +1,75 @@
-import { addValidProp, shuffleProps, } from "../../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
 import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
 import { Point } from "../../../../../math/geometry/point.js";
-import { Rational } from "../../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../../utils/alea/random.js";
-const getPoints = (c) => {
-    const midC = new Rational(c, 2).simplify().toTree();
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPoints = (identifiers) => {
+    const { c, rotationAngle } = identifiers;
+    // const midC = new Rational(c, 2).simplify().toTree();
+    const midC = c / 2;
+    const oppMidC = -c / 2;
     const zeroTree = (0).toTree();
-    const cTree = c.toTree();
+    const center = new Point("O", zeroTree, zeroTree);
     const points = [
-        { name: "A", x: zeroTree, y: zeroTree },
-        { name: "I", x: midC, y: zeroTree },
-        { name: "B", x: cTree, y: zeroTree },
-        { name: "J", x: cTree, y: midC },
-        { name: "C", x: cTree, y: cTree },
-        { name: "K", x: midC, y: cTree },
-        { name: "D", x: zeroTree, y: cTree },
-        { name: "L", x: zeroTree, y: midC },
-        { name: "O", x: midC, y: midC },
-    ];
-    return points;
+        { name: "A", x: oppMidC, y: oppMidC },
+        { name: "I", x: zeroTree, y: oppMidC },
+        { name: "B", x: midC, y: oppMidC },
+        { name: "J", x: midC, y: zeroTree },
+        { name: "C", x: midC, y: midC },
+        { name: "K", x: zeroTree, y: midC },
+        { name: "D", x: oppMidC, y: midC },
+        { name: "L", x: oppMidC, y: zeroTree },
+    ].map((d) => new Point(d.name, d.x, d.y).rotate(rotationAngle, center));
+    return [...points, center];
 };
 const buildFromIdentifiers = (identifiers) => { };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, c }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    const wrongAnswers = [
+        c.toTree(),
+        frac(c, 2),
+        (c * c).toTree(),
+        frac(c ** 2, 4),
+    ];
     while (propositions.length < n) {
-        throw Error("QCM not implemented");
+        let wrongItem = random(wrongAnswers);
+        if (coinFlip())
+            wrongItem = opposite(wrongItem);
+        tryToAddWrongProp(propositions, wrongItem.simplify().toTex());
     }
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    return Math.random() + "";
+    const { areSameDirection, c, vec1Name, vec1ProjLength, vec2Name, vec2ProjLength, } = identifiers;
+    const frac1 = new NumberNode(vec1ProjLength).toFrac();
+    const frac2 = new NumberNode(vec2ProjLength).toFrac();
+    if (areSameDirection) {
+        return multiply(frac1, frac2).simplify().toTex();
+    }
+    return opposite(multiply(frac1, frac2)).simplify().toTex();
 };
-const getInstruction = ({ c, vector1Name, vector2Name, }) => {
+const getInstruction = ({ c, vec1Name, vec2Name, }) => {
     return `$ABCD$ est un carré de côté $${c}$ et de centre $O$. Les points $I$,$J$,$K$ et $L$ sont les milieux respectifs des segments $[AB]$, $[BC]$, $[CD]$ et $[AD]$. Calculer : 
   
 $$
-\\overrightarrow{${vector1Name}}\\cdot \\overrightarrow{${vector2Name}}
+\\overrightarrow{${vec1Name}}\\cdot \\overrightarrow{${vec2Name}}
 $$`;
 };
-const getHint = (identifiers) => {
-    return "";
-};
-const getCorrection = (identifiers) => {
-    return "";
-};
-const getGGBOptions = ({ c }) => {
-    const points = getPoints(c).map((d) => new Point(d.name, d.x, d.y));
+const getGGBOptions = (identifiers) => {
+    const { c } = identifiers;
+    const points = getPoints(identifiers);
     const ggb = new GeogebraConstructor({
         commands: [
-            ...points.flatMap((p) => p.toGGBCommand()),
+            ...points.flatMap((p) => p.toGGBCommand({ style: 1 })),
             `Polygon(A,B,C,D)`,
             `Segment(A,C)`,
             `Segment(B,D)`,
@@ -60,56 +78,70 @@ const getGGBOptions = ({ c }) => {
         hideGrid: true,
     });
     return ggb.getOptions({
-        coords: [-1, c + 1, -1, c + 1],
+        coords: ggb.getCoordsForPoints(points),
     });
 };
 const getKeys = (identifiers) => {
     return [];
 };
 const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const getScalarProductOrthoInSquareQuestion = () => {
     const c = randint(1, 10);
-    // AB AO
-    // AB AK
-    // AB AJ
-    // AB AC
-    //ou
-    // AI AO
-    // AI AK
-    // AI AC
-    // AI AJ
-    //ou
-    // AB IJ
-    // AB OC
-    // AB LK
-    // AB OJ
-    // AB LO
-    //ou
-    // AI IJ
-    // AI OC
-    // AI LK
-    // AI OJ
-    // AI LO
-    // puis on shuffle dans tous les sens
-    const firstPointIndex = random([0, 2, 4, 6]); //A,B,C,D
-    const isD = firstPointIndex === 6;
-    const delta = isD ? 3 : 2;
-    const secondPointIndex = random([
-        (firstPointIndex + delta) % 8,
-        (firstPointIndex + 1) % 8,
-    ]); //si first=A alors B ou I, idem par translation pour les autres
-    const thirdPointIndex = random([(1 + delta) % 8, (7 + delta * 8) % 8, 8]);
-    const identifiers = { c, vector1Name: "BC", vector2Name: "AC" };
+    // A(B,I) * A(J,C,O,K)
+    // A(D,L) * A(J,C,O,K)
+    //puis on reverse tout possiblement
+    const isFirstVecOnAB = coinFlip();
+    const vecs = {
+        AB: { projLength: c, reps: ["AB", "DC"] },
+        AC: { projLength: c, reps: ["AC"] },
+        AD: { projLength: c, reps: ["AD", "IK", "BC"] },
+        AJ: { projLength: isFirstVecOnAB ? c : c / 2, reps: ["AJ", "LC"] },
+        AO: { projLength: c / 2, reps: ["AO", "LK", "OC", "IJ"] },
+        AK: { projLength: isFirstVecOnAB ? c / 2 : c, reps: ["AK", "IC"] },
+        AI: {
+            projLength: c / 2,
+            reps: ["AI", "IB", "LO", "OJ", "DK", "KC"],
+        },
+        AL: {
+            projLength: c / 2,
+            reps: ["AL", "LD", "IO", "OK", "BJ", "BC"],
+        },
+    };
+    const vec1Choices = random(isFirstVecOnAB ? ["AB", "AI"] : ["AD", "AL"]);
+    const vec2Choices = random(["AJ", "AC", "AO", "AK"]);
+    let vec1 = random(vecs[vec1Choices].reps);
+    let vec2 = random(vecs[vec2Choices].reps);
+    let inversionsCount = 0;
+    if (coinFlip()) {
+        inversionsCount++;
+        vec1 = vec1.split("").reverse().join("");
+    }
+    if (coinFlip()) {
+        inversionsCount++;
+        vec2 = vec2.split("").reverse().join("");
+    }
+    const identifiers = {
+        c,
+        vec1Name: vec1,
+        vec2Name: vec2,
+        areSameDirection: inversionsCount % 2 === 0,
+        vec1ProjLength: vecs[vec1Choices].projLength,
+        vec2ProjLength: vecs[vec2Choices].projLength,
+        rotationAngle: Math.random() * 2 * Math.PI,
+    };
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -126,8 +158,8 @@ export const scalarProductOrthoInSquare = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    getHint,
-    getCorrection,
     getAnswer,
     getGGBOptions,
+    getInstruction,
+    hasGeogebra: true,
 };

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../../math/geometry/triangle.js";
+type Identifiers = {
+    triangleIdentifiers: TriangleIdentifiers;
+};
+export declare const scalarProductViaNorms: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductViaNorms.d.ts.map

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductViaNorms.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAWzC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA8IF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaNorms.js

@@ -0,0 +1,147 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { TriangleConstructor, } from "../../../../../math/geometry/triangle.js";
+import { randint } from "../../../../../math/utils/random/randint.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 { cdot } from "../../../../../tree/nodes/operators/scalarProductNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, triangleIdentifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const A = triangle.sides[0].getLength();
+    const B = triangle.sides[1].getLength();
+    const C = triangle.sides[2].getLength();
+    // return multiply(frac(1, 2), substract(add(C, B), A));
+    tryToAddWrongProp(propositions, substract(add(C ** 2, B ** 2), A ** 2)
+        .simplify()
+        .toTex());
+    tryToAddWrongProp(propositions, multiply(frac(1, 2), substract(add(C, B), A))
+        .simplify()
+        .toTex());
+    tryToAddWrongProp(propositions, multiply(frac(1, 2), substract(add(A ** 2, B ** 2), C ** 2))
+        .simplify()
+        .toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-50, 50).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const A = triangle.sides[0].getLength() ** 2;
+    const B = triangle.sides[1].getLength() ** 2;
+    const C = triangle.sides[2].getLength() ** 2;
+    return multiply(frac(1, 2), substract(add(C, B), A));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sides = triangle.sides.map((e) => e.toLengthTex()).reverse();
+    const vectors = triangle.sides.map((e) => e.toVector()).reverse();
+    return `Le triangle $${triangle.name}$ est tel que $${sides[0]}$, $${sides[1]}$ et $${sides[2]}$. 
+
+Calculer $${cdot(vectors[0], vectors[1]).toTex()}$.`;
+};
+const getHint = (identifiers) => {
+    return `Si $A$, $B$ et $C$ sont trois points du plan, alors : 
+  
+$$
+\\overrightarrow{AB}\\cdot \\overrightarrow{AC} = \\frac{1}{2}\\left(AB^2 + AC^2 - BC^2 \\right)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sidesInsideNames = triangle.sides
+        .map((e) => e.toInsideName())
+        .reverse();
+    const answerNode = getAnswerNode(identifiers);
+    return `D'après le cours, on a : 
+ 
+${alignTex([
+        [
+            "",
+            `\\overrightarrow{${sidesInsideNames[0]}}\\cdot \\overrightarrow{${sidesInsideNames[1]}}`,
+        ],
+        [
+            "=",
+            `\\frac{1}{2}\\left(${sidesInsideNames[0]}^2 + ${sidesInsideNames[1]}^2 - ${sidesInsideNames[2]}^2 \\right)`,
+        ],
+        ["=", answerNode.toTex()],
+        ["=", answerNode.simplify().toTex()],
+    ])}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.showSidesLength();
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getScalarProductViaNormsQuestion = (ops) => {
+    const triangle = TriangleConstructor.randomNiceSides({
+        randomName: true,
+        intSides: true,
+    });
+    const identifiers = {
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const scalarProductViaNorms = {
+    id: "scalarProductViaNorms",
+    connector: "=",
+    label: "Calculer un produit scalaire (formule des normes)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductViaNormsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA+FF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}
+{"version":3,"file":"calculateFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAyGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.js

@@ -3,37 +3,44 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     const { k, nbEssais } = identifiers;
     addValidProp(propositions, answer);
     tryToAddWrongProp(propositions, k + "");
-    tryToAddWrongProp(propositions, frac(k, 100).toTex());
+    tryToAddWrongProp(propositions, round(k / 100, 2).frenchify());
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+        tryToAddWrongProp(propositions, round(RationalConstructor.randomIrreductible().toTree().evaluate(), 2).frenchify());
     }
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
     const { k, nbEssais } = identifiers;
-    return frac(k, nbEssais).simplify().toTex();
+    return round(k / nbEssais, 2).frenchify();
 };
 const getInstruction = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;
+    let instruction = ";";
     switch (type) {
         case 0: //pièce
-            return `On lance une pièce de monnaie $${nbEssais}$ fois. On tombe $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance une pièce de monnaie $${nbEssais}$ fois. On tombe $${k}$ fois sur ${caracType}.`;
         case 1: //dé 6 faces
-            return `On lance un dé à $6$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance un dé à $6$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}.`;
         case 2: // dé X faces
-            return `On lance un dé à $12$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance un dé à $12$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}.`;
         case 3:
         default: //deux dés 6 faces
-            return `On lance deux dés à $6$ faces $${nbEssais}$ fois. On note la somme obtenue. On tombe $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+            instruction = `On lance deux dés à $6$ faces $${nbEssais}$ fois. On note la somme obtenue. On tombe $${k}$ fois sur ${caracType}.`;
     }
+    instruction += `
+
+Quelle est la fréquence d'apparition de ${caracType} ? Arrondir au centième près.`;
+    return instruction;
 };
 const getHint = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;
@@ -44,15 +51,17 @@ const getCorrection = (identifiers) => {
     return `On a obtenu $${k}$ fois ${caracType} sur les $${nbEssais}$ lancers. La fréquence d'apparition de ${caracType} est donc : 
   
 $$
-${frac(k, nbEssais).toSimplificationString()}
+${frac(k, nbEssais).toTex()} ${approxOrEqual(k / nbEssais, 2).join("")}
 $$`;
 };
 const getKeys = (identifiers) => {
     return [];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, k, nbEssais }) => {
     try {
-        return rationalVEA(ans, answer, { decimalPrecision: 2 });
+        return rationalVEA(ans, frac(k, nbEssais).simplify().toTex(), {
+            decimalPrecision: 2,
+        });
     }
     catch (err) {
         return handleVEAError(err);

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAcpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAyCnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAcpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAiDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -60,10 +60,18 @@ export class GeogebraConstructor {
         }
         else {
             const coords = [
-                xMin === xMax ? xMin - 1 : xMin - Math.max(1, coeff * Math.abs(xDelta)),
-                xMin === xMax ? xMax + 1 : xMax + Math.max(1, coeff * Math.abs(xDelta)),
-                yMin === yMax ? yMin - 1 : yMin - Math.max(1, coeff * Math.abs(yDelta)),
-                yMin === yMax ? yMax + 1 : yMax + Math.max(1, coeff * Math.abs(yDelta)),
+                xMin === xMax
+                    ? xMin - 1
+                    : xMin - Math.max(0.5, coeff * Math.abs(xDelta)),
+                xMin === xMax
+                    ? xMax + 1
+                    : xMax + Math.max(0.5, coeff * Math.abs(xDelta)),
+                yMin === yMax
+                    ? yMin - 1
+                    : yMin - Math.max(0.5, coeff * Math.abs(yDelta)),
+                yMin === yMax
+                    ? yMax + 1
+                    : yMax + Math.max(0.5, coeff * Math.abs(yDelta)),
             ];
             if (showAxes) {
                 coords[0] = Math.min(-1, coords[0]);

package/lib/index.d.ts

@@ -864,6 +864,14 @@ declare const mathExercises: (Exercise<{
     a?: number;
     uCoeffs: number[];
     vCoeffs: number[];
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    uA: number;
 }, {}> | Exercise<{
     a: number;
     k: number;
@@ -1165,6 +1173,16 @@ declare const mathExercises: (Exercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+}, {}> | Exercise<{
+    c: number;
+    vec1Name: string;
+    vec2Name: string;
+    areSameDirection: boolean;
+    vec1ProjLength: number;
+    vec2ProjLength: number;
+    rotationAngle: number;
+}, {}> | Exercise<{
+    triangleIdentifiers: import("./math/geometry/triangle.js").TriangleIdentifiers;
 }, {}> | Exercise<{
     points: import("./math/geometry/point.js").PointIdentifiers[];
     startPointIndex: number;
@@ -1265,6 +1283,13 @@ declare const mathExercises: (Exercise<{
     angleType: string;
     angleIndex: number;
     apexIndex: number;
+}, {}> | Exercise<{
+    lines: {
+        pointA: number[];
+        pointB: number[];
+        label: string;
+    }[];
+    coupleAsked: number;
 }, {}> | Exercise<{
     coeffs: number[];
     to: string;

package/lib/index.d.ts.map

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

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

@@ -2,6 +2,7 @@ import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
 import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
 import { Line } from "./line.js";
+import { Segment } from "./segment.js";
 export type PointIdentifiers = {
     id: "point";
     name: string;
@@ -14,7 +15,7 @@ export declare abstract class PointConstructor {
     static origin(name?: string): Point;
     static random(name: string, min?: number, max?: number): Point;
     static fromIdentifiers(identifiers: PointIdentifiers): Point;
-    static onSegment(A: Point, B: Point, name: string, { spacing, coefficient, }?: {
+    static onSegment(segment: Segment, name: string, { spacing, coefficient, }?: {
         spacing?: number;
         coefficient?: number;
     }): Point;

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":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}

package/lib/math/geometry/point.js

@@ -29,10 +29,10 @@ export class PointConstructor {
     static fromIdentifiers(identifiers) {
         return new Point(identifiers.name, NodeConstructor.fromIdentifiers(identifiers.x), NodeConstructor.fromIdentifiers(identifiers.y));
     }
-    static onSegment(A, B, name, { spacing = 0.1, coefficient, } = {}) {
+    static onSegment(segment, name, { spacing = 0.1, coefficient, } = {}) {
         const coeff = coefficient ?? randfloat(spacing, 1 - spacing);
-        const vector = VectorConstructor.fromPoints(A, B).times(coeff.toTree());
-        const point = vector.getEndPoint(A, name);
+        const vector = VectorConstructor.fromSegment(segment).times(coeff.toTree());
+        const point = vector.getEndPoint(segment.pointA, name);
         return point;
     }
     static randomDifferent(count, { names, minDistance, minDistanceToOrigin, }) {

package/lib/math/geometry/triangle.d.ts

@@ -9,9 +9,10 @@ export type TriangleIdentifiers = {
 };
 export declare abstract class TriangleConstructor {
     static fromIdentifiers(identifiers: TriangleIdentifiers): Triangle;
-    static randomNiceSides({ names, randomName, }: {
+    static randomNiceSides({ names, randomName, intSides, }: {
         names?: string[] | undefined;
         randomName?: boolean | undefined;
+        intSides?: boolean | undefined;
     }): Triangle;
     static randomName(): string[];
 }
@@ -35,12 +36,6 @@ export declare class Triangle {
     props?: TriangleProps;
     constructor(points: Point[], props?: TriangleProps);
     toIdentifiers(): TriangleIdentifiers;
-    /*************  ✨ Codeium Command ⭐  *************/
-    /**
-     * Returns the perimeter of the triangle.
-     * @returns {number} the perimeter of the triangle.
-     */
-    /******  fbb7c5d7-3919-4ef2-b5ba-db0d6770666d  *******/
     getPerimeter(): number;
     getArea(): number;
     isRight(): Boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAE7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,GACnB;;;KAAA,GAAG,QAAQ;IA8BZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IAyClD,aAAa,IAAI,mBAAmB;IAepC,mDAAmD;IACnD;;;OAGG;IACH,uDAAuD;IACvD,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAWH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;CAkB3B"}
+{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,GACjB;;;;KAAA,GAAG,QAAQ;IA8BZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IAyClD,aAAa,IAAI,mBAAmB;IAepC,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAWH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;CAkB3B"}