math-exercises 2.2.81 → 2.2.83

package/lib/exercises/math/sets/intervals/intervalsUnion.js

@@ -3,42 +3,90 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.intervalsUnion = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const intervals_1 = require("../../../../math/sets/intervals/intervals");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const unionIntervalParser_1 = require("../../../../tree/parsers/unionIntervalParser");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
-const getIntervalsUnionQuestion = () => {
-    const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
+const rebuildIdentifiers = (oldIds) => {
+    if (!!oldIds.int1Identifiers)
+        return oldIds;
+    const a1 = oldIds.int1Min === "-infty" || oldIds.int2Min === -Infinity
+        ? infiniteNode_1.MinusInfinityNode
+        : oldIds.int1Min.toTree();
+    const b1 = oldIds.int1Max === "infty" || oldIds.int1Max === Infinity
+        ? infiniteNode_1.PlusInfinityNode
+        : oldIds.int1Max.toTree();
+    const closure1 = oldIds.int1Closure;
+    const interval1 = new intervalNode_1.IntervalNode(a1, b1, closure1);
+    const a2 = oldIds.int2Min === "-infty" || oldIds.int2Min === -Infinity
+        ? infiniteNode_1.MinusInfinityNode
+        : oldIds.int2Min.toTree();
+    const b2 = oldIds.int2Max === "infty" || oldIds.int2Max === Infinity
+        ? infiniteNode_1.PlusInfinityNode
+        : oldIds.int2Max.toTree();
+    const closure2 = oldIds.int2Closure;
+    const interval2 = new intervalNode_1.IntervalNode(a2, b2, closure2);
+    return {
+        int1Identifiers: interval1.toIdentifiers(),
+        int2Identifiers: interval2.toIdentifiers(),
+    };
+};
+const getInstruction = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    return `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$.
+  
+Déterminer $I\\cup J$.`;
+};
+const getAnswer = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
     const set = int1.union(int2);
-    const answer = set.tex;
+    return set.toTex();
+};
+const getIntervalsUnionQuestion = () => {
+    const [int1, int2] = intervalNode_1.IntervalNodeConstructor.differentRandoms(2);
+    const identifiers = {
+        int1Identifiers: int1.toIdentifiers(),
+        int2Identifiers: int2.toIdentifiers(),
+    };
     const question = {
-        answer,
-        instruction: `Soit $I = ${int1.tex}$ et $J = ${int2.tex}$. Déterminer $I\\cup J$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["infty", "lbracket", "rbracket", "semicolon", "cup", "cap"],
         answerFormat: "tex",
-        identifiers: {
-            int1Closure: int1.closure,
-            int1Max: int1.max,
-            int1Min: int1.min,
-            int2Closure: int2.closure,
-            int2Max: int2.max,
-            int2Min: int2.min,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
+const getPropositions = (n, { answer, int1Identifiers, int2Identifiers }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Min.toTree(), int1Max.toTree(), int1Closure);
-    const int2 = new intervals_1.Interval(int2Min.toTree(), int2Max.toTree(), int2Closure);
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int2Identifiers),
+    ];
     (0, exercise_1.tryToAddWrongProp)(propositions, int1.intersection(int2).toTex());
     while (propositions.length < n) {
-        const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
+        const wrongAnswer = intervalNode_1.IntervalNodeConstructor.random().toTex();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    try {
+        const parsed = (0, unionIntervalParser_1.unionIntervalParser)(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.intervalsUnion = {
     id: "intervalsUnion",
@@ -53,4 +101,5 @@ exports.intervalsUnion = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    rebuildIdentifiers,
 };

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

@@ -47,6 +47,8 @@ export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCoords";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCos";
 export * from "../math/geometry/vectors/coordinatesReading";
 export * from "../math/functions/affines/affineExpressionReading";
+export * from "../math/geometry/thales/thales";
+export * from "../math/geometry/thales/thalesCalcul";
 export * from "../math/equaDiff/equaDiffCheckSolutionFirstOrder";
 export * from "../math/equaDiff/equaDiffGeneralForme";
 export * from "../math/equaDiff/equaDiffGeneralFormeWithIC";
@@ -55,4 +57,6 @@ export * from "../math/derivation/derivative/usualderivative";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/thirdDegreeDerivative";
 export { firstDegreeDerivative } from "../math/derivation/derivative/firstDegreeDerivative";
 export { secondDegreeDerivative } from "../math/derivation/derivative/secondDegreeDerivative";
+export * from "../math/trigonometry/trigonometrySideCalcul";
+export * from "../math/trigonometry/trigonometryAngleCalcul";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/pc/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC;AACxD,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AAExB,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,+DAA+D,CAAC;AAC9E,cAAc,4DAA4D,CAAC;AAC3E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAIlE,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC;AACxD,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AAExB,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,+DAA+D,CAAC;AAC9E,cAAc,4DAA4D,CAAC;AAC3E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAC9F,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC"}

package/lib/exercises/pc/index.js

@@ -68,9 +68,8 @@ __exportStar(require("../math/geometry/vectors/scalarProduct/scalarProductViaCoo
 __exportStar(require("../math/geometry/vectors/scalarProduct/scalarProductViaCos"), exports);
 __exportStar(require("../math/geometry/vectors/coordinatesReading"), exports);
 __exportStar(require("../math/functions/affines/affineExpressionReading"), exports);
-//!FIX TRIANGLE
-// export * from "../math/geometry/thales/thales";
-// export * from "../math/geometry/thales/thalesCalcul";
+__exportStar(require("../math/geometry/thales/thales"), exports);
+__exportStar(require("../math/geometry/thales/thalesCalcul"), exports);
 __exportStar(require("../math/equaDiff/equaDiffCheckSolutionFirstOrder"), exports);
 __exportStar(require("../math/equaDiff/equaDiffGeneralForme"), exports);
 __exportStar(require("../math/equaDiff/equaDiffGeneralFormeWithIC"), exports);
@@ -82,6 +81,5 @@ var firstDegreeDerivative_1 = require("../math/derivation/derivative/firstDegree
 Object.defineProperty(exports, "firstDegreeDerivative", { enumerable: true, get: function () { return firstDegreeDerivative_1.firstDegreeDerivative; } });
 var secondDegreeDerivative_1 = require("../math/derivation/derivative/secondDegreeDerivative");
 Object.defineProperty(exports, "secondDegreeDerivative", { enumerable: true, get: function () { return secondDegreeDerivative_1.secondDegreeDerivative; } });
-// export * from "../math/trigonometry/trigonometrySideCalcul";
-// export * from "../math/trigonometry/trigonometryAngleCalcul";
-//!FIX TRIANGLE
+__exportStar(require("../math/trigonometry/trigonometrySideCalcul"), exports);
+__exportStar(require("../math/trigonometry/trigonometryAngleCalcul"), exports);

package/lib/exercises/vea/equationVEA.js

@@ -12,9 +12,9 @@ const equationVEA = (ans, solutionTex) => {
         }
         else {
             const setParsed = (0, discreteSetParser_1.discreteSetParser)(ans);
-            if (!setParsed || setParsed.length !== 1)
+            if (!setParsed || setParsed.elements.length !== 1)
                 return false;
-            return (0, rationalVEA_1.rationalVEA)(setParsed[0].toTex(), solutionTex);
+            return (0, rationalVEA_1.rationalVEA)(setParsed.elements[0].toTex(), solutionTex);
         }
     }
     catch (err) {

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

@@ -1 +1 @@
-{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAelE,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAIlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAelE,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

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

@@ -1 +1 @@
-{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAKlE,8BAAsB,iBAAiB;IACrC,MAAM;CAQP;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAIlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAKlE,8BAAsB,iBAAiB;IACrC,MAAM;CAQP;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/index.d.ts

@@ -354,14 +354,18 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, {}> | Exercise<{
+}, {
+    inequationSolutionFormat: string;
+}> | Exercise<{
     coeff: number;
     ineqType: import("./math/inequations/inequation").InegalitySymbols;
     a: number;
     b: number;
     c: number;
     d: number;
-}, {}> | Exercise<{
+}, {
+    inequationSolutionFormat: string;
+}> | Exercise<{
     k: number;
     inequationSymbol: import("./math/inequations/inequation").InegalitySymbols;
 }, {}> | Exercise<{
@@ -1635,27 +1639,15 @@ declare const mathExercises: (Exercise<{
     points: number[][];
     isArithmetic: boolean;
 }, {}> | Exercise<{
-    intervalMin: string | number;
-    intervalMax: string | number;
-    intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
+    intervalIdentifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
-    int1Min: number;
-    int1Max: number;
-    int1Closure: import("./tree/nodes/sets/closure").ClosureType;
-    int2Min: number;
-    int2Max: number;
-    int2Closure: import("./tree/nodes/sets/closure").ClosureType;
+    int1Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
+    int2Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
-    int1Min: number;
-    int1Max: number;
-    int1Closure: import("./tree/nodes/sets/closure").ClosureType;
-    int2Min: number;
-    int2Max: number;
-    int2Closure: import("./tree/nodes/sets/closure").ClosureType;
+    int1Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
+    int2Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
-    intervalMin: string | number;
-    intervalMax: string | number;
-    intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
+    intervalIdentifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
     type: number;
     nb: string;
@@ -1886,6 +1878,23 @@ declare const pcExercises: (Exercise<{
     isLog10: boolean;
 }, {
     isLog10: boolean;
+}> | Exercise<{
+    vertices: string[];
+    xA: number;
+    yA: number;
+    xB: number;
+    yB: number;
+    xC: number;
+    yC: number;
+    factor: number;
+}, {}> | Exercise<{
+    ratio: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
+    insidePointsNames: string[];
+    segmentAskedName: string;
+    isPapillon: boolean;
+}, {
+    configurationType: string;
 }> | Exercise<{
     xA: number;
     xB: number;
@@ -1907,6 +1916,15 @@ declare const pcExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+}, {}> | Exercise<{
+    randAngle: number;
+    hiddenSide: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
+}, {}> | Exercise<{
+    sideAsked: number;
+    givenSide: number;
+    givenAngle: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
     reactionArray: import("./pc/constants/molecularChemistry/reaction").ReactionSpecies[];
 }, {}> | Exercise<{

package/lib/index.d.ts.map

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

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

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAO1C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAM1C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}

package/lib/math/inequations/inequation.d.ts

@@ -11,6 +11,6 @@ export declare class InequationSymbol {
     reversed: () => InegalitySymbols;
     toReversed: () => InequationSymbol;
     toStrictnessToggled: () => InequationSymbol;
-    strictnessToggled: () => "<" | ">" | "\\le" | "\\ge";
+    strictnessToggled: () => InegalitySymbols;
 }
 //# sourceMappingURL=inequation.d.ts.map

package/lib/math/inequations/inequation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequation.d.ts","sourceRoot":"","sources":["../../../src/math/inequations/inequation.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,gBAAgB,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3D,8BAAsB,2BAA2B;IAC/C,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,YAAY;CAGpB;AACD,qBAAa,gBAAgB;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,gBAAgB,CAAC;gBACb,MAAM,EAAE,gBAAgB;IAKpC,QAAQ,QAAO,gBAAgB,CAW7B;IACF,UAAU,yBAER;IACF,mBAAmB,yBAEjB;IACF,iBAAiB,oCAWf;CACH"}
+{"version":3,"file":"inequation.d.ts","sourceRoot":"","sources":["../../../src/math/inequations/inequation.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,gBAAgB,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3D,8BAAsB,2BAA2B;IAC/C,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,YAAY;CAGpB;AACD,qBAAa,gBAAgB;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,gBAAgB,CAAC;gBACb,MAAM,EAAE,gBAAgB;IAKpC,QAAQ,QAAO,gBAAgB,CAW7B;IACF,UAAU,yBAER;IACF,mBAAmB,yBAEjB;IACF,iBAAiB,QAAO,gBAAgB,CAWtC;CACH"}

package/lib/math/numbers/integer/integer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,iBAAiB,UAK7B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM;IAIN,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMxB,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,iBAAiB,UAK7B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,UAAU;IAIpB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMxB,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}

package/lib/math/numbers/rationals/rational.d.ts

@@ -1,6 +1,5 @@
-import { OppositeNode } from "../../../tree/nodes/functions/oppositeNode";
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode";
 import { NodeOptions } from "../../../tree/nodes/node";
-import { FractionNode } from "../../../tree/nodes/operators/fractionNode";
 import { Integer } from "../integer/integer";
 import { Nombre, NumberType } from "../nombre";
 export declare abstract class RationalConstructor {
@@ -30,7 +29,7 @@ export declare class Rational implements Nombre {
     reverse(shouldSimplify: boolean): Nombre;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
-    toTree(opts?: NodeOptions): FractionNode | OppositeNode<FractionNode>;
+    toTree(opts?: NodeOptions): AlgebraicNode;
     isIrreductible(): boolean;
     simplify(): Integer | Rational;
 }

package/lib/math/numbers/rationals/rational.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAMvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAgBzB,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}
+{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa;IAgBzC,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}

package/lib/math/polynomials/trinom.d.ts

@@ -1,10 +1,8 @@
 import { NumberNode } from "../../tree/nodes/numbers/numberNode";
 import { AddNode } from "../../tree/nodes/operators/addNode";
-import { FractionNode } from "../../tree/nodes/operators/fractionNode";
 import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
 import { Point } from "../geometry/point";
 import { Polynomial } from "./polynomial";
-import { OppositeNode } from "../../tree/nodes/functions/oppositeNode";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare abstract class TrinomConstructor {
     static random(aOpts?: {
@@ -65,9 +63,9 @@ export declare class Trinom extends Polynomial {
     getRootsNode(): AlgebraicNode[];
     getRootsEquationSolutionTex(): string;
     getAlpha(): number;
-    getAlphaNode(): NumberNode | FractionNode | OppositeNode<FractionNode>;
+    getAlphaNode(): AlgebraicNode | NumberNode;
     getBeta(): number;
-    getBetaNode(): NumberNode | FractionNode | OppositeNode<FractionNode>;
+    getBetaNode(): AlgebraicNode | NumberNode;
     getFactorizedForm(): AlgebraicNode | MultiplyNode;
     getCanonicalForm(): AddNode | MultiplyNode;
     getSommet(): Point;

package/lib/math/polynomials/trinom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAE7D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAIvE,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAI1C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAK/D,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM;IAmBT,MAAM,CAAC,eAAe,CACpB,KAAK,CAAC,EAAE;QACN,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACjB,EACD,SAAS,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC/D,QAAQ,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC7D,MAAM;IAmBT,MAAM,CAAC,gBAAgB,CACrB,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,MAAM,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC5D,MAAM,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC3D,MAAM;IAoBT,MAAM,CAAC,eAAe,CAAC,SAAS,GAAE,MAAU;IAqB5C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE;CAGnC;AAED,KAAK,aAAa,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAC1C,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,aAAa;IAQjE,QAAQ;IAGR,YAAY,IAAI,UAAU;IAI1B,QAAQ;IAUR,YAAY,IAAI,aAAa,EAAE;IAyD/B,2BAA2B;IAO3B,QAAQ;IAGR,YAAY;IAIZ,OAAO;IAIP,WAAW;IAIX,iBAAiB;IA4CjB,gBAAgB;IAsBhB,SAAS;IAIT,SAAS;IAYT,QAAQ;IAkCR,aAAa,CACX,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE;;;;KAA4C;CAYrE"}

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAKtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAsDA,eAAO,MAAM,UAAU,YAGtB,CAAC"}

package/lib/playground.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
+const sqrtNode_1 = require("./tree/nodes/functions/sqrtNode");
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
+const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
 const playground = () => {
-    // const a = multiply(-3, power("x", 2));
-    // console.log(isMonom(a));
-    // const a = "-3x^2";
-    // console.log(isMonom(parsed));
+    const a = (0, multiplyNode_1.multiply)(3, (0, sqrtNode_1.sqrt)(2));
+    console.log(a.simplify().toTex());
 };
 exports.playground = playground;
 const logIdentifiers = () => {

package/lib/tree/nodes/equations/equationSolutionNode.d.ts

@@ -23,7 +23,6 @@ export declare class EquationSolutionNode implements Node {
     toAllTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions): EquationSolutionNode[];
     toMathString(): string;
-    toMathjs(): string;
     toTex(): string;
     simplify(): this;
 }

package/lib/tree/nodes/equations/equationSolutionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,KAAK,2BAA2B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC7E,qBAAa,oBAAqB,YAAW,IAAI;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,YAAY,EAAE,eAAe,EAC7B,MAAM,CAAC,EAAE,2BAA2B;IActC,aAAa;;;;;;;;;IAMb,cAAc;IAId,SAAS;IAkBT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;IAGL,QAAQ;CAGT"}
+{"version":3,"file":"equationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,KAAK,2BAA2B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC7E,qBAAa,oBAAqB,YAAW,IAAI;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,YAAY,EAAE,eAAe,EAC7B,MAAM,CAAC,EAAE,2BAA2B;IActC,aAAa;;;;;;;;;IAMb,cAAc;IAId,SAAS;IAkBT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAIZ,KAAK;IAGL,QAAQ;CAGT"}

package/lib/tree/nodes/equations/equationSolutionNode.js

@@ -49,9 +49,6 @@ class EquationSolutionNode {
     toMathString() {
         return "";
     }
-    toMathjs() {
-        return `S={${this.solutionsSet.toMathjs()}}`;
-    }
     toTex() {
         return `S=${this.solutionsSet.toTex()}`;
     }

package/lib/tree/nodes/inequations/inequationNode.d.ts

@@ -18,12 +18,13 @@ export declare class InequationNode implements Node {
         symbols: InegalitySymbols[];
     };
     toInterval(): IntervalNode;
+    /**turns x<3 into 3>x */
     toReversed(): InequationNode;
     toSwitched(): InequationNode;
+    toSwicthedStrictness(): InequationNode;
     toAllValidTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions | undefined): InequationNode[];
     toMathString(): string;
-    toMathjs(): string;
     toAllTexs(): string[];
     toTex(): string;
     simplify(opts?: SimplifyOptions): InequationNode;

package/lib/tree/nodes/inequations/inequationNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAMvD,qBAAa,cAAe,YAAW,IAAI;IACzC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAuBhD,aAAa;;;;;;;IAOb,UAAU;IA6CV,UAAU;IAQV,UAAU;IAMV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;IAGL,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,cAAc;CAcjD;AAED,eAAO,MAAM,kCAAkC,WACrC,MAAM,SACP,gBAAgB,SAChB,aAAa,WAuBrB,CAAC"}
+{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAMvD,qBAAa,cAAe,YAAW,IAAI;IACzC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAuBhD,aAAa;;;;;;;IAOb,UAAU;IA8CV,wBAAwB;IACxB,UAAU;IAQV,UAAU;IAMV,oBAAoB;IAMpB,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,SAAS;IAGT,KAAK;IAGL,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,cAAc;CAcjD;AAED,eAAO,MAAM,kCAAkC,WACrC,MAAM,SACP,gBAAgB,SAChB,aAAa,WAuBrB,CAAC"}

package/lib/tree/nodes/inequations/inequationNode.js

@@ -79,6 +79,7 @@ class InequationNode {
             return new intervalNode_1.IntervalNode(leftIsInf ? infiniteNode_1.MinusInfinityNode : this.children[1], rightIsInf ? infiniteNode_1.PlusInfinityNode : this.children[1], closure);
         }
     }
+    /**turns x<3 into 3>x */
     toReversed() {
         const newChildren = [...this.children].reverse();
         const newSymbols = this.symbols.map((el) => new inequation_1.InequationSymbol(el).reversed());
@@ -87,6 +88,9 @@ class InequationNode {
     toSwitched() {
         return new InequationNode(this.children, this.symbols.map((el) => new inequation_1.InequationSymbol(el).reversed()));
     }
+    toSwicthedStrictness() {
+        return new InequationNode(this.children, this.symbols.map((el) => new inequation_1.InequationSymbol(el).strictnessToggled()));
+    }
     toAllValidTexs() {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }
@@ -105,9 +109,6 @@ class InequationNode {
     toMathString() {
         return this.tex;
     }
-    toMathjs() {
-        return this.tex;
-    }
     toAllTexs() {
         return [this.toTex()];
     }

package/lib/tree/nodes/inequations/inequationSolutionNode.d.ts

@@ -24,7 +24,6 @@ export declare class InequationSolutionNode implements Node {
     toAllValidTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions): (import("./inequationNode").InequationNode | InequationSolutionNode)[];
     toMathString(): string;
-    toMathjs(): string;
     toTex(): string;
     simplify(): this;
 }

package/lib/tree/nodes/inequations/inequationSolutionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,KAAK,6BAA6B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC/E,qBAAa,sBAAuB,YAAW,IAAI;IACjD,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,CAAC;IACnD,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,EAClD,MAAM,CAAC,EAAE,6BAA6B;IAaxC,aAAa;;;;;;;;;IAMb,SAAS;IAUT,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAepC,YAAY;IAGZ,QAAQ;IAGR,KAAK;IAGL,QAAQ;CAGT"}
+{"version":3,"file":"inequationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,KAAK,6BAA6B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC/E,qBAAa,sBAAuB,YAAW,IAAI;IACjD,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,CAAC;IACnD,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,EAClD,MAAM,CAAC,EAAE,6BAA6B;IAaxC,aAAa;;;;;;;;;IAMb,SAAS;IAUT,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAepC,YAAY;IAIZ,KAAK;IAGL,QAAQ;CAGT"}

package/lib/tree/nodes/inequations/inequationSolutionNode.js

@@ -51,9 +51,6 @@ class InequationSolutionNode {
     toMathString() {
         return "";
     }
-    toMathjs() {
-        return `S={${this.intervalSolution.toMathjs()}}`;
-    }
     toTex() {
         return `S=\\ ${this.intervalSolution.toTex()}`;
     }

package/lib/tree/nodes/numbers/numberNode.d.ts

@@ -24,7 +24,7 @@ export declare class NumberNode implements AlgebraicNode {
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): NumberNode | import("../operators/fractionNode").FractionNode | OppositeNode<import("../operators/fractionNode").FractionNode>;
+    simplify(opts?: SimplifyOptions): AlgebraicNode | NumberNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): this;
     derivative(varName?: string | undefined): AlgebraicNode;

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

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAS1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,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,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IA4ErC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAiK/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAU1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,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,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAiK/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

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

@@ -20,6 +20,7 @@ const addNode_1 = require("./addNode");
 const round_1 = require("../../../math/utils/round");
 const colorize_1 = require("../../../utils/latex/colorize");
 const substractNode_1 = require("./substractNode");
+const constantNode_1 = require("../numbers/constantNode");
 function isMultiplyNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.multiply;
 }
@@ -91,10 +92,14 @@ class MultiplyNode {
             return (0, colorize_1.colorize)("-" + rightTex, color);
             // }
         }
+        //!this is atrocious
         let showTimesSign = !opts?.forceDotSign &&
             (opts?.forceTimesSign ||
                 !isNaN(+rightTex[0]) ||
-                (this.rightChild.isNumeric && this.leftChild.isNumeric) ||
+                (this.rightChild.isNumeric &&
+                    this.leftChild.isNumeric &&
+                    !(0, constantNode_1.isConstantNode)(this.rightChild) &&
+                    !(0, sqrtNode_1.isSqrtNode)(this.rightChild)) ||
                 (0, numberNode_1.isNumberNode)(this.rightChild) ||
                 ((0, variableNode_1.isVariableNode)(this.leftChild) &&
                     (0, variableNode_1.isVariableNode)(this.rightChild) &&

package/lib/tree/nodes/sets/closure.d.ts

@@ -11,7 +11,12 @@ export declare abstract class Closure {
     static rightReverse(closure: ClosureType): ClosureType;
     static switch(closure: ClosureType): ClosureType;
     static fromBrackets(left: "[" | "]", right: "]" | "["): ClosureType;
+    static toBrackets(closure: ClosureType): string[];
     static isLeftOpen(closure: ClosureType): boolean;
     static isRightOpen(closure: ClosureType): boolean;
+    static getLessLeftStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
+    static getLessRightStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
+    static getMostLeftStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
+    static getMostRightStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
 }
 //# sourceMappingURL=closure.d.ts.map

package/lib/tree/nodes/sets/closure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"closure.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/closure.ts"],"names":[],"mappings":"AAEA,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,8BAAsB,OAAO;IAC3B,MAAM,CAAC,MAAM;IAcb,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW;IAYnC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;IAYvC,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW;IAYxC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW;IAYlC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;IAQrD,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW;IAUtC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;CAUxC"}
+{"version":3,"file":"closure.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/closure.ts"],"names":[],"mappings":"AAEA,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,8BAAsB,OAAO;IAC3B,MAAM,CAAC,MAAM;IAcb,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW;IAYnC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;IAYvC,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW;IAYxC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW;IAYlC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;IAQrD,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW;IAatC,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW;IAUtC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;IAWvC,MAAM,CAAC,iBAAiB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGpD;IACF,MAAM,CAAC,kBAAkB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGrD;IACF,MAAM,CAAC,iBAAiB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGpD;IACF,MAAM,CAAC,kBAAkB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGrD;CACH"}