math-exercises 2.2.98 → 3.0.0

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/index.js

@@ -1,33 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pcExercises = exports.mathExercises = void 0;
-const MathExercises = __importStar(require("./exercises/math"));
-const PCExercises = __importStar(require("./exercises/pc"));
-require("./prototypesEnhancement");
+import * as MathExercises from "./exercises/math/index.js";
+import * as PCExercises from "./exercises/pc/index.js";
+import "./prototypesEnhancement.js";
 const mathExercises = Object.values(MathExercises);
-exports.mathExercises = mathExercises;
 const pcExercises = Object.values(PCExercises);
-exports.pcExercises = pcExercises;
+export { mathExercises, pcExercises };

package/lib/latexTester.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.latexTester = void 0;
-const latexTester = (latex, isDefaultInMathMode = false) => {
+export const latexTester = (latex, isDefaultInMathMode = false) => {
     let inDollarMode = isDefaultInMathMode ?? false;
     let inDoubleDollarMode = isDefaultInMathMode ?? false;
     let commandModeCount = 0;
@@ -132,7 +129,6 @@ const latexTester = (latex, isDefaultInMathMode = false) => {
         throw new Error("Python not closed");
     return true;
 };
-exports.latexTester = latexTester;
 const mustEscapeCharacters = ["%", "`"];
 const mustBeInMath = ["%", "#", "_", "~", "^"];
 const mustBeInArrays = ["&", "\\tabularnewline", "\\hline"];

package/lib/math/complex/complex.d.ts

@@ -1,7 +1,7 @@
-import { ComplexNode } from "../../tree/nodes/complex/complexNode";
-import { OppositeNode } from "../../tree/nodes/functions/oppositeNode";
-import { NumberNode } from "../../tree/nodes/numbers/numberNode";
-import { FractionNode } from "../../tree/nodes/operators/fractionNode";
+import { ComplexNode } from "../../tree/nodes/complex/complexNode.js";
+import { OppositeNode } from "../../tree/nodes/functions/oppositeNode.js";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
+import { FractionNode } from "../../tree/nodes/operators/fractionNode.js";
 export declare abstract class ComplexConstructor {
     static random(): Complex;
     static randomNotReal(): Complex;
@@ -18,8 +18,8 @@ export declare class Complex {
     times(n: number): Complex;
     opposite(): Complex;
     conjugate(): Complex;
-    toArgumentTree(): import("../../tree/nodes/numbers/constantNode").ConstantNode | NumberNode | FractionNode | OppositeNode<FractionNode> | undefined;
-    toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
+    toArgumentTree(): import("../../tree/nodes/numbers/constantNode.js").ConstantNode | NumberNode | FractionNode | OppositeNode<FractionNode> | undefined;
+    toModuleTree(): import("../../tree/nodes/algebraicNode.js").AlgebraicNode;
     toTree(): ComplexNode;
 }
 //# sourceMappingURL=complex.d.ts.map

package/lib/math/complex/complex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../../src/math/complex/complex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAKvE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAQb,MAAM,CAAC,aAAa;CAQrB;AACD,qBAAa,OAAO;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;gBACC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIlC,aAAa;IAIb,WAAW;IAQX,GAAG,CAAC,CAAC,EAAE,OAAO;IAGd,UAAU,CAAC,CAAC,EAAE,OAAO;IAWrB,QAAQ,CAAC,CAAC,EAAE,OAAO;IAMnB,KAAK,CAAC,CAAC,EAAE,MAAM;IAGf,QAAQ;IAGR,SAAS;IAGT,cAAc;IAqBd,YAAY;IAGZ,MAAM;CAGP"}
+{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../../src/math/complex/complex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAEpE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAK1E,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAQb,MAAM,CAAC,aAAa;CAQrB;AACD,qBAAa,OAAO;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;gBACC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIlC,aAAa;IAIb,WAAW;IAQX,GAAG,CAAC,CAAC,EAAE,OAAO;IAGd,UAAU,CAAC,CAAC,EAAE,OAAO;IAWrB,QAAQ,CAAC,CAAC,EAAE,OAAO;IAMnB,KAAK,CAAC,CAAC,EAAE,MAAM;IAGf,QAAQ;IAGR,SAAS;IAGT,cAAc;IAqBd,YAAY;IAGZ,MAAM;CAGP"}

package/lib/math/complex/complex.js

@@ -1,34 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Complex = exports.ComplexConstructor = void 0;
-const complexNode_1 = require("../../tree/nodes/complex/complexNode");
-const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const piNode_1 = require("../../tree/nodes/numbers/piNode");
-const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
-const rational_1 = require("../numbers/rationals/rational");
-const real_1 = require("../numbers/reals/real");
-const randint_1 = require("../utils/random/randint");
-class ComplexConstructor {
+import { ComplexNode } from "../../tree/nodes/complex/complexNode.js";
+import { OppositeNode } from "../../tree/nodes/functions/oppositeNode.js";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
+import { PiNode } from "../../tree/nodes/numbers/piNode.js";
+import { FractionNode } from "../../tree/nodes/operators/fractionNode.js";
+import { Rational } from "../numbers/rationals/rational.js";
+import { SquareRoot } from "../numbers/reals/real.js";
+import { randint } from "../utils/random/randint.js";
+export class ComplexConstructor {
     static random() {
-        const re = (0, randint_1.randint)(-10, 11);
+        const re = randint(-10, 11);
         let im = 0;
         do {
-            im = (0, randint_1.randint)(-10, 11);
+            im = randint(-10, 11);
         } while (re === 0 && im === 0);
         return new Complex(re, im);
     }
     static randomNotReal() {
-        const re = (0, randint_1.randint)(-10, 11);
+        const re = randint(-10, 11);
         let im = 0;
         do {
-            im = (0, randint_1.randint)(-10, 11, [0]);
+            im = randint(-10, 11, [0]);
         } while (re === 0 && im === 0);
         return new Complex(re, im);
     }
 }
-exports.ComplexConstructor = ComplexConstructor;
-class Complex {
+export class Complex {
+    re;
+    im;
     constructor(re, im) {
         this.re = re;
         this.im = im;
@@ -39,22 +37,22 @@ class Complex {
     inverseNode() {
         const moduleSq = this.moduleSquared();
         const conj = this.conjugate();
-        const invRe = new rational_1.Rational(conj.re, moduleSq).simplify().toTree();
-        const invIm = new rational_1.Rational(conj.im, moduleSq).simplify().toTree();
-        return new complexNode_1.ComplexNode(invRe, invIm);
+        const invRe = new Rational(conj.re, moduleSq).simplify().toTree();
+        const invIm = new Rational(conj.im, moduleSq).simplify().toTree();
+        return new ComplexNode(invRe, invIm);
     }
     add(z) {
         return new Complex(this.re + z.re, this.im + z.im);
     }
     divideNode(z) {
         const moduleSq = z.moduleSquared();
-        const newRe = new rational_1.Rational(this.re * z.re + this.im * z.im, moduleSq)
+        const newRe = new Rational(this.re * z.re + this.im * z.im, moduleSq)
             .simplify()
             .toTree();
-        const newIm = new rational_1.Rational(this.im * z.re - z.im * this.re, moduleSq)
+        const newIm = new Rational(this.im * z.re - z.im * this.re, moduleSq)
             .simplify()
             .toTree();
-        return new complexNode_1.ComplexNode(newRe, newIm);
+        return new ComplexNode(newRe, newIm);
     }
     multiply(z) {
         return new Complex(this.re * z.re - this.im * z.im, this.re * z.im + this.im * z.re);
@@ -72,17 +70,17 @@ class Complex {
         if (this.re === 0 && this.im === 0)
             throw Error("0 n'a pas d'argument");
         if (this.re === 0) {
-            const piOver2 = new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(2));
+            const piOver2 = new FractionNode(PiNode, new NumberNode(2));
             if (this.im > 0)
                 return piOver2;
             else
-                return new oppositeNode_1.OppositeNode(piOver2);
+                return new OppositeNode(piOver2);
         }
         if (this.im === 0) {
             if (this.re > 0)
-                return new numberNode_1.NumberNode(0);
+                return new NumberNode(0);
             else
-                return piNode_1.PiNode;
+                return PiNode;
         }
         if (this.re > 0) {
             //arctan(b/a)
@@ -95,10 +93,9 @@ class Complex {
         }
     }
     toModuleTree() {
-        return new real_1.SquareRoot(this.re ** 2 + this.im ** 2).simplify().toTree();
+        return new SquareRoot(this.re ** 2 + this.im ** 2).simplify().toTree();
     }
     toTree() {
-        return new complexNode_1.ComplexNode(new numberNode_1.NumberNode(this.re), new numberNode_1.NumberNode(this.im));
+        return new ComplexNode(new NumberNode(this.re), new NumberNode(this.im));
     }
 }
-exports.Complex = Complex;

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

@@ -1,6 +1,6 @@
-import { Point, PointIdentifiers } from "./point";
-import { EqualNode } from "../../tree/nodes/equations/equalNode";
-import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { Point, PointIdentifiers } from "./point.js";
+import { EqualNode } from "../../tree/nodes/equations/equalNode.js";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
 export type CloudPointsIdentifiers = {
     pointsIdentifiers: PointIdentifiers[];
 };

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

@@ -1 +1 @@
-{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAgB,MAAM,qCAAqC,CAAC;AAM/E,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAAC;AACF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAU9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,aAAa,IAAI,sBAAsB;IAMvC,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}
+{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EACL,UAAU,EAEX,MAAM,wCAAwC,CAAC;AAMhD,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAAC;AACF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAU9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,aAAa,IAAI,sBAAsB;IAMvC,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}

package/lib/math/geometry/CloudPoints.js

@@ -1,43 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudPoints = exports.CloudPointsConstructor = void 0;
-const point_1 = require("./point");
-const equalNode_1 = require("../../tree/nodes/equations/equalNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const variableNode_1 = require("../../tree/nodes/variables/variableNode");
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const randint_1 = require("../utils/random/randint");
-const covariance_1 = require("../utils/stats/covariance");
-const variance_1 = require("../utils/stats/variance");
-class CloudPointsConstructor {
+import { Point, PointConstructor } from "./point.js";
+import { EqualNode } from "../../tree/nodes/equations/equalNode.js";
+import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../tree/nodes/variables/variableNode.js";
+import { NumberNode, } from "../../tree/nodes/numbers/numberNode.js";
+import { AddNode } from "../../tree/nodes/operators/addNode.js";
+import { randint } from "../utils/random/randint.js";
+import { covarianceXY } from "../utils/stats/covariance.js";
+import { variance } from "../utils/stats/variance.js";
+export class CloudPointsConstructor {
     static random(nbPoints) {
         const names = [];
         for (let i = 0; i < nbPoints; i++) {
             names.push(`a${i}`);
         }
-        return new CloudPoints(point_1.PointConstructor.randomDifferent(nbPoints, { names }));
+        return new CloudPoints(PointConstructor.randomDifferent(nbPoints, { names }));
     }
     static randomLinear(nbPoints) {
         const points = [];
-        const deltaX = (0, randint_1.randint)(2, 6, [0]);
-        const deltaY = (0, randint_1.randint)(2, 6, [0]);
-        const a = (0, randint_1.randint)(-5, 6, [0]);
-        const b = (0, randint_1.randint)(-5, 6);
+        const deltaX = randint(2, 6, [0]);
+        const deltaY = randint(2, 6, [0]);
+        const a = randint(-5, 6, [0]);
+        const b = randint(-5, 6);
         for (let i = -nbPoints * 2; i < nbPoints * 2; i += 4) {
-            points.push(new point_1.Point(`a${i + nbPoints * 2}`, new numberNode_1.NumberNode(i), new numberNode_1.NumberNode(a * i + b)));
+            points.push(new Point(`a${i + nbPoints * 2}`, new NumberNode(i), new NumberNode(a * i + b)));
         }
         points.forEach((point) => {
             const x = point.getXnumber();
             const y = point.getYnumber();
-            point.y = new numberNode_1.NumberNode(y + (0, randint_1.randint)(-deltaX, deltaX + 1));
-            point.x = new numberNode_1.NumberNode(x + (0, randint_1.randint)(-deltaY, deltaY + 1, [deltaX, -deltaX]));
+            point.y = new NumberNode(y + randint(-deltaX, deltaX + 1));
+            point.x = new NumberNode(x + randint(-deltaY, deltaY + 1, [deltaX, -deltaX]));
         });
         return new CloudPoints(points);
     }
 }
-exports.CloudPointsConstructor = CloudPointsConstructor;
-class CloudPoints {
+export class CloudPoints {
+    points;
     constructor(points) {
         this.points = points;
     }
@@ -75,7 +72,7 @@ class CloudPoints {
         }) / this.points.length;
         const a = (avgXY - avgX * avgY) / (avgXsquare * Math.pow(avgX, avgX));
         const b = avgY - a * avgX;
-        return new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(+a.toFixed(2)), new variableNode_1.VariableNode("x")).simplify(), new numberNode_1.NumberNode(+b.toFixed(2))));
+        return new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(+a.toFixed(2)), new VariableNode("x")).simplify(), new NumberNode(+b.toFixed(2))));
     }
     getCorrelationCoeff() {
         const xValues = this.points.map((point) => {
@@ -90,10 +87,9 @@ class CloudPoints {
         const avgY = yValues.reduce((accumulator, nb) => {
             return accumulator + nb;
         }) / this.points.length;
-        const covXY = (0, covariance_1.covarianceXY)(xValues, avgX, yValues, avgY);
-        const xVariance = (0, variance_1.variance)(xValues, avgX);
-        const yVariance = (0, variance_1.variance)(yValues, avgY);
-        return new numberNode_1.NumberNode(+(covXY / Math.sqrt(xVariance * yVariance)).toFixed(2));
+        const covXY = covarianceXY(xValues, avgX, yValues, avgY);
+        const xVariance = variance(xValues, avgX);
+        const yVariance = variance(yValues, avgY);
+        return new NumberNode(+(covXY / Math.sqrt(xVariance * yVariance)).toFixed(2));
     }
 }
-exports.CloudPoints = CloudPoints;

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

@@ -1,6 +1,6 @@
-import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
-import { Point, PointIdentifiers } from "./point";
-import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { Point, PointIdentifiers } from "./point.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
 export declare abstract class AngleConstructor {
     static fromIdentifiers(identifiers: AngleIdentifiers): Angle;
 }
@@ -35,7 +35,7 @@ export declare class Angle {
     isCorrespondant(a: Angle): boolean;
     isSummitOpposite(a: Angle): boolean;
     evaluate(inRadian?: boolean): number;
-    getValueNode(inDegree?: boolean): AlgebraicNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | import("../../tree/nodes/numbers/numberNode").NumberNode;
+    getValueNode(inDegree?: boolean): AlgebraicNode | import("../../tree/nodes/numbers/constantNode.js").ConstantNode | import("../../tree/nodes/numbers/numberNode.js").NumberNode;
     isRight(): boolean;
     toTex(): string;
     toCommands(opts?: {

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

@@ -1 +1 @@
-{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAI1C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;CAgB1D"}
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAI7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;CAgB1D"}

package/lib/math/geometry/angle.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Angle = exports.AngleConstructor = void 0;
-const piNode_1 = require("../../tree/nodes/numbers/piNode");
-const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const round_1 = require("../utils/round");
-const point_1 = require("./point");
-const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
-const vector_1 = require("./vector");
-const line_1 = require("./line");
-class AngleConstructor {
+import { PiNode } from "../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
+import { round } from "../utils/round.js";
+import { PointConstructor } from "./point.js";
+import { reifyAlgebraic, } from "../../tree/nodes/nodeConstructor.js";
+import { VectorConstructor } from "./vector.js";
+import { Line } from "./line.js";
+export class AngleConstructor {
     static fromIdentifiers(identifiers) {
-        return new Angle(identifiers.points.map(point_1.PointConstructor.fromIdentifiers), {
+        return new Angle(identifiers.points.map(PointConstructor.fromIdentifiers), {
             degreeValueNode: identifiers.props?.degreeValueNode
-                ? (0, nodeConstructor_1.reifyAlgebraic)(identifiers.props.degreeValueNode)
+                ? reifyAlgebraic(identifiers.props.degreeValueNode)
                 : undefined,
             radianValueNode: identifiers.props?.radianValueNode
-                ? (0, nodeConstructor_1.reifyAlgebraic)(identifiers.props.radianValueNode)
+                ? reifyAlgebraic(identifiers.props.radianValueNode)
                 : undefined,
         });
     }
 }
-exports.AngleConstructor = AngleConstructor;
-class Angle {
+export class Angle {
+    points;
+    radianValueNode;
+    degreeValueNode;
+    props;
     /**
      *
      * @param points [pointA, pointB, pointC] with apex = B
@@ -33,10 +33,10 @@ class Angle {
         this.radianValueNode = props?.radianValueNode;
         this.degreeValueNode = props?.degreeValueNode;
         if (props?.radianValueNode && !props.degreeValueNode) {
-            this.degreeValueNode = (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(props.radianValueNode, (180).toTree()), piNode_1.PiNode);
+            this.degreeValueNode = frac(multiply(props.radianValueNode, (180).toTree()), PiNode);
         }
         if (props?.degreeValueNode && !props.radianValueNode) {
-            this.radianValueNode = (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(props.degreeValueNode, piNode_1.PiNode), (180).toTree());
+            this.radianValueNode = frac(multiply(props.degreeValueNode, PiNode), (180).toTree());
         }
     }
     toIdentifiers() {
@@ -56,12 +56,12 @@ class Angle {
             return false;
         const vecs = [
             [
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[0]),
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2]),
+                VectorConstructor.fromPoints(this.points[1], this.points[0]),
+                VectorConstructor.fromPoints(this.points[1], this.points[2]),
             ],
             [
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[0]),
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2]),
+                VectorConstructor.fromPoints(a.points[1], a.points[0]),
+                VectorConstructor.fromPoints(a.points[1], a.points[2]),
             ],
         ];
         if (vecs[0][0].hasSameOrientation(vecs[1][0])) {
@@ -87,20 +87,20 @@ class Angle {
             return false;
         if (this.isFlat() || a.isFlat())
             return false;
-        const apexesVec = vector_1.VectorConstructor.fromPoints(this.points[1], a.points[1]);
-        const line = new line_1.Line(this.points[1], a.points[1]);
+        const apexesVec = VectorConstructor.fromPoints(this.points[1], a.points[1]);
+        const line = new Line(this.points[1], a.points[1]);
         const aPointIndexOnLine = a.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
         const thisPointIndexOnLine = this.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
         if (aPointIndexOnLine < 0 || thisPointIndexOnLine < 0)
             return false;
         const vecs = [
             [
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2 - thisPointIndexOnLine]),
+                VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
+                VectorConstructor.fromPoints(this.points[1], this.points[2 - thisPointIndexOnLine]),
             ],
             [
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[aPointIndexOnLine]),
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2 - aPointIndexOnLine]),
+                VectorConstructor.fromPoints(a.points[1], a.points[aPointIndexOnLine]),
+                VectorConstructor.fromPoints(a.points[1], a.points[2 - aPointIndexOnLine]),
             ],
         ];
         return (vecs[0][0].hasSameOrientation(apexesVec) &&
@@ -108,7 +108,7 @@ class Angle {
             vecs[0][1].scalarProduct(vecs[1][1]).evaluate() < 0);
     }
     isFlat() {
-        return vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2]).isColinear(vector_1.VectorConstructor.fromPoints(this.points[1], this.points[0]));
+        return VectorConstructor.fromPoints(this.points[1], this.points[2]).isColinear(VectorConstructor.fromPoints(this.points[1], this.points[0]));
     }
     isCorrespondant(a) {
         if (this.hasSameApex(a))
@@ -116,7 +116,7 @@ class Angle {
         //angles plats ne sont pas créés par intersections de droites donc ne peuvent pas etre correspondants
         if (this.isFlat() || a.isFlat())
             return false;
-        const line = new line_1.Line(this.points[1], a.points[1]);
+        const line = new Line(this.points[1], a.points[1]);
         const aPointIndexOnLine = a.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
         const thisPointIndexOnLine = this.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
         if (aPointIndexOnLine < 0 || thisPointIndexOnLine < 0)
@@ -126,12 +126,12 @@ class Angle {
             return false;
         const vecs = [
             [
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2 - thisPointIndexOnLine]),
+                VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
+                VectorConstructor.fromPoints(this.points[1], this.points[2 - thisPointIndexOnLine]),
             ],
             [
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[aPointIndexOnLine]),
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2 - aPointIndexOnLine]),
+                VectorConstructor.fromPoints(a.points[1], a.points[aPointIndexOnLine]),
+                VectorConstructor.fromPoints(a.points[1], a.points[2 - aPointIndexOnLine]),
             ],
         ];
         return (vecs[0][0].hasSameOrientation(vecs[1][0]) &&
@@ -142,12 +142,12 @@ class Angle {
             return false;
         const vecs = [
             [
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[0]),
-                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2]),
+                VectorConstructor.fromPoints(this.points[1], this.points[0]),
+                VectorConstructor.fromPoints(this.points[1], this.points[2]),
             ],
             [
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[0]),
-                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2]),
+                VectorConstructor.fromPoints(a.points[1], a.points[0]),
+                VectorConstructor.fromPoints(a.points[1], a.points[2]),
             ],
         ];
         if (vecs[0][0].hasOppositeOrientation(vecs[1][0])) {
@@ -173,8 +173,8 @@ class Angle {
             angleRadians += 2 * Math.PI;
         }
         if (inRadian)
-            return (0, round_1.round)(angleRadians, 4);
-        return (0, round_1.round)(angleRadians * (180 / Math.PI), 4);
+            return round(angleRadians, 4);
+        return round(angleRadians * (180 / Math.PI), 4);
     }
     getValueNode(inDegree = false) {
         if (this.degreeValueNode || this.radianValueNode) {
@@ -185,7 +185,7 @@ class Angle {
         const angle = this.evaluate();
         if (inDegree)
             return angle.toTree();
-        return (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(angle, piNode_1.PiNode), 180).simplify();
+        return frac(multiply(angle, PiNode), 180).simplify();
     }
     isRight() {
         const value = this.evaluate();
@@ -200,11 +200,10 @@ class Angle {
             `${name} = Angle(${this.points[0].name},${this.points[1].name},${this.points[2].name}, xAxis)`,
             `ShowLabel(${name}, ${opts?.showValue ? "true" : "false"})`,
         ];
-        cmds.push(`SetCaption(${name}, "$\\footnotesize ${(0, round_1.round)(this.evaluate(), 1).frenchify() + "°"}$")`);
+        cmds.push(`SetCaption(${name}, "$\\footnotesize ${round(this.evaluate(), 1).frenchify() + "°"}$")`);
         if (opts?.color) {
             cmds.push(`SetColor(${name}, "${opts.color}")`);
         }
         return cmds;
     }
 }
-exports.Angle = Angle;

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

@@ -1,5 +1,5 @@
-import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
-import { Point } from "./point";
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
+import { Point } from "./point.js";
 export declare class Circle {
     center: Point;
     point: Point;

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

@@ -1 +1 @@
-{"version":3,"file":"circle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/circle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,MAAM;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAMtD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;CAkC7B"}
+{"version":3,"file":"circle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/circle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,MAAM;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAMtD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;CAkC7B"}

package/lib/math/geometry/circle.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Circle = void 0;
-class Circle {
+export class Circle {
+    center;
+    point;
+    name;
     constructor(center, point, name) {
         this.center = center;
         this.point = point;
@@ -30,4 +30,3 @@ class Circle {
         return commands;
     }
 }
-exports.Circle = Circle;

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

@@ -1,11 +1,11 @@
-import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
-import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
-import { EqualNode } from "../../tree/nodes/equations/equalNode";
-import { AddNode } from "../../tree/nodes/operators/addNode";
-import { SubstractNode } from "../../tree/nodes/operators/substractNode";
-import { Point, PointIdentifiers } from "./point";
-import { Segment } from "./segment";
-import { Vector } from "./vector";
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { EqualNode } from "../../tree/nodes/equations/equalNode.js";
+import { AddNode } from "../../tree/nodes/operators/addNode.js";
+import { SubstractNode } from "../../tree/nodes/operators/substractNode.js";
+import { Point, PointIdentifiers } from "./point.js";
+import { Segment } from "./segment.js";
+import { Vector } from "./vector.js";
 export type LineIdentifiers = {
     name?: string;
     pointA: PointIdentifiers;
@@ -44,7 +44,7 @@ export declare class Line {
     toCartesian(): AddNode;
     toCartesianCoeffs(): {
         a: AlgebraicNode;
-        b: import("../../tree/nodes/functions/oppositeNode").OppositeNode<AlgebraicNode>;
+        b: import("../../tree/nodes/functions/oppositeNode.js").OppositeNode<AlgebraicNode>;
         c: SubstractNode;
     };
     toTex(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;IAmC5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,OAAO,EAAO,MAAM,uCAAuC,CAAC;AAMrE,OAAO,EACL,aAAa,EAEd,MAAM,6CAA6C,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;IAmC5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}