bigintbigintAbsolute value. abs(a)==a if a>=0. abs(a)==-a if a<0
egcdReturnegcdReturnAn iterative implementation of the extended euclidean algorithm or extended greatest common divisor algorithm. Take positive integers a, b as input, and return a triple (g, x, y), such that ax + by = g = gcd(a, b).
bigintbigintGreatest-common divisor of two integers based on the iterative binary algorithm.
PromisePromiseThe test first tries if any of the first 250 small primes are a factor of the input number and then passes several iterations of Miller-Rabin Probabilistic Primality Test (FIPS 186-4 C.3.1)
bigintbigintThe least common multiple computed as abs(a*b)/gcd(a,b)
bigintbigintModular inverse.
bigintbigintModular exponentiation a**b mod n
PromisePromiseA probably-prime (Miller-Rabin), cryptographically-secure, random-number generator. The browser version uses web workers to parallelise prime look up. Therefore, it does not lock the UI main process, and it can be much faster (if several cores or cpu are available).
PromisePromiseReturns a cryptographically secure random integer between [min,max]
PromisePromiseSecure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
bigintbigintFinds the smallest positive element that is congruent to a in modulo n
bigint
+## abs(a) ⇒ bigint
Absolute value. abs(a)==a if a>=0. abs(a)==-a if a<0
-**Kind**: global constant
+**Kind**: global function
**Returns**: bigint - the absolute value of a
| Param | Type |
@@ -142,11 +140,11 @@ Absolute value. abs(a)==a if a>=0. abs(a)==-a if a<0
-## eGcd ⇒ [egcdReturn](#egcdReturn)
+## eGcd(a, b) ⇒ [egcdReturn](#egcdReturn)
An iterative implementation of the extended euclidean algorithm or extended greatest common divisor algorithm.
Take positive integers a, b as input, and return a triple (g, x, y), such that ax + by = g = gcd(a, b).
-**Kind**: global constant
+**Kind**: global function
| Param | Type |
| --- | --- |
@@ -155,10 +153,10 @@ Take positive integers a, b as input, and return a triple (g, x, y), such that a
-## gcd ⇒ bigint
+## gcd(a, b) ⇒ bigint
Greatest-common divisor of two integers based on the iterative binary algorithm.
-**Kind**: global constant
+**Kind**: global function
**Returns**: bigint - The greatest common divisor of a and b
| Param | Type |
@@ -168,10 +166,10 @@ Greatest-common divisor of two integers based on the iterative binary algorithm.
-## isProbablyPrime ⇒ Promise
+## isProbablyPrime(w, iterations) ⇒ Promise
The test first tries if any of the first 250 small primes are a factor of the input number and then passes several iterations of Miller-Rabin Probabilistic Primality Test (FIPS 186-4 C.3.1)
-**Kind**: global constant
+**Kind**: global function
**Returns**: Promise - A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite)
| Param | Type | Description |
@@ -181,10 +179,10 @@ The test first tries if any of the first 250 small primes are a factor of the in
-## lcm ⇒ bigint
+## lcm(a, b) ⇒ bigint
The least common multiple computed as abs(a*b)/gcd(a,b)
-**Kind**: global constant
+**Kind**: global function
**Returns**: bigint - The least common multiple of a and b
| Param | Type |
@@ -194,10 +192,10 @@ The least common multiple computed as abs(a*b)/gcd(a,b)
-## modInv ⇒ bigint
+## modInv(a, n) ⇒ bigint
Modular inverse.
-**Kind**: global constant
+**Kind**: global function
**Returns**: bigint - the inverse modulo n
| Param | Type | Description |
@@ -207,10 +205,10 @@ Modular inverse.
-## modPow ⇒ bigint
+## modPow(a, b, n) ⇒ bigint
Modular exponentiation a**b mod n
-**Kind**: global constant
+**Kind**: global function
**Returns**: bigint - a**b mod n
| Param | Type | Description |
@@ -221,12 +219,12 @@ Modular exponentiation a**b mod n
-## prime ⇒ Promise
+## prime(bitLength, iterations) ⇒ Promise
A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator.
The browser version uses web workers to parallelise prime look up. Therefore, it does not lock the UI
main process, and it can be much faster (if several cores or cpu are available).
-**Kind**: global constant
+**Kind**: global function
**Returns**: Promise - A promise that resolves to a bigint probable prime of bitLength bits
| Param | Type | Description |
@@ -236,10 +234,10 @@ main process, and it can be much faster (if several cores or cpu are available).
-## randBetween ⇒ Promise
+## randBetween(max, min) ⇒ Promise
Returns a cryptographically secure random integer between [min,max]
-**Kind**: global constant
+**Kind**: global function
**Returns**: Promise - A promise that resolves to a cryptographically secure random bigint between [min,max]
| Param | Type | Description |
@@ -249,10 +247,10 @@ Returns a cryptographically secure random integer between [min,max]
-## randBytes ⇒ Promise
+## randBytes(byteLength, forceLength) ⇒ Promise
Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
-**Kind**: global constant
+**Kind**: global function
**Returns**: Promise - A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes
| Param | Type | Description |
@@ -262,10 +260,10 @@ Secure random bytes for both node and browsers. Node version uses crypto.randomF
-## toZn ⇒ bigint
+## toZn(a, n) ⇒ bigint
Finds the smallest positive element that is congruent to a in modulo n
-**Kind**: global constant
+**Kind**: global function
**Returns**: bigint - The smallest positive representation of a in modulo n
| Param | Type | Description |
diff --git a/dist/bigint-crypto-utils-latest.browser.js b/dist/bigint-crypto-utils-latest.browser.js
index 6c3d154..0200bdf 100644
--- a/dist/bigint-crypto-utils-latest.browser.js
+++ b/dist/bigint-crypto-utils-latest.browser.js
@@ -8,10 +8,10 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {bigint} the absolute value of a
*/
- const abs = function (a) {
+ function abs(a) {
a = BigInt(a);
return (a >= BigInt(0)) ? a : -a;
- };
+ }
/**
* @typedef {Object} egcdReturn A triple (g, x, y), such that ax + by = g = gcd(a, b).
@@ -28,7 +28,7 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {egcdReturn}
*/
- const eGcd = function (a, b) {
+ function eGcd(a, b) {
a = BigInt(a);
b = BigInt(b);
let x = BigInt(0);
@@ -53,7 +53,7 @@ var bigintCryptoUtils = (function (exports) {
x: x,
y: y
};
- };
+ }
/**
* Greatest-common divisor of two integers based on the iterative binary algorithm.
@@ -63,7 +63,7 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {bigint} The greatest common divisor of a and b
*/
- const gcd = function (a, b) {
+ function gcd(a, b) {
a = abs(a);
b = abs(b);
let shift = BigInt(0);
@@ -85,7 +85,7 @@ var bigintCryptoUtils = (function (exports) {
// rescale
return a << shift;
- };
+ }
/**
* The test first tries if any of the first 250 small primes are a factor of the input number and then passes several iterations of Miller-Rabin Probabilistic Primality Test (FIPS 186-4 C.3.1)
@@ -95,7 +95,7 @@ var bigintCryptoUtils = (function (exports) {
*
* @return {Promise} A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite)
*/
- const isProbablyPrime = async function (w, iterations = 16) {
+ async function isProbablyPrime(w, iterations = 16) {
{
return new Promise(resolve => {
let worker = new Worker(_isProbablyPrimeWorkerURL());
@@ -111,7 +111,7 @@ var bigintCryptoUtils = (function (exports) {
});
});
}
- };
+ }
/**
* The least common multiple computed as abs(a*b)/gcd(a,b)
@@ -120,11 +120,11 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {bigint} The least common multiple of a and b
*/
- const lcm = function (a, b) {
+ function lcm(a, b) {
a = BigInt(a);
b = BigInt(b);
return abs(a * b) / gcd(a, b);
- };
+ }
/**
* Modular inverse.
@@ -134,14 +134,14 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {bigint} the inverse modulo n
*/
- const modInv = function (a, n) {
+ function modInv(a, n) {
let egcd = eGcd(a, n);
if (egcd.b !== BigInt(1)) {
return null; // modular inverse does not exist
} else {
return toZn(egcd.x, n);
}
- };
+ }
/**
* Modular exponentiation a**b mod n
@@ -151,7 +151,7 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {bigint} a**b mod n
*/
- const modPow = function (a, b, n) {
+ function modPow(a, b, n) {
// See Knuth, volume 2, section 4.6.3.
n = BigInt(n);
a = toZn(a, n);
@@ -172,7 +172,7 @@ var bigintCryptoUtils = (function (exports) {
x = x % n;
}
return result;
- };
+ }
/**
* A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator.
@@ -184,7 +184,7 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {Promise} A promise that resolves to a bigint probable prime of bitLength bits
*/
- const prime = async function (bitLength, iterations = 16) {
+ async function prime(bitLength, iterations = 16) {
return new Promise(async (resolve) => {
{
let workerList = [];
@@ -224,7 +224,7 @@ var bigintCryptoUtils = (function (exports) {
}
});
- };
+ }
/**
* Returns a cryptographically secure random integer between [min,max]
@@ -233,7 +233,7 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {Promise} A promise that resolves to a cryptographically secure random bigint between [min,max]
*/
- const randBetween = async function (max, min = 1) {
+ async function randBetween(max, min = 1) {
let bitLen = bitLength(max);
let byteLength = bitLen >> 3;
let remaining = bitLen - (byteLength * 8);
@@ -252,7 +252,7 @@ var bigintCryptoUtils = (function (exports) {
rnd = fromBuffer(buf);
} while (rnd > max || rnd < min);
return rnd;
- };
+ }
/**
* Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
@@ -262,7 +262,7 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {Promise} A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes
*/
- const randBytes = async function (byteLength, forceLength = false) {
+ async function randBytes(byteLength, forceLength = false) {
return new Promise((resolve) => {
let buf;
@@ -275,7 +275,7 @@ var bigintCryptoUtils = (function (exports) {
resolve(buf);
}
});
- };
+ }
/**
* Finds the smallest positive element that is congruent to a in modulo n
@@ -284,11 +284,11 @@ var bigintCryptoUtils = (function (exports) {
*
* @returns {bigint} The smallest positive representation of a in modulo n
*/
- const toZn = function (a, n) {
+ function toZn(a, n) {
n = BigInt(n);
a = BigInt(a) % n;
return (a < 0) ? a + n : a;
- };
+ }
diff --git a/dist/bigint-crypto-utils-latest.browser.min.js b/dist/bigint-crypto-utils-latest.browser.min.js
index 021e4a0..c497ece 100644
--- a/dist/bigint-crypto-utils-latest.browser.min.js
+++ b/dist/bigint-crypto-utils-latest.browser.min.js
@@ -1 +1 @@
-var bigintCryptoUtils=function(a){'use strict';function b(a){let b=BigInt(0);for(let c of a.values()){let a=BigInt(c);b=(b<