@intlayer/backend 7.0.8 → 7.0.9-canary.2

package/dist/esm/node_modules/node-forge/lib/pki.mjs

@@ -0,0 +1,105 @@
+import { __commonJS } from "../../../_virtual/rolldown_runtime.mjs";
+import { require_forge } from "./forge.mjs";
+import { require_util } from "./util.mjs";
+import { require_oids } from "./oids.mjs";
+import { require_asn1 } from "./asn1.mjs";
+import { require_pem } from "./pem.mjs";
+import { require_pbkdf2 } from "./pbkdf2.mjs";
+import { require_rsa } from "./rsa.mjs";
+import { require_pbe } from "./pbe.mjs";
+import { require_pss } from "./pss.mjs";
+import { require_x509 } from "./x509.mjs";
+import { require_pkcs12 } from "./pkcs12.mjs";
+
+//#region ../../node_modules/node-forge/lib/pki.js
+var require_pki = /* @__PURE__ */ __commonJS({ "../../node_modules/node-forge/lib/pki.js": ((exports, module) => {
+	/**
+	* Javascript implementation of a basic Public Key Infrastructure, including
+	* support for RSA public and private keys.
+	*
+	* @author Dave Longley
+	*
+	* Copyright (c) 2010-2013 Digital Bazaar, Inc.
+	*/
+	var forge = require_forge();
+	require_asn1();
+	require_oids();
+	require_pbe();
+	require_pem();
+	require_pbkdf2();
+	require_pkcs12();
+	require_pss();
+	require_rsa();
+	require_util();
+	require_x509();
+	var asn1 = forge.asn1;
+	var pki = module.exports = forge.pki = forge.pki || {};
+	/**
+	* NOTE: THIS METHOD IS DEPRECATED. Use pem.decode() instead.
+	*
+	* Converts PEM-formatted data to DER.
+	*
+	* @param pem the PEM-formatted data.
+	*
+	* @return the DER-formatted data.
+	*/
+	pki.pemToDer = function(pem) {
+		var msg = forge.pem.decode(pem)[0];
+		if (msg.procType && msg.procType.type === "ENCRYPTED") throw new Error("Could not convert PEM to DER; PEM is encrypted.");
+		return forge.util.createBuffer(msg.body);
+	};
+	/**
+	* Converts an RSA private key from PEM format.
+	*
+	* @param pem the PEM-formatted private key.
+	*
+	* @return the private key.
+	*/
+	pki.privateKeyFromPem = function(pem) {
+		var msg = forge.pem.decode(pem)[0];
+		if (msg.type !== "PRIVATE KEY" && msg.type !== "RSA PRIVATE KEY") {
+			var error = /* @__PURE__ */ new Error("Could not convert private key from PEM; PEM header type is not \"PRIVATE KEY\" or \"RSA PRIVATE KEY\".");
+			error.headerType = msg.type;
+			throw error;
+		}
+		if (msg.procType && msg.procType.type === "ENCRYPTED") throw new Error("Could not convert private key from PEM; PEM is encrypted.");
+		var obj = asn1.fromDer(msg.body);
+		return pki.privateKeyFromAsn1(obj);
+	};
+	/**
+	* Converts an RSA private key to PEM format.
+	*
+	* @param key the private key.
+	* @param maxline the maximum characters per line, defaults to 64.
+	*
+	* @return the PEM-formatted private key.
+	*/
+	pki.privateKeyToPem = function(key, maxline) {
+		var msg = {
+			type: "RSA PRIVATE KEY",
+			body: asn1.toDer(pki.privateKeyToAsn1(key)).getBytes()
+		};
+		return forge.pem.encode(msg, { maxline });
+	};
+	/**
+	* Converts a PrivateKeyInfo to PEM format.
+	*
+	* @param pki the PrivateKeyInfo.
+	* @param maxline the maximum characters per line, defaults to 64.
+	*
+	* @return the PEM-formatted private key.
+	*/
+	pki.privateKeyInfoToPem = function(pki$1, maxline) {
+		var msg = {
+			type: "PRIVATE KEY",
+			body: asn1.toDer(pki$1).getBytes()
+		};
+		return forge.pem.encode(msg, { maxline });
+	};
+}) });
+
+//#endregion
+export default require_pki();
+
+export { require_pki };
+//# sourceMappingURL=pki.mjs.map

package/dist/esm/node_modules/node-forge/lib/pki.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pki.mjs","names":["pki"],"sources":["../../../../../../../node_modules/node-forge/lib/pki.js"],"sourcesContent":["/**\n * Javascript implementation of a basic Public Key Infrastructure, including\n * support for RSA public and private keys.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2013 Digital Bazaar, Inc.\n */\nvar forge = require('./forge');\nrequire('./asn1');\nrequire('./oids');\nrequire('./pbe');\nrequire('./pem');\nrequire('./pbkdf2');\nrequire('./pkcs12');\nrequire('./pss');\nrequire('./rsa');\nrequire('./util');\nrequire('./x509');\n\n// shortcut for asn.1 API\nvar asn1 = forge.asn1;\n\n/* Public Key Infrastructure (PKI) implementation. */\nvar pki = module.exports = forge.pki = forge.pki || {};\n\n/**\n * NOTE: THIS METHOD IS DEPRECATED. Use pem.decode() instead.\n *\n * Converts PEM-formatted data to DER.\n *\n * @param pem the PEM-formatted data.\n *\n * @return the DER-formatted data.\n */\npki.pemToDer = function(pem) {\n  var msg = forge.pem.decode(pem)[0];\n  if(msg.procType && msg.procType.type === 'ENCRYPTED') {\n    throw new Error('Could not convert PEM to DER; PEM is encrypted.');\n  }\n  return forge.util.createBuffer(msg.body);\n};\n\n/**\n * Converts an RSA private key from PEM format.\n *\n * @param pem the PEM-formatted private key.\n *\n * @return the private key.\n */\npki.privateKeyFromPem = function(pem) {\n  var msg = forge.pem.decode(pem)[0];\n\n  if(msg.type !== 'PRIVATE KEY' && msg.type !== 'RSA PRIVATE KEY') {\n    var error = new Error('Could not convert private key from PEM; PEM ' +\n      'header type is not \"PRIVATE KEY\" or \"RSA PRIVATE KEY\".');\n    error.headerType = msg.type;\n    throw error;\n  }\n  if(msg.procType && msg.procType.type === 'ENCRYPTED') {\n    throw new Error('Could not convert private key from PEM; PEM is encrypted.');\n  }\n\n  // convert DER to ASN.1 object\n  var obj = asn1.fromDer(msg.body);\n\n  return pki.privateKeyFromAsn1(obj);\n};\n\n/**\n * Converts an RSA private key to PEM format.\n *\n * @param key the private key.\n * @param maxline the maximum characters per line, defaults to 64.\n *\n * @return the PEM-formatted private key.\n */\npki.privateKeyToPem = function(key, maxline) {\n  // convert to ASN.1, then DER, then PEM-encode\n  var msg = {\n    type: 'RSA PRIVATE KEY',\n    body: asn1.toDer(pki.privateKeyToAsn1(key)).getBytes()\n  };\n  return forge.pem.encode(msg, {maxline: maxline});\n};\n\n/**\n * Converts a PrivateKeyInfo to PEM format.\n *\n * @param pki the PrivateKeyInfo.\n * @param maxline the maximum characters per line, defaults to 64.\n *\n * @return the PEM-formatted private key.\n */\npki.privateKeyInfoToPem = function(pki, maxline) {\n  // convert to DER, then PEM-encode\n  var msg = {\n    type: 'PRIVATE KEY',\n    body: asn1.toDer(pki).getBytes()\n  };\n  return forge.pem.encode(msg, {maxline: maxline});\n};\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;CAQA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;CAGA,IAAI,OAAO,MAAM;CAGjB,IAAI,MAAM,OAAO,UAAU,MAAM,MAAM,MAAM,OAAO,EAAE;;;;;;;;;;AAWtD,KAAI,WAAW,SAAS,KAAK;EAC3B,IAAI,MAAM,MAAM,IAAI,OAAO,IAAI,CAAC;AAChC,MAAG,IAAI,YAAY,IAAI,SAAS,SAAS,YACvC,OAAM,IAAI,MAAM,kDAAkD;AAEpE,SAAO,MAAM,KAAK,aAAa,IAAI,KAAK;;;;;;;;;AAU1C,KAAI,oBAAoB,SAAS,KAAK;EACpC,IAAI,MAAM,MAAM,IAAI,OAAO,IAAI,CAAC;AAEhC,MAAG,IAAI,SAAS,iBAAiB,IAAI,SAAS,mBAAmB;GAC/D,IAAI,wBAAQ,IAAI,MAAM,yGACqC;AAC3D,SAAM,aAAa,IAAI;AACvB,SAAM;;AAER,MAAG,IAAI,YAAY,IAAI,SAAS,SAAS,YACvC,OAAM,IAAI,MAAM,4DAA4D;EAI9E,IAAI,MAAM,KAAK,QAAQ,IAAI,KAAK;AAEhC,SAAO,IAAI,mBAAmB,IAAI;;;;;;;;;;AAWpC,KAAI,kBAAkB,SAAS,KAAK,SAAS;EAE3C,IAAI,MAAM;GACR,MAAM;GACN,MAAM,KAAK,MAAM,IAAI,iBAAiB,IAAI,CAAC,CAAC,UAAU;GACvD;AACD,SAAO,MAAM,IAAI,OAAO,KAAK,EAAU,SAAQ,CAAC;;;;;;;;;;AAWlD,KAAI,sBAAsB,SAAS,OAAK,SAAS;EAE/C,IAAI,MAAM;GACR,MAAM;GACN,MAAM,KAAK,MAAMA,MAAI,CAAC,UAAU;GACjC;AACD,SAAO,MAAM,IAAI,OAAO,KAAK,EAAU,SAAQ,CAAC"}

package/dist/esm/node_modules/node-forge/lib/prime.mjs

@@ -0,0 +1,197 @@
+import { __commonJS } from "../../../_virtual/rolldown_runtime.mjs";
+import { require_forge } from "./forge.mjs";
+import { require_util } from "./util.mjs";
+import { require_random } from "./random.mjs";
+import { require_jsbn } from "./jsbn.mjs";
+
+//#region ../../node_modules/node-forge/lib/prime.js
+var require_prime = /* @__PURE__ */ __commonJS({ "../../node_modules/node-forge/lib/prime.js": ((exports, module) => {
+	/**
+	* Prime number generation API.
+	*
+	* @author Dave Longley
+	*
+	* Copyright (c) 2014 Digital Bazaar, Inc.
+	*/
+	var forge = require_forge();
+	require_util();
+	require_jsbn();
+	require_random();
+	(function() {
+		if (forge.prime) {
+			module.exports = forge.prime;
+			return;
+		}
+		var prime = module.exports = forge.prime = forge.prime || {};
+		var BigInteger = forge.jsbn.BigInteger;
+		var GCD_30_DELTA = [
+			6,
+			4,
+			2,
+			4,
+			2,
+			4,
+			6,
+			2
+		];
+		var THIRTY = new BigInteger(null);
+		THIRTY.fromInt(30);
+		var op_or = function(x, y) {
+			return x | y;
+		};
+		/**
+		* Generates a random probable prime with the given number of bits.
+		*
+		* Alternative algorithms can be specified by name as a string or as an
+		* object with custom options like so:
+		*
+		* {
+		*   name: 'PRIMEINC',
+		*   options: {
+		*     maxBlockTime: <the maximum amount of time to block the main
+		*       thread before allowing I/O other JS to run>,
+		*     millerRabinTests: <the number of miller-rabin tests to run>,
+		*     workerScript: <the worker script URL>,
+		*     workers: <the number of web workers (if supported) to use,
+		*       -1 to use estimated cores minus one>.
+		*     workLoad: the size of the work load, ie: number of possible prime
+		*       numbers for each web worker to check per work assignment,
+		*       (default: 100).
+		*   }
+		* }
+		*
+		* @param bits the number of bits for the prime number.
+		* @param options the options to use.
+		*          [algorithm] the algorithm to use (default: 'PRIMEINC').
+		*          [prng] a custom crypto-secure pseudo-random number generator to use,
+		*            that must define "getBytesSync".
+		*
+		* @return callback(err, num) called once the operation completes.
+		*/
+		prime.generateProbablePrime = function(bits, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = {};
+			}
+			options = options || {};
+			var algorithm = options.algorithm || "PRIMEINC";
+			if (typeof algorithm === "string") algorithm = { name: algorithm };
+			algorithm.options = algorithm.options || {};
+			var prng = options.prng || forge.random;
+			var rng = { nextBytes: function(x) {
+				var b = prng.getBytesSync(x.length);
+				for (var i = 0; i < x.length; ++i) x[i] = b.charCodeAt(i);
+			} };
+			if (algorithm.name === "PRIMEINC") return primeincFindPrime(bits, rng, algorithm.options, callback);
+			throw new Error("Invalid prime generation algorithm: " + algorithm.name);
+		};
+		function primeincFindPrime(bits, rng, options, callback) {
+			if ("workers" in options) return primeincFindPrimeWithWorkers(bits, rng, options, callback);
+			return primeincFindPrimeWithoutWorkers(bits, rng, options, callback);
+		}
+		function primeincFindPrimeWithoutWorkers(bits, rng, options, callback) {
+			var num = generateRandom(bits, rng);
+			var deltaIdx = 0;
+			var mrTests = getMillerRabinTests(num.bitLength());
+			if ("millerRabinTests" in options) mrTests = options.millerRabinTests;
+			var maxBlockTime = 10;
+			if ("maxBlockTime" in options) maxBlockTime = options.maxBlockTime;
+			_primeinc(num, bits, rng, deltaIdx, mrTests, maxBlockTime, callback);
+		}
+		function _primeinc(num, bits, rng, deltaIdx, mrTests, maxBlockTime, callback) {
+			var start = +/* @__PURE__ */ new Date();
+			do {
+				if (num.bitLength() > bits) num = generateRandom(bits, rng);
+				if (num.isProbablePrime(mrTests)) return callback(null, num);
+				num.dAddOffset(GCD_30_DELTA[deltaIdx++ % 8], 0);
+			} while (maxBlockTime < 0 || +/* @__PURE__ */ new Date() - start < maxBlockTime);
+			forge.util.setImmediate(function() {
+				_primeinc(num, bits, rng, deltaIdx, mrTests, maxBlockTime, callback);
+			});
+		}
+		function primeincFindPrimeWithWorkers(bits, rng, options, callback) {
+			if (typeof Worker === "undefined") return primeincFindPrimeWithoutWorkers(bits, rng, options, callback);
+			var num = generateRandom(bits, rng);
+			var numWorkers = options.workers;
+			var workLoad = options.workLoad || 100;
+			var range = workLoad * 30 / 8;
+			var workerScript = options.workerScript || "forge/prime.worker.js";
+			if (numWorkers === -1) return forge.util.estimateCores(function(err, cores) {
+				if (err) cores = 2;
+				numWorkers = cores - 1;
+				generate();
+			});
+			generate();
+			function generate() {
+				numWorkers = Math.max(1, numWorkers);
+				var workers = [];
+				for (var i = 0; i < numWorkers; ++i) workers[i] = new Worker(workerScript);
+				var running = numWorkers;
+				for (var i = 0; i < numWorkers; ++i) workers[i].addEventListener("message", workerMessage);
+				var found = false;
+				function workerMessage(e) {
+					if (found) return;
+					--running;
+					var data = e.data;
+					if (data.found) {
+						for (var i$1 = 0; i$1 < workers.length; ++i$1) workers[i$1].terminate();
+						found = true;
+						return callback(null, new BigInteger(data.prime, 16));
+					}
+					if (num.bitLength() > bits) num = generateRandom(bits, rng);
+					var hex = num.toString(16);
+					e.target.postMessage({
+						hex,
+						workLoad
+					});
+					num.dAddOffset(range, 0);
+				}
+			}
+		}
+		/**
+		* Generates a random number using the given number of bits and RNG.
+		*
+		* @param bits the number of bits for the number.
+		* @param rng the random number generator to use.
+		*
+		* @return the random number.
+		*/
+		function generateRandom(bits, rng) {
+			var num = new BigInteger(bits, rng);
+			var bits1 = bits - 1;
+			if (!num.testBit(bits1)) num.bitwiseTo(BigInteger.ONE.shiftLeft(bits1), op_or, num);
+			num.dAddOffset(31 - num.mod(THIRTY).byteValue(), 0);
+			return num;
+		}
+		/**
+		* Returns the required number of Miller-Rabin tests to generate a
+		* prime with an error probability of (1/2)^80.
+		*
+		* See Handbook of Applied Cryptography Chapter 4, Table 4.4.
+		*
+		* @param bits the bit size.
+		*
+		* @return the required number of iterations.
+		*/
+		function getMillerRabinTests(bits) {
+			if (bits <= 100) return 27;
+			if (bits <= 150) return 18;
+			if (bits <= 200) return 15;
+			if (bits <= 250) return 12;
+			if (bits <= 300) return 9;
+			if (bits <= 350) return 8;
+			if (bits <= 400) return 7;
+			if (bits <= 500) return 6;
+			if (bits <= 600) return 5;
+			if (bits <= 800) return 4;
+			if (bits <= 1250) return 3;
+			return 2;
+		}
+	})();
+}) });
+
+//#endregion
+export default require_prime();
+
+export { require_prime };
+//# sourceMappingURL=prime.mjs.map

package/dist/esm/node_modules/node-forge/lib/prime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prime.mjs","names":["i"],"sources":["../../../../../../../node_modules/node-forge/lib/prime.js"],"sourcesContent":["/**\n * Prime number generation API.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2014 Digital Bazaar, Inc.\n */\nvar forge = require('./forge');\nrequire('./util');\nrequire('./jsbn');\nrequire('./random');\n\n(function() {\n\n// forge.prime already defined\nif(forge.prime) {\n  module.exports = forge.prime;\n  return;\n}\n\n/* PRIME API */\nvar prime = module.exports = forge.prime = forge.prime || {};\n\nvar BigInteger = forge.jsbn.BigInteger;\n\n// primes are 30k+i for i = 1, 7, 11, 13, 17, 19, 23, 29\nvar GCD_30_DELTA = [6, 4, 2, 4, 2, 4, 6, 2];\nvar THIRTY = new BigInteger(null);\nTHIRTY.fromInt(30);\nvar op_or = function(x, y) {return x|y;};\n\n/**\n * Generates a random probable prime with the given number of bits.\n *\n * Alternative algorithms can be specified by name as a string or as an\n * object with custom options like so:\n *\n * {\n *   name: 'PRIMEINC',\n *   options: {\n *     maxBlockTime: <the maximum amount of time to block the main\n *       thread before allowing I/O other JS to run>,\n *     millerRabinTests: <the number of miller-rabin tests to run>,\n *     workerScript: <the worker script URL>,\n *     workers: <the number of web workers (if supported) to use,\n *       -1 to use estimated cores minus one>.\n *     workLoad: the size of the work load, ie: number of possible prime\n *       numbers for each web worker to check per work assignment,\n *       (default: 100).\n *   }\n * }\n *\n * @param bits the number of bits for the prime number.\n * @param options the options to use.\n *          [algorithm] the algorithm to use (default: 'PRIMEINC').\n *          [prng] a custom crypto-secure pseudo-random number generator to use,\n *            that must define \"getBytesSync\".\n *\n * @return callback(err, num) called once the operation completes.\n */\nprime.generateProbablePrime = function(bits, options, callback) {\n  if(typeof options === 'function') {\n    callback = options;\n    options = {};\n  }\n  options = options || {};\n\n  // default to PRIMEINC algorithm\n  var algorithm = options.algorithm || 'PRIMEINC';\n  if(typeof algorithm === 'string') {\n    algorithm = {name: algorithm};\n  }\n  algorithm.options = algorithm.options || {};\n\n  // create prng with api that matches BigInteger secure random\n  var prng = options.prng || forge.random;\n  var rng = {\n    // x is an array to fill with bytes\n    nextBytes: function(x) {\n      var b = prng.getBytesSync(x.length);\n      for(var i = 0; i < x.length; ++i) {\n        x[i] = b.charCodeAt(i);\n      }\n    }\n  };\n\n  if(algorithm.name === 'PRIMEINC') {\n    return primeincFindPrime(bits, rng, algorithm.options, callback);\n  }\n\n  throw new Error('Invalid prime generation algorithm: ' + algorithm.name);\n};\n\nfunction primeincFindPrime(bits, rng, options, callback) {\n  if('workers' in options) {\n    return primeincFindPrimeWithWorkers(bits, rng, options, callback);\n  }\n  return primeincFindPrimeWithoutWorkers(bits, rng, options, callback);\n}\n\nfunction primeincFindPrimeWithoutWorkers(bits, rng, options, callback) {\n  // initialize random number\n  var num = generateRandom(bits, rng);\n\n  /* Note: All primes are of the form 30k+i for i < 30 and gcd(30, i)=1. The\n  number we are given is always aligned at 30k + 1. Each time the number is\n  determined not to be prime we add to get to the next 'i', eg: if the number\n  was at 30k + 1 we add 6. */\n  var deltaIdx = 0;\n\n  // get required number of MR tests\n  var mrTests = getMillerRabinTests(num.bitLength());\n  if('millerRabinTests' in options) {\n    mrTests = options.millerRabinTests;\n  }\n\n  // find prime nearest to 'num' for maxBlockTime ms\n  // 10 ms gives 5ms of leeway for other calculations before dropping\n  // below 60fps (1000/60 == 16.67), but in reality, the number will\n  // likely be higher due to an 'atomic' big int modPow\n  var maxBlockTime = 10;\n  if('maxBlockTime' in options) {\n    maxBlockTime = options.maxBlockTime;\n  }\n\n  _primeinc(num, bits, rng, deltaIdx, mrTests, maxBlockTime, callback);\n}\n\nfunction _primeinc(num, bits, rng, deltaIdx, mrTests, maxBlockTime, callback) {\n  var start = +new Date();\n  do {\n    // overflow, regenerate random number\n    if(num.bitLength() > bits) {\n      num = generateRandom(bits, rng);\n    }\n    // do primality test\n    if(num.isProbablePrime(mrTests)) {\n      return callback(null, num);\n    }\n    // get next potential prime\n    num.dAddOffset(GCD_30_DELTA[deltaIdx++ % 8], 0);\n  } while(maxBlockTime < 0 || (+new Date() - start < maxBlockTime));\n\n  // keep trying later\n  forge.util.setImmediate(function() {\n    _primeinc(num, bits, rng, deltaIdx, mrTests, maxBlockTime, callback);\n  });\n}\n\n// NOTE: This algorithm is indeterminate in nature because workers\n// run in parallel looking at different segments of numbers. Even if this\n// algorithm is run twice with the same input from a predictable RNG, it\n// may produce different outputs.\nfunction primeincFindPrimeWithWorkers(bits, rng, options, callback) {\n  // web workers unavailable\n  if(typeof Worker === 'undefined') {\n    return primeincFindPrimeWithoutWorkers(bits, rng, options, callback);\n  }\n\n  // initialize random number\n  var num = generateRandom(bits, rng);\n\n  // use web workers to generate keys\n  var numWorkers = options.workers;\n  var workLoad = options.workLoad || 100;\n  var range = workLoad * 30 / 8;\n  var workerScript = options.workerScript || 'forge/prime.worker.js';\n  if(numWorkers === -1) {\n    return forge.util.estimateCores(function(err, cores) {\n      if(err) {\n        // default to 2\n        cores = 2;\n      }\n      numWorkers = cores - 1;\n      generate();\n    });\n  }\n  generate();\n\n  function generate() {\n    // require at least 1 worker\n    numWorkers = Math.max(1, numWorkers);\n\n    // TODO: consider optimizing by starting workers outside getPrime() ...\n    // note that in order to clean up they will have to be made internally\n    // asynchronous which may actually be slower\n\n    // start workers immediately\n    var workers = [];\n    for(var i = 0; i < numWorkers; ++i) {\n      // FIXME: fix path or use blob URLs\n      workers[i] = new Worker(workerScript);\n    }\n    var running = numWorkers;\n\n    // listen for requests from workers and assign ranges to find prime\n    for(var i = 0; i < numWorkers; ++i) {\n      workers[i].addEventListener('message', workerMessage);\n    }\n\n    /* Note: The distribution of random numbers is unknown. Therefore, each\n    web worker is continuously allocated a range of numbers to check for a\n    random number until one is found.\n\n    Every 30 numbers will be checked just 8 times, because prime numbers\n    have the form:\n\n    30k+i, for i < 30 and gcd(30, i)=1 (there are 8 values of i for this)\n\n    Therefore, if we want a web worker to run N checks before asking for\n    a new range of numbers, each range must contain N*30/8 numbers.\n\n    For 100 checks (workLoad), this is a range of 375. */\n\n    var found = false;\n    function workerMessage(e) {\n      // ignore message, prime already found\n      if(found) {\n        return;\n      }\n\n      --running;\n      var data = e.data;\n      if(data.found) {\n        // terminate all workers\n        for(var i = 0; i < workers.length; ++i) {\n          workers[i].terminate();\n        }\n        found = true;\n        return callback(null, new BigInteger(data.prime, 16));\n      }\n\n      // overflow, regenerate random number\n      if(num.bitLength() > bits) {\n        num = generateRandom(bits, rng);\n      }\n\n      // assign new range to check\n      var hex = num.toString(16);\n\n      // start prime search\n      e.target.postMessage({\n        hex: hex,\n        workLoad: workLoad\n      });\n\n      num.dAddOffset(range, 0);\n    }\n  }\n}\n\n/**\n * Generates a random number using the given number of bits and RNG.\n *\n * @param bits the number of bits for the number.\n * @param rng the random number generator to use.\n *\n * @return the random number.\n */\nfunction generateRandom(bits, rng) {\n  var num = new BigInteger(bits, rng);\n  // force MSB set\n  var bits1 = bits - 1;\n  if(!num.testBit(bits1)) {\n    num.bitwiseTo(BigInteger.ONE.shiftLeft(bits1), op_or, num);\n  }\n  // align number on 30k+1 boundary\n  num.dAddOffset(31 - num.mod(THIRTY).byteValue(), 0);\n  return num;\n}\n\n/**\n * Returns the required number of Miller-Rabin tests to generate a\n * prime with an error probability of (1/2)^80.\n *\n * See Handbook of Applied Cryptography Chapter 4, Table 4.4.\n *\n * @param bits the bit size.\n *\n * @return the required number of iterations.\n */\nfunction getMillerRabinTests(bits) {\n  if(bits <= 100) return 27;\n  if(bits <= 150) return 18;\n  if(bits <= 200) return 15;\n  if(bits <= 250) return 12;\n  if(bits <= 300) return 9;\n  if(bits <= 350) return 8;\n  if(bits <= 400) return 7;\n  if(bits <= 500) return 6;\n  if(bits <= 600) return 5;\n  if(bits <= 800) return 4;\n  if(bits <= 1250) return 3;\n  return 2;\n}\n\n})();\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/esm/node_modules/node-forge/lib/prng.mjs

@@ -0,0 +1,295 @@
+import { __commonJS } from "../../../_virtual/rolldown_runtime.mjs";
+import { require_forge } from "./forge.mjs";
+import { require_util } from "./util.mjs";
+import { require_lib } from "../lib.mjs";
+
+//#region ../../node_modules/node-forge/lib/prng.js
+var require_prng = /* @__PURE__ */ __commonJS({ "../../node_modules/node-forge/lib/prng.js": ((exports, module) => {
+	/**
+	* A javascript implementation of a cryptographically-secure
+	* Pseudo Random Number Generator (PRNG). The Fortuna algorithm is followed
+	* here though the use of SHA-256 is not enforced; when generating an
+	* a PRNG context, the hashing algorithm and block cipher used for
+	* the generator are specified via a plugin.
+	*
+	* @author Dave Longley
+	*
+	* Copyright (c) 2010-2014 Digital Bazaar, Inc.
+	*/
+	var forge = require_forge();
+	require_util();
+	var _crypto = null;
+	if (forge.util.isNodejs && !forge.options.usePureJavaScript && !process.versions["node-webkit"]) _crypto = require_lib();
+	var prng = module.exports = forge.prng = forge.prng || {};
+	/**
+	* Creates a new PRNG context.
+	*
+	* A PRNG plugin must be passed in that will provide:
+	*
+	* 1. A function that initializes the key and seed of a PRNG context. It
+	*   will be given a 16 byte key and a 16 byte seed. Any key expansion
+	*   or transformation of the seed from a byte string into an array of
+	*   integers (or similar) should be performed.
+	* 2. The cryptographic function used by the generator. It takes a key and
+	*   a seed.
+	* 3. A seed increment function. It takes the seed and returns seed + 1.
+	* 4. An api to create a message digest.
+	*
+	* For an example, see random.js.
+	*
+	* @param plugin the PRNG plugin to use.
+	*/
+	prng.create = function(plugin) {
+		var ctx = {
+			plugin,
+			key: null,
+			seed: null,
+			time: null,
+			reseeds: 0,
+			generated: 0,
+			keyBytes: ""
+		};
+		var md = plugin.md;
+		var pools = new Array(32);
+		for (var i = 0; i < 32; ++i) pools[i] = md.create();
+		ctx.pools = pools;
+		ctx.pool = 0;
+		/**
+		* Generates random bytes. The bytes may be generated synchronously or
+		* asynchronously. Web workers must use the asynchronous interface or
+		* else the behavior is undefined.
+		*
+		* @param count the number of random bytes to generate.
+		* @param [callback(err, bytes)] called once the operation completes.
+		*
+		* @return count random bytes as a string.
+		*/
+		ctx.generate = function(count, callback) {
+			if (!callback) return ctx.generateSync(count);
+			var cipher = ctx.plugin.cipher;
+			var increment = ctx.plugin.increment;
+			var formatKey = ctx.plugin.formatKey;
+			var formatSeed = ctx.plugin.formatSeed;
+			var b = forge.util.createBuffer();
+			ctx.key = null;
+			generate();
+			function generate(err) {
+				if (err) return callback(err);
+				if (b.length() >= count) return callback(null, b.getBytes(count));
+				if (ctx.generated > 1048575) ctx.key = null;
+				if (ctx.key === null) return forge.util.nextTick(function() {
+					_reseed(generate);
+				});
+				var bytes = cipher(ctx.key, ctx.seed);
+				ctx.generated += bytes.length;
+				b.putBytes(bytes);
+				ctx.key = formatKey(cipher(ctx.key, increment(ctx.seed)));
+				ctx.seed = formatSeed(cipher(ctx.key, ctx.seed));
+				forge.util.setImmediate(generate);
+			}
+		};
+		/**
+		* Generates random bytes synchronously.
+		*
+		* @param count the number of random bytes to generate.
+		*
+		* @return count random bytes as a string.
+		*/
+		ctx.generateSync = function(count) {
+			var cipher = ctx.plugin.cipher;
+			var increment = ctx.plugin.increment;
+			var formatKey = ctx.plugin.formatKey;
+			var formatSeed = ctx.plugin.formatSeed;
+			ctx.key = null;
+			var b = forge.util.createBuffer();
+			while (b.length() < count) {
+				if (ctx.generated > 1048575) ctx.key = null;
+				if (ctx.key === null) _reseedSync();
+				var bytes = cipher(ctx.key, ctx.seed);
+				ctx.generated += bytes.length;
+				b.putBytes(bytes);
+				ctx.key = formatKey(cipher(ctx.key, increment(ctx.seed)));
+				ctx.seed = formatSeed(cipher(ctx.key, ctx.seed));
+			}
+			return b.getBytes(count);
+		};
+		/**
+		* Private function that asynchronously reseeds a generator.
+		*
+		* @param callback(err) called once the operation completes.
+		*/
+		function _reseed(callback) {
+			if (ctx.pools[0].messageLength >= 32) {
+				_seed();
+				return callback();
+			}
+			var needed = 32 - ctx.pools[0].messageLength << 5;
+			ctx.seedFile(needed, function(err, bytes) {
+				if (err) return callback(err);
+				ctx.collect(bytes);
+				_seed();
+				callback();
+			});
+		}
+		/**
+		* Private function that synchronously reseeds a generator.
+		*/
+		function _reseedSync() {
+			if (ctx.pools[0].messageLength >= 32) return _seed();
+			var needed = 32 - ctx.pools[0].messageLength << 5;
+			ctx.collect(ctx.seedFileSync(needed));
+			_seed();
+		}
+		/**
+		* Private function that seeds a generator once enough bytes are available.
+		*/
+		function _seed() {
+			ctx.reseeds = ctx.reseeds === 4294967295 ? 0 : ctx.reseeds + 1;
+			var md$1 = ctx.plugin.md.create();
+			md$1.update(ctx.keyBytes);
+			var _2powK = 1;
+			for (var k = 0; k < 32; ++k) {
+				if (ctx.reseeds % _2powK === 0) {
+					md$1.update(ctx.pools[k].digest().getBytes());
+					ctx.pools[k].start();
+				}
+				_2powK = _2powK << 1;
+			}
+			ctx.keyBytes = md$1.digest().getBytes();
+			md$1.start();
+			md$1.update(ctx.keyBytes);
+			var seedBytes = md$1.digest().getBytes();
+			ctx.key = ctx.plugin.formatKey(ctx.keyBytes);
+			ctx.seed = ctx.plugin.formatSeed(seedBytes);
+			ctx.generated = 0;
+		}
+		/**
+		* The built-in default seedFile. This seedFile is used when entropy
+		* is needed immediately.
+		*
+		* @param needed the number of bytes that are needed.
+		*
+		* @return the random bytes.
+		*/
+		function defaultSeedFile(needed) {
+			var getRandomValues = null;
+			var globalScope = forge.util.globalScope;
+			var _crypto$1 = globalScope.crypto || globalScope.msCrypto;
+			if (_crypto$1 && _crypto$1.getRandomValues) getRandomValues = function(arr) {
+				return _crypto$1.getRandomValues(arr);
+			};
+			var b = forge.util.createBuffer();
+			if (getRandomValues) while (b.length() < needed) {
+				var count = Math.max(1, Math.min(needed - b.length(), 65536) / 4);
+				var entropy = new Uint32Array(Math.floor(count));
+				try {
+					getRandomValues(entropy);
+					for (var i$1 = 0; i$1 < entropy.length; ++i$1) b.putInt32(entropy[i$1]);
+				} catch (e) {
+					if (!(typeof QuotaExceededError !== "undefined" && e instanceof QuotaExceededError)) throw e;
+				}
+			}
+			if (b.length() < needed) {
+				var hi, lo, next;
+				var seed = Math.floor(Math.random() * 65536);
+				while (b.length() < needed) {
+					lo = 16807 * (seed & 65535);
+					hi = 16807 * (seed >> 16);
+					lo += (hi & 32767) << 16;
+					lo += hi >> 15;
+					lo = (lo & 2147483647) + (lo >> 31);
+					seed = lo & 4294967295;
+					for (var i$1 = 0; i$1 < 3; ++i$1) {
+						next = seed >>> (i$1 << 3);
+						next ^= Math.floor(Math.random() * 256);
+						b.putByte(next & 255);
+					}
+				}
+			}
+			return b.getBytes(needed);
+		}
+		if (_crypto) {
+			ctx.seedFile = function(needed, callback) {
+				_crypto.randomBytes(needed, function(err, bytes) {
+					if (err) return callback(err);
+					callback(null, bytes.toString());
+				});
+			};
+			ctx.seedFileSync = function(needed) {
+				return _crypto.randomBytes(needed).toString();
+			};
+		} else {
+			ctx.seedFile = function(needed, callback) {
+				try {
+					callback(null, defaultSeedFile(needed));
+				} catch (e) {
+					callback(e);
+				}
+			};
+			ctx.seedFileSync = defaultSeedFile;
+		}
+		/**
+		* Adds entropy to a prng ctx's accumulator.
+		*
+		* @param bytes the bytes of entropy as a string.
+		*/
+		ctx.collect = function(bytes) {
+			var count = bytes.length;
+			for (var i$1 = 0; i$1 < count; ++i$1) {
+				ctx.pools[ctx.pool].update(bytes.substr(i$1, 1));
+				ctx.pool = ctx.pool === 31 ? 0 : ctx.pool + 1;
+			}
+		};
+		/**
+		* Collects an integer of n bits.
+		*
+		* @param i the integer entropy.
+		* @param n the number of bits in the integer.
+		*/
+		ctx.collectInt = function(i$1, n) {
+			var bytes = "";
+			for (var x = 0; x < n; x += 8) bytes += String.fromCharCode(i$1 >> x & 255);
+			ctx.collect(bytes);
+		};
+		/**
+		* Registers a Web Worker to receive immediate entropy from the main thread.
+		* This method is required until Web Workers can access the native crypto
+		* API. This method should be called twice for each created worker, once in
+		* the main thread, and once in the worker itself.
+		*
+		* @param worker the worker to register.
+		*/
+		ctx.registerWorker = function(worker) {
+			if (worker === self) ctx.seedFile = function(needed, callback) {
+				function listener$1(e) {
+					var data = e.data;
+					if (data.forge && data.forge.prng) {
+						self.removeEventListener("message", listener$1);
+						callback(data.forge.prng.err, data.forge.prng.bytes);
+					}
+				}
+				self.addEventListener("message", listener$1);
+				self.postMessage({ forge: { prng: { needed } } });
+			};
+			else {
+				var listener = function(e) {
+					var data = e.data;
+					if (data.forge && data.forge.prng) ctx.seedFile(data.forge.prng.needed, function(err, bytes) {
+						worker.postMessage({ forge: { prng: {
+							err,
+							bytes
+						} } });
+					});
+				};
+				worker.addEventListener("message", listener);
+			}
+		};
+		return ctx;
+	};
+}) });
+
+//#endregion
+export default require_prng();
+
+export { require_prng };
+//# sourceMappingURL=prng.mjs.map

package/dist/esm/node_modules/node-forge/lib/prng.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prng.mjs","names":["md","_crypto","i","listener"],"sources":["../../../../../../../node_modules/node-forge/lib/prng.js"],"sourcesContent":["/**\n * A javascript implementation of a cryptographically-secure\n * Pseudo Random Number Generator (PRNG). The Fortuna algorithm is followed\n * here though the use of SHA-256 is not enforced; when generating an\n * a PRNG context, the hashing algorithm and block cipher used for\n * the generator are specified via a plugin.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2014 Digital Bazaar, Inc.\n */\nvar forge = require('./forge');\nrequire('./util');\n\nvar _crypto = null;\nif(forge.util.isNodejs && !forge.options.usePureJavaScript &&\n  !process.versions['node-webkit']) {\n  _crypto = require('crypto');\n}\n\n/* PRNG API */\nvar prng = module.exports = forge.prng = forge.prng || {};\n\n/**\n * Creates a new PRNG context.\n *\n * A PRNG plugin must be passed in that will provide:\n *\n * 1. A function that initializes the key and seed of a PRNG context. It\n *   will be given a 16 byte key and a 16 byte seed. Any key expansion\n *   or transformation of the seed from a byte string into an array of\n *   integers (or similar) should be performed.\n * 2. The cryptographic function used by the generator. It takes a key and\n *   a seed.\n * 3. A seed increment function. It takes the seed and returns seed + 1.\n * 4. An api to create a message digest.\n *\n * For an example, see random.js.\n *\n * @param plugin the PRNG plugin to use.\n */\nprng.create = function(plugin) {\n  var ctx = {\n    plugin: plugin,\n    key: null,\n    seed: null,\n    time: null,\n    // number of reseeds so far\n    reseeds: 0,\n    // amount of data generated so far\n    generated: 0,\n    // no initial key bytes\n    keyBytes: ''\n  };\n\n  // create 32 entropy pools (each is a message digest)\n  var md = plugin.md;\n  var pools = new Array(32);\n  for(var i = 0; i < 32; ++i) {\n    pools[i] = md.create();\n  }\n  ctx.pools = pools;\n\n  // entropy pools are written to cyclically, starting at index 0\n  ctx.pool = 0;\n\n  /**\n   * Generates random bytes. The bytes may be generated synchronously or\n   * asynchronously. Web workers must use the asynchronous interface or\n   * else the behavior is undefined.\n   *\n   * @param count the number of random bytes to generate.\n   * @param [callback(err, bytes)] called once the operation completes.\n   *\n   * @return count random bytes as a string.\n   */\n  ctx.generate = function(count, callback) {\n    // do synchronously\n    if(!callback) {\n      return ctx.generateSync(count);\n    }\n\n    // simple generator using counter-based CBC\n    var cipher = ctx.plugin.cipher;\n    var increment = ctx.plugin.increment;\n    var formatKey = ctx.plugin.formatKey;\n    var formatSeed = ctx.plugin.formatSeed;\n    var b = forge.util.createBuffer();\n\n    // paranoid deviation from Fortuna:\n    // reset key for every request to protect previously\n    // generated random bytes should the key be discovered;\n    // there is no 100ms based reseeding because of this\n    // forced reseed for every `generate` call\n    ctx.key = null;\n\n    generate();\n\n    function generate(err) {\n      if(err) {\n        return callback(err);\n      }\n\n      // sufficient bytes generated\n      if(b.length() >= count) {\n        return callback(null, b.getBytes(count));\n      }\n\n      // if amount of data generated is greater than 1 MiB, trigger reseed\n      if(ctx.generated > 0xfffff) {\n        ctx.key = null;\n      }\n\n      if(ctx.key === null) {\n        // prevent stack overflow\n        return forge.util.nextTick(function() {\n          _reseed(generate);\n        });\n      }\n\n      // generate the random bytes\n      var bytes = cipher(ctx.key, ctx.seed);\n      ctx.generated += bytes.length;\n      b.putBytes(bytes);\n\n      // generate bytes for a new key and seed\n      ctx.key = formatKey(cipher(ctx.key, increment(ctx.seed)));\n      ctx.seed = formatSeed(cipher(ctx.key, ctx.seed));\n\n      forge.util.setImmediate(generate);\n    }\n  };\n\n  /**\n   * Generates random bytes synchronously.\n   *\n   * @param count the number of random bytes to generate.\n   *\n   * @return count random bytes as a string.\n   */\n  ctx.generateSync = function(count) {\n    // simple generator using counter-based CBC\n    var cipher = ctx.plugin.cipher;\n    var increment = ctx.plugin.increment;\n    var formatKey = ctx.plugin.formatKey;\n    var formatSeed = ctx.plugin.formatSeed;\n\n    // paranoid deviation from Fortuna:\n    // reset key for every request to protect previously\n    // generated random bytes should the key be discovered;\n    // there is no 100ms based reseeding because of this\n    // forced reseed for every `generateSync` call\n    ctx.key = null;\n\n    var b = forge.util.createBuffer();\n    while(b.length() < count) {\n      // if amount of data generated is greater than 1 MiB, trigger reseed\n      if(ctx.generated > 0xfffff) {\n        ctx.key = null;\n      }\n\n      if(ctx.key === null) {\n        _reseedSync();\n      }\n\n      // generate the random bytes\n      var bytes = cipher(ctx.key, ctx.seed);\n      ctx.generated += bytes.length;\n      b.putBytes(bytes);\n\n      // generate bytes for a new key and seed\n      ctx.key = formatKey(cipher(ctx.key, increment(ctx.seed)));\n      ctx.seed = formatSeed(cipher(ctx.key, ctx.seed));\n    }\n\n    return b.getBytes(count);\n  };\n\n  /**\n   * Private function that asynchronously reseeds a generator.\n   *\n   * @param callback(err) called once the operation completes.\n   */\n  function _reseed(callback) {\n    if(ctx.pools[0].messageLength >= 32) {\n      _seed();\n      return callback();\n    }\n    // not enough seed data...\n    var needed = (32 - ctx.pools[0].messageLength) << 5;\n    ctx.seedFile(needed, function(err, bytes) {\n      if(err) {\n        return callback(err);\n      }\n      ctx.collect(bytes);\n      _seed();\n      callback();\n    });\n  }\n\n  /**\n   * Private function that synchronously reseeds a generator.\n   */\n  function _reseedSync() {\n    if(ctx.pools[0].messageLength >= 32) {\n      return _seed();\n    }\n    // not enough seed data...\n    var needed = (32 - ctx.pools[0].messageLength) << 5;\n    ctx.collect(ctx.seedFileSync(needed));\n    _seed();\n  }\n\n  /**\n   * Private function that seeds a generator once enough bytes are available.\n   */\n  function _seed() {\n    // update reseed count\n    ctx.reseeds = (ctx.reseeds === 0xffffffff) ? 0 : ctx.reseeds + 1;\n\n    // goal is to update `key` via:\n    // key = hash(key + s)\n    //   where 's' is all collected entropy from selected pools, then...\n\n    // create a plugin-based message digest\n    var md = ctx.plugin.md.create();\n\n    // consume current key bytes\n    md.update(ctx.keyBytes);\n\n    // digest the entropy of pools whose index k meet the\n    // condition 'n mod 2^k == 0' where n is the number of reseeds\n    var _2powK = 1;\n    for(var k = 0; k < 32; ++k) {\n      if(ctx.reseeds % _2powK === 0) {\n        md.update(ctx.pools[k].digest().getBytes());\n        ctx.pools[k].start();\n      }\n      _2powK = _2powK << 1;\n    }\n\n    // get digest for key bytes\n    ctx.keyBytes = md.digest().getBytes();\n\n    // paranoid deviation from Fortuna:\n    // update `seed` via `seed = hash(key)`\n    // instead of initializing to zero once and only\n    // ever incrementing it\n    md.start();\n    md.update(ctx.keyBytes);\n    var seedBytes = md.digest().getBytes();\n\n    // update state\n    ctx.key = ctx.plugin.formatKey(ctx.keyBytes);\n    ctx.seed = ctx.plugin.formatSeed(seedBytes);\n    ctx.generated = 0;\n  }\n\n  /**\n   * The built-in default seedFile. This seedFile is used when entropy\n   * is needed immediately.\n   *\n   * @param needed the number of bytes that are needed.\n   *\n   * @return the random bytes.\n   */\n  function defaultSeedFile(needed) {\n    // use window.crypto.getRandomValues strong source of entropy if available\n    var getRandomValues = null;\n    var globalScope = forge.util.globalScope;\n    var _crypto = globalScope.crypto || globalScope.msCrypto;\n    if(_crypto && _crypto.getRandomValues) {\n      getRandomValues = function(arr) {\n        return _crypto.getRandomValues(arr);\n      };\n    }\n\n    var b = forge.util.createBuffer();\n    if(getRandomValues) {\n      while(b.length() < needed) {\n        // max byte length is 65536 before QuotaExceededError is thrown\n        // http://www.w3.org/TR/WebCryptoAPI/#RandomSource-method-getRandomValues\n        var count = Math.max(1, Math.min(needed - b.length(), 65536) / 4);\n        var entropy = new Uint32Array(Math.floor(count));\n        try {\n          getRandomValues(entropy);\n          for(var i = 0; i < entropy.length; ++i) {\n            b.putInt32(entropy[i]);\n          }\n        } catch(e) {\n          /* only ignore QuotaExceededError */\n          if(!(typeof QuotaExceededError !== 'undefined' &&\n            e instanceof QuotaExceededError)) {\n            throw e;\n          }\n        }\n      }\n    }\n\n    // be sad and add some weak random data\n    if(b.length() < needed) {\n      /* Draws from Park-Miller \"minimal standard\" 31 bit PRNG,\n      implemented with David G. Carta's optimization: with 32 bit math\n      and without division (Public Domain). */\n      var hi, lo, next;\n      var seed = Math.floor(Math.random() * 0x010000);\n      while(b.length() < needed) {\n        lo = 16807 * (seed & 0xFFFF);\n        hi = 16807 * (seed >> 16);\n        lo += (hi & 0x7FFF) << 16;\n        lo += hi >> 15;\n        lo = (lo & 0x7FFFFFFF) + (lo >> 31);\n        seed = lo & 0xFFFFFFFF;\n\n        // consume lower 3 bytes of seed\n        for(var i = 0; i < 3; ++i) {\n          // throw in more pseudo random\n          next = seed >>> (i << 3);\n          next ^= Math.floor(Math.random() * 0x0100);\n          b.putByte(next & 0xFF);\n        }\n      }\n    }\n\n    return b.getBytes(needed);\n  }\n  // initialize seed file APIs\n  if(_crypto) {\n    // use nodejs async API\n    ctx.seedFile = function(needed, callback) {\n      _crypto.randomBytes(needed, function(err, bytes) {\n        if(err) {\n          return callback(err);\n        }\n        callback(null, bytes.toString());\n      });\n    };\n    // use nodejs sync API\n    ctx.seedFileSync = function(needed) {\n      return _crypto.randomBytes(needed).toString();\n    };\n  } else {\n    ctx.seedFile = function(needed, callback) {\n      try {\n        callback(null, defaultSeedFile(needed));\n      } catch(e) {\n        callback(e);\n      }\n    };\n    ctx.seedFileSync = defaultSeedFile;\n  }\n\n  /**\n   * Adds entropy to a prng ctx's accumulator.\n   *\n   * @param bytes the bytes of entropy as a string.\n   */\n  ctx.collect = function(bytes) {\n    // iterate over pools distributing entropy cyclically\n    var count = bytes.length;\n    for(var i = 0; i < count; ++i) {\n      ctx.pools[ctx.pool].update(bytes.substr(i, 1));\n      ctx.pool = (ctx.pool === 31) ? 0 : ctx.pool + 1;\n    }\n  };\n\n  /**\n   * Collects an integer of n bits.\n   *\n   * @param i the integer entropy.\n   * @param n the number of bits in the integer.\n   */\n  ctx.collectInt = function(i, n) {\n    var bytes = '';\n    for(var x = 0; x < n; x += 8) {\n      bytes += String.fromCharCode((i >> x) & 0xFF);\n    }\n    ctx.collect(bytes);\n  };\n\n  /**\n   * Registers a Web Worker to receive immediate entropy from the main thread.\n   * This method is required until Web Workers can access the native crypto\n   * API. This method should be called twice for each created worker, once in\n   * the main thread, and once in the worker itself.\n   *\n   * @param worker the worker to register.\n   */\n  ctx.registerWorker = function(worker) {\n    // worker receives random bytes\n    if(worker === self) {\n      ctx.seedFile = function(needed, callback) {\n        function listener(e) {\n          var data = e.data;\n          if(data.forge && data.forge.prng) {\n            self.removeEventListener('message', listener);\n            callback(data.forge.prng.err, data.forge.prng.bytes);\n          }\n        }\n        self.addEventListener('message', listener);\n        self.postMessage({forge: {prng: {needed: needed}}});\n      };\n    } else {\n      // main thread sends random bytes upon request\n      var listener = function(e) {\n        var data = e.data;\n        if(data.forge && data.forge.prng) {\n          ctx.seedFile(data.forge.prng.needed, function(err, bytes) {\n            worker.postMessage({forge: {prng: {err: err, bytes: bytes}}});\n          });\n        }\n      };\n      // TODO: do we need to remove the event listener when the worker dies?\n      worker.addEventListener('message', listener);\n    }\n  };\n\n  return ctx;\n};\n"],"x_google_ignoreList":[0],"mappings":"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"}