@numio/bigmath 1.0.7 → 1.0.8

package/index.d.ts

@@ -1,8 +1,8 @@
-import { add } from "./src/mathOperations/add/index.d.ts";
-import { mul } from "./src/mathOperations/mul/index.d.ts";
-import { sub } from "./src/mathOperations/sub/index.d.ts";
-import { div } from "./src/mathOperations/div/index.d.ts";
-import { round } from "./src/round/index.d.ts";
+import { add } from "./src/mathOperations/add/main.d.ts";
+import { mul } from "./src/mathOperations/mul/main.d.ts";
+import { sub } from "./src/mathOperations/sub/main.d.ts";
+import { div } from "./src/mathOperations/div/main.d.ts";
+import { round } from "./src/round/main.d.ts";
 import { pipe } from "./src/pipe/main.d.ts";
 import { quartile } from "./src/quartile/main.d.ts";
 import { sort } from "./src/sort/main.d.ts";

package/index.js

@@ -1,8 +1,8 @@
-import { add } from "./src/mathOperations/add/index.js";
-import { mul } from "./src/mathOperations/mul/index.js";
-import { sub } from "./src/mathOperations/sub/index.js";
-import { div } from "./src/mathOperations/div/index.js";
-import { round } from "./src/round/index.js";
+import { add } from "./src/mathOperations/add/main.js";
+import { mul } from "./src/mathOperations/mul/main.js";
+import { sub } from "./src/mathOperations/sub/main.js";
+import { div } from "./src/mathOperations/div/main.js";
+import { round } from "./src/round/main.js";
 import { pipe } from "./src/pipe/main.js";
 import { quartile } from "./src/quartile/main.js";
 import { sort } from "./src/sort/main.js";

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": "1.0.7",
+  "version": "1.0.8",
   "keywords": [
     "precision",
     "arithmetic",

package/src/MAD/main.d.ts

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

package/src/MAD/main.js

@@ -0,0 +1,18 @@
+import { subRoute } from "../mathOperations/sub/utils.js";
+import { mean } from "../mean/main.js";
+import { quartileInner } from "../quartile/utils.js";
+import { DEFAULT } from "../shared/constant.js";
+import { a2s, s2a } from "../shared/utils.js";
+import { ASC } from "../sort/constants.js";
+import { sortInner } from "../sort/utils.js";
+export var MADQ2 = function (array) {
+    var meanOfAnArray = mean(array);
+    var madArray = array
+        .map(function (element) {
+        var res = subRoute([s2a(element), s2a(meanOfAnArray)], DEFAULT);
+        res.isNegative = false;
+        return res;
+    });
+    var sorted = sortInner(madArray, ASC);
+    return a2s(quartileInner(sorted).Q2);
+};

package/src/MAD/types.d.ts

@@ -0,0 +1 @@
+export type TMADQ2 = (array: string[]) => string;

package/src/compare/main.d.ts

@@ -1,7 +1,4 @@
-import type { CompareRawFn, Max, MaxRawFn, Min, MinRawFn } from "./types.d.ts";
-export declare const compareRawFn: CompareRawFn;
-export declare const maxRawFn: MaxRawFn;
-export declare const minRawFn: MinRawFn;
+import type { Max, Min } from "./types.d.ts";
 /** This function returns max number. */
 export declare const max: Max;
 /** This function returns min number. */

package/src/compare/main.js

@@ -1,80 +1,15 @@
 import { a2s, s2a } from "../shared/utils.js";
-export var compareRawFn = function (l, r) {
-    var _a;
-    var idx = 0;
-    var _b = [l, r], left = _b[0], right = _b[1];
-    var lIsNeg = l.isNegative, lIntLen = l.intLength;
-    var rIsNeg = r.isNegative, rIntLen = r.intLength;
-    var lenL = l.array.length;
-    var lenR = r.array.length;
-    var bothNeg = lIsNeg && rIsNeg;
-    var bothPos = !lIsNeg && !rIsNeg;
-    var bothIntPos = lIntLen > 0 && rIntLen > 0;
-    var bothIntNeg = lIntLen <= 0 && rIntLen <= 0;
-    if (lIsNeg && !rIsNeg)
-        return [r, false];
-    if (!lIsNeg && rIsNeg)
-        return [l, true];
-    if (bothPos && bothIntPos && lIntLen < rIntLen)
-        return [r, false];
-    if (bothPos && bothIntNeg && lIntLen < rIntLen)
-        return [r, false];
-    if (bothNeg && bothIntPos && lIntLen < rIntLen)
-        return [l, true];
-    if (bothNeg && bothIntNeg && lIntLen < rIntLen)
-        return [l, true];
-    if (bothNeg && bothIntNeg && lIntLen > rIntLen)
-        return [r, false];
-    if (bothNeg && bothIntPos && lIntLen > rIntLen)
-        return [r, false];
-    if (bothPos && bothIntPos && lIntLen > rIntLen)
-        return [l, true];
-    if (bothPos && bothIntNeg && lIntLen > rIntLen)
-        return [l, true];
-    if (bothNeg)
-        _a = [r, l], left = _a[0], right = _a[1];
-    while (idx < (lenL > lenR ? lenL : lenR)) {
-        var numL = left.array[idx];
-        var numR = right.array[idx];
-        if (!numL && bothPos)
-            return [r, false];
-        if (!numR && bothPos)
-            return [l, true];
-        if (!numL && bothNeg)
-            return [l, true];
-        if (!numR && bothNeg)
-            return [r, false];
-        if (numL !== numR) {
-            return numL > numR ? [l, true] : [r, false];
-        }
-        idx += 1;
-    }
-    return [l, true];
-};
-export var maxRawFn = function (array) {
-    var max = array[0];
-    for (var i = 1; i < array.length; i++) {
-        compareRawFn(max, array[i])[1] || (max = array[i]);
-    }
-    return max;
-};
-export var minRawFn = function (array) {
-    var min = array[0];
-    for (var i = 1; i < array.length; i++) {
-        compareRawFn(min, array[i])[1] && (min = array[i]);
-    }
-    return min;
-};
+import { compareInner, maxInner, minInner } from "./utils.js";
 /** This function returns max number. */
 export var max = function (strs) {
     var array = strs.map(function (str) { return s2a(str); });
-    return a2s(maxRawFn(array));
+    return a2s(maxInner(array));
 };
 /** This function returns min number. */
 export var min = function (strs) {
     var array = strs.map(function (str) { return s2a(str); });
-    return a2s(minRawFn(array));
+    return a2s(minInner(array));
 };
 export var isGreater = function (l, r) {
-    return compareRawFn(s2a(l), s2a(r))[1];
+    return compareInner(s2a(l), s2a(r))[1];
 };

package/src/compare/types.d.ts

@@ -1,6 +1,6 @@
 import type { InputData } from "../types.d.ts";
-export type CompareRawFn = (left: InputData, right: InputData) => [InputData, boolean];
+export type CompareInner = (left: InputData, right: InputData) => [InputData, boolean];
 export type Min = (strs: string[]) => string;
 export type Max = (strs: string[]) => string;
-export type MinRawFn = (array: InputData[]) => InputData;
-export type MaxRawFn = (array: InputData[]) => InputData;
+export type MinInner = (array: InputData[]) => InputData;
+export type MaxInner = (array: InputData[]) => InputData;

package/src/compare/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CompareInner, MaxInner, MinInner } from "./types.d.ts";
+export declare const maxInner: MaxInner;
+export declare const minInner: MinInner;
+export declare const compareInner: CompareInner;

package/src/compare/utils.js

@@ -0,0 +1,74 @@
+export var maxInner = function (array) {
+    var max = array[0];
+    for (var i = 1; i < array.length; i++) {
+        compareInner(max, array[i])[1] || (max = array[i]);
+    }
+    return max;
+};
+export var minInner = function (array) {
+    var min = array[0];
+    for (var i = 1; i < array.length; i++) {
+        compareInner(min, array[i])[1] && (min = array[i]);
+    }
+    return min;
+};
+export var compareInner = function (l, r) {
+    var _a;
+    var idx = 0;
+    var _b = [l, r], left = _b[0], right = _b[1];
+    var lIsNeg = l.isNegative, lIntLen = l.intLength;
+    var rIsNeg = r.isNegative, rIntLen = r.intLength;
+    var lenL = l.array.length;
+    var lenR = r.array.length;
+    var bothNeg = lIsNeg && rIsNeg;
+    var bothPos = !lIsNeg && !rIsNeg;
+    var bothIntPos = lIntLen > 0 && rIntLen > 0;
+    var bothIntNeg = lIntLen <= 0 && rIntLen <= 0;
+    if (lIsNeg && !rIsNeg)
+        return [r, false];
+    if (!lIsNeg && rIsNeg)
+        return [l, true];
+    if (bothPos && lIntLen > 0 && rIntLen === 0)
+        return [l, true];
+    if (bothPos && lIntLen === 0 && rIntLen > 0)
+        return [r, false];
+    if (!bothPos && lIntLen > 0 && rIntLen === 0)
+        return [r, false];
+    if (!bothPos && lIntLen === 0 && rIntLen > 0)
+        return [l, true];
+    if (bothPos && bothIntPos && lIntLen < rIntLen)
+        return [r, false];
+    if (bothPos && bothIntNeg && lIntLen < rIntLen)
+        return [r, false];
+    if (bothNeg && bothIntPos && lIntLen < rIntLen)
+        return [l, true];
+    if (bothNeg && bothIntNeg && lIntLen < rIntLen)
+        return [l, true];
+    if (bothNeg && bothIntNeg && lIntLen > rIntLen)
+        return [r, false];
+    if (bothNeg && bothIntPos && lIntLen > rIntLen)
+        return [r, false];
+    if (bothPos && bothIntPos && lIntLen > rIntLen)
+        return [l, true];
+    if (bothPos && bothIntNeg && lIntLen > rIntLen)
+        return [l, true];
+    if (bothNeg)
+        _a = [r, l], left = _a[0], right = _a[1];
+    while (idx < (lenL > lenR ? lenL : lenR)) {
+        var numL = left.array[idx];
+        var numR = right.array[idx];
+        if (!numL && bothPos)
+            return [r, false];
+        if (!numR && bothPos)
+            return [l, true];
+        if (!numL && bothNeg)
+            return [l, true];
+        if (!numR && bothNeg)
+            return [r, false];
+        if (numL !== numR) {
+            return numL > numR ? [l, true] : [r, false];
+        }
+        idx += 1;
+    }
+    return [l, true];
+};

package/src/mathOperations/add/types.d.ts

@@ -1,2 +1,2 @@
 import type { InputData } from "../../types.d.ts";
-export type Addition = (L: [number[], number], R: [number[], number], isNegative: boolean) => InputData;
+export type AddInner = (L: [number[], number], R: [number[], number], isNegative: boolean) => InputData;

package/src/mathOperations/add/utils.d.ts

@@ -1,5 +1,5 @@
 import type { Route } from "../../types.d.ts";
-import type { Addition } from "./types.d.ts";
+import type { AddInner } from "./types.d.ts";
 /** This function adds 2 numbers (as array). */
-export declare const addition: Addition;
+export declare const addInner: AddInner;
 export declare const addRoute: Route;

package/src/mathOperations/add/utils.js

@@ -1,6 +1,6 @@
-import { subtract } from "../sub/utils.js";
+import { subInner } from "../sub/utils.js";
 /** This function adds 2 numbers (as array). */
-export var addition = function (_a, _b, isNegative) {
+export var addInner = function (_a, _b, isNegative) {
     var _c, _d;
     var arrL = _a[0], intL = _a[1];
     var arrR = _b[0], intR = _b[1];
@@ -49,11 +49,11 @@ export var addRoute = function (input, initValue) {
         if (left.array.length === 0)
             return right;
         if (left.isNegative && !right.isNegative) {
-            return subtract([right.array, right.intLength], [left.array, left.intLength]);
+            return subInner([right.array, right.intLength], [left.array, left.intLength]);
         }
         if (!left.isNegative && right.isNegative) {
-            return subtract([left.array, left.intLength], [right.array, right.intLength]);
+            return subInner([left.array, left.intLength], [right.array, right.intLength]);
         }
-        return addition([left.array, left.intLength], [right.array, right.intLength], left.isNegative && right.isNegative);
+        return addInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative && right.isNegative);
     }, initValue);
 };

package/src/mathOperations/div/types.d.ts

@@ -1,3 +1,3 @@
 import type { InputData } from "../../types.d.ts";
-export type Division = (L: [number[], number], R: [number[], number], isNegative: boolean, initLimit: number) => InputData;
+export type DivInner = (L: [number[], number], R: [number[], number], isNegative: boolean, initLimit: number) => InputData;
 export type DivRoute = (input: InputData[], initValue: InputData, limit: number) => InputData;

package/src/mathOperations/div/utils.d.ts

@@ -1,3 +1,3 @@
-import type { Division, DivRoute } from "./types.d.ts";
-export declare const division: Division;
+import type { DivInner, DivRoute } from "./types.d.ts";
+export declare const divInner: DivInner;
 export declare const divRoute: DivRoute;

package/src/mathOperations/div/utils.js

@@ -1,4 +1,4 @@
-export var division = function (_a, _b, isNegative, initLimit) {
+export var divInner = function (_a, _b, isNegative, initLimit) {
     var arrL = _a[0], intL = _a[1];
     var arrR = _b[0], intR = _b[1];
     var decDiff = (arrL.length - intL) - (arrR.length - intR);
@@ -98,6 +98,6 @@ export var divRoute = function (input, initValue, limit) {
     return input.reduce(function (left, right) {
         if (left.array.length === 0)
             return right;
-        return division([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative, limit);
+        return divInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative, limit);
     }, initValue);
 };

package/src/mathOperations/mul/types.d.ts

@@ -1,2 +1,2 @@
 import type { InputData } from "../../types.d.ts";
-export type Multiplication = (arrL: [number[], number], arrR: [number[], number], isNegative: boolean) => InputData;
+export type MulInner = (arrL: [number[], number], arrR: [number[], number], isNegative: boolean) => InputData;

package/src/mathOperations/mul/utils.d.ts

@@ -1,5 +1,5 @@
 import type { Route } from "../../types.d.ts";
-import type { Multiplication } from "./types.d.ts";
+import type { MulInner } from "./types.d.ts";
 /** This function multiplies 2 numbers (as array). */
-export declare const multiplication: Multiplication;
+export declare const mulInner: MulInner;
 export declare const mulRoute: Route;

package/src/mathOperations/mul/utils.js

@@ -1,5 +1,5 @@
 /** This function multiplies 2 numbers (as array). */
-export var multiplication = function (_a, _b, isNegative) {
+export var mulInner = function (_a, _b, isNegative) {
     var _c, _d;
     var arrL = _a[0], intL = _a[1];
     var arrR = _b[0], intR = _b[1];
@@ -44,6 +44,6 @@ export var mulRoute = function (input, initValue) {
     return input.reduce(function (left, right) {
         if (left.array.length === 0)
             return right;
-        return multiplication([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative);
+        return mulInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative !== right.isNegative);
     }, initValue);
 };

package/src/mathOperations/sub/types.d.ts

@@ -1,2 +1,2 @@
 import type { InputData } from "../../types.d.ts";
-export type Subtract = (L: [number[], number], R: [number[], number]) => InputData;
+export type SubInner = (L: [number[], number], R: [number[], number]) => InputData;

package/src/mathOperations/sub/utils.d.ts

@@ -1,5 +1,5 @@
 import type { Route } from "../../types.d.ts";
-import type { Subtract } from "./types.d.ts";
+import type { SubInner } from "./types.d.ts";
 /** This function subtracts 2 numbers (as array). */
-export declare const subtract: Subtract;
+export declare const subInner: SubInner;
 export declare const subRoute: Route;

package/src/mathOperations/sub/utils.js

@@ -1,6 +1,6 @@
-import { addition } from "../add/utils.js";
+import { addInner } from "../add/utils.js";
 /** This function subtracts 2 numbers (as array). */
-export var subtract = function (_a, _b) {
+export var subInner = function (_a, _b) {
     var _c, _d;
     var _e, _f;
     var arrL = _a[0], intL = _a[1];
@@ -71,11 +71,11 @@ export var subRoute = function (input, initValue) {
         if (left.array.length === 0)
             return right;
         if (left.isNegative && right.isNegative) {
-            return subtract([right.array, right.intLength], [left.array, left.intLength]);
+            return subInner([right.array, right.intLength], [left.array, left.intLength]);
         }
         if (!left.isNegative && !right.isNegative) {
-            return subtract([left.array, left.intLength], [right.array, right.intLength]);
+            return subInner([left.array, left.intLength], [right.array, right.intLength]);
         }
-        return addition([left.array, left.intLength], [right.array, right.intLength], left.isNegative);
+        return addInner([left.array, left.intLength], [right.array, right.intLength], left.isNegative);
     }, initValue);
 };

package/src/pipe/main.d.ts

@@ -1,8 +1,8 @@
 import type { A2S } from "../shared/types.d.ts";
 import type { InputData } from "../types.d.ts";
-declare class Pipe {
+export declare class Pipe {
     result: InputData;
-    constructor();
+    constructor(array: InputData);
     add(strs: string[]): Pipe;
     sub(strs: string[]): Pipe;
     div(strs: string[], limit?: number): Pipe;
@@ -11,4 +11,3 @@ declare class Pipe {
 }
 /** Using this function you can chain operations (add, sub, div, mul). */
 export declare const pipe: Pipe;
-export {};

package/src/pipe/main.js

@@ -5,8 +5,8 @@ import { addRoute } from "../mathOperations/add/utils.js";
 import { divRoute } from "../mathOperations/div/utils.js";
 import { mulRoute } from "../mathOperations/mul/utils.js";
 var Pipe = /** @class */ (function () {
-    function Pipe() {
-        this.result = DEFAULT;
+    function Pipe(array) {
+        this.result = array;
     }
     Pipe.prototype.add = function (strs) {
         this.result = addRoute(strs.map(function (str) { return s2a(str); }), this.result);
@@ -32,5 +32,6 @@ var Pipe = /** @class */ (function () {
     };
     return Pipe;
 }());
+export { Pipe };
 /** Using this function you can chain operations (add, sub, div, mul). */
-export var pipe = new Pipe();
+export var pipe = new Pipe(DEFAULT);

package/src/quartile/main.js

@@ -1,20 +1,12 @@
-import { pipe } from "../pipe/main.js";
-var mean = function (idx, array) {
-    return pipe.add([array[idx], array[idx - 1]]).div(["2"]).calc();
-};
+import { a2s, s2a } from "../shared/utils.js";
+import { quartileInner } from "./utils.js";
 /** This function returns Q1, Q2, Q3 (quartile). */
-export var quartile = function (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;
+export var quartile = function (strs) {
+    var array = strs.map(function (str) { return s2a(str); });
+    var Qs = quartileInner(array);
     return {
-        Q1: isEvenHalf ? array[Q1Idx] : mean(Q1Idx, array),
-        Q2: length % 2 !== 0 ? array[Q2Idx] : mean(Q2Idx, array),
-        Q3: isEvenHalf ? array[Q3Idx - 1] : mean(Q3Idx, array),
+        Q1: a2s(Qs.Q1),
+        Q2: a2s(Qs.Q2),
+        Q3: a2s(Qs.Q3),
     };
 };

package/src/quartile/types.d.ts

@@ -1,6 +1,12 @@
+import type { InputData } from "../types.d.ts";
 export type Quartile = (array: string[]) => {
     Q1: string;
     Q2: string;
     Q3: string;
 };
-export type Mean = (index: number, array: string[]) => string;
+export type Mean = (index: number, array: InputData[]) => InputData;
+export type QuartileInner = (array: InputData[]) => {
+    Q1: InputData;
+    Q2: InputData;
+    Q3: InputData;
+};

package/src/quartile/utils.d.ts

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

package/src/quartile/utils.js

@@ -0,0 +1,27 @@
+import { addRoute } from "../mathOperations/add/utils.js";
+import { divRoute } from "../mathOperations/div/utils.js";
+import { DEFAULT } from "../shared/constant.js";
+var mean = function (idx, array) {
+    var sum = addRoute([structuredClone(array[idx]), array[idx - 1]], DEFAULT);
+    return divRoute([sum, {
+            array: [50],
+            intLength: 1,
+            isFloat: false,
+            isNegative: false,
+        }], DEFAULT, 20);
+};
+export var quartileInner = function (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;
+    return {
+        Q1: isEvenHalf ? array[Q1Idx] : mean(Q1Idx, array),
+        Q2: length % 2 !== 0 ? array[Q2Idx] : mean(Q2Idx, array),
+        Q3: isEvenHalf ? array[Q3Idx - 1] : mean(Q3Idx, array),
+    };
+};

package/src/shared/types.d.ts

@@ -1,3 +1,4 @@
 import type { InputData } from "../types.d.ts";
 export type A2S = (input: InputData) => string;
 export type S2A = (strings: string) => InputData;
+export type Convert = (isNegative: InputData["isNegative"], array: InputData["array"]) => string;

package/src/shared/utils.js

@@ -5,6 +5,9 @@ export var a2s = function (_a) {
     var array = _a.array, isFloat = _a.isFloat, isNegative = _a.isNegative, intLength = _a.intLength;
     var result = [];
     var lastValuableIdx = array.length;
+    var isNil = array.length === 1 && array[0] === 48;
+    if (isNil)
+        return convert(isNegative, array);
     if (isFloat) {
         var idx = array.length - 1;
         while (array[idx] === 48 && idx >= intLength) {
@@ -38,13 +41,13 @@ export var s2a = function (string) {
     var shift = isNegative ? 1 : 0;
     var dec = 0;
     var isNil = string.length === 1 && string.charCodeAt(0) === 48;
-    var isNegNil = string.length === 2 && string.charCodeAt(0) === 45 &&
+    var isNegNil = string.length === 2 && isNegative &&
         string.charCodeAt(1) === 48;
     if (isNil || isNegNil) {
         return {
             array: [48],
-            intLength: 1,
-            isNegative: false,
+            intLength: 0,
+            isNegative: isNegNil,
             isFloat: false,
         };
     }

package/src/sort/main.js

@@ -1,44 +1,10 @@
-import { compareRawFn } from "../compare/main.js";
 import { a2s, s2a } from "../shared/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;
-    if (sorting === ASC) {
-        if (idxL < len && compareRawFn(array[idxL], array[idx])[1])
-            idx = idxL;
-        if (idxR < len && compareRawFn(array[idxR], array[idx])[1])
-            idx = idxR;
-    }
-    else {
-        if (idxL < len && compareRawFn(array[idx], array[idxL])[1])
-            idx = idxL;
-        if (idxR < len && compareRawFn(array[idx], array[idxR])[1])
-            idx = idxR;
-    }
-    if (idx !== i) {
-        _a = [array[idx], array[i]], array[i] = _a[0], array[idx] = _a[1];
-        heapify(array, len, idx, sorting);
-    }
-};
-var sortRawFn = function (array, sorting) {
-    var _a;
-    var len = array.length;
-    for (var 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];
-        heapify(array, i, 0, sorting);
-    }
-    return array;
-};
+import { sortInner } from "./utils.js";
 /** Using this function sort an array. */
 export var sort = function (array, sorting) {
     if (sorting === void 0) { sorting = ASC; }
     var inputDataArray = array.map(function (str) { return s2a(str); });
-    sortRawFn(inputDataArray, sorting);
+    sortInner(inputDataArray, sorting);
     return inputDataArray.map(function (input) { return a2s(input); });
 };

package/src/sort/types.d.ts

@@ -2,5 +2,5 @@ import type { InputData } from "../types.d.ts";
 import type { sortingArray } from "./constants.d.ts";
 export type Sorting = typeof sortingArray[number];
 export type Sort = (array: string[], sorting?: Sorting) => string[];
-export type SortRawFn = (array: InputData[], sorting: Sorting) => InputData[];
+export type SortInner = (array: InputData[], sorting: Sorting) => InputData[];
 export type Heapify = (array: InputData[], len: number, i: number, sorting: Sorting) => void;

package/src/sort/utils.d.ts

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

package/src/sort/utils.js

@@ -0,0 +1,36 @@
+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;
+    if (sorting === ASC) {
+        if (idxL < len && compareInner(array[idxL], array[idx])[1])
+            idx = idxL;
+        if (idxR < len && compareInner(array[idxR], array[idx])[1])
+            idx = idxR;
+    }
+    else {
+        if (idxL < len && compareInner(array[idx], array[idxL])[1])
+            idx = idxL;
+        if (idxR < len && compareInner(array[idx], array[idxR])[1])
+            idx = idxR;
+    }
+    if (idx !== i) {
+        _a = [array[idx], array[i]], array[i] = _a[0], array[idx] = _a[1];
+        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--) {
+        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];
+        heapify(array, i, 0, sorting);
+    }
+    return array;
+};