math-exercises 2.0.21 → 2.0.22

package/lib/exercises/calculLitteral/equation/equationType3Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAgBlC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAiBlC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/calculLitteral/equation/equationType3Exercise.js

@@ -15,15 +15,16 @@ const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
 const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const shuffle_1 = require("../../../utils/shuffle");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const getEquationType3ExerciseQuestion = () => {
     const interval = new intervals_1.Interval("[[-10; 10]]");
     const intervalStar = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)]));
-    const b = intervalStar.getRandomElement();
-    const a = intervalStar.getRandomElement();
-    const c = interval.getRandomElement();
-    const affine = new affine_1.Affine(a.value, b.value).toTree();
-    const solution = new rational_1.Rational(c.value - b.value, a.value).simplify();
-    const statementTree = new equalNode_1.EqualNode(affine, c.toTree());
+    const b = (0, randint_1.randint)(-10, 11, [0]);
+    const a = (0, randint_1.randint)(-10, 11, [0, 1]);
+    const c = (0, randint_1.randint)(-10, 11);
+    const affine = new affine_1.Affine(a, b).toTree();
+    const solution = new rational_1.Rational(c - b, a).simplify();
+    const statementTree = new equalNode_1.EqualNode(affine, new numberNode_1.NumberNode(c));
     const answerTree = new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), solution.toTree());
     const answer = answerTree.toTex();
     const question = {
@@ -32,7 +33,7 @@ const getEquationType3ExerciseQuestion = () => {
         answer,
         keys: equationKeys_1.equationKeys,
         answerFormat: "tex",
-        identifiers: { a: a.value, b: b.value, c: c.value },
+        identifiers: { a, b, c },
     };
     return question;
 };

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA6DF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA8DF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType0.js

@@ -13,8 +13,9 @@ const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**x +b < c */
 const getFirstDegreeInequationsQuestion = () => {
-    const affine = new affine_1.Affine(1, (0, randint_1.randint)(-10, 11));
+    const affine = new affine_1.Affine(1, (0, randint_1.randint)(-10, 11, [0]));
     const c = (0, randint_1.randint)(-10, 11);
     const result = c - affine.b;
     const ineqType = inequation_1.InequationSymbolConstructor.random();

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType1.js

@@ -13,6 +13,7 @@ const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequa
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**ax<b */
 const getFirstDegreeInequationsQuestion = () => {
     const affine = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0, 1]), 0);
     const b = (0, randint_1.randint)(-10, 11);

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType2.js

@@ -13,6 +13,7 @@ const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequa
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**ax+b<c */
 const getFirstDegreeInequationsQuestion = () => {
     const affine = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0, 1]), (0, randint_1.randint)(-10, 10, [0]));
     const c = (0, randint_1.randint)(-10, 11);

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoFF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType3.js

@@ -13,6 +13,7 @@ const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequa
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**ax+b<cx+d */
 const getFirstDegreeInequationsQuestion = () => {
     const affine1 = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0]), (0, randint_1.randint)(-10, 10));
     const affine2 = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0, affine1.a]), (0, randint_1.randint)(-10, 10));

package/lib/exercises/geometry/vectors/alignementViaColinearity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/alignementViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}
+{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/alignementViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkDF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/geometry/vectors/alignementViaColinearity.js

@@ -3,24 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.alignementViaColinearity = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const line_1 = require("../../../math/geometry/line");
 const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
 const getAlignementViaColinearityQuestion = () => {
     const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
-    const line = new line_1.Line(points[0], points[1]);
+    const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let C;
     const isAligned = (0, coinFlip_1.coinFlip)();
+    const coeff = new numberNode_1.NumberNode((0, randint_1.randint)(-4, 4, [0, 1]));
     if (isAligned) {
-        do {
-            C = line.getRandomPoint("C");
-        } while (C.equals(points[0]) || C.equals(points[1]));
+        console.log("1");
+        C = AB.times(coeff).getEndPoint(points[0], "C");
     }
     else {
         do {
+            console.log(`2 : ${AB.x.toTex()} et ${AB.y.toTex()}`);
             C = point_1.PointConstructor.random("C");
-        } while (C.equals(points[0]) || C.equals(points[1]) || line.includes(C));
+        } while (AB.isColinear(vector_1.VectorConstructor.fromPoints(points[0], C)));
     }
     const answer = isAligned ? "Oui" : "Non";
     const question = {
@@ -49,7 +52,7 @@ const getPropositions = (n, { answer }) => {
 };
 exports.alignementViaColinearity = {
     id: "alignementViaColinearity",
-    label: "",
+    label: "Utiliser la colinéarité pour déterminer un alignement",
     levels: ["2nde", "1reSpé"],
     isSingleStep: true,
     sections: ["Vecteurs", "Droites"],

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const fourthParallelogramPoint: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=fourthParallelogramPoint.d.ts.map

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fourthParallelogramPoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/fourthParallelogramPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwDF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fourthParallelogramPoint = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const coordinatesKeys_1 = require("../../../exercises/utils/keys/coordinatesKeys");
+const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getFourthParallelogramPointQuestion = () => {
+    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        D = point_1.PointConstructor.random("D");
+    } while (AB.isColinear(vector_1.VectorConstructor.fromPoints(D, points[0])));
+    const C = AB.getEndPoint(D, "C");
+    const answer = D.toCoords();
+    const question = {
+        answer,
+        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, et $${C.toTexWithCoords()}$. Quelles sont les coordonnées du point $D$ tel que $ABCD$ soit un parallélogramme ?`,
+        keys: coordinatesKeys_1.coordinatesKeys,
+        answerFormat: "tex",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            xD: D.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+            yD: D.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, xC, yA, yB, yC, yD }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    const AB = new vector_1.Vector("u", new numberNode_1.NumberNode(xB - xA), new numberNode_1.NumberNode(yB - yA));
+    const C = new point_1.Point("C", new numberNode_1.NumberNode(xC), new numberNode_1.NumberNode(yC));
+    const fakeD = AB.getEndPoint(C);
+    (0, exercise_1.tryToAddWrongProp)(propositions, fakeD.toCoords());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${(0, randint_1.randint)(-10, 10)};${(0, randint_1.randint)(-10, 10)}\\right)`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [ans, ans.replace(",", ";"), "\\left(" + ans + "\\right)"].includes(answer);
+};
+exports.fourthParallelogramPoint = {
+    id: "fourthParallelogramPoint",
+    label: "Déterminer les coordonnées du quatrième point d'un parallélogramme",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFourthParallelogramPointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/vectors/index.d.ts

@@ -5,4 +5,8 @@ export * from "./scalarProductViaCoords";
 export * from "./vectorCoordinatesFromTwoPoints";
 export * from "./scalarProductViaCos";
 export * from "./colinearity";
+export * from "./alignementViaColinearity";
+export * from "./paralellismViaColinearity";
+export * from "./parallelogramViaEqualVectors";
+export * from "./fourthParallelogramPoint";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/geometry/vectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC"}

package/lib/exercises/geometry/vectors/index.js

@@ -21,4 +21,7 @@ __exportStar(require("./scalarProductViaCoords"), exports);
 __exportStar(require("./vectorCoordinatesFromTwoPoints"), exports);
 __exportStar(require("./scalarProductViaCos"), exports);
 __exportStar(require("./colinearity"), exports);
-// export * from "./alignementViaColinearity";
+__exportStar(require("./alignementViaColinearity"), exports);
+__exportStar(require("./paralellismViaColinearity"), exports);
+__exportStar(require("./parallelogramViaEqualVectors"), exports);
+__exportStar(require("./fourthParallelogramPoint"), exports);

package/lib/exercises/geometry/vectors/paralellismViaColinearity.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const paralellismViaColinearity: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=paralellismViaColinearity.d.ts.map

package/lib/exercises/geometry/vectors/paralellismViaColinearity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paralellismViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/paralellismViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA2DF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAY/D,CAAC"}

package/lib/exercises/geometry/vectors/paralellismViaColinearity.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paralellismViaColinearity = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const line_1 = require("../../../math/geometry/line");
+const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getParalellismViaColinearityQuestion = () => {
+    let points = [];
+    do {
+        points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    } while (points[0].x.equals(points[1].x));
+    const line = new line_1.Line(points[0], points[1]);
+    let C;
+    do {
+        C = point_1.PointConstructor.random("C");
+    } while (line.includes(C));
+    let D;
+    const coeff = new numberNode_1.NumberNode((0, randint_1.randint)(-4, 4, [0]));
+    const parallele = line.getParallele(C);
+    const isParallele = (0, coinFlip_1.coinFlip)();
+    if (isParallele) {
+        D = vector_1.VectorConstructor.fromPoints(points[0], points[1])
+            .times(coeff)
+            .getEndPoint(C, "D");
+    }
+    else {
+        do {
+            D = point_1.PointConstructor.random("D");
+        } while (parallele.includes(D));
+    }
+    const answer = isParallele ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, $${C.toTexWithCoords()}$ et $${D.toTexWithCoords()}$. Les droites $(AB)$ et $(CD)$ sont-elles parallèles ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            xD: D.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+            yD: D.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.paralellismViaColinearity = {
+    id: "paralellismViaColinearity",
+    label: "Utiliser la colinéarité pour déterminer un parallélisme",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParalellismViaColinearityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/parallelogramViaEqualVectors.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const parallelogramViaEqualVectors: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramViaEqualVectors.d.ts.map

package/lib/exercises/geometry/vectors/parallelogramViaEqualVectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramViaEqualVectors.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/parallelogramViaEqualVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyDF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAYlE,CAAC"}

package/lib/exercises/geometry/vectors/parallelogramViaEqualVectors.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelogramViaEqualVectors = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getParallelogramViaEqualVectorsQuestion = () => {
+    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        console.log(`1 : points: ${points.map((p) => p.toCoords())}, vec : ${AB.x.toTex()} et ${AB.y.toTex()}`);
+        D = point_1.PointConstructor.random("D");
+    } while (AB.isColinear(vector_1.VectorConstructor.fromPoints(D, points[0])));
+    let C;
+    const isParallelogram = (0, coinFlip_1.coinFlip)();
+    if (isParallelogram) {
+        C = AB.getEndPoint(D, "C");
+    }
+    else {
+        do {
+            console.log("2");
+            C = point_1.PointConstructor.random("C");
+        } while (AB.equals(vector_1.VectorConstructor.fromPoints(D, C)));
+    }
+    const answer = isParallelogram ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, $${C.toTexWithCoords()}$ et $${D.toTexWithCoords()}$. $ABCD$ est-il un parallélogramme ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            xD: D.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+            yD: D.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.parallelogramViaEqualVectors = {
+    id: "parallelogramViaEqualVectors",
+    label: "Utiliser les vecteurs pour reconnaître un parallélogramme",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParallelogramViaEqualVectorsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vectorCoordinatesFromTwoPoints.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AAuDF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CAapE,CAAC"}
+{"version":3,"file":"vectorCoordinatesFromTwoPoints.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AAyDF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CAapE,CAAC"}

package/lib/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.js

@@ -35,7 +35,7 @@ const getPropositions = (n, { answer, A, B }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return [ans, ans.replace(",", ";"), "\\left(" + ans + "\\right)"].includes(answer);
 };
 exports.vectorCoordinatesFromTwoPoints = {
     id: "vectorCoordinatesFromTwoPoints",

package/lib/exercises/sequences/arithmetic/arithmeticFindExplicitFormula.js

@@ -17,7 +17,7 @@ const getArithmeticFindExplicitFormula = () => {
     const question = {
         instruction: `$(u_n)$ est une suite arithmétique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $r = ${reason}$. $\\\\$ Donner l'expression de $u_n$ en fonction de $n$.`,
         answer,
-        keys: ["un", "equal", "r", "n", "u", "underscore"],
+        keys: ["un", "equal", "n"],
         answerFormat: "tex",
         identifiers: { firstValue, reason },
     };

package/lib/exercises/sequences/geometric/geometricFindExplicitFormula.js

@@ -19,7 +19,7 @@ const getGeometricFindExplicitFormula = () => {
     const question = {
         instruction: `$(u_n)$ est une suite géométrique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $q = ${reason}$. $\\\\$ Donner l'expression de $u_n$ en fonction de $n$.`,
         answer,
-        keys: ["un", "equal", "q", "n", "u", "underscore"],
+        keys: ["un", "equal", "n"],
         answerFormat: "tex",
         identifiers: { reason, firstValue },
     };

package/lib/exercises/utils/keys/coordinatesKeys.d.ts

@@ -0,0 +1,3 @@
+import { KeyId } from "../../../types/keyIds";
+export declare const coordinatesKeys: KeyId[];
+//# sourceMappingURL=coordinatesKeys.d.ts.map

package/lib/exercises/utils/keys/coordinatesKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinatesKeys.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/keys/coordinatesKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,eAAO,MAAM,eAAe,EAAE,KAAK,EAAsC,CAAC"}

package/lib/exercises/utils/keys/coordinatesKeys.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coordinatesKeys = void 0;
+exports.coordinatesKeys = ["lbrace", "semicolon", "rbrace"];

package/lib/index.d.ts

@@ -515,6 +515,40 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     yu: number;
     xv: number;
     yv: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    yA: number;
+    yB: number;
+    yC: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
 }> | import("./exercises/exercise").MathExercise<{
     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":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

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

@@ -7,6 +7,7 @@ export declare class Line {
     a: AlgebraicNode | undefined;
     b: AlgebraicNode | undefined;
     constructor(pointA: Point, pointB: Point);
+    getParallele(point: Point): Line;
     includes(point: Point): boolean;
     getRandomPoint(name?: string): Point;
 }

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,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,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;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,QAAQ,CAAC,KAAK,EAAE,KAAK;IAWrB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;CAY7B"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,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;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IAUzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;CAa7B"}

package/lib/math/geometry/line.js

@@ -22,18 +22,30 @@ class Line {
             this.b = new substractNode_1.SubstractNode(this.pointA.y, new multiplyNode_1.MultiplyNode(this.a, this.pointA.x)).simplify();
         }
     }
+    getParallele(point) {
+        if (this.isVertical) {
+            console.log(this.pointA.toTexWithCoords(), this.pointB.toTexWithCoords());
+            throw Error("Parallel vertical lines not implemented");
+        }
+        const x = new addNode_1.AddNode(point.x, new numberNode_1.NumberNode(1)).simplify();
+        const y = new addNode_1.AddNode(point.y, this.a).simplify();
+        const secondPoint = new point_1.Point("D", x, y);
+        return new Line(point, secondPoint);
+    }
     includes(point) {
         if (this.isVertical) {
             return point.x.equals(this.pointA.x);
         }
         return (new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({}) === 0);
     }
+    //! caution: simplify ne gère pas bien ici
     getRandomPoint(name) {
         if (this.isVertical) {
             return new point_1.Point(name ?? "A", this.pointA.x, new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10)));
         }
         const x = new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10));
         const y = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, x), this.b).simplify();
+        console.log(y.toTex(), this.a.toTex(), x.toTex(), this.b?.toTex());
         return new point_1.Point(name ?? "A", x, y);
     }
 }

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":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAKlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,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;CAK7B"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,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;CAK7B"}

package/lib/math/geometry/point.js

@@ -22,6 +22,7 @@ class PointConstructor {
                 x = (0, randint_1.randint)(-10, 11);
                 y = (0, randint_1.randint)(-10, 11);
             } while (points.some((point) => point[0] === x && point[1] === y));
+            points.push([x, y]);
             res.push(new Point(names[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y)));
         }
         return res;

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

@@ -17,5 +17,7 @@ export declare class Vector {
     determinant(v: Vector): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): Vector;
     scalarProduct(v: Vector): Node;
+    getEndPoint(startPoint: Point, name?: string): Point;
+    equals(v: Vector): boolean;
 }
 //# sourceMappingURL=vector.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAKvD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAcrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;CAa/B"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAMvD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAcrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAc9B,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;CAGjB"}

package/lib/math/geometry/vector.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector = exports.VectorConstructor = void 0;
 const node_1 = require("../../tree/nodes/node");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
 const randint_1 = require("../utils/random/randint");
+const point_1 = require("./point");
 class VectorConstructor {
     static fromPoints(origin, end) {
         return new Vector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x).simplify(), new substractNode_1.SubstractNode(end.y, origin.y).simplify());
@@ -55,5 +57,11 @@ class Vector {
         const vyValue = v.y.value;
         return new numberNode_1.NumberNode(xValue * vxValue + yValue * vyValue);
     }
+    getEndPoint(startPoint, name) {
+        return new point_1.Point(name ?? "B", new addNode_1.AddNode(startPoint.x, this.x).simplify(), new addNode_1.AddNode(startPoint.y, this.y).simplify());
+    }
+    equals(v) {
+        return this.x.equals(v.x) && this.y.equals(v.y);
+    }
 }
 exports.Vector = Vector;

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

@@ -1,3 +1,4 @@
+import { OppositeNode } from '../../../tree/nodes/functions/oppositeNode';
 import { NumberNode } from '../../../tree/nodes/numbers/numberNode';
 import { MultiplyNode } from '../../../tree/nodes/operators/multiplyNode';
 import { SubstractNode } from '../../../tree/nodes/operators/substractNode';
@@ -11,6 +12,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | OppositeNode | SubstractNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}
+{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}

package/lib/server.js

@@ -35,41 +35,12 @@ const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
-const decimal_1 = require("./math/numbers/decimals/decimal");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
-    // const string = "\\frac{9}{12}";
-    // const a = string.match(/^[0-9]+,?[0-9]*/);
-    // const before = Date.now();
-    // const parsed = parseLatex(string);
-    // console.log("res", parsed);
-    // console.log(parsed?.toTex());
-    // console.log(parsed?.simplify().toTex());
-    // console.log(parsed?.evaluate({ x: 1 }));
-    // console.log("time", Date.now() - before);
-    // tokenize(string);
-    // const a = DecimalConstructor.random(-4, 8);
-    // const a = new Decimal(-0.0009343);
-    // console.log(a.value, a.multiplyByPowerOfTen(-2).toTree().toTex());
-    // const b = new Decimal(0.0009343);
-    // console.log(b.value, b.multiplyByPowerOfTen(-2).toTree().toTex());
-    // const c = new Decimal(-2.00009343);
-    // console.log(c.value, c.multiplyByPowerOfTen(-2).toTree().toTex());
-    // const d = new Decimal(2.009343);
-    // console.log(d.value, d.multiplyByPowerOfTen(-2).toTree().toTex());
-    const power = 1;
-    const a = new decimal_1.Decimal(-0.00400250009343);
-    console.log(a.value, a.multiplyByPowerOfTen(power).toTree().toTex());
-    const b = new decimal_1.Decimal(0.04010009343);
-    console.log(b.value, b.multiplyByPowerOfTen(power).toTree().toTex());
-    const c = new decimal_1.Decimal(-23.00009343);
-    console.log(c.value, c.multiplyByPowerOfTen(power).toTree().toTex());
-    const d = new decimal_1.Decimal(20.4009343);
-    console.log(d.value, d.multiplyByPowerOfTen(power).toTree().toTex());
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

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

@@ -1,5 +1,6 @@
 import { Node, NodeOptions, NodeType } from "../node";
 import { FunctionNode, FunctionsIds } from "./functionNode";
+import { NumberNode } from "../numbers/numberNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isOppositeNode(a: Node): a is OppositeNode;
 export declare class OppositeNode implements FunctionNode {
@@ -19,7 +20,7 @@ export declare class OppositeNode implements FunctionNode {
      */
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode | NumberNode;
     equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=oppositeNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,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,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAG/B,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAgB,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,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,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAI/B,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

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

@@ -71,6 +71,8 @@ class OppositeNode {
         return -this.child.evaluate(vars);
     }
     simplify(opts) {
+        if ((0, numberNode_1.isNumberNode)(this.child))
+            return new numberNode_1.NumberNode(-this.child.value);
         return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(-1), this.child).simplify(opts);
     }
     equals(node) {

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

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAmF/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyF/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

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

@@ -78,6 +78,12 @@ class FractionNode {
         const simplifiedNum = this.leftChild.simplify(opts);
         const simplifiedDenum = this.rightChild.simplify(opts);
         const copy = new FractionNode(simplifiedNum, simplifiedDenum, this.opts);
+        if ((0, numberNode_1.isNumberNode)(simplifiedDenum) && simplifiedDenum.value === 1) {
+            return simplifiedNum;
+        }
+        if ((0, numberNode_1.isNumberNode)(simplifiedDenum) && simplifiedDenum.value === -1) {
+            return new oppositeNode_1.OppositeNode(simplifiedNum).simplify(opts);
+        }
         const externalsNums = [];
         const externalsDenums = [];
         const recursiveNums = (node) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.0.21",
+  "version": "2.0.22",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [