bigint-crypto-utils/dist/bundles/esm.js

895 lines
48 KiB
JavaScript
Raw Normal View History

2022-08-01 02:40:02 +00:00
/**
* Absolute value. abs(a)==a if a>=0. abs(a)==-a if a<0
*
* @param a
*
* @returns The absolute value of a
*/
function abs(a) {
return (a >= 0) ? a : -a;
}
/**
2022-10-03 17:57:08 +00:00
* Returns the (minimum) length of a number expressed in bits.
2022-08-01 02:40:02 +00:00
*
* @param a
* @returns The bit length
*/
function bitLength(a) {
if (typeof a === 'number')
a = BigInt(a);
if (a === 1n) {
return 1;
}
let bits = 1;
do {
bits++;
} while ((a >>= 1n) > 1n);
return bits;
}
/**
* 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).
*
* @param a
* @param b
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if a or b are <= 0
2022-08-01 02:40:02 +00:00
*
* @returns A triple (g, x, y), such that ax + by = g = gcd(a, b).
*/
function eGcd(a, b) {
if (typeof a === 'number')
a = BigInt(a);
if (typeof b === 'number')
b = BigInt(b);
if (a <= 0n || b <= 0n)
throw new RangeError('a and b MUST be > 0'); // a and b MUST be positive
let x = 0n;
let y = 1n;
let u = 1n;
let v = 0n;
while (a !== 0n) {
const q = b / a;
const r = b % a;
const m = x - (u * q);
const n = y - (v * q);
b = a;
a = r;
x = u;
y = v;
u = m;
v = n;
}
return {
g: b,
x: x,
y: y
};
}
/**
2022-09-12 09:14:59 +00:00
* Greatest common divisor of two integers based on the iterative binary algorithm.
2022-08-01 02:40:02 +00:00
*
* @param a
* @param b
*
* @returns The greatest common divisor of a and b
*/
function gcd(a, b) {
let aAbs = (typeof a === 'number') ? BigInt(abs(a)) : abs(a);
let bAbs = (typeof b === 'number') ? BigInt(abs(b)) : abs(b);
if (aAbs === 0n) {
return bAbs;
}
else if (bAbs === 0n) {
return aAbs;
}
let shift = 0n;
while (((aAbs | bAbs) & 1n) === 0n) {
aAbs >>= 1n;
bAbs >>= 1n;
shift++;
}
while ((aAbs & 1n) === 0n)
aAbs >>= 1n;
do {
while ((bAbs & 1n) === 0n)
bAbs >>= 1n;
if (aAbs > bAbs) {
const x = aAbs;
aAbs = bAbs;
bAbs = x;
}
bAbs -= aAbs;
} while (bAbs !== 0n);
// rescale
return aAbs << shift;
}
/**
* The least common multiple computed as abs(a*b)/gcd(a,b)
* @param a
* @param b
*
* @returns The least common multiple of a and b
*/
function lcm(a, b) {
if (typeof a === 'number')
a = BigInt(a);
if (typeof b === 'number')
b = BigInt(b);
if (a === 0n && b === 0n)
return BigInt(0);
// return abs(a * b) as bigint / gcd(a, b)
return abs((a / gcd(a, b)) * b);
}
/**
2022-09-12 09:14:59 +00:00
* Maximum. max(a,b)==a if a>=b. max(a,b)==b if a<b
2022-08-01 02:40:02 +00:00
*
* @param a
* @param b
*
* @returns Maximum of numbers a and b
*/
function max(a, b) {
return (a >= b) ? a : b;
}
/**
2022-09-12 09:14:59 +00:00
* Minimum. min(a,b)==b if a>=b. min(a,b)==a if a<b
2022-08-01 02:40:02 +00:00
*
* @param a
* @param b
*
* @returns Minimum of numbers a and b
*/
function min(a, b) {
return (a >= b) ? b : a;
}
/**
* Finds the smallest positive element that is congruent to a in modulo n
*
* @remarks
* a and b must be the same type, either number or bigint
*
* @param a - An integer
* @param n - The modulo
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if n <= 0
2022-08-01 02:40:02 +00:00
*
* @returns A bigint with the smallest positive representation of a modulo n
*/
function toZn(a, n) {
if (typeof a === 'number')
a = BigInt(a);
if (typeof n === 'number')
n = BigInt(n);
if (n <= 0n) {
throw new RangeError('n must be > 0');
}
const aZn = a % n;
return (aZn < 0n) ? aZn + n : aZn;
}
/**
* Modular inverse.
*
* @param a The number to find an inverse for
* @param n The modulo
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if a does not have inverse modulo n
2022-08-01 02:40:02 +00:00
*
* @returns The inverse modulo n
*/
function modInv(a, n) {
const egcd = eGcd(toZn(a, n), n);
if (egcd.g !== 1n) {
throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`); // modular inverse does not exist
}
else {
return toZn(egcd.x, n);
}
}
/**
* Modular exponentiation b**e mod n. Currently using the right-to-left binary method
*
* @param b base
* @param e exponent
* @param n modulo
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if n <= 0
2022-08-01 02:40:02 +00:00
*
* @returns b**e mod n
*/
function modPow(b, e, n) {
if (typeof b === 'number')
b = BigInt(b);
if (typeof e === 'number')
e = BigInt(e);
if (typeof n === 'number')
n = BigInt(n);
if (n <= 0n) {
throw new RangeError('n must be > 0');
}
else if (n === 1n) {
return 0n;
}
b = toZn(b, n);
if (e < 0n) {
return modInv(modPow(b, abs(e), n), n);
}
let r = 1n;
while (e > 0) {
if ((e % 2n) === 1n) {
r = r * b % n;
}
e = e / 2n;
b = b ** 2n % n;
}
return r;
}
function fromBuffer(buf) {
let ret = 0n;
for (const i of buf.values()) {
const bi = BigInt(i);
ret = (ret << 8n) + bi;
}
return ret;
}
/**
* Secure random bytes for both node and browsers. Node version uses crypto.randomBytes() and browser one self.crypto.getRandomValues()
*
* @param byteLength - The desired number of random bytes
2022-09-12 09:14:59 +00:00
* @param forceLength - Set to true if you want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1
2022-08-01 02:40:02 +00:00
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if byteLength < 1
2022-08-01 02:40:02 +00:00
*
* @returns A promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes
*/
function randBytes(byteLength, forceLength = false) {
if (byteLength < 1)
throw new RangeError('byteLength MUST be > 0');
return new Promise(function (resolve, reject) {
{ // browser
const buf = new Uint8Array(byteLength);
// the maximum number of bytes of entropy available via self.crypto.getRandomValues is 65536
if (byteLength <= 65536) {
self.crypto.getRandomValues(buf);
}
else {
for (let i = 0; i < Math.ceil(byteLength / 65536); i++) {
const begin = i * 65536;
const end = ((begin + 65535) < byteLength) ? begin + 65535 : byteLength - 1;
self.crypto.getRandomValues(buf.subarray(begin, end));
}
}
2022-08-01 02:40:02 +00:00
// If fixed length is required we put the first bit to 1 -> to get the necessary bitLength
if (forceLength)
buf[0] = buf[0] | 128;
resolve(buf);
}
});
}
/**
* Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
2022-09-12 09:14:59 +00:00
* This is the synchronous version, consider using the asynchronous one for improved efficiency.
2022-08-01 02:40:02 +00:00
*
* @param byteLength - The desired number of random bytes
2022-09-12 09:14:59 +00:00
* @param forceLength - Set to true if you want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1
2022-08-01 02:40:02 +00:00
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if byteLength < 1
2022-08-01 02:40:02 +00:00
*
* @returns A UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes
*/
function randBytesSync(byteLength, forceLength = false) {
if (byteLength < 1)
throw new RangeError('byteLength MUST be > 0');
/* eslint-disable no-lone-blocks */
{ // browser
const buf = new Uint8Array(byteLength);
// the maximum number of bytes of entropy available via self.crypto.getRandomValues is 65536
if (byteLength <= 65536) {
self.crypto.getRandomValues(buf);
}
else {
for (let i = 0; i < Math.ceil(byteLength / 65536); i++) {
const begin = i * 65536;
const end = ((begin + 65535) < byteLength) ? begin + 65535 : byteLength - 1;
self.crypto.getRandomValues(buf.subarray(begin, end));
}
}
2022-08-01 02:40:02 +00:00
// If fixed length is required we put the first bit to 1 -> to get the necessary bitLength
if (forceLength)
buf[0] = buf[0] | 128;
return buf;
}
/* eslint-enable no-lone-blocks */
}
/**
* Secure random bits for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
*
* @param bitLength - The desired number of random bits
2022-09-12 09:14:59 +00:00
* @param forceLength - Set to true if you want to force the output to have a specific bit length. It basically forces the msb to be 1
2022-08-01 02:40:02 +00:00
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if bitLength < 1
2022-08-01 02:40:02 +00:00
*
* @returns A Promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits
*/
function randBits(bitLength, forceLength = false) {
if (bitLength < 1)
throw new RangeError('bitLength MUST be > 0');
const byteLength = Math.ceil(bitLength / 8);
const bitLengthMod8 = bitLength % 8;
return new Promise((resolve, reject) => {
randBytes(byteLength, false).then(function (rndBytes) {
if (bitLengthMod8 !== 0) {
// Fill with 0's the extra bits
rndBytes[0] = rndBytes[0] & (2 ** bitLengthMod8 - 1);
}
if (forceLength) {
const mask = (bitLengthMod8 !== 0) ? 2 ** (bitLengthMod8 - 1) : 128;
rndBytes[0] = rndBytes[0] | mask;
}
resolve(rndBytes);
});
});
}
/**
* Secure random bits for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
* @param bitLength - The desired number of random bits
2022-09-12 09:14:59 +00:00
* @param forceLength - Set to true if you want to force the output to have a specific bit length. It basically forces the msb to be 1
2022-08-01 02:40:02 +00:00
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if bitLength < 1
2022-08-01 02:40:02 +00:00
*
* @returns A Uint8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits
*/
function randBitsSync(bitLength, forceLength = false) {
if (bitLength < 1)
throw new RangeError('bitLength MUST be > 0');
const byteLength = Math.ceil(bitLength / 8);
const rndBytes = randBytesSync(byteLength, false);
const bitLengthMod8 = bitLength % 8;
if (bitLengthMod8 !== 0) {
// Fill with 0's the extra bits
rndBytes[0] = rndBytes[0] & (2 ** bitLengthMod8 - 1);
}
if (forceLength) {
const mask = (bitLengthMod8 !== 0) ? 2 ** (bitLengthMod8 - 1) : 128;
rndBytes[0] = rndBytes[0] | mask;
}
return rndBytes;
}
/**
* Returns a cryptographically secure random integer between [min,max].
* @param max Returned value will be <= max
* @param min Returned value will be >= min
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if max <= min
2022-08-01 02:40:02 +00:00
*
* @returns A cryptographically secure random bigint between [min,max]
*/
function randBetween(max, min = 1n) {
if (max <= min)
throw new RangeError('Arguments MUST be: max > min');
const interval = max - min;
const bitLen = bitLength(interval);
let rnd;
do {
const buf = randBitsSync(bitLen);
rnd = fromBuffer(buf);
} while (rnd > interval);
return rnd + min;
}
function _workerUrl(workerCode) {
workerCode = `(() => {${workerCode}})()`; // encapsulate IIFE
const _blob = new Blob([workerCode], { type: 'text/javascript' });
return window.URL.createObjectURL(_blob);
}
let _useWorkers = false; // The following is just to check whether we can use workers
/* eslint-disable no-lone-blocks */
{ // Native JS
if (self.Worker !== undefined)
_useWorkers = true;
}
/**
* 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)
*
* @param w - A positive integer to be tested for primality
2022-09-12 09:14:59 +00:00
* @param iterations - The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 of FIPS 186-4
2022-08-01 02:40:02 +00:00
* @param disableWorkers - Disable the use of workers for the primality test
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if w<0
2022-08-01 02:40:02 +00:00
*
* @returns A promise that resolves to a boolean that is either true (a probably prime number) or false (definitely composite)
*/
function isProbablyPrime(w, iterations = 16, disableWorkers = false) {
if (typeof w === 'number') {
w = BigInt(w);
}
if (w < 0n)
throw RangeError('w MUST be >= 0');
{ // browser
return new Promise((resolve, reject) => {
const worker = new Worker(_isProbablyPrimeWorkerUrl());
worker.onmessage = (event) => {
2022-09-08 11:56:49 +00:00
if (event?.data?._bcu?.isPrime !== undefined) {
worker.terminate();
resolve(event.data._bcu.isPrime);
}
2022-08-01 02:40:02 +00:00
};
worker.onmessageerror = (event) => {
reject(event);
};
const msg = {
2022-09-08 11:56:49 +00:00
_bcu: {
rnd: w,
iterations: iterations,
id: 0
}
2022-08-01 02:40:02 +00:00
};
worker.postMessage(msg);
});
}
}
function _isProbablyPrime(w, iterations) {
/*
PREFILTERING. Even values but 2 are not primes, so don't test.
1 is not a prime and the M-R algorithm needs w>1.
*/
if (w === 2n)
return true;
else if ((w & 1n) === 0n || w === 1n)
return false;
/*
Test if any of the first 250 small primes are a factor of w. 2 is not tested because it was already tested above.
*/
const firstPrimes = [
3n,
5n,
7n,
11n,
13n,
17n,
19n,
23n,
29n,
31n,
37n,
41n,
43n,
47n,
53n,
59n,
61n,
67n,
71n,
73n,
79n,
83n,
89n,
97n,
101n,
103n,
107n,
109n,
113n,
127n,
131n,
137n,
139n,
149n,
151n,
157n,
163n,
167n,
173n,
179n,
181n,
191n,
193n,
197n,
199n,
211n,
223n,
227n,
229n,
233n,
239n,
241n,
251n,
257n,
263n,
269n,
271n,
277n,
281n,
283n,
293n,
307n,
311n,
313n,
317n,
331n,
337n,
347n,
349n,
353n,
359n,
367n,
373n,
379n,
383n,
389n,
397n,
401n,
409n,
419n,
421n,
431n,
433n,
439n,
443n,
449n,
457n,
461n,
463n,
467n,
479n,
487n,
491n,
499n,
503n,
509n,
521n,
523n,
541n,
547n,
557n,
563n,
569n,
571n,
577n,
587n,
593n,
599n,
601n,
607n,
613n,
617n,
619n,
631n,
641n,
643n,
647n,
653n,
659n,
661n,
673n,
677n,
683n,
691n,
701n,
709n,
719n,
727n,
733n,
739n,
743n,
751n,
757n,
761n,
769n,
773n,
787n,
797n,
809n,
811n,
821n,
823n,
827n,
829n,
839n,
853n,
857n,
859n,
863n,
877n,
881n,
883n,
887n,
907n,
911n,
919n,
929n,
937n,
941n,
947n,
953n,
967n,
971n,
977n,
983n,
991n,
997n,
1009n,
1013n,
1019n,
1021n,
1031n,
1033n,
1039n,
1049n,
1051n,
1061n,
1063n,
1069n,
1087n,
1091n,
1093n,
1097n,
1103n,
1109n,
1117n,
1123n,
1129n,
1151n,
1153n,
1163n,
1171n,
1181n,
1187n,
1193n,
1201n,
1213n,
1217n,
1223n,
1229n,
1231n,
1237n,
1249n,
1259n,
1277n,
1279n,
1283n,
1289n,
1291n,
1297n,
1301n,
1303n,
1307n,
1319n,
1321n,
1327n,
1361n,
1367n,
1373n,
1381n,
1399n,
1409n,
1423n,
1427n,
1429n,
1433n,
1439n,
1447n,
1451n,
1453n,
1459n,
1471n,
1481n,
1483n,
1487n,
1489n,
1493n,
1499n,
1511n,
1523n,
1531n,
1543n,
1549n,
1553n,
1559n,
1567n,
1571n,
1579n,
1583n,
1597n
];
for (let i = 0; i < firstPrimes.length && (firstPrimes[i] <= w); i++) {
const p = firstPrimes[i];
if (w === p)
return true;
else if (w % p === 0n)
return false;
}
/*
1. Let a be the largest integer such that 2**a divides w1.
2. m = (w1) / 2**a.
3. wlen = len (w).
4. For i = 1 to iterations do
4.1 Obtain a string b of wlen bits from an RBG.
Comment: Ensure that 1 < b < w1.
4.2 If ((b 1) or (b w1)), then go to step 4.1.
4.3 z = b**m mod w.
4.4 If ((z = 1) or (z = w 1)), then go to step 4.7.
4.5 For j = 1 to a 1 do.
4.5.1 z = z**2 mod w.
4.5.2 If (z = w1), then go to step 4.7.
4.5.3 If (z = 1), then go to step 4.6.
4.6 Return COMPOSITE.
4.7 Continue.
Comment: Increment i for the do-loop in step 4.
5. Return PROBABLY PRIME.
*/
let a = 0n;
const d = w - 1n;
let aux = d;
while (aux % 2n === 0n) {
aux /= 2n;
++a;
}
const m = d / (2n ** a);
do {
const b = randBetween(d, 2n);
let z = modPow(b, m, w);
if (z === 1n || z === d)
continue;
let j = 1;
while (j < a) {
z = modPow(z, 2n, w);
if (z === d)
break;
if (z === 1n)
return false;
j++;
}
if (z !== d)
return false;
} while (--iterations !== 0);
return true;
}
function _isProbablyPrimeWorkerUrl() {
// Let's us first add all the required functions
2022-09-08 11:56:49 +00:00
let workerCode = `
'use strict';
const ${eGcd.name} = ${eGcd.toString()};
const ${modInv.name} = ${modInv.toString()};
const ${modPow.name} = ${modPow.toString()};
const ${toZn.name} = ${toZn.toString()};
const ${randBitsSync.name} = ${randBitsSync.toString()};
const ${randBytesSync.name} = ${randBytesSync.toString()};
const ${randBetween.name} = ${randBetween.toString()};
const ${isProbablyPrime.name} = ${_isProbablyPrime.toString()};
${bitLength.toString()};
${fromBuffer.toString()};`;
workerCode += `
onmessage = async function(msg) {
if (msg !== undefined && msg.data !== undefined && msg.data._bcu !== undefined && msg.data._bcu.id !== undefined && msg.data._bcu.iterations !== undefined && msg.data._bcu.rnd !== undefined) {
const msgToParent = {
_bcu: {
isPrime: await ${isProbablyPrime.name}(msg.data._bcu.rnd, msg.data._bcu.iterations),
value: msg.data._bcu.rnd,
id: msg.data._bcu.id
}
};
postMessage(msgToParent);
}
}`;
2022-08-01 02:40:02 +00:00
return _workerUrl(workerCode);
}
/**
* 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).
* The node version can also use worker_threads if they are available (enabled by default with Node 11 and
* and can be enabled at runtime executing node --experimental-worker with node >=10.5.0).
*
* @param bitLength - The required bit length for the generated prime
* @param iterations - The number of iterations for the Miller-Rabin Probabilistic Primality Test
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if bitLength < 1
2022-08-01 02:40:02 +00:00
*
* @returns A promise that resolves to a bigint probable prime of bitLength bits.
*/
function prime(bitLength, iterations = 16) {
if (bitLength < 1)
throw new RangeError('bitLength MUST be > 0');
2022-08-01 17:10:00 +00:00
/* c8 ignore start */
2022-08-01 02:40:02 +00:00
if (!_useWorkers) { // If there is no support for workers
let rnd = 0n;
do {
rnd = fromBuffer(randBitsSync(bitLength, true));
} while (!_isProbablyPrime(rnd, iterations));
return new Promise((resolve) => { resolve(rnd); });
}
2022-08-01 17:10:00 +00:00
/* c8 ignore stop */
2022-08-01 02:40:02 +00:00
return new Promise((resolve, reject) => {
const workerList = [];
const _onmessage = (msg, newWorker) => {
2022-09-08 11:56:49 +00:00
if (msg._bcu.isPrime) {
2022-08-01 02:40:02 +00:00
// if a prime number has been found, stop all the workers, and return it
for (let j = 0; j < workerList.length; j++) {
workerList[j].terminate(); // eslint-disable-line @typescript-eslint/no-floating-promises
}
while (workerList.length > 0) {
workerList.pop();
}
2022-09-08 11:56:49 +00:00
resolve(msg._bcu.value);
2022-08-01 02:40:02 +00:00
}
else { // if a composite is found, make the worker test another random number
const buf = randBitsSync(bitLength, true);
const rnd = fromBuffer(buf);
try {
const msgToWorker = {
2022-09-08 11:56:49 +00:00
_bcu: {
rnd: rnd,
iterations: iterations,
id: msg._bcu.id
}
2022-08-01 02:40:02 +00:00
};
newWorker.postMessage(msgToWorker);
}
catch (error) {
// The worker has already terminated. There is nothing to handle here
}
}
};
{ // browser
const workerURL = _isProbablyPrimeWorkerUrl();
for (let i = 0; i < self.navigator.hardwareConcurrency - 1; i++) {
const newWorker = new Worker(workerURL);
newWorker.onmessage = (event) => _onmessage(event.data, newWorker);
workerList.push(newWorker);
}
}
for (let i = 0; i < workerList.length; i++) {
randBits(bitLength, true).then(function (buf) {
const rnd = fromBuffer(buf);
workerList[i].postMessage({
2022-09-08 11:56:49 +00:00
_bcu: {
rnd: rnd,
iterations: iterations,
id: i
}
2022-08-01 02:40:02 +00:00
});
}).catch(reject);
}
});
}
/**
* A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator.
* The sync version is NOT RECOMMENDED since it won't use workers and thus it'll be slower and may freeze thw window in browser's javascript. Please consider using prime() instead.
*
* @param bitLength - The required bit length for the generated prime
* @param iterations - The number of iterations for the Miller-Rabin Probabilistic Primality Test
*
2022-09-12 09:14:59 +00:00
* @throws {@link RangeError} if bitLength < 1
2022-08-01 02:40:02 +00:00
*
* @returns A bigint probable prime of bitLength bits.
*/
function primeSync(bitLength, iterations = 16) {
if (bitLength < 1)
throw new RangeError('bitLength MUST be > 0');
let rnd = 0n;
do {
rnd = fromBuffer(randBitsSync(bitLength, true));
} while (!_isProbablyPrime(rnd, iterations));
return rnd;
}
export { abs, bitLength, eGcd, gcd, isProbablyPrime, lcm, max, min, modInv, modPow, prime, primeSync, randBetween, randBits, randBitsSync, randBytes, randBytesSync, toZn };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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