@numio/bigmath 2.0.0 → 2.1.0

package/README.md

@@ -21,6 +21,8 @@
 * **Round Based on Significant Figures:** Control rounding based on the number of significant figures, crucial for scientific and engineering applications.
 * **Calculate Roots:**
     * **Calculate Square Root (`sqrt`):** Compute the square root of a number with arbitrary precision. You can also specify the desired precision of the result.
+    * **NEW! Calculate Cube Root (`cbrt`):** Determine the cube root of a number with arbitrary precision, allowing you to specify the desired accuracy.
+
 * **Chain Operations with Pipe:** Simplify complex calculations by chaining arithmetic operations in a readable and intuitive manner.
 * **Analyze Data Distribution:**
     * **Calculate Quartiles (Q1, Q2, Q3):** Understand the spread and central tendency of your numerical data, helping identify outliers and the shape of the distribution.
@@ -29,9 +31,12 @@
 * **Compare Numbers:**
     * **Check for Equality (`isEqual`):** Accurately determine if two arbitrary-precision numbers are equal.
     * **Check if Left is Greater (`isLeftGreater`):** Precisely compare two arbitrary-precision numbers to see if the left operand is greater than the right.
+    * **NEW! Check if Left is Greater or Equal (`isLeftGreaterOrEqual`):** Precisely compare two arbitrary-precision numbers to determine if the left operand is greater than or equal to the right.
 * **Sort Numbers Accurately:** Sort arrays of numbers, including negative and decimal values, in ascending or descending order, correctly handling string representations of numbers that JavaScript's native sort might misinterpret.
 * **Calculate Central Tendency:** Easily compute the mean (average) of a set of numbers.
 * **Identify Extremes:** Find the maximum and minimum values within an array of numbers.
+* **NEW! Calculate Absolute Value (`abs`):** Determine the non-negative value of a number, regardless of its sign.
+* **NEW! Convert Number to Another Base (`toBase`):** Seamlessly convert numbers between decimal, hexadecimal (HEX), binary, and octal representations.
 
 ## When is @numio/bigmath essential?
 
@@ -208,18 +213,24 @@ round("1.000119", { decimals: 2, sigFig: true }); // 1
 ### Pipe
 
 ```javascript
-import { pipe } from "@numio/bigmath";
+import { Pipe } from "@numio/bigmath";
 
 const addNums = ["1", "2", "3"];
 const subNums = ["0.2", "0.3"];
 const divNums = ["4"];
 const mulNums = ["2", "5", "0.2"];
 
-pipe.add(addNums) // 6
+new Pipe().add(addNums) // 6
   .div(divNums) // 6 / 4 = 1.5 
   .sub(subNums) // 1.5 - 0.2 - 0.3 = 1
   .mul(mulNums) // 1 * 2 * 5 * 0.2 = 2
   .calc() // convert end result to readable string
+
+new Pipe().sub(["1", "5"]) // 1 - 5 = -4
+  .abs() // 4 - returns absolute value
+
+new Pipe().add(["10", "5"]) // 11 + 5 = 15
+  .resultToBase(16) // f - returns result converted to base 16
 ```
 
 ### Quartile
@@ -289,6 +300,16 @@ isLeftGreater({left: "0.1", right: "0.1"}) // false;
 isLeftGreater({left: "0.1", right: "-0.1"}) // true;
 ```
 
+### IsLeftGreaterOrEqual
+```javascript
+import { isLeftGreaterOrEqual } from "@numio/bigmath";
+
+isLeftGreaterOrEqual({left: "0.1", right: "2"}) // false;
+isLeftGreaterOrEqual({left: "2", right: "0.1"}) // true;
+isLeftGreaterOrEqual({left: "0.1", right: "0.1"}) // true;
+isLeftGreaterOrEqual({left: "0.1", right: "-0.1"}) // true;
+```
+
 ### MAD - Median Absolute Deviation
 ```javascript
 import { MAD } from "@numio/bigmath";
@@ -315,12 +336,46 @@ sqrt("3", "0.01") // 1.732;
 sqrt("3", "0.000000000000000000001") // 1.732050807568877293527;
 ```
 
+### CBRT - cube root of a number
+```javascript
+import { cbrt } from "@numio/bigmath";
+
+cbrt("37") // 3;
+cbrt("1000") // 10;
+cbrt("15"), // 2.4662120743305
+
+// you can change precision of a result (second parameter), 
+cbrt("15", "0.001") // 2.466
+```
+
+### ABS - absolute value
+```javascript
+import { abs } from "@numio/bigmath";
+
+abs("-1") // 1;
+abs("1") // 1;
+```
+
+### toBase - convert number to another base
+```javascript
+import { toBase } from "@numio/bigmath";
+
+toBase({ value: "11", toBase: 16 }) // b
+// 0x - HEX
+toBase({ value: "0xb", toBase: 10 }) // 11
+// 0b - binary
+toBase({ value: "0b101", toBase: 10 }) // 5
+toBase({ value: "0b1101", toBase: 16 }) // d
+// 0o - octal
+toBase({ value: "0o11", toBase: 10 }) // 9
+```
+
 Does not have a limitation on the number of digits. You can use any length you'd
 like
 
 ```javascript
 // NO precision loss using numeric literals with more than 15 significant digits.
-const int = sub(
+const int = add(
   "999999999999999999999999999999999999999999999999999999999999999",
   "2",
 ); // "1000000000000000000000000000000000000000000000000000000000000001"

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.1.0",
   "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/abs/main.d.ts

@@ -0,0 +1,2 @@
+import type { Abs } from "./types.d.ts";
+export declare const abs: Abs;

package/src/abs/main.js

@@ -0,0 +1,6 @@
+import { bi2s, s2bi } from "../shared/utils.js";
+import { absInner } from "./utils.js";
+export const abs = (value) => {
+    const [bi, fpe] = absInner(s2bi(value));
+    return bi2s(bi, fpe);
+};

package/src/abs/types.d.ts

@@ -0,0 +1,3 @@
+import type { BI } from "../shared/types.d.ts";
+export type Abs = (value: string) => string;
+export type AbsInner = (value: BI) => BI;

package/src/abs/utils.d.ts

@@ -0,0 +1,2 @@
+import type { AbsInner } from "./types.d.ts";
+export declare const absInner: AbsInner;

package/src/abs/utils.js

@@ -0,0 +1,3 @@
+export const absInner = ([bi, fpe]) => {
+    return [bi < 0n ? bi * -1n : bi, fpe];
+};

package/src/cbrt/main.d.ts

@@ -0,0 +1,3 @@
+import type { Cbrt } from "./types.d.ts";
+/** Find cube root of a number */
+export declare const cbrt: Cbrt;

package/src/cbrt/main.js

@@ -0,0 +1,9 @@
+import { round } from "../round/main.js";
+import { bi2s, s2bi } from "../shared/utils.js";
+import { cbrtInner } from "./utils.js";
+/** Find cube root of a number */
+export const cbrt = (value, precision) => {
+    const valueInner = s2bi(value);
+    const [[bi, fpe], decimals] = cbrtInner(valueInner, precision ? s2bi(precision) : undefined);
+    return round(bi2s(bi, fpe), { decimals });
+};

package/src/cbrt/types.d.ts

@@ -0,0 +1,3 @@
+import type { BI } from "../shared/types.d.ts";
+export type CbrtInner = (value: BI, prec?: BI, max?: number) => [BI, number];
+export type Cbrt = (value: string, precision?: string) => string;

package/src/cbrt/utils.d.ts

@@ -0,0 +1,2 @@
+import type { CbrtInner } from "./types.d.ts";
+export declare const cbrtInner: CbrtInner;

package/src/cbrt/utils.js

@@ -0,0 +1,22 @@
+import { isLeftGreaterInner } from "../compare/utils.js";
+import { divInner } from "../operations/div/utils.js";
+import { PipeInner } from "../pipe/utils.js";
+import { calcInner } from "../shared/utils.js";
+export const cbrtInner = (value, prec = [1n, 13], max = 100) => {
+    let guess = value;
+    for (let i = 0; i < max; i++) {
+        const mul = calcInner([guess, guess], (a, b) => a * b);
+        const nextGuess = new PipeInner().add([
+            calcInner([guess, [2n, 0]], (a, b) => a * b),
+            divInner([value, mul], 20),
+        ]).div([[3n, 0]]).calc();
+        let [bi, fpe] = new PipeInner().sub([nextGuess, guess]).calc();
+        if (bi < 0n)
+            bi *= -1n;
+        if (isLeftGreaterInner({ left: prec, right: [bi, fpe] })) {
+            return [nextGuess, prec[1]];
+        }
+        guess = nextGuess;
+    }
+    return [guess, prec[1]];
+};

package/src/compare/main.d.ts

@@ -1,9 +1,11 @@
-import type { IsEqual, IsLeftGreater, Max, Min } from "./types.d.ts";
+import type { IsEqual, IsLeftGreater, IsLeftGreaterOrEqual, Max, Min } from "./types.d.ts";
 /** This function returns max value. */
 export declare const max: Max;
 /** This function returns min value. */
 export declare const min: Min;
 /** This function returns if left value is greater than right value */
 export declare const isLeftGreater: IsLeftGreater;
+/** This function returns if left value is greater than right value */
+export declare const isLeftGreaterOrEqual: IsLeftGreaterOrEqual;
 /** This function returns if left and right values are equal */
 export declare const isEqual: IsEqual;

package/src/compare/main.js

@@ -1,24 +1,26 @@
 import { bi2s, s2bi } from "../shared/utils.js";
-import { isEqualInner, isLeftGreaterInner, maxInner, minInner, } from "./utils.js";
+import { isEqualInner, isLeftGreaterInner, isLeftGreaterOrEqualInner, 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 value is greater than right value */
+export const isLeftGreaterOrEqual = ({ left, right }) => {
+    return isLeftGreaterOrEqualInner({ 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/types.d.ts

@@ -1,16 +1,24 @@
 import type { BI } from "../shared/types.d.ts";
 export type Min = (strs: string[]) => string;
 export type Max = Min;
-export type IsLeftGreater = (attr: {
+export type IsLeftGreater = (arg: {
+    left: string;
+    right: string;
+}) => boolean;
+export type IsEqual = (arg: {
+    left: string;
+    right: string;
+}) => boolean;
+export type IsLeftGreaterOrEqual = (arg: {
     left: string;
     right: string;
 }) => boolean;
-export type IsEqual = IsLeftGreater;
 export type CompareInner = (left: BI, right: BI) => [BI, number];
 export type MinInner = (array: BI[]) => BI;
 export type MaxInner = MinInner;
-export type IsEqualInner = (attr: {
+export type IsEqualInner = (arg: {
     left: BI;
     right: BI;
 }) => boolean;
 export type IsLeftGreaterInner = IsEqualInner;
+export type IsLeftGreaterOrEqualInner = IsEqualInner;

package/src/compare/utils.d.ts

@@ -1,6 +1,7 @@
-import type { CompareInner, IsEqualInner, IsLeftGreaterInner, MaxInner, MinInner } from "./types.d.ts";
+import type { CompareInner, IsEqualInner, IsLeftGreaterInner, IsLeftGreaterOrEqualInner, MaxInner, MinInner } from "./types.d.ts";
 export declare const maxInner: MaxInner;
 export declare const minInner: MinInner;
 export declare const compareInner: CompareInner;
 export declare const isEqualInner: IsEqualInner;
 export declare const isLeftGreaterInner: IsLeftGreaterInner;
+export declare const isLeftGreaterOrEqualInner: IsLeftGreaterOrEqualInner;

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,12 @@ 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;
 };
+export const isLeftGreaterOrEqualInner = ({ 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.d.ts

@@ -1,12 +1,13 @@
 import type { BI2S } from "../shared/types.d.ts";
+/** Using this function you can chain operations (add, sub, div, mul). */
 export declare class Pipe {
     #private;
-    constructor();
+    constructor(value?: string);
     add(array: string[]): Pipe;
     sub(array: string[]): Pipe;
     div(array: string[], limit?: number): Pipe;
     mul(array: string[]): Pipe;
+    abs(): Pipe;
     calc(): ReturnType<BI2S>;
+    resultToBase(radix: number): string;
 }
-/** Using this function you can chain operations (add, sub, div, mul). */
-export declare const pipe: Pipe;

package/src/pipe/main.js

@@ -1,52 +1,67 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var _Pipe_result;
 import { bi2s, calcInner, s2bi } from "../shared/utils.js";
 import { divInner } from "../operations/div/utils.js";
-var Pipe = /** @class */ (function () {
-    function Pipe() {
+import { absInner } from "../abs/utils.js";
+/** Using this function you can chain operations (add, sub, div, mul). */
+export class Pipe {
+    constructor(value) {
         _Pipe_result.set(this, void 0);
+        value && (__classPrivateFieldSet(this, _Pipe_result, s2bi(value), "f"));
     }
-    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;
+    }
+    abs() {
+        if (!__classPrivateFieldGet(this, _Pipe_result, "f")) {
+            throw new Error("Cannot calculate the absolute value of an undefined.");
+        }
+        __classPrivateFieldSet(this, _Pipe_result, absInner(__classPrivateFieldGet(this, _Pipe_result, "f")), "f");
         return this;
-    };
-    Pipe.prototype.calc = function () {
+    }
+    calc() {
+        if (!__classPrivateFieldGet(this, _Pipe_result, "f")) {
+            throw new Error("Cannot calculate based on an undefined input.");
+        }
+        const [bi, fpe] = __classPrivateFieldGet(this, _Pipe_result, "f");
+        return bi2s(bi, fpe);
+    }
+    resultToBase(radix) {
         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);
-        __classPrivateFieldSet(this, _Pipe_result, undefined, "f");
-        return result;
-    };
-    return Pipe;
-}());
-export { Pipe };
+        if (!__classPrivateFieldGet(this, _Pipe_result, "f")) {
+            throw new Error(`Cannot convert an undefined result to base ${radix}.`);
+        }
+        if (__classPrivateFieldGet(this, _Pipe_result, "f")[1] > 0) {
+            throw new Error(`Cannot convert non integer result to base ${radix}.`);
+        }
+        return (_a = __classPrivateFieldGet(this, _Pipe_result, "f")) === null || _a === void 0 ? void 0 : _a[0].toString(radix);
+    }
+}
 _Pipe_result = new WeakMap();
-/** Using this function you can chain operations (add, sub, div, mul). */
-export var 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,8 @@ 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 = (value, precision) => {
+    const valueInner = s2bi(value);
+    const [[bi, fpe], decimals] = sqrtInner(valueInner, precision ? s2bi(precision) : undefined);
+    return round(bi2s(bi, fpe), { decimals });
 };

package/src/sqrt/types.d.ts

@@ -1,3 +1,3 @@
 import type { BI } from "../shared/types.d.ts";
-export type SqrtInner = (input: BI, prec?: BI, max?: number) => [BI, number];
-export type Sqrt = (str: string, precision?: string) => string;
+export type SqrtInner = (value: BI, prec?: BI, max?: number) => [BI, number];
+export type Sqrt = (value: string, precision?: string) => string;

package/src/sqrt/utils.js

@@ -1,18 +1,14 @@
 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()
-            .div([input, guess])
+export const sqrtInner = (value, prec = [1n, 13], max = 100) => {
+    let guess = value;
+    for (let i = 0; i < max; i++) {
+        const nextGuess = new PipeInner()
+            .div([value, guess])
             .add([guess])
-            .mul([halfInner])
+            .mul([[5n, 1]])
             .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] })) {

package/src/toBase/main.d.ts

@@ -0,0 +1,2 @@
+import type { ToBase } from "./types.d.ts";
+export declare const toBase: ToBase;

package/src/toBase/main.js

@@ -0,0 +1,3 @@
+export const toBase = ({ value, toBase }) => {
+    return BigInt(value).toString(toBase);
+};

package/src/toBase/types.d.ts

@@ -0,0 +1,4 @@
+export type ToBase = (arg: {
+    value: string;
+    toBase: number;
+}) => string;