math-exercises 2.2.59 → 2.2.60

package/lib/exercises/math/squareRoots/squareRootsFractions.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+export declare const squareRootsFractions: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=squareRootsFractions.d.ts.map

package/lib/exercises/math/squareRoots/squareRootsFractions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareRootsFractions.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsFractions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8EF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsFractions.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootsFractions = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const rationalParser_1 = require("../../../tree/parsers/rationalParser");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, rational_1.RationalConstructor.randomIrreductible().toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)(b)), (0, multiplyNode_1.multiply)(c, (0, sqrtNode_1.sqrt)(d)))
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return `Simplifier au maximum : 
+  
+$$
+${(0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)(b)), (0, multiplyNode_1.multiply)(c, (0, sqrtNode_1.sqrt)(d))).toTex()}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = (0, rationalParser_1.rationalParser)(ans);
+    if (!parsed)
+        return false;
+    return parsed.simplify().toTex() === answer;
+};
+// a/√b + c/√d
+// avec b/d = q^2 ou b/d = 1/q^2
+const getSquareRootsFractionsQuestion = () => {
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const c = (0, randint_1.randint)(-10, 10, [0]);
+    const q = (0, randint_1.randint)(2, 10);
+    let b;
+    let d;
+    if ((0, coinFlip_1.coinFlip)()) {
+        d = (0, randint_1.randint)(2, 10);
+        b = d * q ** 2;
+    }
+    else {
+        b = (0, randint_1.randint)(2, 10);
+        d = b * q ** 2;
+    }
+    const identifiers = {
+        a,
+        b,
+        c,
+        d,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.squareRootsFractions = {
+    id: "squareRootsFractions",
+    connector: "=",
+    label: "Fractions de racines carrées",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareRootsFractionsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

package/lib/exercises/math/squareRoots/squareRootsToSquare.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor";
+type Identifiers = {
+    a: number;
+    k: NodeIdentifiers;
+    isSquareInside: boolean;
+};
+export declare const squareRootsToSquare: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=squareRootsToSquare.d.ts.map

package/lib/exercises/math/squareRoots/squareRootsToSquare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareRootsToSquare.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsToSquare.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAO1C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,eAAe,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAmHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsToSquare.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootsToSquare = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const oppositeNode_1 = require("../../../tree/nodes/functions/oppositeNode");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const nodeConstructor_1 = require("../../../tree/nodes/nodeConstructor");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const rationalParser_1 = require("../../../tree/parsers/rationalParser");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer, a, isSquareInside, k }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const kNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(k);
+    if (kNode.evaluate() < 0) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, oppositeNode_1.opposite)(getAnswerNode({ a, k, isSquareInside })).toTex());
+    }
+    if (isSquareInside) {
+    }
+    else {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, multiplyNode_1.multiply)(a ** 2, (0, sqrtNode_1.sqrt)(kNode))
+            .simplify()
+            .toTex());
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, multiplyNode_1.multiply)(a, kNode).simplify().toTex());
+    }
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, numberNode_1.isNumberNode)(kNode)
+            ? (0, randint_1.randint)(2, 100).frenchify()
+            : rational_1.RationalConstructor.randomIrreductible().toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { a, k, isSquareInside } = identifiers;
+    const kNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(k);
+    const ansNode = (isSquareInside
+        ? (0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)((0, powerNode_1.square)(kNode)))
+        : (0, powerNode_1.square)((0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)(kNode)))).simplify();
+    return ansNode;
+};
+const getAnswer = (identifiers) => {
+    return `${getAnswerNode(identifiers).toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, k, isSquareInside } = identifiers;
+    const kNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(k);
+    return `Simplifier au maximum : 
+  
+$$
+${(isSquareInside
+        ? (0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)((0, powerNode_1.square)(kNode)))
+        : (0, powerNode_1.square)((0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)(kNode)))).toTex()}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, a, isSquareInside, k }) => {
+    const answerNode = getAnswerNode({ a, isSquareInside, k });
+    const parsed = (0, rationalParser_1.rationalParser)(ans);
+    if (!parsed)
+        return false;
+    const simpTex = parsed.simplify().toTex();
+    return (simpTex === answerNode.toTex() ||
+        simpTex === answerNode.evaluate().frenchify());
+};
+//a √(k^2) ou (a√k)^2
+//avec k=b ou b/c
+const getSquareRootsToSquareQuestion = () => {
+    const a = (0, randint_1.randint)(2, 10);
+    const isSquareInside = (0, coinFlip_1.coinFlip)();
+    const isInt = (0, coinFlip_1.coinFlip)();
+    const k = isInt
+        ? (0, randint_1.randint)(isSquareInside ? -10 : 2, 11, [0, 1]).toTree()
+        : isSquareInside
+            ? rational_1.RationalConstructor.randomIrreductibleWithSign().toTree()
+            : rational_1.RationalConstructor.randomIrreductible().toTree();
+    const identifiers = {
+        a,
+        k: k.toIdentifiers(),
+        isSquareInside,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.squareRootsToSquare = {
+    id: "squareRootsToSquare",
+    connector: "=",
+    label: "Passer une racine carrée au carré",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareRootsToSquareQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    getInstruction,
+};

package/lib/exercises/math/trigonometry/mainAngleMeasure.js

@@ -43,13 +43,13 @@ ${angle.toTex()}
 $$
   `;
 };
-const getHint = (identifiers) => {
-    const angle = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.nodeIds);
-    return `La mesure principale d'un angle en radian est sa valeur appartenant à l'intervalle $]-\\pi; \\pi]$. Il faut donc ajouter (ou retirer) $2\\pi$ à $${angle.toTex()}$ jusqu'à ce que le résultat soit dans cet intervalle.`;
-};
-const getCorrection = (identifiers) => {
-    return `a`;
-};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   const angle = NodeConstructor.fromIdentifiers(identifiers.nodeIds);
+//   return `La mesure principale d'un angle en radian est sa valeur appartenant à l'intervalle $]-\\pi; \\pi]$. Il faut donc ajouter (ou retirer) $2\\pi$ à $${angle.toTex()}$ jusqu'à ce que le résultat soit dans cet intervalle.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return `a`;
+// };
 const getKeys = (identifiers) => {
     return ["pi"];
 };
@@ -67,7 +67,7 @@ const isAnswerValid = (ans, { answer, degree }) => {
 };
 const getMainAngleMeasureQuestion = () => {
     const value = (0, random_1.random)(remarkableValues_1.mainTrigoValues);
-    const multipleOf2PiToAdd = (0, randint_1.randint)(-3, 4, [0]);
+    const multipleOf2PiToAdd = (0, randint_1.randint)(-100, 100, [0]);
     const node = new addNode_1.AddNode(value.angle, new multiplyNode_1.MultiplyNode((2 * multipleOf2PiToAdd).toTree(), piNode_1.PiNode)).simplify();
     const identifiers = {
         degree: value.degree,
@@ -80,8 +80,8 @@ const getMainAngleMeasureQuestion = () => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -97,8 +97,8 @@ exports.mainAngleMeasure = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    getHint,
-    getCorrection,
+    // getHint,
+    // getCorrection,
     getAnswer,
-    hasHintAndCorrection: true,
+    // hasHintAndCorrection: false,
 };

package/lib/index.d.ts

@@ -26,14 +26,19 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     integerFirst: boolean;
     integer: number;
-    rational: [number, number];
+    rational: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
     integer: number;
-    rational: [number, number];
-}, {}> | import("./exercises/exercise").Exercise<{
+    rational: number[];
+    integerFirst: boolean;
+}, {
+    allowNonIrreductible?: boolean | undefined;
+}> | import("./exercises/exercise").Exercise<{
     integer: number;
     rational: [number, number];
-}, {}> | import("./exercises/exercise").Exercise<{
+}, {
+    allowNonIrreductible?: boolean | undefined;
+}> | import("./exercises/exercise").Exercise<{
     rand: number;
     numerator: number;
     denominator: number;
@@ -43,9 +48,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     rationalNum: [number, number];
     rationalDenum: [number, number];
-}, {}> | import("./exercises/exercise").Exercise<{
-    rational: [number, number];
-    rational2: [number, number];
+}, {
+    allowNonIrreductible?: boolean | undefined;
+}> | import("./exercises/exercise").Exercise<{
+    rational: number[];
+    rational2: number[];
 }, {
     allowNonIrreductible?: boolean | undefined;
 }> | import("./exercises/exercise").Exercise<{
@@ -131,13 +138,21 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     xValues: any[];
     yValues: any[];
     isProportionnal: boolean;
-    type: number;
-}, {}> | import("./exercises/exercise").Exercise<{
+    coeffType: string;
+    valuesType: string;
+}, {
+    coeffNumberTypes: string[];
+    valuesNumberTypes: string[];
+}> | import("./exercises/exercise").Exercise<{
     coeffIds: any;
     xValues: any[];
     yValues: any[];
-    type: number;
-}, {}> | import("./exercises/exercise").Exercise<{
+    coeffType: string;
+    valuesType: string;
+}, {
+    coeffNumberTypes: string[];
+    valuesNumberTypes: string[];
+}> | import("./exercises/exercise").Exercise<{
     xValues: number[];
     yValues: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
@@ -1553,6 +1568,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     b: number;
     c: number;
     d: number;
+}, {}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}, {}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    k: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    isSquareInside: boolean;
 }, {}> | import("./exercises/exercise").Exercise<{
     valueIndex: number;
     isCos: boolean;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -13,6 +13,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | OppositeNode | AddNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | OppositeNode | MultiplyNode | AddNode | SubstractNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,UAAU,YAMtB,CAAC"}

package/lib/playground.js

@@ -1,5 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
-const playground = () => { };
+const sqrtNode_1 = require("./tree/nodes/functions/sqrtNode");
+const fractionNode_1 = require("./tree/nodes/operators/fractionNode");
+const powerNode_1 = require("./tree/nodes/operators/powerNode");
+const playground = () => {
+    console.log((0, sqrtNode_1.sqrt)((0, powerNode_1.square)((0, fractionNode_1.frac)(2, 3)))
+        .simplify()
+        .toTex());
+};
 exports.playground = playground;

package/lib/tree/nodes/functions/absNode.d.ts

@@ -18,7 +18,7 @@ export declare class AbsNode implements FunctionNode {
     toTex(): string;
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
-    simplify(): AbsNode;
+    simplify(): AlgebraicNode | AbsNode;
     evaluate(vars?: Record<string, number>): number;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): AbsNode;

package/lib/tree/nodes/functions/absNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"absNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/absNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAOf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ;IAIR,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa;IAI1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAGzD"}
+{"version":3,"file":"absNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/absNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAOf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ;IAUR,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa;IAI1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAGzD"}

package/lib/tree/nodes/functions/absNode.js

@@ -4,6 +4,8 @@ exports.AbsNode = exports.isAbsNode = void 0;
 // import { abs } from "mathjs";
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
+const numberNode_1 = require("../numbers/numberNode");
+const oppositeNode_1 = require("./oppositeNode");
 function isAbsNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.abs;
 }
@@ -42,7 +44,13 @@ class AbsNode {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }
     simplify() {
-        return new AbsNode(this.child.simplify());
+        const childSimplified = this.child.simplify();
+        if ((0, numberNode_1.isNumberNode)(childSimplified))
+            return Math.abs(childSimplified.value).toTree();
+        if ((0, oppositeNode_1.isOppositeNode)(childSimplified)) {
+            return childSimplified.child;
+        }
+        return new AbsNode(childSimplified);
     }
     evaluate(vars) {
         return Math.abs(this.child.evaluate(vars));

package/lib/tree/nodes/functions/sqrtNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK5E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,eAAO,MAAM,IAAI,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,aAItD,CAAC;AAEF,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAmC/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAGzD"}
+{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK5E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMlE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,eAAO,MAAM,IAAI,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,aAItD,CAAC;AAEF,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAyC/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAGzD"}

package/lib/tree/nodes/functions/sqrtNode.js

@@ -9,6 +9,9 @@ const numberNode_1 = require("../numbers/numberNode");
 const multiplyNode_1 = require("../operators/multiplyNode");
 const isInt_1 = require("../../../utils/isInt");
 const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
+const fractionNode_1 = require("../operators/fractionNode");
+const powerNode_1 = require("../operators/powerNode");
+const absNode_1 = require("./absNode");
 function isSqrtNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.sqrt;
 }
@@ -88,6 +91,12 @@ class SqrtNode {
                 return sqrt.simplify().toTree();
             }
             //TODO diviser par 2 les puissances (dont exp)
+            if ((0, powerNode_1.isSquareNode)(a)) {
+                return new absNode_1.AbsNode(a.leftChild).simplify();
+            }
+            if ((0, fractionNode_1.isFractionNode)(a)) {
+                return (0, fractionNode_1.frac)((0, exports.sqrt)(a.leftChild), (0, exports.sqrt)(a.rightChild)).simplify(opts);
+            }
             return new SqrtNode(a);
         };
         const simplifyIteration = () => {

package/lib/tree/nodes/operators/operatorNode.d.ts

@@ -9,7 +9,8 @@ export declare enum OperatorIds {
     power = 5,
     limit = 6,
     integral = 7,
-    binomialCoefficient = 8
+    binomialCoefficient = 8,
+    square = 9
 }
 export interface OperatorNode extends AlgebraicNode {
     id: OperatorIds;

package/lib/tree/nodes/operators/operatorNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operatorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/operatorNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,QAAQ,IAAA;IACR,mBAAmB,IAAA;CACpB;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;CAC3B;AACD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;CAC3B"}
+{"version":3,"file":"operatorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/operatorNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,QAAQ,IAAA;IACR,mBAAmB,IAAA;IACnB,MAAM,IAAA;CACP;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;CAC3B;AACD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;CAC3B"}

package/lib/tree/nodes/operators/operatorNode.js

@@ -13,6 +13,7 @@ var OperatorIds;
     OperatorIds[OperatorIds["limit"] = 6] = "limit";
     OperatorIds[OperatorIds["integral"] = 7] = "integral";
     OperatorIds[OperatorIds["binomialCoefficient"] = 8] = "binomialCoefficient";
+    OperatorIds[OperatorIds["square"] = 9] = "square";
 })(OperatorIds || (exports.OperatorIds = OperatorIds = {}));
 function isOperatorNode(a) {
     return a.type === node_1.NodeType.operator;

package/lib/tree/nodes/operators/powerNode.d.ts

@@ -2,6 +2,7 @@ import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isPowerNode(a: Node): a is PowerNode;
+export declare function isSquareNode(a: Node): a is SquareNode;
 export declare const square: (a: AlgebraicNode | number | string) => SquareNode;
 export declare class PowerNode implements OperatorNode {
     opts?: NodeOptions;

package/lib/tree/nodes/operators/powerNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,eAAO,MAAM,MAAM,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IA8FxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqC/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAGrD"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGlE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,eAAO,MAAM,MAAM,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA2C/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAIrD"}