@numio/bigmath 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Oleksandr Brudnovskyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# @numio/bigmath
+
+@numio/bigmath is an arbitrary-precision arithmetic library. This library provides functions for performing arithmetic operations (addition, subtraction, multiplication, and division) on numbers of arbitrary length. It addresses the limitations of JavaScript's built-in number type, which suffers from precision loss when dealing with very large or very small numbers, or numbers with more than 15 significant digits.
+
+
+## Key Features and Benefits
+
+* **Arbitrary Precision:** Handles numbers of any length, avoiding the limitations of JavaScript's `Number` type. This allows for calculations with extremely large or small numbers without loss of precision.
+* **No Precision Loss:** Eliminates precision errors that occur when using numeric literals with more than 15 significant digits. The library ensures accurate calculations even with very long numbers.
+* **Four Basic Operations:** Provides functions for addition (`add`), subtraction (`sub`), multiplication (`mul`), and division (`div`).
+* **Decimal Handling:** Correctly handles decimal numbers and performs calculations accurately, including scenarios involving negative numbers.
+* **Division Precision Control:** The `div` function allows you to specify the number of digits after the decimal point for the result. The default precision is 20 digits.
+* **Easy to Use:** The library provides simple and intuitive functions for performing arithmetic operations.
+
+
+## How it Solves the Problem
+
+JavaScript's `Number` type uses a 64-bit floating-point representation (IEEE 754), which can lead to precision issues when dealing with numbers that exceed its representable range or require more than 15 significant digits. This library likely uses a different representation internally (e.g., strings or arrays of digits) to store and manipulate numbers, effectively bypassing the limitations of the built-in `Number` type. This allows it to perform calculations on numbers of virtually unlimited size and maintain accuracy.
+
+## Use Cases
+
+This library is particularly useful in scenarios where precise calculations with large numbers are essential, such as:
+
+* **Financial applications:** Dealing with large sums of money or precise interest calculations.
+* **Scientific computing:** Working with very large or small numbers in scientific simulations.
+* **Cryptography:** Implementing cryptographic algorithms that require high precision.
+* **Any application** where exceeding JavaScript's number limits is a concern.
+
+
+### Latest update
+
+In version 1.0.1 arguments for calculation changed to array, which increases performance dramatically \
+In version 0.3.0 added handling of negative numbers \
+In version 0.2.0 added division (int & float numbers)
+
+# Install:
+
+### NPM
+
+```bash
+npm install @numio/bigmath
+```
+
+### YARN
+
+```bash
+yarn add @numio/bigmath
+```
+
+### BUN
+
+```bash
+bun add @numio/bigmath
+```
+
+### PNPM
+
+```bash
+pnpm add @numio/bigmath
+```
+
+### DENO
+
+```bash
+deno add jsr:@numio/bigmath
+```
+
+# Examples:
+
+### Add numbers
+
+```javascript
+import { add } from "@numio/bigmath";
+
+const int = add(["12345", "99"]); // 124444
+const float = add(["0.1", "0.2", "0.3"]); // 0.6
+const negative = add(["0.1", "-0.3", "0.1"]); // -0.1
+```
+
+### Subtract numbers
+```javascript
+import { sub } from "@numio/bigmath";
+
+const int = sub(["150", "99"]); // 51
+const float = sub(["1", "0.99"]); // 0.01
+const negative = sub(["-0.1", "-0.3", "0.4"]); // -0.2
+```
+
+### Multiply numbers
+```javascript
+import { mul } from "@numio/bigmath";
+
+const int = mul(["15", "11", "2"]); // 330
+const float = mul(["0.01", "0.99"]); // 0.0099
+const negative = mul(["-2", "3"]); // -6
+```
+
+### Divide numbers
+```javascript
+import { div } from "@numio/bigmath";
+
+const int = div(["9999", "33"]); // 
+const float = div(["0.06", "0.2"]); // 0.3
+const negative = div(["-2", "-3", "2"]); // 3
+
+// set number of digit after the decimal. By default it's 20
+div("10", "3"); // 3.33333
+```
+
+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(
+  "999999999999999999999999999999999999999999999999999999999999999",
+  "2",
+); // "1000000000000000000000000000000000000000000000000000000000000001"
+
+const float = mul(
+  "0.00000000000000000000000000000000000000000000000000000000000000000009",
+  "0.000000002",
+); // 0.00000000000000000000000000000000000000000000000000000000000000000000000000018
+```
+
+Download from NPM - https://www.npmjs.com/package/@numio/bigmath \
+Download from JSR - https://jsr.io/@numio/bigmath \
+Home page - https://github.com/shpunter/numio-bigmath/blob/main/README.md \
+License - https://github.com/shpunter/numio-bigmath/blob/main/LICENSE

package/build.ts

@@ -0,0 +1,45 @@
+const rootPath = "./npm";
+const decoder = new TextDecoder("utf-8");
+const encoder = new TextEncoder();
+
+async function walk(path: string, cb: ({ path, fileInfo }: CB) => void) {
+  const fileInfo = await Deno.lstat(path);
+
+  cb({ fileInfo, path });
+
+  if (fileInfo.isDirectory) {
+    const entries = await Deno.readDir(path);
+
+    for await (const entry of entries) {
+      await walk(`${path}/${entry.name}`, cb);
+    }
+  }
+}
+
+await walk(rootPath, ({ path, fileInfo }) => {
+  if (fileInfo.isFile && path.endsWith(".js")) {
+    const content = decoder.decode(Deno.readFileSync(path));
+    const fixed = content.replaceAll(".ts", ".js");
+
+    Deno.writeFileSync(path, encoder.encode(fixed));
+  }
+
+  if (fileInfo.isFile && path.endsWith(".d.ts")) {
+    const content = decoder.decode(Deno.readFileSync(path));
+    const fixed = content.replaceAll(".ts", ".d.ts");
+
+    Deno.writeFileSync(path, encoder.encode(fixed));
+  }
+
+  if (fileInfo.isFile && path.endsWith("types.js")) {
+    Deno.remove(path);
+  }
+});
+
+Deno.copyFileSync("LICENSE", "npm/LICENSE");
+Deno.copyFileSync("README.md", "npm/README.md");
+Deno.copyFileSync("package.json", "npm/package.json");
+Deno.copyFileSync("package-lock.json", "npm/package-lock.json");
+
+
+type CB = { path: string; fileInfo: Deno.FileInfo };

package/index.ts

@@ -0,0 +1,6 @@
+import { add } from "./src/add/index.ts";
+import { mul } from "./src/mul/index.ts";
+import { sub } from "./src/sub/index.ts";
+import { div } from "./src/div/index.ts";
+
+export { add, mul, sub, div };

package/npm/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Oleksandr Brudnovskyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/npm/README.md

@@ -0,0 +1,129 @@
+# @numio/bigmath
+
+@numio/bigmath is an arbitrary-precision arithmetic library. This library provides functions for performing arithmetic operations (addition, subtraction, multiplication, and division) on numbers of arbitrary length. It addresses the limitations of JavaScript's built-in number type, which suffers from precision loss when dealing with very large or very small numbers, or numbers with more than 15 significant digits.
+
+
+## Key Features and Benefits
+
+* **Arbitrary Precision:** Handles numbers of any length, avoiding the limitations of JavaScript's `Number` type. This allows for calculations with extremely large or small numbers without loss of precision.
+* **No Precision Loss:** Eliminates precision errors that occur when using numeric literals with more than 15 significant digits. The library ensures accurate calculations even with very long numbers.
+* **Four Basic Operations:** Provides functions for addition (`add`), subtraction (`sub`), multiplication (`mul`), and division (`div`).
+* **Decimal Handling:** Correctly handles decimal numbers and performs calculations accurately, including scenarios involving negative numbers.
+* **Division Precision Control:** The `div` function allows you to specify the number of digits after the decimal point for the result. The default precision is 20 digits.
+* **Easy to Use:** The library provides simple and intuitive functions for performing arithmetic operations.
+
+
+## How it Solves the Problem
+
+JavaScript's `Number` type uses a 64-bit floating-point representation (IEEE 754), which can lead to precision issues when dealing with numbers that exceed its representable range or require more than 15 significant digits. This library likely uses a different representation internally (e.g., strings or arrays of digits) to store and manipulate numbers, effectively bypassing the limitations of the built-in `Number` type. This allows it to perform calculations on numbers of virtually unlimited size and maintain accuracy.
+
+## Use Cases
+
+This library is particularly useful in scenarios where precise calculations with large numbers are essential, such as:
+
+* **Financial applications:** Dealing with large sums of money or precise interest calculations.
+* **Scientific computing:** Working with very large or small numbers in scientific simulations.
+* **Cryptography:** Implementing cryptographic algorithms that require high precision.
+* **Any application** where exceeding JavaScript's number limits is a concern.
+
+
+### Latest update
+
+In version 1.0.1 arguments for calculation changed to array, which increases performance dramatically \
+In version 0.3.0 added handling of negative numbers \
+In version 0.2.0 added division (int & float numbers)
+
+# Install:
+
+### NPM
+
+```bash
+npm install @numio/bigmath
+```
+
+### YARN
+
+```bash
+yarn add @numio/bigmath
+```
+
+### BUN
+
+```bash
+bun add @numio/bigmath
+```
+
+### PNPM
+
+```bash
+pnpm add @numio/bigmath
+```
+
+### DENO
+
+```bash
+deno add jsr:@numio/bigmath
+```
+
+# Examples:
+
+### Add numbers
+
+```javascript
+import { add } from "@numio/bigmath";
+
+const int = add(["12345", "99"]); // 124444
+const float = add(["0.1", "0.2", "0.3"]); // 0.6
+const negative = add(["0.1", "-0.3", "0.1"]); // -0.1
+```
+
+### Subtract numbers
+```javascript
+import { sub } from "@numio/bigmath";
+
+const int = sub(["150", "99"]); // 51
+const float = sub(["1", "0.99"]); // 0.01
+const negative = sub(["-0.1", "-0.3", "0.4"]); // -0.2
+```
+
+### Multiply numbers
+```javascript
+import { mul } from "@numio/bigmath";
+
+const int = mul(["15", "11", "2"]); // 330
+const float = mul(["0.01", "0.99"]); // 0.0099
+const negative = mul(["-2", "3"]); // -6
+```
+
+### Divide numbers
+```javascript
+import { div } from "@numio/bigmath";
+
+const int = div(["9999", "33"]); // 
+const float = div(["0.06", "0.2"]); // 0.3
+const negative = div(["-2", "-3", "2"]); // 3
+
+// set number of digit after the decimal. By default it's 20
+div("10", "3"); // 3.33333
+```
+
+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(
+  "999999999999999999999999999999999999999999999999999999999999999",
+  "2",
+); // "1000000000000000000000000000000000000000000000000000000000000001"
+
+const float = mul(
+  "0.00000000000000000000000000000000000000000000000000000000000000000009",
+  "0.000000002",
+); // 0.00000000000000000000000000000000000000000000000000000000000000000000000000018
+```
+
+Download from NPM - https://www.npmjs.com/package/@numio/bigmath \
+Download from JSR - https://jsr.io/@numio/bigmath \
+Home page - https://github.com/shpunter/numio-bigmath/blob/main/README.md \
+License - https://github.com/shpunter/numio-bigmath/blob/main/LICENSE

package/npm/index.d.ts

@@ -0,0 +1,5 @@
+import { add } from "./src/add/index.d.ts";
+import { mul } from "./src/mul/index.d.ts";
+import { sub } from "./src/sub/index.d.ts";
+import { div } from "./src/div/index.d.ts";
+export { add, mul, sub, div };

package/npm/index.js

@@ -0,0 +1,5 @@
+import { add } from "./src/add/index.js";
+import { mul } from "./src/mul/index.js";
+import { sub } from "./src/sub/index.js";
+import { div } from "./src/div/index.js";
+export { add, mul, sub, div };

package/npm/package-lock.json

@@ -0,0 +1,16 @@
+{
+  "name": "@numio/bigmath",
+  "version": "1.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@numio/bigmath",
+      "version": "1.0.1",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    }
+  }
+}

package/npm/package.json

@@ -0,0 +1,57 @@
+{
+  "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.1",
+  "keywords": [
+    "precision",
+    "arithmetic",
+    "big",
+    "number",
+    "decimal",
+    "float",
+    "biginteger",
+    "bigdecimal",
+    "bignumber",
+    "bigint",
+    "bignum",
+    "infinite",
+    "longnumbers",
+    "infinitenumbers",
+    "integer",
+    "float",
+    "math",
+    "add",
+    "multiply",
+    "subtract",
+    "plus",
+    "minus",
+    "divide",
+    "long division",
+    "bigmath",
+    "numio"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shpunter/numio-bigmath.git"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": {
+    "name": "Oleksandr Brudnovskyi ",
+    "email": "oleksandr.brudnovskyi@gmail.com"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "node test"
+  },
+  "dependencies": {}
+}

package/npm/src/add/index.d.ts

@@ -0,0 +1,2 @@
+/** This function adds 2 numbers (as string). */
+export declare function add(strs: string[]): string;

package/npm/src/add/index.js

@@ -0,0 +1,19 @@
+import { a2sSA, s2aSA } from "../shared/utils.js";
+import { subtract } from "../sub/utils.js";
+import { addition } from "./utils.js";
+/** This function adds 2 numbers (as string). */
+export function add(strs) {
+    var arrays = strs.map(function (str) { return s2aSA(str); });
+    var inputData = arrays.reduce(function (left, right) {
+        if (left.array.length === 0)
+            return right;
+        if (left.isNegative && !right.isNegative) {
+            return subtract([right.array, right.intLength], [left.array, left.intLength]);
+        }
+        if (!left.isNegative && right.isNegative) {
+            return subtract([left.array, left.intLength], [right.array, right.intLength]);
+        }
+        return addition([left.array, left.intLength], [right.array, right.intLength], left.isNegative && right.isNegative);
+    }, { array: [], intLength: 0, isFloat: false, isNegative: false });
+    return a2sSA(inputData.array, inputData.isFloat, inputData.isNegative);
+}

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

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

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

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

package/npm/src/add/utils.js

@@ -0,0 +1,48 @@
+/** This function adds 2 numbers (as array). */
+export var addition = function (_a, _b, isNegative) {
+    var _c, _d;
+    var arrL = _a[0], intL = _a[1];
+    var arrR = _b[0], intR = _b[1];
+    var _e = intL >= intR
+        ? [arrL, arrR, intL, intR]
+        : [arrR, arrL, intR, intL], left = _e[0], right = _e[1], intLeft = _e[2], intRight = _e[3];
+    var fracLenL = left.length - intLeft;
+    var fracLenR = right.length - intRight;
+    var fracMaxLen = (fracLenL >= fracLenR ? fracLenL : fracLenR) - 1;
+    var pl = (intLeft >= intRight ? intLeft : intRight) + fracMaxLen;
+    var pr = (intLeft >= intRight ? intRight : intLeft) + fracMaxLen;
+    var carryOver = 48;
+    if (fracLenL === 0 && fracLenR > 0)
+        left.push(46);
+    while (pr >= 0) {
+        if (left[pl] === 46 || right[pr] === 46) {
+            pr -= 1;
+            pl -= 1;
+        }
+        var sum = (((_c = left[pl]) !== null && _c !== void 0 ? _c : 48) + ((_d = right[pr]) !== null && _d !== void 0 ? _d : 48) + carryOver) -
+            3 * 48;
+        if (sum > 9) {
+            left[pl] = (sum % 10) + 48;
+            carryOver = ((sum / 10) | 0) + 48;
+        }
+        else {
+            left[pl] = sum + 48;
+            carryOver = 48;
+        }
+        pr -= 1;
+        pl -= 1;
+    }
+    while (pl >= 0 && carryOver) {
+        var sum = (left[pl] + carryOver) - 2 * 48;
+        left[pl] = (sum % 10) + 48;
+        carryOver = ((sum / 10) | 0) + 48;
+        pl -= 1;
+    }
+    carryOver > 48 && left.unshift(carryOver);
+    return {
+        array: left,
+        intLength: left.length - 1 - fracMaxLen,
+        isNegative: isNegative,
+        isFloat: fracLenL + fracLenR > 0,
+    };
+};

package/npm/src/div/index.d.ts

@@ -0,0 +1,2 @@
+/** This function should divide 2 numbers (as string). */
+export declare const div: (strs: string[], limit?: number) => string;

package/npm/src/div/index.js

@@ -0,0 +1,15 @@
+import { a2sMD, s2aMD } from "../shared/utils.js";
+import { division } from "./utils.js";
+/** This function should divide 2 numbers (as string). */
+export var div = function (strs, limit) {
+    if (limit === void 0) { limit = 20; }
+    if (strs[0] === "0")
+        return strs[0];
+    var arrays = strs.map(function (str) { return s2aMD(str); });
+    var inputData = arrays.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);
+    }, { array: [], intLength: 0, isNegative: false, isFloat: false });
+    return a2sMD(inputData.array, inputData.intLength != inputData.array.length, inputData.isNegative, inputData.intLength);
+};

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

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

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

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

package/npm/src/div/utils.js

@@ -0,0 +1,90 @@
+export var division = 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);
+    var _c = [[arrR, 1], [arrL, -1]], L = _c[0], R = _c[1];
+    var _d = decDiff > 0 ? L : R, arr = _d[0], abs = _d[1];
+    for (var i = 0; i < decDiff * abs; i++) {
+        arr.push(48);
+    }
+    var digit = 48;
+    var limit = initLimit;
+    var isFloat = false;
+    var l = 0;
+    var r = arrR.length - 1;
+    var intLength = 0;
+    var result = [];
+    var lenArrayL = r - arrL.length;
+    for (var i = 0; i <= lenArrayL; i++) {
+        if (i === 0) {
+            isFloat = true;
+            intLength = 1;
+        }
+        result.push(48);
+        arrL.push(48);
+        limit -= 1;
+    }
+    while (r < arrL.length && limit >= 0) {
+        var comp = false;
+        if (arrL[l] === 48)
+            l += 1;
+        for (var i = 0; i < arrR.length; i++) {
+            if ((r - l + 1) < arrR.length)
+                comp = true;
+            if ((r - l + 1) !== arrR.length)
+                break;
+            if (arrL[l + i] !== arrR[i]) {
+                comp = arrL[l + i] < arrR[i];
+                break;
+            }
+        }
+        if (comp) {
+            if (r < arrL.length && (result.length > 0 || digit !== 48)) {
+                if (!isFloat)
+                    intLength += 1;
+                result.push(digit);
+            }
+            if (r >= arrL.length - 1) {
+                if (initLimit === limit)
+                    isFloat = true;
+                arrL.push(48);
+                limit -= 1;
+            }
+            r += 1;
+            digit = 48;
+            continue;
+        }
+        for (var i = arrR.length - 1; i >= 0; i--) {
+            var idx = r - (arrR.length - 1 - i);
+            if (arrL[idx] < arrR[i]) {
+                arrL[idx] = arrL[idx] - arrR[i] + 58;
+                arrL[idx - 1] -= 1;
+            }
+            else {
+                arrL[idx] = arrL[idx] - arrR[i] + 48;
+            }
+        }
+        digit += 1;
+    }
+    var multipliedResult = [];
+    var count = 0;
+    if (result[0] === 48) {
+        var isGrZero = false;
+        for (var i = 0; i < result.length; i++) {
+            if (!isGrZero)
+                result[i] > 48 ? isGrZero = true : count += 1;
+            isGrZero && multipliedResult.push(result[i]);
+        }
+        for (var i = 0; i < count; i++) {
+            multipliedResult.push(48);
+            intLength -= 1;
+        }
+    }
+    var isZero = result.length === count;
+    return {
+        array: result[0] === 48 ? multipliedResult : result,
+        isFloat: isZero ? false : isFloat,
+        isNegative: isZero ? false : isNegative,
+        intLength: isZero ? 1 : intLength,
+    };
+};

package/npm/src/mul/index.d.ts

@@ -0,0 +1,2 @@
+/** This function multiplies 2 numbers (as string). */
+export declare const mul: (strs: string[]) => string;

package/npm/src/mul/index.js

@@ -0,0 +1,12 @@
+import { a2sMD, s2aMD } from "../shared/utils.js";
+import { multiplication } from "./utils.js";
+/** This function multiplies 2 numbers (as string). */
+export var mul = function (strs) {
+    var arrays = strs.map(function (str) { return s2aMD(str); });
+    var inputData = arrays.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);
+    }, { array: [], intLength: 0, isNegative: false, isFloat: false });
+    return a2sMD(inputData.array, inputData.intLength != inputData.array.length, inputData.isNegative, inputData.intLength);
+};

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

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