math-exercises 2.2.98 → 3.0.2

package/lib/tree/nodes/sets/closure.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Closure = exports.ClosureType = void 0;
-const randint_1 = require("../../../math/utils/random/randint");
-var ClosureType;
+import { randint } from "../../../math/utils/random/randint.js";
+export var ClosureType;
 (function (ClosureType) {
     ClosureType[ClosureType["FF"] = 0] = "FF";
     ClosureType[ClosureType["FO"] = 1] = "FO";
     ClosureType[ClosureType["OF"] = 2] = "OF";
     ClosureType[ClosureType["OO"] = 3] = "OO";
-})(ClosureType || (exports.ClosureType = ClosureType = {}));
-class Closure {
+})(ClosureType || (ClosureType = {}));
+export class Closure {
     static random() {
-        const rand = (0, randint_1.randint)(0, 4);
+        const rand = randint(0, 4);
         switch (rand) {
             case 0:
                 return ClosureType.FF;
@@ -115,25 +112,24 @@ class Closure {
                 return true;
         }
     }
-}
-exports.Closure = Closure;
-Closure.getLessLeftStrict = (a, b) => {
-    if (a === "[" || b === "[")
-        return "[";
-    return "]";
-};
-Closure.getLessRightStrict = (a, b) => {
-    if (a === "]" || b === "]")
-        return "]";
-    return "[";
-};
-Closure.getMostLeftStrict = (a, b) => {
-    if (a === "]" || b === "]")
+    static getLessLeftStrict = (a, b) => {
+        if (a === "[" || b === "[")
+            return "[";
         return "]";
-    return "[";
-};
-Closure.getMostRightStrict = (a, b) => {
-    if (a === "[" || b === "[")
+    };
+    static getLessRightStrict = (a, b) => {
+        if (a === "]" || b === "]")
+            return "]";
         return "[";
-    return "]";
-};
+    };
+    static getMostLeftStrict = (a, b) => {
+        if (a === "]" || b === "]")
+            return "]";
+        return "[";
+    };
+    static getMostRightStrict = (a, b) => {
+        if (a === "[" || b === "[")
+            return "[";
+        return "]";
+    };
+}

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

@@ -1,6 +1,6 @@
-import { AlgebraicNode } from "../algebraicNode";
-import { Node, NodeIds, NodeOptions, NodeType } from "../node";
-import { SetIds, SetNode } from "./setNode";
+import { AlgebraicNode } from "../algebraicNode.js";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
+import { SetIds, SetNode } from "./setNode.js";
 export declare function isDiscreteSetNode(a: Node): a is DiscreteSetNode;
 export declare class DiscreteSetNode implements SetNode {
     type: NodeType;

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

@@ -1 +1 @@
-{"version":3,"file":"discreteSetNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/discreteSetNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,eAAe,CAE/D;AACD,qBAAa,eAAgB,YAAW,OAAO;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;gBACL,QAAQ,EAAE,aAAa,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAOzD,UAAU;IAIV,YAAY;IAGZ,cAAc;IAGd,aAAa;;;;;;IAMb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAyBpC,YAAY;IAIZ,KAAK;IAOL,qBAAqB;IAMrB,QAAQ;CAOT;AAED,eAAO,MAAM,QAAQ,iBAA0B,CAAC"}
+{"version":3,"file":"discreteSetNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/discreteSetNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,cAAc,CAAC;AAC1D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,eAAe,CAE/D;AACD,qBAAa,eAAgB,YAAW,OAAO;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;gBACL,QAAQ,EAAE,aAAa,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAOzD,UAAU;IAIV,YAAY;IAGZ,cAAc;IAGd,aAAa;;;;;;IAMb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAyBpC,YAAY;IAIZ,KAAK;IAOL,qBAAqB;IAMrB,QAAQ;CAOT;AAED,eAAO,MAAM,QAAQ,iBAA0B,CAAC"}

package/lib/tree/nodes/sets/discreteSetNode.js

@@ -1,18 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptySet = exports.DiscreteSetNode = exports.isDiscreteSetNode = void 0;
-const cartesianProducts_1 = require("../../../utils/arrays/cartesianProducts");
-const permutations_1 = require("../../../utils/arrays/permutations");
-const node_1 = require("../node");
-const setNode_1 = require("./setNode");
-function isDiscreteSetNode(a) {
-    return (0, setNode_1.isSetNode)(a) && a.id === setNode_1.SetIds.discrete;
+import { getCartesiansProducts } from "../../../utils/arrays/cartesianProducts.js";
+import { permute } from "../../../utils/arrays/permutations.js";
+import { NodeIds, NodeType } from "../node.js";
+import { SetIds, isSetNode } from "./setNode.js";
+export function isDiscreteSetNode(a) {
+    return isSetNode(a) && a.id === SetIds.discrete;
 }
-exports.isDiscreteSetNode = isDiscreteSetNode;
-class DiscreteSetNode {
+export class DiscreteSetNode {
+    type;
+    id;
+    opts;
+    elements;
+    isEmpty;
     constructor(elements, opts) {
-        this.type = node_1.NodeType.set;
-        this.id = setNode_1.SetIds.discrete;
+        this.type = NodeType.set;
+        this.id = SetIds.discrete;
         this.elements = elements;
         this.opts = opts;
         this.isEmpty = !elements.length;
@@ -28,7 +29,7 @@ class DiscreteSetNode {
     }
     toIdentifiers() {
         return {
-            id: node_1.NodeIds.discreteSet,
+            id: NodeIds.discreteSet,
             children: this.elements.map((e) => e.toIdentifiers()),
         };
     }
@@ -45,9 +46,9 @@ class DiscreteSetNode {
             const res = [];
             const equivNodesArr = this.elements.map((node) => node.toEquivalentNodes(opts ?? this.opts));
             //!pas opti car si [2,3,3] alors les 3 se permutent et donc double sortie [2,3_1,3_2], [2,3_2,3_1]
-            let equivNodesPermutations = (0, permutations_1.permute)(equivNodesArr);
+            let equivNodesPermutations = permute(equivNodesArr);
             equivNodesPermutations.forEach((permutation) => {
-                const cartesiansProducts = (0, cartesianProducts_1.getCartesiansProducts)(permutation);
+                const cartesiansProducts = getCartesiansProducts(permutation);
                 cartesiansProducts.forEach((product) => {
                     res.push(new DiscreteSetNode(product));
                 });
@@ -77,5 +78,4 @@ class DiscreteSetNode {
             .sort((a, b) => a.evaluate() - b.evaluate()));
     }
 }
-exports.DiscreteSetNode = DiscreteSetNode;
-exports.EmptySet = new DiscreteSetNode([]);
+export const EmptySet = new DiscreteSetNode([]);

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

@@ -1,11 +1,11 @@
-import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
-import { InequationNode } from "../inequations/inequationNode";
-import { Node, NodeIds, NodeOptions, NodeType } from "../node";
-import { NodeIdentifiers } from "../nodeConstructor";
-import { ClosureType } from "./closure";
-import { DiscreteSetNode } from "./discreteSetNode";
-import { SetIds, SetNode } from "./setNode";
-import { UnionIntervalNode } from "./unionIntervalNode";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
+import { InequationNode } from "../inequations/inequationNode.js";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
+import { NodeIdentifiers } from "../nodeConstructor.js";
+import { ClosureType } from "./closure.js";
+import { DiscreteSetNode } from "./discreteSetNode.js";
+import { SetIds, SetNode } from "./setNode.js";
+import { UnionIntervalNode } from "./unionIntervalNode.js";
 export declare function isIntervalNode(a: Node): a is IntervalNode;
 export declare abstract class IntervalNodeConstructor {
     static random(): 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":"AAKA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AAIrE,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,eAAe,EAAY,MAAM,mBAAmB,CAAC;AAC9D,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;AAED,8BAAsB,uBAAuB;IAC3C,MAAM,CAAC,MAAM;IA2Cb,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,MAAM;IAYlC,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,uBAAuB;CAQpD;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AACF,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,MAAM,CAAC,CAAC,EAAE,YAAY;IAMtB,iBAAiB;IAGjB,qBAAqB;IAGrB,sBAAsB;IAGtB,wBAAwB;IAYxB,YAAY;IAkCZ,KAAK;IAWL,SAAS,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAOvC,aAAa,IAAI,uBAAuB;IAUxC,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;IAiB7C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAS/B,YAAY;IAGZ,aAAa;IAGb,QAAQ,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO;IAanC,UAAU,CAAC,QAAQ,EAAE,YAAY;IAEjC,YAAY,CAAC,QAAQ,EAAE,YAAY;IAwDnC,YAAY;IAIZ,KAAK,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,GAAG,iBAAiB;CAkDhE"}
+{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,eAAe,EAAkB,MAAM,uBAAuB,CAAC;AAOxE,OAAO,EAAW,WAAW,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,eAAe,EAAY,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,8BAAsB,uBAAuB;IAC3C,MAAM,CAAC,MAAM;IA2Cb,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,MAAM;IAYlC,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,uBAAuB;CAQpD;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AACF,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,MAAM,CAAC,CAAC,EAAE,YAAY;IAMtB,iBAAiB;IAGjB,qBAAqB;IAGrB,sBAAsB;IAGtB,wBAAwB;IAYxB,YAAY;IAkCZ,KAAK;IAWL,SAAS,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAOvC,aAAa,IAAI,uBAAuB;IAUxC,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;IAiB7C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAS/B,YAAY;IAGZ,aAAa;IAGb,QAAQ,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO;IAanC,UAAU,CAAC,QAAQ,EAAE,YAAY;IAEjC,YAAY,CAAC,QAAQ,EAAE,YAAY;IAwDnC,YAAY;IAIZ,KAAK,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,GAAG,iBAAiB;CAkDhE"}

package/lib/tree/nodes/sets/intervalNode.js

@@ -1,64 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntervalNode = exports.IntervalNodeConstructor = exports.isIntervalNode = void 0;
-const randint_1 = require("../../../math/utils/random/randint");
-const coinFlip_1 = require("../../../utils/alea/coinFlip");
-const random_1 = require("../../../utils/alea/random");
-const cartesianProducts_1 = require("../../../utils/arrays/cartesianProducts");
-const inequationNode_1 = require("../inequations/inequationNode");
-const node_1 = require("../node");
-const nodeConstructor_1 = require("../nodeConstructor");
-const constantNode_1 = require("../numbers/constantNode");
-const infiniteNode_1 = require("../numbers/infiniteNode");
-const variableNode_1 = require("../variables/variableNode");
-const closure_1 = require("./closure");
-const discreteSetNode_1 = require("./discreteSetNode");
-const setNode_1 = require("./setNode");
-const unionIntervalNode_1 = require("./unionIntervalNode");
-function isIntervalNode(a) {
-    return (0, setNode_1.isSetNode)(a) && a.id === setNode_1.SetIds.interval;
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../utils/arrays/cartesianProducts.js";
+import { InequationNode } from "../inequations/inequationNode.js";
+import { NodeIds, NodeType } from "../node.js";
+import { reifyAlgebraic } from "../nodeConstructor.js";
+import { isConstantNode, isInfiniteNode } from "../numbers/constantNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../numbers/infiniteNode.js";
+import { VariableNode } from "../variables/variableNode.js";
+import { Closure, ClosureType } from "./closure.js";
+import { DiscreteSetNode, EmptySet } from "./discreteSetNode.js";
+import { SetIds, isSetNode } from "./setNode.js";
+import { UnionIntervalNode } from "./unionIntervalNode.js";
+export function isIntervalNode(a) {
+    return isSetNode(a) && a.id === SetIds.interval;
 }
-exports.isIntervalNode = isIntervalNode;
-class IntervalNodeConstructor {
+export class IntervalNodeConstructor {
     static random() {
-        const randType = (0, randint_1.randint)(0, 6);
+        const randType = randint(0, 6);
         let a, b;
         let min, max, closure;
         switch (randType) {
             case 0:
-                min = infiniteNode_1.MinusInfinityNode;
-                max = (0, randint_1.randint)(-10, 10).toTree();
-                closure = (0, coinFlip_1.coinFlip)() ? closure_1.ClosureType.OF : closure_1.ClosureType.OO;
+                min = MinusInfinityNode;
+                max = randint(-10, 10).toTree();
+                closure = coinFlip() ? ClosureType.OF : ClosureType.OO;
                 break;
             case 1:
-                min = (0, randint_1.randint)(-10, 10).toTree();
-                max = infiniteNode_1.PlusInfinityNode;
-                closure = (0, coinFlip_1.coinFlip)() ? closure_1.ClosureType.OO : closure_1.ClosureType.FO;
+                min = randint(-10, 10).toTree();
+                max = PlusInfinityNode;
+                closure = coinFlip() ? ClosureType.OO : ClosureType.FO;
                 break;
             case 2:
-                a = (0, randint_1.randint)(-10, 10);
+                a = randint(-10, 10);
                 min = a.toTree();
-                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = closure_1.ClosureType.FF;
+                max = randint(a + 1, a + 10).toTree();
+                closure = ClosureType.FF;
                 break;
             case 3:
-                a = (0, randint_1.randint)(-10, 10);
+                a = randint(-10, 10);
                 min = a.toTree();
-                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = closure_1.ClosureType.OF;
+                max = randint(a + 1, a + 10).toTree();
+                closure = ClosureType.OF;
                 break;
             case 4:
-                a = (0, randint_1.randint)(-10, 10);
+                a = randint(-10, 10);
                 min = a.toTree();
-                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = closure_1.ClosureType.FO;
+                max = randint(a + 1, a + 10).toTree();
+                closure = ClosureType.FO;
                 break;
             case 5:
             default:
-                a = (0, randint_1.randint)(-10, 10);
+                a = randint(-10, 10);
                 min = a.toTree();
-                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = closure_1.ClosureType.OO;
+                max = randint(a + 1, a + 10).toTree();
+                closure = ClosureType.OO;
                 break;
         }
         return new IntervalNode(min, max, closure);
@@ -75,14 +71,20 @@ class IntervalNodeConstructor {
         return res;
     }
     static fromIdentifiers(ids) {
-        return new IntervalNode((0, nodeConstructor_1.reifyAlgebraic)(ids.leftChild), (0, nodeConstructor_1.reifyAlgebraic)(ids.rightChild), ids.closure, ids.opts);
+        return new IntervalNode(reifyAlgebraic(ids.leftChild), reifyAlgebraic(ids.rightChild), ids.closure, ids.opts);
     }
 }
-exports.IntervalNodeConstructor = IntervalNodeConstructor;
-class IntervalNode {
+export class IntervalNode {
+    type;
+    id;
+    opts;
+    closure;
+    a;
+    b;
+    isEmpty;
     constructor(a, b, closure, opts) {
-        this.type = node_1.NodeType.set;
-        this.id = setNode_1.SetIds.interval;
+        this.type = NodeType.set;
+        this.id = SetIds.interval;
         this.closure = closure;
         this.a = a;
         this.b = b;
@@ -98,27 +100,27 @@ class IntervalNode {
             this.a.toEquivalentNodes(opts ?? this.opts),
             this.b.toEquivalentNodes(opts ?? this.opts),
         ];
-        const cartesians = (0, cartesianProducts_1.getCartesiansProducts)(equivs);
+        const cartesians = getCartesiansProducts(equivs);
         cartesians.forEach((product) => {
             res.push(new IntervalNode(product[0], product[1], this.closure, opts ?? this.opts));
         });
         return res;
     }
     toInequality(middleChild) {
-        let middle = middleChild ?? new variableNode_1.VariableNode("x");
-        if ((0, constantNode_1.isConstantNode)(this.a) && this.a.tex.includes("infty")) {
-            return new inequationNode_1.InequationNode([middle, this.b], this.closure === closure_1.ClosureType.OF ? "\\le" : "<");
+        let middle = middleChild ?? new VariableNode("x");
+        if (isConstantNode(this.a) && this.a.tex.includes("infty")) {
+            return new InequationNode([middle, this.b], this.closure === ClosureType.OF ? "\\le" : "<");
         }
-        if ((0, constantNode_1.isConstantNode)(this.b) && this.b.tex.includes("infty")) {
-            return new inequationNode_1.InequationNode([middle, this.a], this.closure === closure_1.ClosureType.FO ? "\\ge" : ">");
+        if (isConstantNode(this.b) && this.b.tex.includes("infty")) {
+            return new InequationNode([middle, this.a], this.closure === ClosureType.FO ? "\\ge" : ">");
         }
-        const leftSymbol = this.closure === closure_1.ClosureType.FO || this.closure === closure_1.ClosureType.FF
+        const leftSymbol = this.closure === ClosureType.FO || this.closure === ClosureType.FF
             ? "\\le"
             : "<";
-        const rightSymbol = this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.OF
+        const rightSymbol = this.closure === ClosureType.FF || this.closure === ClosureType.OF
             ? "\\le"
             : "<";
-        return new inequationNode_1.InequationNode([this.a, middle, this.b], [leftSymbol, rightSymbol]);
+        return new InequationNode([this.a, middle, this.b], [leftSymbol, rightSymbol]);
     }
     toMathString() {
         return this.toTex();
@@ -127,48 +129,48 @@ class IntervalNode {
         return (i.a.equals(this.a) && i.b.equals(this.b) && i.closure === this.closure);
     }
     toReversedClosure() {
-        return new IntervalNode(this.a, this.b, closure_1.Closure.reverse(this.closure));
+        return new IntervalNode(this.a, this.b, Closure.reverse(this.closure));
     }
     toLeftReversedClosure() {
-        return new IntervalNode(this.a, this.b, closure_1.Closure.leftReverse(this.closure));
+        return new IntervalNode(this.a, this.b, Closure.leftReverse(this.closure));
     }
     toRightReversedClosure() {
-        return new IntervalNode(this.a, this.b, closure_1.Closure.rightReverse(this.closure));
+        return new IntervalNode(this.a, this.b, Closure.rightReverse(this.closure));
     }
     toRandomDifferentClosure() {
-        if ((0, constantNode_1.isInfiniteNode)(this.a) && (0, constantNode_1.isInfiniteNode)(this.b))
+        if (isInfiniteNode(this.a) && isInfiniteNode(this.b))
             return this;
         let closure;
         do {
-            const left = (0, constantNode_1.isInfiniteNode)(this.a) ? "]" : (0, random_1.random)(["[", "]"]);
-            const right = (0, constantNode_1.isInfiniteNode)(this.b)
+            const left = isInfiniteNode(this.a) ? "]" : random(["[", "]"]);
+            const right = isInfiniteNode(this.b)
                 ? "["
-                : (0, random_1.random)(["[", "]"]);
-            closure = closure_1.Closure.fromBrackets(left, right);
+                : random(["[", "]"]);
+            closure = Closure.fromBrackets(left, right);
         } while (closure === this.closure);
         return new IntervalNode(this.a, this.b, closure);
     }
     toComplement() {
-        if ((0, constantNode_1.isInfiniteNode)(this.a) && (0, constantNode_1.isInfiniteNode)(this.b))
+        if (isInfiniteNode(this.a) && isInfiniteNode(this.b))
             return this;
-        if ((0, constantNode_1.isInfiniteNode)(this.a)) {
-            return new IntervalNode(this.b, infiniteNode_1.PlusInfinityNode, this.closure === closure_1.ClosureType.OF ? closure_1.ClosureType.FO : closure_1.ClosureType.OO);
+        if (isInfiniteNode(this.a)) {
+            return new IntervalNode(this.b, PlusInfinityNode, this.closure === ClosureType.OF ? ClosureType.FO : ClosureType.OO);
         }
-        if ((0, constantNode_1.isInfiniteNode)(this.b)) {
-            return new IntervalNode(infiniteNode_1.MinusInfinityNode, this.a, this.closure === closure_1.ClosureType.FO ? closure_1.ClosureType.OO : closure_1.ClosureType.OF);
+        if (isInfiniteNode(this.b)) {
+            return new IntervalNode(MinusInfinityNode, this.a, this.closure === ClosureType.FO ? ClosureType.OO : ClosureType.OF);
         }
-        const aClosed = this.closure === closure_1.ClosureType.FO || this.closure === closure_1.ClosureType.FF;
-        const bClosed = this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.OF;
-        return new unionIntervalNode_1.UnionIntervalNode([
-            new IntervalNode(infiniteNode_1.MinusInfinityNode, this.a, aClosed ? closure_1.ClosureType.OO : closure_1.ClosureType.OF),
-            new IntervalNode(this.b, infiniteNode_1.PlusInfinityNode, bClosed ? closure_1.ClosureType.OO : closure_1.ClosureType.FO),
+        const aClosed = this.closure === ClosureType.FO || this.closure === ClosureType.FF;
+        const bClosed = this.closure === ClosureType.FF || this.closure === ClosureType.OF;
+        return new UnionIntervalNode([
+            new IntervalNode(MinusInfinityNode, this.a, aClosed ? ClosureType.OO : ClosureType.OF),
+            new IntervalNode(this.b, PlusInfinityNode, bClosed ? ClosureType.OO : ClosureType.FO),
         ]);
     }
     toTex() {
-        const left = this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.FO
+        const left = this.closure === ClosureType.FF || this.closure === ClosureType.FO
             ? "[\\ "
             : "]\\ ";
-        const right = this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.OF
+        const right = this.closure === ClosureType.FF || this.closure === ClosureType.OF
             ? "\\ ]\\ "
             : "\\ [\\ ";
         return `${left}${this.a.toTex()};${this.b.toTex()}${right}`;
@@ -182,7 +184,7 @@ class IntervalNode {
     }
     toIdentifiers() {
         return {
-            id: node_1.NodeIds.interval,
+            id: NodeIds.interval,
             leftChild: this.a.toIdentifiers(),
             rightChild: this.b.toIdentifiers(),
             closure: this.closure,
@@ -191,24 +193,24 @@ class IntervalNode {
     }
     toText(isPlural, isFeminine) {
         const conjugaison = isFeminine ? "e" : "" + isPlural ? "s" : "";
-        return (0, constantNode_1.isInfiniteNode)(this.a)
-            ? closure_1.Closure.isRightOpen(this.closure)
+        return isInfiniteNode(this.a)
+            ? Closure.isRightOpen(this.closure)
                 ? `strictement inférieur${conjugaison} à $${this.b.toTex()}$`
                 : `inférieur${conjugaison} à $${this.b.toTex()}$`
-            : (0, constantNode_1.isInfiniteNode)(this.b)
-                ? closure_1.Closure.isLeftOpen(this.closure)
+            : isInfiniteNode(this.b)
+                ? Closure.isLeftOpen(this.closure)
                     ? `strictement supérieur${conjugaison} à $${this.a.toTex()}$`
                     : `supérieur${conjugaison} à $${this.a.toTex()}$`
-                : `compris entre $${this.a.toTex()}$ ${closure_1.Closure.isLeftOpen(this.closure) ? "exclu" : "inclus"} et $${this.b.toTex()}$ ${closure_1.Closure.isRightOpen(this.closure) ? "exclu" : "inclus"}`;
+                : `compris entre $${this.a.toTex()}$ ${Closure.isLeftOpen(this.closure) ? "exclu" : "inclus"} et $${this.b.toTex()}$ ${Closure.isRightOpen(this.closure) ? "exclu" : "inclus"}`;
     }
     simplify(opts) {
         return new IntervalNode(this.a.simplify(opts), this.b.simplify(opts), this.closure, this.opts);
     }
     isLeftClosed() {
-        return this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.FO;
+        return this.closure === ClosureType.FF || this.closure === ClosureType.FO;
     }
     isRightClosed() {
-        return this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.OF;
+        return this.closure === ClosureType.FF || this.closure === ClosureType.OF;
     }
     includes(a) {
         const ev = a.evaluate();
@@ -232,67 +234,66 @@ class IntervalNode {
         const orderedEv = ordered.map((e) => {
             return [e.a.evaluate(), e.b.evaluate()];
         });
-        const orderedBrackets = ordered.map((int) => closure_1.Closure.toBrackets(int.closure));
+        const orderedBrackets = ordered.map((int) => Closure.toBrackets(int.closure));
         if (ordered[0].includes(ordered[1].a) ||
             Math.abs(thisA - otherA) < 0.0000000001) {
             if (Math.abs(orderedEv[0][1] - orderedEv[1][0]) < 0.0000000001) {
-                return new discreteSetNode_1.DiscreteSetNode([ordered[1].a]);
+                return new DiscreteSetNode([ordered[1].a]);
             }
             let leftBracket = "[";
             if (Math.abs(thisA - otherA) < 0.0000000001) {
-                leftBracket = closure_1.Closure.getMostLeftStrict(orderedBrackets[0][0], orderedBrackets[1][0]);
+                leftBracket = Closure.getMostLeftStrict(orderedBrackets[0][0], orderedBrackets[1][0]);
             }
             else
                 leftBracket = orderedBrackets[1][0];
             let rightBracket = "[";
             if (Math.abs(thisB - otherB) < 0.0000000001) {
-                rightBracket = closure_1.Closure.getMostRightStrict(orderedBrackets[0][1], orderedBrackets[1][1]);
-                return new IntervalNode(ordered[1].a, ordered[1].b, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+                rightBracket = Closure.getMostRightStrict(orderedBrackets[0][1], orderedBrackets[1][1]);
+                return new IntervalNode(ordered[1].a, ordered[1].b, Closure.fromBrackets(leftBracket, rightBracket));
             }
             else {
                 const rightBornIndex = ordered[0].b.evaluate() < ordered[1].b.evaluate() ? 0 : 1;
                 const right = ordered[rightBornIndex].b;
                 rightBracket = orderedBrackets[rightBornIndex][1];
-                return new IntervalNode(ordered[1].a, right, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+                return new IntervalNode(ordered[1].a, right, Closure.fromBrackets(leftBracket, rightBracket));
             }
         }
         else {
-            return discreteSetNode_1.EmptySet;
+            return EmptySet;
         }
     }
     toClosedForm() {
-        return new IntervalNode(this.a, this.b, closure_1.ClosureType.FF, this.opts);
+        return new IntervalNode(this.a, this.b, ClosureType.FF, this.opts);
     }
     union(otherInt) {
         const [thisA, thisB] = [this.a.evaluate(), this.b.evaluate()];
         const [otherA, otherB] = [otherInt.a.evaluate(), otherInt.b.evaluate()];
         const ordered = thisA < otherA ? [this, otherInt] : [otherInt, this];
-        const orderedBrackets = ordered.map((int) => closure_1.Closure.toBrackets(int.closure));
+        const orderedBrackets = ordered.map((int) => Closure.toBrackets(int.closure));
         if (ordered[0].includes(ordered[1].a) ||
             ordered[1].includes(ordered[0].b) ||
             ordered[1].includes(ordered[0].a) ||
             Math.abs(thisA - otherA) < 0.0000000001) {
             let leftBracket = "[";
             if (Math.abs(thisA - otherA) < 0.0000000001) {
-                leftBracket = closure_1.Closure.getLessLeftStrict(orderedBrackets[0][0], orderedBrackets[1][0]);
+                leftBracket = Closure.getLessLeftStrict(orderedBrackets[0][0], orderedBrackets[1][0]);
             }
             else
                 leftBracket = orderedBrackets[0][0];
             let rightBracket = "[";
             if (Math.abs(thisB - otherB) < 0.0000000001) {
-                rightBracket = closure_1.Closure.getLessRightStrict(orderedBrackets[0][1], orderedBrackets[1][1]);
-                return new IntervalNode(ordered[0].a, ordered[1].b, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+                rightBracket = Closure.getLessRightStrict(orderedBrackets[0][1], orderedBrackets[1][1]);
+                return new IntervalNode(ordered[0].a, ordered[1].b, Closure.fromBrackets(leftBracket, rightBracket));
             }
             else {
                 const rightBornIndex = ordered[0].b.evaluate() > ordered[1].b.evaluate() ? 0 : 1;
                 const right = ordered[rightBornIndex].b;
                 rightBracket = orderedBrackets[rightBornIndex][1];
-                return new IntervalNode(ordered[0].a, right, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+                return new IntervalNode(ordered[0].a, right, Closure.fromBrackets(leftBracket, rightBracket));
             }
         }
         else {
-            return new unionIntervalNode_1.UnionIntervalNode([ordered[0], ordered[1]], this.opts);
+            return new UnionIntervalNode([ordered[0], ordered[1]], this.opts);
         }
     }
 }
-exports.IntervalNode = IntervalNode;

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

@@ -1 +1,2 @@
+export {};
 //# sourceMappingURL=majorSets.d.ts.map

package/lib/tree/nodes/sets/majorSets.js

@@ -1 +1 @@
-"use strict";
+export {};

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

@@ -1,4 +1,4 @@
-import { Node, NodeOptions } from "../node";
+import { Node, NodeOptions } from "../node.js";
 export declare enum SetIds {
     interval = 0,
     discrete = 1,

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

@@ -1 +1 @@
-{"version":3,"file":"setNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/setNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAY,MAAM,SAAS,CAAC;AAEtD,oBAAY,MAAM;IAChB,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,KAAK,IAAA;CACN;AACD,MAAM,WAAW,OAAQ,SAAQ,IAAI;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,EAAE,CAAC;IACrD,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,YAAY,EAAE,MAAM,OAAO,CAAC;CAC7B;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C"}
+{"version":3,"file":"setNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/setNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAY,MAAM,YAAY,CAAC;AAEzD,oBAAY,MAAM;IAChB,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,KAAK,IAAA;CACN;AACD,MAAM,WAAW,OAAQ,SAAQ,IAAI;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,EAAE,CAAC;IACrD,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,YAAY,EAAE,MAAM,OAAO,CAAC;CAC7B;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C"}

package/lib/tree/nodes/sets/setNode.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSetNode = exports.SetIds = void 0;
-const node_1 = require("../node");
-var SetIds;
+import { NodeType } from "../node.js";
+export var SetIds;
 (function (SetIds) {
     SetIds[SetIds["interval"] = 0] = "interval";
     SetIds[SetIds["discrete"] = 1] = "discrete";
     SetIds[SetIds["union"] = 2] = "union";
-})(SetIds || (exports.SetIds = SetIds = {}));
-function isSetNode(a) {
-    return a.type === node_1.NodeType.set;
+})(SetIds || (SetIds = {}));
+export function isSetNode(a) {
+    return a.type === NodeType.set;
 }
-exports.isSetNode = isSetNode;

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

@@ -1,6 +1,6 @@
-import { AlgebraicNode } from "../algebraicNode";
-import { Node, NodeIds, NodeOptions, NodeType } from "../node";
-import { SetIds, SetNode } from "./setNode";
+import { AlgebraicNode } from "../algebraicNode.js";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
+import { SetIds, SetNode } from "./setNode.js";
 export declare function isUnionIntervalNode(a: Node): a is UnionIntervalNode;
 export declare abstract class UnionIntervalNodeBuilder {
     static realMinus(a: AlgebraicNode): UnionIntervalNode;

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

@@ -1 +1 @@
-{"version":3,"file":"unionIntervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/unionIntervalNode.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAI/D,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AAEvD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,iBAAiB,CAEnE;AACD,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,aAAa;CAMlC;AACD,qBAAa,iBAAkB,YAAW,IAAI;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;gBACJ,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAO/C,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAcpC,YAAY;IAIZ,QAAQ;IAIR,KAAK;IAGL,aAAa;;;;;;IAMb,QAAQ;IAMR,YAAY;CAMb"}
+{"version":3,"file":"unionIntervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/unionIntervalNode.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAIlE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,cAAc,CAAC;AAE1D,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,iBAAiB,CAEnE;AACD,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,aAAa;CAMlC;AACD,qBAAa,iBAAkB,YAAW,IAAI;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;gBACJ,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAO/C,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAcpC,YAAY;IAIZ,QAAQ;IAIR,KAAK;IAGL,aAAa;;;;;;IAMb,QAAQ;IAMR,YAAY;CAMb"}