math-exercises 2.2.51 → 2.2.53

package/lib/geogebra/spline.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "../math/geometry/point";
+import { IntervalNode } from "../tree/nodes/sets/intervalNode";
+export declare abstract class SplineConstructor {
+    random(): Spline;
+}
+export declare class Spline {
+    points: number[][];
+    constructor(interval: IntervalNode, points?: Point[]);
+    getCommands(): string[];
+}
+//# sourceMappingURL=spline.d.ts.map

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

@@ -0,0 +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"}

package/lib/geogebra/spline.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spline = exports.SplineConstructor = void 0;
+const randfloat_1 = require("../math/utils/random/randfloat");
+const randint_1 = require("../math/utils/random/randint");
+const closure_1 = require("../tree/nodes/sets/closure");
+const intervalNode_1 = require("../tree/nodes/sets/intervalNode");
+const doWhile_1 = require("../utils/doWhile");
+const colors_1 = require("./colors");
+class SplineConstructor {
+    random() {
+        const a = (0, randint_1.randint)(-10, 0);
+        const b = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(0, 10), (x) => Math.abs(x - a) < 5);
+        return new Spline(new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure_1.ClosureType.FF));
+    }
+}
+exports.SplineConstructor = SplineConstructor;
+class Spline {
+    constructor(interval, points) {
+        const a = interval.a.evaluate({});
+        const b = interval.b.evaluate();
+        this.points = [];
+        const sortedPoints = points
+            ?.map((a) => [a.x.evaluate({}), a.y.evaluate({})])
+            .sort((a, b) => a[0] - b[0]);
+        if (!Number.isFinite(a) || !Number.isFinite(b))
+            throw Error("unimplement infinity spline");
+        const length = Math.abs(b - a);
+        const nbOfSlices = sortedPoints?.length
+            ? sortedPoints.length + 3
+            : (0, randint_1.randint)(4, 8);
+        const step = length / nbOfSlices;
+        const yCoeff = 1 / nbOfSlices;
+        for (let i = 0; i < nbOfSlices; i++) {
+            const xMin = a + i * step;
+            const xMax = xMin + step;
+            if (i === 0) {
+                const pointInSlice = sortedPoints?.length && sortedPoints[0][0] < xMax;
+                this.points.push([
+                    a,
+                    pointInSlice
+                        ? sortedPoints[0][1] + yCoeff * (0, randfloat_1.randfloat)(-2, 3)
+                        : (0, randfloat_1.randfloat)(-10, 10),
+                ]);
+            }
+            const fittedPoints = sortedPoints?.filter((point) => point[0] >= xMin && point[0] < xMax);
+            this.points.push(...(fittedPoints ?? []));
+            if (!fittedPoints?.length && i > 0 && i < nbOfSlices - 1) {
+                const nextYInSlice = sortedPoints?.find((p) => p[0] >= xMax && p[0] < xMax + step)?.[1];
+                const x = (0, randfloat_1.randfloat)(xMin + step / 4, xMax - step / 4, 6);
+                const prevy = this.points[this.points.length - 1][1];
+                const y = nextYInSlice !== undefined
+                    ? prevy + (nextYInSlice - prevy) / 2
+                    : prevy + yCoeff * (0, randfloat_1.randfloat)(-3, 4, 5);
+                this.points.push([x, y]);
+            }
+            if (i === nbOfSlices - 1) {
+                const prevY = this.points[this.points.length - 1][1];
+                this.points.push([b, prevY + yCoeff * (0, randfloat_1.randfloat)(-2, 3)]);
+            }
+        }
+    }
+    getCommands() {
+        const commands = [
+            `S = Spline(${this.points
+                .map((point) => `(${point[0]},${point[1]})`)
+                .join(",")})`,
+            "SetFixed(S, true)",
+            `SetColor(S, "${(0, colors_1.randomColor)()}")`,
+        ];
+        return commands;
+    }
+}
+exports.Spline = Spline;

package/lib/index.d.ts

@@ -126,6 +126,17 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     scale: number;
     isSmallScale: boolean;
     fakeDistance: number;
+}, {}> | import("./exercises/exercise").Exercise<{
+    coeffIds: any;
+    xValues: any[];
+    yValues: any[];
+    isProportionnal: boolean;
+    type: number;
+}, {}> | import("./exercises/exercise").Exercise<{
+    coeffIds: any;
+    xValues: any[];
+    yValues: any[];
+    type: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     precisionAsked: number;
     decimal: number;
@@ -254,6 +265,16 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     solutionNodeIds: any;
     equationNodeIds: any;
 }, {}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}, {
+    integerSolutions: boolean;
+}> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
 }, {}> | import("./exercises/exercise").Exercise<{
@@ -603,10 +624,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     poly2: number[];
     xValue: number;
 }, {}> | import("./exercises/exercise").Exercise<{
-    rand: boolean;
-    poly1: number[];
-    poly2: number[];
-    xValue: number;
+    isSpline: boolean;
+    splinePoints: number[][];
+    x: number;
+    y: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     poly1: number[];
     xValue: number;
@@ -1247,7 +1268,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     AD: number;
     BC: number;
     BD: number;
-}, {}> | import("./exercises/exercise").Exercise<{
+}, {
+    allowApproximate: string;
+}> | import("./exercises/exercise").Exercise<{
     randomValues: number[];
     randomEffectives: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
@@ -1299,7 +1322,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     event: string;
     type: string;
     probaFrac: number[];
-}, {}> | import("./exercises/exercise").Exercise<{
+}, {
+    allowNonIrreductible?: boolean | undefined;
+}> | import("./exercises/exercise").Exercise<{
     nX: number;
     a: number;
     b: number;
@@ -1485,6 +1510,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     x: number;
     y: number;
     z: number | undefined;
+}, {}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     valueIndex: number;
     isCos: boolean;

package/lib/index.d.ts.map

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

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -2,10 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const playground = () => {
-    // const mul = new MultiplyNode(
-    //   new SqrtNode((2).toTree()),
-    //   (-1).toTree(),
-    // ).simplify();
-    // console.log(mul.toTex());
+    // const node = multiply(sqrt(3), sqrt(8)).simplify();
+    // console.log(node.toTex());
 };
 exports.playground = playground;

package/lib/tree/nodes/algebraicNode.d.ts

@@ -5,6 +5,7 @@ export type SimplifyOptions = {
     keepPowers?: boolean;
     scientific?: number;
     isDegree?: boolean;
+    towardsDistribute?: boolean;
 };
 export interface AlgebraicNode extends Node {
     evaluate: (vars?: Record<string, number>) => number;

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}

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

@@ -1,4 +1,6 @@
+import { AlgebraicNode } from "../algebraicNode";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
+export declare const equal: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => EqualNode;
 export declare const isEqualNode: (node: Node) => node is EqualNode;
 export declare class EqualNode implements Node {
     leftChild: Node;

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

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/D,eAAO,MAAM,WAAW,SAAU,IAAI,sBACL,CAAC;AAElC,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,aAAa;;;;;;;;;IAOb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAUT"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/D,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,eAAO,MAAM,WAAW,SAAU,IAAI,sBACL,CAAC;AAElC,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,aAAa;;;;;;;;;IAOb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAUT"}

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

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EqualNode = exports.isEqualNode = void 0;
+exports.EqualNode = exports.isEqualNode = exports.equal = void 0;
 const node_1 = require("../node");
+const equal = (a, b) => {
+    const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
+    const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
+    return new EqualNode(nodeA, nodeB);
+};
+exports.equal = equal;
 const isEqualNode = (node) => node.type === node_1.NodeType.equality;
 exports.isEqualNode = isEqualNode;
 class EqualNode {

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

@@ -1,13 +1,14 @@
 import { InegalitySymbols } from "../../../math/inequations/inequation";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { IntervalNode } from "../sets/intervalNode";
+import { AlgebraicNode } from "../algebraicNode";
 export declare class InequationNode implements Node {
     opts?: NodeOptions | undefined;
     type: NodeType;
     tex: string;
-    children: Node[];
+    children: AlgebraicNode[];
     symbols: InegalitySymbols[];
-    constructor(children: Node[], symbols: InegalitySymbols[] | InegalitySymbols);
+    constructor(children: AlgebraicNode[], symbols: InegalitySymbols[] | InegalitySymbols);
     toIdentifiers(): {
         id: NodeIds;
         children: ({

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;AAEpD,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,IAAI,EAAE,CAAC;IACjB,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,IAAI,EAAE,EAChB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAuBhD,aAAa;;;;;;;IAOb,UAAU;IA6CV,UAAU;IAQV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;IAGL,QAAQ;CAGT"}
+{"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,MAAM,kBAAkB,CAAC;AAEjD,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,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;IAGL,QAAQ;CAGT"}

package/lib/tree/nodes/nodeConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAkBvC,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjD,IAAI;CAwQR"}
+{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAkBvC,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjD,IAAI;CA4QR"}

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

@@ -2,7 +2,7 @@ import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node";
 import { CommutativeOperatorNode, OperatorIds } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isMultiplyNode(a: Node): a is MultiplyNode;
-export declare const multiply: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => MultiplyNode;
+export declare const multiply: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string, opts?: NodeOptions) => MultiplyNode;
 export declare const sortMultiplyNodes: (arr: AlgebraicNode[]) => void;
 export declare class MultiplyNode implements CommutativeOperatorNode {
     opts?: NodeOptions;

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;AAQ1B,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,iBAOnC,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;IAoErC,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;IA4H/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAMzD"}
+{"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;IAqErC,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;IAoJ/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAMzD"}

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

@@ -19,14 +19,15 @@ const functionNode_1 = require("../functions/functionNode");
 const addNode_1 = require("./addNode");
 const round_1 = require("../../../math/utils/round");
 const colorize_1 = require("../../../utils/latex/colorize");
+const substractNode_1 = require("./substractNode");
 function isMultiplyNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.multiply;
 }
 exports.isMultiplyNode = isMultiplyNode;
-const multiply = (a, b) => {
+const multiply = (a, b, opts) => {
     const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
     const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
-    return new MultiplyNode(nodeA, nodeB);
+    return new MultiplyNode(nodeA, nodeB, opts);
 };
 exports.multiply = multiply;
 const sortMultiplyNodes = (arr) => {
@@ -92,7 +93,8 @@ class MultiplyNode {
                 (0, numberNode_1.isNumberNode)(this.rightChild) ||
                 ((0, variableNode_1.isVariableNode)(this.leftChild) &&
                     (0, variableNode_1.isVariableNode)(this.rightChild) &&
-                    this.leftChild.name === this.rightChild.name));
+                    this.leftChild.name === this.rightChild.name) ||
+                ((0, sqrtNode_1.isSqrtNode)(this.leftChild) && (0, sqrtNode_1.isSqrtNode)(this.rightChild)));
         if ((0, operatorNode_1.isOperatorNode)(this.rightChild)) {
             showTimesSign ||= [operatorNode_1.OperatorIds.fraction].includes(this.rightChild.id);
         }
@@ -235,36 +237,40 @@ class MultiplyNode {
         const leftSimplified = this.leftChild.simplify(opts);
         const rightSimplified = this.rightChild.simplify(opts);
         const copy = new MultiplyNode(leftSimplified, rightSimplified, this.opts);
-        /**get externals nodes
+        /**get externals nodes (= extremités du sous arbre non multiplicatif)
          * les opposites sont supprimés et on ajoute *-1 à la fin si leur nb est impair
          */
-        let externals = [];
-        let oppositesCount = 0;
-        const recursive = (node) => {
-            if (isMultiplyNode(node)) {
-                recursive(node.leftChild);
-                recursive(node.rightChild);
-            }
-            else if ((0, oppositeNode_1.isOppositeNode)(node)) {
-                oppositesCount++;
-                recursive(node.child);
-            }
-            else if ((0, numberNode_1.isNumberNode)(node) && node.value < 0) {
-                oppositesCount++;
-                externals.push(new numberNode_1.NumberNode(Math.abs(node.value)));
-            }
-            else {
-                externals.push(node);
+        const getExternalNodes = (root) => {
+            let oppositesCount = 0;
+            const res = [];
+            const recursive = (node) => {
+                if (isMultiplyNode(node)) {
+                    recursive(node.leftChild);
+                    recursive(node.rightChild);
+                }
+                else if ((0, oppositeNode_1.isOppositeNode)(node)) {
+                    oppositesCount++;
+                    recursive(node.child);
+                }
+                else if ((0, numberNode_1.isNumberNode)(node) && node.value < 0) {
+                    oppositesCount++;
+                    res.push(new numberNode_1.NumberNode(Math.abs(node.value)));
+                }
+                else {
+                    res.push(node);
+                }
+            };
+            recursive(root);
+            if (oppositesCount % 2 === 1) {
+                res.unshift(new numberNode_1.NumberNode(-1));
             }
+            return res;
         };
-        recursive(copy);
+        let externals = getExternalNodes(copy);
         //si 0 on s'arrete
         if (externals.some((node) => (0, numberNode_1.isNumberNode)(node) && node.value === 0)) {
             return new numberNode_1.NumberNode(0);
         }
-        if (oppositesCount % 2 === 1) {
-            externals.unshift(new numberNode_1.NumberNode(-1));
-        }
         //suppression des 1
         externals = externals.filter((node) => !(0, numberNode_1.isNumberNode)(node) || node.value !== 1);
         if (!externals.length)
@@ -319,6 +325,13 @@ class MultiplyNode {
             powerSimplified = powerSimplify(b, a, opts);
             if (powerSimplified)
                 return powerSimplified;
+            if (opts?.towardsDistribute && ((0, addNode_1.isAddNode)(a) || (0, substractNode_1.isSubstractNode)(a))) {
+                return (0, addNode_1.add)((0, exports.multiply)(a.leftChild, b), (0, exports.multiply)(a.rightChild, b)).simplify();
+            }
+            else if (opts?.towardsDistribute &&
+                ((0, addNode_1.isAddNode)(b) || (0, substractNode_1.isSubstractNode)(b))) {
+                return (0, addNode_1.add)((0, exports.multiply)(a, b.leftChild), (0, exports.multiply)(a, b.rightChild)).simplify();
+            }
             //TODo continue
             return null;
         };
@@ -331,8 +344,14 @@ class MultiplyNode {
                     const right = externals[j];
                     const simplified = simplifyExternalNodes(left, right);
                     if (simplified) {
-                        externals[i] = simplified;
                         externals.splice(j, 1);
+                        if (isMultiplyNode(simplified)) {
+                            const subExternals = getExternalNodes(simplified);
+                            externals.splice(i, 1, ...subExternals);
+                        }
+                        else {
+                            externals[i] = simplified;
+                        }
                         if ((0, numberNode_1.isNumberNode)(simplified) && simplified.value === 1) {
                             externals.splice(i, 1);
                         }
@@ -347,6 +366,7 @@ class MultiplyNode {
             return new numberNode_1.NumberNode(1);
         if (externals.length === 1)
             return externals[0];
+        (0, exports.sortMultiplyNodes)(externals);
         return (0, operatorComposition_1.operatorComposition)(MultiplyNode, externals);
     }
     equals(node) {

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

@@ -1,3 +1,4 @@
+import { AlgebraicNode } from "../algebraicNode";
 import { InequationNode } from "../inequations/inequationNode";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { ClosureType } from "./closure";
@@ -9,13 +10,13 @@ export declare class IntervalNode implements SetNode {
     id: SetIds;
     opts?: NodeOptions | undefined;
     closure: ClosureType;
-    a: Node;
-    b: Node;
+    a: AlgebraicNode;
+    b: AlgebraicNode;
     isEmpty: boolean;
-    constructor(a: Node, b: Node, closure: ClosureType, opts?: NodeOptions);
+    constructor(a: AlgebraicNode, b: AlgebraicNode, closure: ClosureType, opts?: NodeOptions);
     toAllValidTexs(opts?: NodeOptions): string[];
     toEquivalentNodes(opts?: NodeOptions): IntervalNode[];
-    toInequality(middleChild?: Node): InequationNode;
+    toInequality(middleChild?: AlgebraicNode): InequationNode;
     toMathString(): string;
     toMathjs(): string;
     toReversedClosure(): IntervalNode;

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

@@ -1 +1 @@
-{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAQ/D,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;IACR,OAAO,EAAE,OAAO,CAAC;gBACL,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW;IAUtE,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW;IAMjC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,IAAI;IA4B/B,YAAY;IAIZ,QAAQ;IAIR,iBAAiB;IAGjB,qBAAqB;IAGrB,sBAAsB;IAGtB,wBAAwB;IAWxB,YAAY;IAkCZ,KAAK;IAWL,aAAa;;;;;;;;;;IASb,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;IAiB7C,QAAQ;CAGT"}
+{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAQ/D,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;gBAEf,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,OAAO,EAAE,WAAW,EACpB,IAAI,CAAC,EAAE,WAAW;IAWpB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW;IAMjC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,aAAa;IA4BxC,YAAY;IAIZ,QAAQ;IAIR,iBAAiB;IAGjB,qBAAqB;IAGrB,sBAAsB;IAGtB,wBAAwB;IAWxB,YAAY;IAkCZ,KAAK;IAWL,aAAa;;;;;;;;;;IASb,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;IAiB7C,QAAQ;CAGT"}

package/package.json

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