@numio/bigmath 2.0.0 → 2.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@numio/bigmath",
   "description": "@numio/bigmath is an arbitrary-precision arithmetic library. It can be used for basic operations with decimal numbers (integers and float)",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "keywords": [
     "precision",
     "arithmetic",

package/src/IQR/main.js

@@ -1,8 +1,8 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { IQRInner } from "./utils.js";
 //** This function returns Interquartile Range */
-export var IQR = function (array, sigNum) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = IQRInner(arrayInner, sigNum), bi = _a[0], fpe = _a[1];
+export const IQR = (array, sigNum) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = IQRInner(arrayInner, sigNum);
     return bi2s(bi, fpe);
 };

package/src/IQR/utils.js

@@ -2,16 +2,15 @@ import { isEqualInner } from "../compare/utils.js";
 import { MADInner } from "../MAD/utils.js";
 import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
-export var MIN_LENGTH_FOR_MAD = 30;
-export var IQRInner = function (array, sigNum) {
-    if (sigNum === void 0) { sigNum = false; }
-    var _a = quartileInner(array), Q1 = _a.Q1, Q3 = _a.Q3;
-    var sub = new PipeInner().sub([Q3, Q1]).calc();
+export const MIN_LENGTH_FOR_MAD = 30;
+export const IQRInner = (array, sigNum = false) => {
+    const { Q1, Q3 } = quartileInner(array);
+    const sub = new PipeInner().sub([Q3, Q1]).calc();
     if (sigNum) {
-        var isEqual = isEqualInner({ left: Q3, right: Q1 });
-        var MAD = MADInner(array);
-        var isNil = isEqualInner({ left: MAD, right: [0n, 0] });
-        var nonNilMAD = isNil ? [1n, 0] : MAD;
+        const isEqual = isEqualInner({ left: Q3, right: Q1 });
+        const MAD = MADInner(array);
+        const isNil = isEqualInner({ left: MAD, right: [0n, 0] });
+        const nonNilMAD = isNil ? [1n, 0] : MAD;
         return isEqual ? nonNilMAD : sub;
     }
     return sub;

package/src/MAD/main.js

@@ -1,8 +1,8 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { MADInner } from "./utils.js";
 //** This function returns Median Absolute Deviation */
-export var MAD = function (array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = MADInner(arrayInner), bi = _a[0], fpe = _a[1];
+export const MAD = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = MADInner(arrayInner);
     return bi2s(bi, fpe);
 };

package/src/MAD/utils.js

@@ -2,12 +2,12 @@ import { PipeInner } from "../pipe/utils.js";
 import { quartileInner } from "../quartile/utils.js";
 import { ASC } from "../sort/constants.js";
 import { sortInner } from "../sort/utils.js";
-export var MADInner = function (array) {
-    var median = quartileInner(array).Q2;
-    var madArray = array.map(function (el) {
-        var _a = new PipeInner().sub([el, median]).calc(), bi = _a[0], fpe = _a[1];
+export const MADInner = (array) => {
+    const median = quartileInner(array).Q2;
+    const madArray = array.map((el) => {
+        const [bi, fpe] = new PipeInner().sub([el, median]).calc();
         return bi < 0n ? [bi * -1n, fpe] : [bi, fpe];
     });
-    var sorted = sortInner(madArray, ASC);
+    const sorted = sortInner(madArray, ASC);
     return quartileInner(sorted).Q2;
 };

package/src/compare/main.js

@@ -1,24 +1,22 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { isEqualInner, isLeftGreaterInner, maxInner, minInner, } from "./utils.js";
 /** This function returns max value. */
-export var max = function (array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = maxInner(arrayInner), bi = _a[0], fpe = _a[1];
+export const max = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = maxInner(arrayInner);
     return bi2s(bi, fpe);
 };
 /** This function returns min value. */
-export var min = function (array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = minInner(arrayInner), bi = _a[0], fpe = _a[1];
+export const min = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = minInner(arrayInner);
     return bi2s(bi, fpe);
 };
 /** This function returns if left value is greater than right value */
-export var isLeftGreater = function (_a) {
-    var left = _a.left, right = _a.right;
+export const isLeftGreater = ({ left, right }) => {
     return isLeftGreaterInner({ left: s2bi(left), right: s2bi(right) });
 };
 /** This function returns if left and right values are equal */
-export var isEqual = function (_a) {
-    var left = _a.left, right = _a.right;
+export const isEqual = ({ left, right }) => {
     return isEqualInner({ left: s2bi(left), right: s2bi(right) });
 };

package/src/compare/utils.js

@@ -1,22 +1,22 @@
-export var maxInner = function (array) {
-    var max = array[0];
-    for (var i = 1; i < array.length; i++) {
+export const maxInner = (array) => {
+    let max = array[0];
+    for (let i = 1; i < array.length; i++) {
         if (compareInner(array[i], max)[1] === 1)
             max = array[i];
     }
     return max;
 };
-export var minInner = function (array) {
-    var min = array[0];
-    for (var i = 1; i < array.length; i++) {
+export const minInner = (array) => {
+    let min = array[0];
+    for (let i = 1; i < array.length; i++) {
         if (compareInner(array[i], min)[1] === -1)
             min = array[i];
     }
     return min;
 };
-export var compareInner = function (l, r) {
-    var biL = l[0], fpeL = l[1];
-    var biR = r[0], fpeR = r[1];
+export const compareInner = (l, r) => {
+    const [biL, fpeL] = l;
+    const [biR, fpeR] = r;
     if (biL > 0n && biR < 0n)
         return [l, 1];
     if (biL < 0n && biR > 0n)
@@ -36,11 +36,11 @@ export var compareInner = function (l, r) {
             if (fpeL === fpeR)
                 return [l, 0];
         }
-        var fpeBiL = BigInt(fpeL);
-        var fpeBiR = BigInt(fpeR);
-        var max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
-        var powL = biL * Math.pow(10n, (max - fpeBiL));
-        var powR = biR * Math.pow(10n, (max - fpeBiR));
+        const fpeBiL = BigInt(fpeL);
+        const fpeBiR = BigInt(fpeR);
+        const max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
+        const powL = biL * 10n ** (max - fpeBiL);
+        const powR = biR * 10n ** (max - fpeBiR);
         if (powL > powR)
             return [l, 1];
         if (powL < powR)
@@ -55,11 +55,11 @@ export var compareInner = function (l, r) {
             if (fpeL === fpeR)
                 return [l, 0];
         }
-        var fpeBiL = BigInt(fpeL);
-        var fpeBiR = BigInt(fpeR);
-        var max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
-        var powL = biL * Math.pow(10n, (max - fpeBiL));
-        var powR = biR * Math.pow(10n, (max - fpeBiR));
+        const fpeBiL = BigInt(fpeL);
+        const fpeBiR = BigInt(fpeR);
+        const max = fpeBiL > fpeBiR ? fpeBiL : fpeBiR;
+        const powL = biL * 10n ** (max - fpeBiL);
+        const powR = biR * 10n ** (max - fpeBiR);
         if (powL > powR)
             return [l, 1];
         if (powL < powR)
@@ -67,11 +67,9 @@ export var compareInner = function (l, r) {
     }
     return [l, 0];
 };
-export var isEqualInner = function (_a) {
-    var left = _a.left, right = _a.right;
+export const isEqualInner = ({ left, right }) => {
     return compareInner(left, right)[1] === 0;
 };
-export var isLeftGreaterInner = function (_a) {
-    var left = _a.left, right = _a.right;
+export const isLeftGreaterInner = ({ left, right }) => {
     return compareInner(left, right)[1] > 0;
 };

package/src/mean/main.js

@@ -1,8 +1,8 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { meanInner } from "./utils.js";
 /** This function returns mean of an array. */
-export var mean = function (array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = meanInner(arrayInner), bi = _a[0], fpe = _a[1];
+export const mean = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bi, fpe] = meanInner(arrayInner);
     return bi2s(bi, fpe);
 };

package/src/mean/utils.js

@@ -1,6 +1,6 @@
 import { PipeInner } from "../pipe/utils.js";
-export var meanInner = function (array) {
-    var left = new PipeInner().add(array).calc();
-    var right = [BigInt(array.length), 0];
+export const meanInner = (array) => {
+    const left = new PipeInner().add(array).calc();
+    const right = [BigInt(array.length), 0];
     return new PipeInner().div([left, right]).calc();
 };

package/src/operations/add/main.js

@@ -1,8 +1,8 @@
 import { bi2s, s2bi } from "../../shared/utils.js";
 import { calcInner } from "../../shared/utils.js";
 /** This function adds numbers (as string). */
-export var add = function (array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = calcInner(arrayInner, function (a, b) { return a + b; }), bigInt = _a[0], fpe = _a[1];
+export const add = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a + b);
     return bi2s(bigInt, fpe);
 };

package/src/operations/div/main.js

@@ -1,9 +1,8 @@
 import { bi2s, s2bi } from "../../shared/utils.js";
 import { divInner } from "./utils.js";
 /** This function should divide numbers (as string). */
-export var div = function (array, limit) {
-    if (limit === void 0) { limit = 20; }
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = divInner(arrayInner, limit !== null && limit !== void 0 ? limit : 20), bigInt = _a[0], fpe = _a[1];
+export const div = (array, limit = 20) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bigInt, fpe] = divInner(arrayInner, limit !== null && limit !== void 0 ? limit : 20);
     return bi2s(bigInt, fpe);
 };

package/src/operations/div/utils.js

@@ -1,10 +1,10 @@
-export var divInner = function (array, limit, def) {
-    var bigInt = def ? def[0] : array[0][0];
-    var fpe = def ? def[1] : array[0][1];
-    var isNeg = bigInt < 0n;
-    for (var i = def ? 0 : 1; i < array.length; i++) {
-        var _a = array[i], bigCurrent = _a[0], dpLen = _a[1];
-        var r = 0n;
+export const divInner = (array, limit, def) => {
+    let bigInt = def ? def[0] : array[0][0];
+    let fpe = def ? def[1] : array[0][1];
+    const isNeg = bigInt < 0n;
+    for (let i = def ? 0 : 1; i < array.length; i++) {
+        let [bigCurrent, dpLen] = array[i];
+        let r = 0n;
         if (bigInt === 0n && fpe === 0)
             return [0n, 0];
         if (fpe === dpLen) {
@@ -12,7 +12,7 @@ export var divInner = function (array, limit, def) {
             dpLen = 0;
         }
         if (dpLen > 0 && fpe < dpLen) {
-            bigInt *= Math.pow(10n, BigInt(dpLen - fpe));
+            bigInt *= 10n ** BigInt(dpLen - fpe);
             fpe = 0;
         }
         if (dpLen > 0 && fpe > dpLen)
@@ -23,13 +23,13 @@ export var divInner = function (array, limit, def) {
             fpe += 1;
             bigInt *= 10n;
         }
-        var q = bigInt / bigCurrent;
+        const q = bigInt / bigCurrent;
         r = bigInt - q * bigCurrent;
         bigInt = q;
         while ((isNeg ? r < 0n : r > 0n) && fpe < limit) {
-            var nextBigInt = r * 10n;
-            var nextQ = nextBigInt / bigCurrent;
-            var nextRemained = nextBigInt - nextQ * bigCurrent;
+            const nextBigInt = r * 10n;
+            const nextQ = nextBigInt / bigCurrent;
+            const nextRemained = nextBigInt - nextQ * bigCurrent;
             bigInt = bigInt * 10n + nextQ;
             r = nextRemained;
             fpe += 1;

package/src/operations/mul/main.js

@@ -1,7 +1,7 @@
 import { bi2s, calcInner, s2bi } from "../../shared/utils.js";
 /** This function multiplies numbers (as string). */
-export var mul = function (array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = calcInner(arrayInner, function (a, b) { return a * b; }), bigInt = _a[0], fpe = _a[1];
+export const mul = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a * b);
     return bi2s(bigInt, fpe);
 };

package/src/operations/sub/main.js

@@ -2,7 +2,7 @@ import { bi2s, s2bi } from "../../shared/utils.js";
 import { calcInner } from "../../shared/utils.js";
 /** This function subtracts numbers (as string). */
 export function sub(array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = calcInner(arrayInner, function (a, b) { return a - b; }), bigInt = _a[0], fpe = _a[1];
+    const arrayInner = array.map((str) => s2bi(str));
+    const [bigInt, fpe] = calcInner(arrayInner, (a, b) => a - b);
     return bi2s(bigInt, fpe);
 }

package/src/pipe/main.js

@@ -12,41 +12,38 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _Pipe_result;
 import { bi2s, calcInner, s2bi } from "../shared/utils.js";
 import { divInner } from "../operations/div/utils.js";
-var Pipe = /** @class */ (function () {
-    function Pipe() {
+export class Pipe {
+    constructor() {
         _Pipe_result.set(this, void 0);
     }
-    Pipe.prototype.add = function (array) {
-        var arrayInner = array.map(function (str) { return s2bi(str); });
-        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, function (a, b) { return a + b; }, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
+    add(array) {
+        const arrayInner = array.map((str) => s2bi(str));
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, (a, b) => a + b, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
-    };
-    Pipe.prototype.sub = function (array) {
-        var arrayInner = array.map(function (str) { return s2bi(str); });
-        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, function (a, b) { return a - b; }, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
+    }
+    sub(array) {
+        const arrayInner = array.map((str) => s2bi(str));
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, (a, b) => a - b, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
-    };
-    Pipe.prototype.div = function (array, limit) {
-        if (limit === void 0) { limit = 20; }
-        var arrayInner = array.map(function (str) { return s2bi(str); });
+    }
+    div(array, limit = 20) {
+        const arrayInner = array.map((str) => s2bi(str));
         __classPrivateFieldSet(this, _Pipe_result, divInner(arrayInner, limit, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
-    };
-    Pipe.prototype.mul = function (array) {
-        var arrayInner = array.map(function (str) { return s2bi(str); });
-        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, function (a, b) { return a * b; }, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
+    }
+    mul(array) {
+        const arrayInner = array.map((str) => s2bi(str));
+        __classPrivateFieldSet(this, _Pipe_result, calcInner(arrayInner, (a, b) => a * b, __classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
-    };
-    Pipe.prototype.calc = function () {
+    }
+    calc() {
         var _a;
-        var _b = (_a = __classPrivateFieldGet(this, _Pipe_result, "f")) !== null && _a !== void 0 ? _a : [0n, 0], bi = _b[0], fpe = _b[1];
-        var result = bi2s(bi, fpe);
+        const [bi, fpe] = (_a = __classPrivateFieldGet(this, _Pipe_result, "f")) !== null && _a !== void 0 ? _a : [0n, 0];
+        const result = bi2s(bi, fpe);
         __classPrivateFieldSet(this, _Pipe_result, undefined, "f");
         return result;
-    };
-    return Pipe;
-}());
-export { Pipe };
+    }
+}
 _Pipe_result = new WeakMap();
 /** Using this function you can chain operations (add, sub, div, mul). */
-export var pipe = new Pipe();
+export const pipe = new Pipe();

package/src/pipe/utils.js

@@ -1,30 +1,26 @@
 import { calcInner } from "../shared/utils.js";
 import { divInner } from "../operations/div/utils.js";
-var PipeInner = /** @class */ (function () {
-    function PipeInner() {
-    }
-    PipeInner.prototype.add = function (array) {
-        this.result = calcInner(array, function (a, b) { return a + b; }, this.result);
+export class PipeInner {
+    constructor() { }
+    add(array) {
+        this.result = calcInner(array, (a, b) => a + b, this.result);
         return this;
-    };
-    PipeInner.prototype.sub = function (array) {
-        this.result = calcInner(array, function (a, b) { return a - b; }, this.result);
+    }
+    sub(array) {
+        this.result = calcInner(array, (a, b) => a - b, this.result);
         return this;
-    };
-    PipeInner.prototype.div = function (array, limit) {
-        if (limit === void 0) { limit = 20; }
+    }
+    div(array, limit = 20) {
         this.result = divInner(array, limit, this.result);
         return this;
-    };
-    PipeInner.prototype.mul = function (array) {
-        this.result = calcInner(array, function (a, b) { return a * b; }, this.result);
+    }
+    mul(array) {
+        this.result = calcInner(array, (a, b) => a * b, this.result);
         return this;
-    };
-    PipeInner.prototype.calc = function () {
+    }
+    calc() {
         var _a;
-        var res = (_a = this.result) !== null && _a !== void 0 ? _a : [0n, 0];
+        const res = (_a = this.result) !== null && _a !== void 0 ? _a : [0n, 0];
         return res;
-    };
-    return PipeInner;
-}());
-export { PipeInner };
+    }
+}

package/src/quartile/main.js

@@ -1,9 +1,9 @@
 import { bi2s, s2bi } from "../shared/utils.js";
 import { quartileInner } from "./utils.js";
 /** This function returns Q1, Q2, Q3 (quartile). */
-export var quartile = function (array) {
-    var arrayInner = array.map(function (str) { return s2bi(str); });
-    var _a = quartileInner(arrayInner), _b = _a.Q1, Q1bi = _b[0], Q1fpe = _b[1], _c = _a.Q2, Q2bi = _c[0], Q2fpe = _c[1], _d = _a.Q3, Q3bi = _d[0], Q3fpe = _d[1];
+export const quartile = (array) => {
+    const arrayInner = array.map((str) => s2bi(str));
+    const { Q1: [Q1bi, Q1fpe], Q2: [Q2bi, Q2fpe], Q3: [Q3bi, Q3fpe] } = quartileInner(arrayInner);
     return {
         Q1: bi2s(Q1bi, Q1fpe),
         Q2: bi2s(Q2bi, Q2fpe),

package/src/quartile/utils.js

@@ -1,17 +1,17 @@
 import { PipeInner } from "../pipe/utils.js";
-var meanQ = function (idx, array) {
-    var left = new PipeInner().add([array[idx], array[idx - 1]]).calc();
+const meanQ = (idx, array) => {
+    const left = new PipeInner().add([array[idx], array[idx - 1]]).calc();
     return new PipeInner().div([left, [2n, 0]]).calc();
 };
-export var quartileInner = function (array) {
+export const quartileInner = (array) => {
     if (array.length < 3) {
         throw Error("To calculate quartile you need at least 3 elements");
     }
-    var length = array.length;
-    var Q2Idx = length >> 1;
-    var Q1Idx = Q2Idx >> 1;
-    var Q3Idx = length - Q1Idx;
-    var isEvenHalf = Q2Idx % 2 !== 0;
+    const { length } = array;
+    const Q2Idx = length >> 1;
+    const Q1Idx = Q2Idx >> 1;
+    const Q3Idx = length - Q1Idx;
+    const isEvenHalf = Q2Idx % 2 !== 0;
     return {
         Q1: isEvenHalf ? array[Q1Idx] : meanQ(Q1Idx, array),
         Q2: length % 2 !== 0 ? array[Q2Idx] : meanQ(Q2Idx, array),

package/src/round/constants.js

@@ -1,10 +1,10 @@
-export var UP = "up";
-export var DOWN = "down";
-export var HALF_UP = "half-up";
-export var HALF_DOWN = "half-down";
-export var HALF_EVEN = "half-even";
-export var HALF_ODD = "half-odd";
-export var ROUND_MODE = [
+export const UP = "up";
+export const DOWN = "down";
+export const HALF_UP = "half-up";
+export const HALF_DOWN = "half-down";
+export const HALF_EVEN = "half-even";
+export const HALF_ODD = "half-odd";
+export const ROUND_MODE = [
     UP,
     DOWN,
     HALF_UP,

package/src/round/main.js

@@ -1,17 +1,16 @@
 import { HALF_UP } from "./constants.js";
 import { calcLast, handleCarryOver, handleTail } from "./utils.js";
 /** This function round number. */
-export var round = function (value, options) {
-    var _a;
-    var _b, _c, _d, _e;
-    var roundMode = (_b = options === null || options === void 0 ? void 0 : options.roundMode) !== null && _b !== void 0 ? _b : HALF_UP;
-    var array = [];
-    var sigFig = (_c = options === null || options === void 0 ? void 0 : options.sigFig) !== null && _c !== void 0 ? _c : false;
-    var decimals = (_d = options === null || options === void 0 ? void 0 : options.decimals) !== null && _d !== void 0 ? _d : 0;
-    var isFloat = false;
-    var isNil = true;
-    for (var i = 0; i < value.length; i++) {
-        var charCode = value.charCodeAt(i);
+export const round = (value, options) => {
+    var _a, _b, _c, _d;
+    const roundMode = (_a = options === null || options === void 0 ? void 0 : options.roundMode) !== null && _a !== void 0 ? _a : HALF_UP;
+    let array = [];
+    let sigFig = (_b = options === null || options === void 0 ? void 0 : options.sigFig) !== null && _b !== void 0 ? _b : false;
+    let decimals = (_c = options === null || options === void 0 ? void 0 : options.decimals) !== null && _c !== void 0 ? _c : 0;
+    let isFloat = false;
+    let isNil = true;
+    for (let i = 0; i < value.length; i++) {
+        const charCode = value.charCodeAt(i);
         if (sigFig && charCode > 48)
             sigFig = false;
         if (isNil && charCode > 48)
@@ -21,14 +20,14 @@ export var round = function (value, options) {
         if (charCode === 46)
             isFloat = true;
         if (isFloat && decimals === 0) {
-            var next = (_e = value.charCodeAt(i + 1)) !== null && _e !== void 0 ? _e : 0;
-            var prev = value.charCodeAt(i - 1);
-            var curr = charCode === 46 ? prev : charCode;
-            var _f = calcLast(curr, next, roundMode), last = _f[0], hasCarryOver = _f[1];
+            const next = (_d = value.charCodeAt(i + 1)) !== null && _d !== void 0 ? _d : 0;
+            const prev = value.charCodeAt(i - 1);
+            const curr = charCode === 46 ? prev : charCode;
+            const [last, hasCarryOver] = calcLast(curr, next, roundMode);
             if (charCode === 46)
                 isFloat = false;
             if (hasCarryOver) {
-                _a = handleCarryOver(array, isFloat), array = _a[0], isFloat = _a[1];
+                [array, isFloat] = handleCarryOver(array, isFloat);
                 break;
             }
             charCode === 46
@@ -41,5 +40,5 @@ export var round = function (value, options) {
     handleTail(array, isFloat);
     return (isNil && array[array.length - 1] <= 48)
         ? "0"
-        : String.fromCharCode.apply(String, array);
+        : String.fromCharCode(...array);
 };

package/src/round/utils.js

@@ -1,6 +1,6 @@
 import { DOWN, HALF_DOWN, HALF_EVEN, HALF_ODD, HALF_UP, UP, } from "./constants.js";
-export var handleTail = function (array, isFloat) {
-    var lastIdx = array.length - 1;
+export const handleTail = (array, isFloat) => {
+    let lastIdx = array.length - 1;
     while (isFloat && array[lastIdx] <= 48) {
         if (array[lastIdx] === 46 || array.length === 1)
             isFloat = false;
@@ -8,53 +8,52 @@ export var handleTail = function (array, isFloat) {
         lastIdx -= 1;
     }
 };
-export var handleCarryOver = function (array, isFloat) {
+export const handleCarryOver = (array, isFloat) => {
     var _a;
-    var hasCarryOver = true;
-    var idx = array.length - 1;
-    var mapFloat = new Map([
-        [57, function () {
+    let hasCarryOver = true;
+    let idx = array.length - 1;
+    const mapFloat = new Map([
+        [57, () => {
                 array.pop();
                 idx -= 1;
             }],
-        [46, function () {
+        [46, () => {
                 array.pop();
                 idx -= 1;
                 isFloat = false;
             }],
-        [0, function () {
+        [0, () => {
                 array[idx] += 1;
                 hasCarryOver = false;
             }],
     ]);
-    var mapInt = new Map([
-        [57, function () {
+    const mapInt = new Map([
+        [57, () => {
                 array[idx] = 48;
                 idx -= 1;
             }],
-        [0, function () {
+        [0, () => {
                 array[idx] += 1;
                 hasCarryOver = false;
             }],
     ]);
     while (hasCarryOver && idx >= 0) {
-        var map = isFloat ? mapFloat : mapInt;
-        var key = map.has(array[idx]) ? array[idx] : 0;
+        const map = isFloat ? mapFloat : mapInt;
+        const key = map.has(array[idx]) ? array[idx] : 0;
         (_a = map.get(key)) === null || _a === void 0 ? void 0 : _a();
     }
     hasCarryOver && array.unshift(49);
     return [array, isFloat];
 };
-export var calcLast = function (current, next, roundMode) {
-    var _a;
-    var isEven = current % 2 === 1;
-    var map = (_a = {},
-        _a[UP] = current + (next > 48 ? 1 : 0),
-        _a[DOWN] = current,
-        _a[HALF_UP] = current + (next >= 53 ? 1 : 0),
-        _a[HALF_DOWN] = current + (next > 53 ? 1 : 0),
-        _a[HALF_EVEN] = current + ((isEven && next >= 53) ? 1 : 0),
-        _a[HALF_ODD] = current + ((!isEven && next >= 53) ? 1 : 0),
-        _a);
+export const calcLast = (current, next, roundMode) => {
+    const isEven = current % 2 === 1;
+    const map = {
+        [UP]: current + (next > 48 ? 1 : 0),
+        [DOWN]: current,
+        [HALF_UP]: current + (next >= 53 ? 1 : 0),
+        [HALF_DOWN]: current + (next > 53 ? 1 : 0),
+        [HALF_EVEN]: current + ((isEven && next >= 53) ? 1 : 0),
+        [HALF_ODD]: current + ((!isEven && next >= 53) ? 1 : 0),
+    };
     return map[roundMode] > 57 ? [48, true] : [map[roundMode], false];
 };

package/src/shared/constant.js

@@ -1,4 +1,4 @@
-export var NIL = {
+export const NIL = {
     array: [48],
     isFloat: false,
     isNegative: false,

package/src/shared/utils.js

@@ -1,23 +1,23 @@
-export var bi2s = function (bigInt, fpe) {
+export const bi2s = (bigInt, fpe) => {
     if (bigInt === 0n)
         return "0";
-    var isNeg = bigInt < 0n;
+    const isNeg = bigInt < 0n;
     isNeg && (bigInt *= -1n);
-    var dp = bigInt % (Math.pow(10n, BigInt(fpe)));
-    var bigStr = bigInt.toString();
-    var fpIdx = bigStr.length - fpe;
+    const dp = bigInt % (10n ** BigInt(fpe));
+    const bigStr = bigInt.toString();
+    let fpIdx = bigStr.length - fpe;
     if (fpIdx < 0)
         fpIdx = 0;
-    var before = bigStr.slice(0, fpIdx);
-    var after = bigStr.slice(fpIdx);
+    const before = bigStr.slice(0, fpIdx);
+    const after = bigStr.slice(fpIdx);
     if (before) {
         return fillHead(bigStr.length, fpe, isNeg, true) +
-            (fpe > 0 && dp > 0 ? trimTail("".concat(before, ".").concat(after)) : before);
+            (fpe > 0 && dp > 0 ? trimTail(`${before}.${after}`) : before);
     }
-    return "".concat(fillHead(bigStr.length, fpe, isNeg, false)).concat(trimTail(after));
+    return `${fillHead(bigStr.length, fpe, isNeg, false)}${trimTail(after)}`;
 };
-export var s2bi = function (str) {
-    var fpi = str.indexOf(".");
+export const s2bi = (str) => {
+    const fpi = str.indexOf(".");
     if (fpi === -1)
         return [BigInt(str), 0];
     return [
@@ -25,12 +25,12 @@ export var s2bi = function (str) {
         fpi === -1 ? 0 : str.length - 1 - fpi,
     ];
 };
-export var calcInner = function (array, op, def) {
-    var bigInt = def ? def[0] : array[0][0];
-    var fpe = def ? def[1] : array[0][1];
-    var opm = op(1n, 1n);
-    for (var i = def ? 0 : 1; i < array.length; i++) {
-        var _a = array[i], bigCurrent = _a[0], dpLen = _a[1];
+export const calcInner = (array, op, def) => {
+    let bigInt = def ? def[0] : array[0][0];
+    let fpe = def ? def[1] : array[0][1];
+    const opm = op(1n, 1n);
+    for (let i = def ? 0 : 1; i < array.length; i++) {
+        const [bigCurrent, dpLen] = array[i];
         if (dpLen === 0 && fpe === 0) {
             bigInt = op(bigInt, bigCurrent);
             continue;
@@ -41,11 +41,11 @@ export var calcInner = function (array, op, def) {
         }
         else {
             if (fpe < dpLen) {
-                var fpDiff = dpLen - fpe;
-                bigInt = op(bigInt * (Math.pow(10n, BigInt(fpDiff))), bigCurrent);
+                const fpDiff = dpLen - fpe;
+                bigInt = op(bigInt * (10n ** BigInt(fpDiff)), bigCurrent);
             }
             if (fpe > dpLen) {
-                bigInt = op(bigInt, bigCurrent * (Math.pow(10n, BigInt(fpe - dpLen))));
+                bigInt = op(bigInt, bigCurrent * (10n ** BigInt(fpe - dpLen)));
             }
             if (fpe === dpLen)
                 bigInt = op(bigInt, bigCurrent);
@@ -55,19 +55,19 @@ export var calcInner = function (array, op, def) {
     }
     return [bigInt, fpe];
 };
-export var fillHead = function (len, fpe, isNeg, hasBefore) {
-    var head = (isNeg ? "-" : "") + (hasBefore ? "" : "0.");
+export const fillHead = (len, fpe, isNeg, hasBefore) => {
+    let head = (isNeg ? "-" : "") + (hasBefore ? "" : "0.");
     while (len < fpe) {
         head = head + "0";
         len += 1;
     }
     return head;
 };
-export var trimTail = function (str) {
+export const trimTail = (str) => {
     if (str[str.length - 1] !== "0")
         return str;
-    var count = 0;
-    for (var i = str.length - 1; i >= 0; i -= 1) {
+    let count = 0;
+    for (let i = str.length - 1; i >= 0; i -= 1) {
         if (str[i] !== "0")
             return str.slice(0, str.length - count);
         count += 1;

package/src/sort/constants.js

@@ -1,3 +1,3 @@
-export var ASC = "asc";
-export var DESC = "desc";
-export var sortingArray = [ASC, DESC];
+export const ASC = "asc";
+export const DESC = "desc";
+export const sortingArray = [ASC, DESC];

package/src/sort/main.js

@@ -2,12 +2,8 @@ import { bi2s, s2bi } from "../shared/utils.js";
 import { ASC } from "./constants.js";
 import { sortInner } from "./utils.js";
 /** Using this function sort an array. */
-export var sort = function (array, sorting) {
-    if (sorting === void 0) { sorting = ASC; }
-    var arrayInner = array.map(function (str) { return s2bi(str); });
+export const sort = (array, sorting = ASC) => {
+    const arrayInner = array.map((str) => s2bi(str));
     sortInner(arrayInner, sorting);
-    return arrayInner.map(function (_a) {
-        var bi = _a[0], fpe = _a[1];
-        return bi2s(bi, fpe);
-    });
+    return arrayInner.map(([bi, fpe]) => bi2s(bi, fpe));
 };

package/src/sort/utils.js

@@ -1,10 +1,9 @@
 import { compareInner } from "../compare/utils.js";
 import { ASC } from "./constants.js";
-var heapify = function (array, len, i, sorting) {
-    var _a;
-    var idxL = 2 * i + 1;
-    var idxR = idxL + 1;
-    var idx = i;
+const heapify = (array, len, i, sorting) => {
+    const idxL = 2 * i + 1;
+    const idxR = idxL + 1;
+    let idx = i;
     if (sorting === ASC) {
         if (idxL < len && compareInner(array[idxL], array[idx])[1] >= 0)
             idx = idxL;
@@ -18,18 +17,17 @@ var heapify = function (array, len, i, sorting) {
             idx = idxR;
     }
     if (idx !== i) {
-        _a = [array[idx], array[i]], array[i] = _a[0], array[idx] = _a[1];
+        [array[i], array[idx]] = [array[idx], array[i]];
         heapify(array, len, idx, sorting);
     }
 };
-export var sortInner = function (array, sorting) {
-    var _a;
-    var len = array.length;
-    for (var i = (len >> 1) - 1; i >= 0; i--) {
+export const sortInner = (array, sorting) => {
+    const { length: len } = array;
+    for (let i = (len >> 1) - 1; i >= 0; i--) {
         heapify(array, len, i, sorting);
     }
-    for (var i = len - 1; i >= 0; i--) {
-        _a = [array[i], array[0]], array[0] = _a[0], array[i] = _a[1];
+    for (let i = len - 1; i >= 0; i--) {
+        [array[0], array[i]] = [array[i], array[0]];
         heapify(array, i, 0, sorting);
     }
     return array;

package/src/sqrt/main.js

@@ -2,9 +2,9 @@ import { round } from "../round/main.js";
 import { bi2s, s2bi } from "../shared/utils.js";
 import { sqrtInner } from "./utils.js";
 /** Find square root of a number */
-export var sqrt = function (str, precision) {
-    var inputInner = s2bi(str);
-    var _a = sqrtInner(inputInner, precision ? s2bi(precision) : undefined), _b = _a[0], bi = _b[0], fpe = _b[1], decimals = _a[1];
-    var outputStr = bi2s(bi, fpe);
-    return round(outputStr, { decimals: decimals });
+export const sqrt = (str, precision) => {
+    const inputInner = s2bi(str);
+    const [[bi, fpe], decimals] = sqrtInner(inputInner, precision ? s2bi(precision) : undefined);
+    const outputStr = bi2s(bi, fpe);
+    return round(outputStr, { decimals });
 };

package/src/sqrt/utils.js

@@ -1,18 +1,16 @@
 import { isLeftGreaterInner } from "../compare/utils.js";
 import { PipeInner } from "../pipe/utils.js";
-var halfInner = [5n, 1];
-var precDef = [1n, 13];
-export var sqrtInner = function (input, prec, max) {
-    if (prec === void 0) { prec = precDef; }
-    if (max === void 0) { max = 100; }
-    var guess = input;
-    for (var i = 0; i < max; i++) {
-        var nextGuess = new PipeInner()
+const halfInner = [5n, 1];
+const precDef = [1n, 13];
+export const sqrtInner = (input, prec = precDef, max = 100) => {
+    let guess = input;
+    for (let i = 0; i < max; i++) {
+        const nextGuess = new PipeInner()
             .div([input, guess])
             .add([guess])
             .mul([halfInner])
             .calc();
-        var _a = new PipeInner().sub([nextGuess, guess]).calc(), bi = _a[0], fpe = _a[1];
+        let [bi, fpe] = new PipeInner().sub([nextGuess, guess]).calc();
         if (bi < 0n)
             bi *= -1n;
         if (isLeftGreaterInner({ left: prec, right: [bi, fpe] })) {