math-exercises 2.0.2 → 2.0.3

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

@@ -1,261 +1,261 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Interval = exports.IntervalConstructor = void 0;
-const epsilon_1 = require("../../../math/numbers/epsilon");
-const integer_1 = require("../../../math/numbers/integer/integer");
-const nombre_1 = require("../../../math/numbers/nombre");
-const real_1 = require("../../../math/numbers/reals/real");
-const randint_1 = require("../../../math/utils/random/randint");
-const round_1 = require("../../../math/utils/round");
-const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
-const coinFlip_1 = require("../../../utils/coinFlip");
-const mathSet_1 = require("../mathSet");
-class IntervalConstructor {
-    static random() {
-        let tex = "";
-        const randType = (0, randint_1.randint)(0, 6);
-        let a, b;
-        switch (randType) {
-            case 0:
-                b = (0, randint_1.randint)(-10, 10);
-                tex = `]-\\infty;${b}${(0, coinFlip_1.coinFlip)() ? "]" : "["}`;
-                break;
-            case 1:
-                a = (0, randint_1.randint)(-10, 10);
-                tex = `${(0, coinFlip_1.coinFlip)() ? "]" : "["}${a};+\\infty[`;
-                break;
-            case 2:
-                a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `[${a};${b}]`;
-                break;
-            case 3:
-                a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `]${a};${b}]`;
-                break;
-            case 4:
-                a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `[${a};${b}[`;
-                break;
-            case 5:
-                a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `]${a};${b}[`;
-                break;
-        }
-        return new Interval(tex);
-    }
-    static differentRandoms(nb) {
-        const res = [];
-        for (let i = 0; i < nb; i++) {
-            let interval;
-            do {
-                interval = this.random();
-            } while (res.some((int) => int.tex === interval.tex));
-            res.push(this.random());
-        }
-        return res;
-    }
-}
-exports.IntervalConstructor = IntervalConstructor;
-class Interval {
-    /**
-     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-     */
-    constructor(tex = "[-10; 10]") {
-        if (!tex.includes(";"))
-            throw Error("wrong interval format");
-        this.tex = tex;
-        const isInt = tex[1] === "[" || tex[1] === "]";
-        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
-        const left = tex[0];
-        const right = tex[tex.length - 1];
-        const [a, b] = tex
-            .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
-            .split(";");
-        this.minTex = a;
-        this.maxTex = b;
-        switch (`${left}a;b${right}`) {
-            case "[a;b]":
-                this.leftBracket = "[";
-                this.leftInequalitySymbol = "\\le";
-                this.rightInequalitySymbol = "\\le";
-                this.rightBracket = "]";
-                this.closure = intervalNode_1.ClosureType.FF;
-                break;
-            case "]a;b[":
-                this.leftBracket = "]";
-                this.rightBracket = "[";
-                this.leftInequalitySymbol = "<";
-                this.rightInequalitySymbol = "<";
-                this.closure = intervalNode_1.ClosureType.OO;
-                break;
-            case "[a;b[":
-                this.leftBracket = "[";
-                this.rightBracket = "[";
-                this.leftInequalitySymbol = "\\le";
-                this.rightInequalitySymbol = "<";
-                this.closure = intervalNode_1.ClosureType.FO;
-                break;
-            case "]a;b]":
-                this.leftBracket = "]";
-                this.rightBracket = "]";
-                this.leftInequalitySymbol = "<";
-                this.rightInequalitySymbol = "\\le";
-                this.closure = intervalNode_1.ClosureType.OF;
-                break;
-            default:
-                throw console.error("wrong interval format");
-        }
-        function getBound(bound) {
-            return bound === "-\\infty"
-                ? Number.NEGATIVE_INFINITY
-                : bound === "+\\infty"
-                    ? Number.POSITIVE_INFINITY
-                    : Number(bound);
-        }
-        this.min = getBound(a);
-        this.max = getBound(b);
-    }
-    union(interval) {
-        let unionRightBracket = this.max > interval.max
-            ? this.rightBracket
-            : this.max === interval.max
-                ? this.rightBracket === "]" || interval.rightBracket === "]"
-                    ? "]"
-                    : "["
-                : interval.rightBracket;
-        let unionLeftBracket = this.min < interval.min
-            ? this.leftBracket
-            : this.max === interval.max
-                ? this.leftBracket === "[" || interval.leftBracket === "["
-                    ? "["
-                    : "]"
-                : interval.leftBracket;
-        let min = Math.min(this.min, interval.min);
-        let minTex = this.min < interval.min ? this.minTex : interval.minTex;
-        let max = Math.max(this.max, interval.max);
-        let maxTex = this.max > interval.max ? this.maxTex : interval.maxTex;
-        if (this.max < interval.min ||
-            this.min > interval.max ||
-            (this.max === interval.min &&
-                this.rightBracket === "[" &&
-                interval.leftBracket === "]") ||
-            (this.min === interval.max &&
-                this.leftBracket === "]" &&
-                interval.rightBracket === "[")) {
-            const firstInterval = this.min < interval.min ? this : interval;
-            const secondInterval = this.min < interval.min ? interval : this;
-            return new mathSet_1.MathSet(`${unionLeftBracket}${firstInterval.minTex};${firstInterval.maxTex}${firstInterval.rightBracket}\\cup${secondInterval.leftBracket}${secondInterval.minTex};${secondInterval.maxTex}${unionRightBracket}`, () => (0, coinFlip_1.coinFlip)()
-                ? firstInterval.getRandomElement()
-                : secondInterval.getRandomElement());
-        }
-        else {
-            return new Interval(`${unionLeftBracket}${minTex};${maxTex}${unionRightBracket}`);
-        }
-    }
-    intersection(interval) {
-        const a = this.min;
-        const b = this.max;
-        const c = interval.min;
-        const d = interval.max;
-        //[a,b] n [c,d]
-        const isDisjoint = b < c ||
-            d < a ||
-            (b === c &&
-                (this.rightBracket === "[" || interval.leftBracket === "]")) ||
-            (a === d && (interval.rightBracket === "[" || this.leftBracket === "]"));
-        if (isDisjoint) {
-            return new mathSet_1.MathSet("\\emptyset", () => null);
-        }
-        const winningLeftBracket = (brack1, brack2) => brack1 === "]" || brack2 === "]" ? "]" : "[";
-        const winningRightBracket = (brack1, brack2) => brack1 === "[" || brack2 === "[" ? "[" : "]";
-        let min = Math.max(a, c);
-        let minTex = a >= c ? this.minTex : interval.minTex;
-        let leftBracket = a === c
-            ? winningLeftBracket(this.leftBracket, interval.leftBracket)
-            : a > c
-                ? this.leftBracket
-                : interval.leftBracket;
-        const max = Math.min(b, d);
-        let maxTex = b <= d ? this.maxTex : interval.maxTex;
-        let rightBracket = b === d
-            ? winningRightBracket(this.rightBracket, interval.rightBracket)
-            : b < d
-                ? this.rightBracket
-                : interval.rightBracket;
-        return new Interval(`${leftBracket}${minTex};${maxTex}${rightBracket}`);
-    }
-    exclude(nb) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (x.value === nb);
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\{${nb}\\}`, rand);
-    }
-    difference(set) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (set.includes(x));
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
-    }
-    insideToTex() {
-        return this.tex.replaceAll("[", "").replaceAll("]", "");
-    }
-    toTex() {
-        return `${this.leftBracket}${this.insideToTex()}${this.rightBracket}`;
-    }
-    toInequality() {
-        const isLeftClosed = this.closure === intervalNode_1.ClosureType.FO || this.closure === intervalNode_1.ClosureType.FF;
-        const isRightClosed = this.closure === intervalNode_1.ClosureType.FF || this.closure === intervalNode_1.ClosureType.OF;
-        if (this.max === Infinity) {
-            if (isLeftClosed) {
-                return `x\\ge${this.min}`;
-            }
-            else
-                return `x>${this.min}`;
-        }
-        else if (this.min === -Infinity) {
-            if (this.closure === intervalNode_1.ClosureType.OF) {
-                return `x\\le${this.max}`;
-            }
-            else
-                return `x<${this.max}`;
-        }
-        return `${this.min}${isLeftClosed ? "\\le x" : "<x"}${isRightClosed ? "\\le" : "<"}${this.max}`;
-    }
-    getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
-        if (this.min === -Infinity || this.max === Infinity)
-            throw Error("Can't chose amongst infinity");
-        let min = this.closure === intervalNode_1.ClosureType.OO || this.closure === intervalNode_1.ClosureType.OF
-            ? this.min + epsilon_1.EPSILON
-            : this.min;
-        let max = this.closure === intervalNode_1.ClosureType.OO || this.closure === intervalNode_1.ClosureType.FO
-            ? this.max - epsilon_1.EPSILON
-            : this.max;
-        const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
-        switch (this.type) {
-            case nombre_1.NumberType.Integer:
-                return new integer_1.Integer(value);
-            default:
-                return new real_1.Real(value, value.toString());
-        }
-    }
-    toTree() {
-        const a = this.min === -Infinity ? infiniteNode_1.MinusInfinityNode : new numberNode_1.NumberNode(this.min);
-        const b = this.max === Infinity ? infiniteNode_1.PlusInfinityNode : new numberNode_1.NumberNode(this.max);
-        return new intervalNode_1.IntervalNode(a, b, this.closure);
-    }
-}
-exports.Interval = Interval;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interval = exports.IntervalConstructor = void 0;
+const epsilon_1 = require("../../../math/numbers/epsilon");
+const integer_1 = require("../../../math/numbers/integer/integer");
+const nombre_1 = require("../../../math/numbers/nombre");
+const real_1 = require("../../../math/numbers/reals/real");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const mathSet_1 = require("../mathSet");
+class IntervalConstructor {
+    static random() {
+        let tex = "";
+        const randType = (0, randint_1.randint)(0, 6);
+        let a, b;
+        switch (randType) {
+            case 0:
+                b = (0, randint_1.randint)(-10, 10);
+                tex = `]-\\infty;${b}${(0, coinFlip_1.coinFlip)() ? "]" : "["}`;
+                break;
+            case 1:
+                a = (0, randint_1.randint)(-10, 10);
+                tex = `${(0, coinFlip_1.coinFlip)() ? "]" : "["}${a};+\\infty[`;
+                break;
+            case 2:
+                a = (0, randint_1.randint)(-10, 10);
+                b = (0, randint_1.randint)(a + 1, a + 10);
+                tex = `[${a};${b}]`;
+                break;
+            case 3:
+                a = (0, randint_1.randint)(-10, 10);
+                b = (0, randint_1.randint)(a + 1, a + 10);
+                tex = `]${a};${b}]`;
+                break;
+            case 4:
+                a = (0, randint_1.randint)(-10, 10);
+                b = (0, randint_1.randint)(a + 1, a + 10);
+                tex = `[${a};${b}[`;
+                break;
+            case 5:
+                a = (0, randint_1.randint)(-10, 10);
+                b = (0, randint_1.randint)(a + 1, a + 10);
+                tex = `]${a};${b}[`;
+                break;
+        }
+        return new Interval(tex);
+    }
+    static differentRandoms(nb) {
+        const res = [];
+        for (let i = 0; i < nb; i++) {
+            let interval;
+            do {
+                interval = this.random();
+            } while (res.some((int) => int.tex === interval.tex));
+            res.push(this.random());
+        }
+        return res;
+    }
+}
+exports.IntervalConstructor = IntervalConstructor;
+class Interval {
+    /**
+     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
+     */
+    constructor(tex = "[-10; 10]") {
+        if (!tex.includes(";"))
+            throw Error("wrong interval format");
+        this.tex = tex;
+        const isInt = tex[1] === "[" || tex[1] === "]";
+        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
+        const left = tex[0];
+        const right = tex[tex.length - 1];
+        const [a, b] = tex
+            .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
+            .split(";");
+        this.minTex = a;
+        this.maxTex = b;
+        switch (`${left}a;b${right}`) {
+            case "[a;b]":
+                this.leftBracket = "[";
+                this.leftInequalitySymbol = "\\le";
+                this.rightInequalitySymbol = "\\le";
+                this.rightBracket = "]";
+                this.closure = intervalNode_1.ClosureType.FF;
+                break;
+            case "]a;b[":
+                this.leftBracket = "]";
+                this.rightBracket = "[";
+                this.leftInequalitySymbol = "<";
+                this.rightInequalitySymbol = "<";
+                this.closure = intervalNode_1.ClosureType.OO;
+                break;
+            case "[a;b[":
+                this.leftBracket = "[";
+                this.rightBracket = "[";
+                this.leftInequalitySymbol = "\\le";
+                this.rightInequalitySymbol = "<";
+                this.closure = intervalNode_1.ClosureType.FO;
+                break;
+            case "]a;b]":
+                this.leftBracket = "]";
+                this.rightBracket = "]";
+                this.leftInequalitySymbol = "<";
+                this.rightInequalitySymbol = "\\le";
+                this.closure = intervalNode_1.ClosureType.OF;
+                break;
+            default:
+                throw console.error("wrong interval format");
+        }
+        function getBound(bound) {
+            return bound === "-\\infty"
+                ? Number.NEGATIVE_INFINITY
+                : bound === "+\\infty"
+                    ? Number.POSITIVE_INFINITY
+                    : Number(bound);
+        }
+        this.min = getBound(a);
+        this.max = getBound(b);
+    }
+    union(interval) {
+        let unionRightBracket = this.max > interval.max
+            ? this.rightBracket
+            : this.max === interval.max
+                ? this.rightBracket === "]" || interval.rightBracket === "]"
+                    ? "]"
+                    : "["
+                : interval.rightBracket;
+        let unionLeftBracket = this.min < interval.min
+            ? this.leftBracket
+            : this.max === interval.max
+                ? this.leftBracket === "[" || interval.leftBracket === "["
+                    ? "["
+                    : "]"
+                : interval.leftBracket;
+        let min = Math.min(this.min, interval.min);
+        let minTex = this.min < interval.min ? this.minTex : interval.minTex;
+        let max = Math.max(this.max, interval.max);
+        let maxTex = this.max > interval.max ? this.maxTex : interval.maxTex;
+        if (this.max < interval.min ||
+            this.min > interval.max ||
+            (this.max === interval.min &&
+                this.rightBracket === "[" &&
+                interval.leftBracket === "]") ||
+            (this.min === interval.max &&
+                this.leftBracket === "]" &&
+                interval.rightBracket === "[")) {
+            const firstInterval = this.min < interval.min ? this : interval;
+            const secondInterval = this.min < interval.min ? interval : this;
+            return new mathSet_1.MathSet(`${unionLeftBracket}${firstInterval.minTex};${firstInterval.maxTex}${firstInterval.rightBracket}\\cup${secondInterval.leftBracket}${secondInterval.minTex};${secondInterval.maxTex}${unionRightBracket}`, () => (0, coinFlip_1.coinFlip)()
+                ? firstInterval.getRandomElement()
+                : secondInterval.getRandomElement());
+        }
+        else {
+            return new Interval(`${unionLeftBracket}${minTex};${maxTex}${unionRightBracket}`);
+        }
+    }
+    intersection(interval) {
+        const a = this.min;
+        const b = this.max;
+        const c = interval.min;
+        const d = interval.max;
+        //[a,b] n [c,d]
+        const isDisjoint = b < c ||
+            d < a ||
+            (b === c &&
+                (this.rightBracket === "[" || interval.leftBracket === "]")) ||
+            (a === d && (interval.rightBracket === "[" || this.leftBracket === "]"));
+        if (isDisjoint) {
+            return new mathSet_1.MathSet("\\emptyset", () => null);
+        }
+        const winningLeftBracket = (brack1, brack2) => brack1 === "]" || brack2 === "]" ? "]" : "[";
+        const winningRightBracket = (brack1, brack2) => brack1 === "[" || brack2 === "[" ? "[" : "]";
+        let min = Math.max(a, c);
+        let minTex = a >= c ? this.minTex : interval.minTex;
+        let leftBracket = a === c
+            ? winningLeftBracket(this.leftBracket, interval.leftBracket)
+            : a > c
+                ? this.leftBracket
+                : interval.leftBracket;
+        const max = Math.min(b, d);
+        let maxTex = b <= d ? this.maxTex : interval.maxTex;
+        let rightBracket = b === d
+            ? winningRightBracket(this.rightBracket, interval.rightBracket)
+            : b < d
+                ? this.rightBracket
+                : interval.rightBracket;
+        return new Interval(`${leftBracket}${minTex};${maxTex}${rightBracket}`);
+    }
+    exclude(nb) {
+        const rand = () => {
+            let x;
+            do {
+                x = this.getRandomElement();
+            } while (x.value === nb);
+            return x;
+        };
+        return new mathSet_1.MathSet(this.toTex() + `\\{${nb}\\}`, rand);
+    }
+    difference(set) {
+        const rand = () => {
+            let x;
+            do {
+                x = this.getRandomElement();
+            } while (set.includes(x));
+            return x;
+        };
+        return new mathSet_1.MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
+    }
+    insideToTex() {
+        return this.tex.replaceAll("[", "").replaceAll("]", "");
+    }
+    toTex() {
+        return `${this.leftBracket}${this.insideToTex()}${this.rightBracket}`;
+    }
+    toInequality() {
+        const isLeftClosed = this.closure === intervalNode_1.ClosureType.FO || this.closure === intervalNode_1.ClosureType.FF;
+        const isRightClosed = this.closure === intervalNode_1.ClosureType.FF || this.closure === intervalNode_1.ClosureType.OF;
+        if (this.max === Infinity) {
+            if (isLeftClosed) {
+                return `x\\ge${this.min}`;
+            }
+            else
+                return `x>${this.min}`;
+        }
+        else if (this.min === -Infinity) {
+            if (this.closure === intervalNode_1.ClosureType.OF) {
+                return `x\\le${this.max}`;
+            }
+            else
+                return `x<${this.max}`;
+        }
+        return `${this.min}${isLeftClosed ? "\\le x" : "<x"}${isRightClosed ? "\\le" : "<"}${this.max}`;
+    }
+    getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
+        if (this.min === -Infinity || this.max === Infinity)
+            throw Error("Can't chose amongst infinity");
+        let min = this.closure === intervalNode_1.ClosureType.OO || this.closure === intervalNode_1.ClosureType.OF
+            ? this.min + epsilon_1.EPSILON
+            : this.min;
+        let max = this.closure === intervalNode_1.ClosureType.OO || this.closure === intervalNode_1.ClosureType.FO
+            ? this.max - epsilon_1.EPSILON
+            : this.max;
+        const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
+        switch (this.type) {
+            case nombre_1.NumberType.Integer:
+                return new integer_1.Integer(value);
+            default:
+                return new real_1.Real(value, value.toString());
+        }
+    }
+    toTree() {
+        const a = this.min === -Infinity ? infiniteNode_1.MinusInfinityNode : new numberNode_1.NumberNode(this.min);
+        const b = this.max === Infinity ? infiniteNode_1.PlusInfinityNode : new numberNode_1.NumberNode(this.max);
+        return new intervalNode_1.IntervalNode(a, b, this.closure);
+    }
+}
+exports.Interval = Interval;

package/lib/math/sets/mathSet.d.ts

@@ -1,9 +1,9 @@
-import { Nombre } from '../numbers/nombre';
-import { MathSetInterface } from './mathSetInterface';
-export declare class MathSet implements MathSetInterface {
-    tex: string;
-    toTex: () => string;
-    getRandomElement: () => Nombre | null;
-    constructor(tex: string, getRandomElement: () => Nombre | null);
-}
+import { Nombre } from '../numbers/nombre';
+import { MathSetInterface } from './mathSetInterface';
+export declare class MathSet implements MathSetInterface {
+    tex: string;
+    toTex: () => string;
+    getRandomElement: () => Nombre | null;
+    constructor(tex: string, getRandomElement: () => Nombre | null);
+}
 //# sourceMappingURL=mathSet.d.ts.map

package/lib/math/sets/mathSet.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MathSet = void 0;
-class MathSet {
-    constructor(tex, getRandomElement) {
-        this.tex = tex;
-        this.getRandomElement = getRandomElement;
-        this.toTex = () => tex;
-    }
-}
-exports.MathSet = MathSet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathSet = void 0;
+class MathSet {
+    constructor(tex, getRandomElement) {
+        this.tex = tex;
+        this.getRandomElement = getRandomElement;
+        this.toTex = () => tex;
+    }
+}
+exports.MathSet = MathSet;

package/lib/math/sets/mathSetInterface.d.ts

@@ -1,7 +1,7 @@
-import { Nombre } from '../numbers/nombre';
-export interface MathSetInterface {
-    tex: string;
-    toTex: () => string;
-    getRandomElement: () => Nombre | null;
-}
+import { Nombre } from '../numbers/nombre';
+export interface MathSetInterface {
+    tex: string;
+    toTex: () => string;
+    getRandomElement: () => Nombre | null;
+}
 //# sourceMappingURL=mathSetInterface.d.ts.map

package/lib/math/sets/mathSetInterface.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/math/trigonometry/remarkableValue.d.ts

@@ -1,16 +1,16 @@
-import { Node } from "../../tree/nodes/node";
-import { Integer } from "../numbers/integer/integer";
-import { Rational } from "../numbers/rationals/rational";
-export interface RemarkableValue {
-    angleValue: Integer | Rational;
-    angle: Node;
-    cos: Node;
-    sin: Node;
-}
-export declare abstract class RemarkableValueConstructor {
-    static mainInterval: () => RemarkableValue;
-    static simplifiable: () => RemarkableValue & {
-        index: number;
-    };
-}
+import { Node } from "../../tree/nodes/node";
+import { Integer } from "../numbers/integer/integer";
+import { Rational } from "../numbers/rationals/rational";
+export interface RemarkableValue {
+    angleValue: Integer | Rational;
+    angle: Node;
+    cos: Node;
+    sin: Node;
+}
+export declare abstract class RemarkableValueConstructor {
+    static mainInterval: () => RemarkableValue;
+    static simplifiable: () => RemarkableValue & {
+        index: number;
+    };
+}
 //# sourceMappingURL=remarkableValue.d.ts.map