better-auth 1.7.0-beta.2 → 1.7.0-beta.4

package/dist/node_modules/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/pkcs7asn1.mjs

@@ -0,0 +1,405 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_forge } from "./forge.mjs";
+import { require_util } from "./util.mjs";
+import { require_asn1 } from "./asn1.mjs";
+//#region ../../node_modules/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/pkcs7asn1.js
+var require_pkcs7asn1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Javascript implementation of ASN.1 validators for PKCS#7 v1.5.
+	*
+	* @author Dave Longley
+	* @author Stefan Siegl
+	*
+	* Copyright (c) 2012-2015 Digital Bazaar, Inc.
+	* Copyright (c) 2012 Stefan Siegl <stesie@brokenpipe.de>
+	*
+	* The ASN.1 representation of PKCS#7 is as follows
+	* (see RFC #2315 for details, http://www.ietf.org/rfc/rfc2315.txt):
+	*
+	* A PKCS#7 message consists of a ContentInfo on root level, which may
+	* contain any number of further ContentInfo nested into it.
+	*
+	* ContentInfo ::= SEQUENCE {
+	*   contentType                ContentType,
+	*   content               [0]  EXPLICIT ANY DEFINED BY contentType OPTIONAL
+	* }
+	*
+	* ContentType ::= OBJECT IDENTIFIER
+	*
+	* EnvelopedData ::= SEQUENCE {
+	*   version                    Version,
+	*   recipientInfos             RecipientInfos,
+	*   encryptedContentInfo       EncryptedContentInfo
+	* }
+	*
+	* EncryptedData ::= SEQUENCE {
+	*   version                    Version,
+	*   encryptedContentInfo       EncryptedContentInfo
+	* }
+	*
+	* id-signedData OBJECT IDENTIFIER ::= { iso(1) member-body(2)
+	*   us(840) rsadsi(113549) pkcs(1) pkcs7(7) 2 }
+	*
+	* SignedData ::= SEQUENCE {
+	*   version           INTEGER,
+	*   digestAlgorithms  DigestAlgorithmIdentifiers,
+	*   contentInfo       ContentInfo,
+	*   certificates      [0] IMPLICIT Certificates OPTIONAL,
+	*   crls              [1] IMPLICIT CertificateRevocationLists OPTIONAL,
+	*   signerInfos       SignerInfos
+	* }
+	*
+	* SignerInfos ::= SET OF SignerInfo
+	*
+	* SignerInfo ::= SEQUENCE {
+	*   version                    Version,
+	*   issuerAndSerialNumber      IssuerAndSerialNumber,
+	*   digestAlgorithm            DigestAlgorithmIdentifier,
+	*   authenticatedAttributes    [0] IMPLICIT Attributes OPTIONAL,
+	*   digestEncryptionAlgorithm  DigestEncryptionAlgorithmIdentifier,
+	*   encryptedDigest            EncryptedDigest,
+	*   unauthenticatedAttributes  [1] IMPLICIT Attributes OPTIONAL
+	* }
+	*
+	* EncryptedDigest ::= OCTET STRING
+	*
+	* Attributes ::= SET OF Attribute
+	*
+	* Attribute ::= SEQUENCE {
+	*   attrType    OBJECT IDENTIFIER,
+	*   attrValues  SET OF AttributeValue
+	* }
+	*
+	* AttributeValue ::= ANY
+	*
+	* Version ::= INTEGER
+	*
+	* RecipientInfos ::= SET OF RecipientInfo
+	*
+	* EncryptedContentInfo ::= SEQUENCE {
+	*   contentType                 ContentType,
+	*   contentEncryptionAlgorithm  ContentEncryptionAlgorithmIdentifier,
+	*   encryptedContent       [0]  IMPLICIT EncryptedContent OPTIONAL
+	* }
+	*
+	* ContentEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
+	*
+	* The AlgorithmIdentifier contains an Object Identifier (OID) and parameters
+	* for the algorithm, if any. In the case of AES and DES3, there is only one,
+	* the IV.
+	*
+	* AlgorithmIdentifer ::= SEQUENCE {
+	*    algorithm OBJECT IDENTIFIER,
+	*    parameters ANY DEFINED BY algorithm OPTIONAL
+	* }
+	*
+	* EncryptedContent ::= OCTET STRING
+	*
+	* RecipientInfo ::= SEQUENCE {
+	*   version                     Version,
+	*   issuerAndSerialNumber       IssuerAndSerialNumber,
+	*   keyEncryptionAlgorithm      KeyEncryptionAlgorithmIdentifier,
+	*   encryptedKey                EncryptedKey
+	* }
+	*
+	* IssuerAndSerialNumber ::= SEQUENCE {
+	*   issuer                      Name,
+	*   serialNumber                CertificateSerialNumber
+	* }
+	*
+	* CertificateSerialNumber ::= INTEGER
+	*
+	* KeyEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
+	*
+	* EncryptedKey ::= OCTET STRING
+	*/
+	var forge = require_forge();
+	require_asn1();
+	require_util();
+	var asn1 = forge.asn1;
+	var p7v = module.exports = forge.pkcs7asn1 = forge.pkcs7asn1 || {};
+	forge.pkcs7 = forge.pkcs7 || {};
+	forge.pkcs7.asn1 = p7v;
+	var contentInfoValidator = {
+		name: "ContentInfo",
+		tagClass: asn1.Class.UNIVERSAL,
+		type: asn1.Type.SEQUENCE,
+		constructed: true,
+		value: [{
+			name: "ContentInfo.ContentType",
+			tagClass: asn1.Class.UNIVERSAL,
+			type: asn1.Type.OID,
+			constructed: false,
+			capture: "contentType"
+		}, {
+			name: "ContentInfo.content",
+			tagClass: asn1.Class.CONTEXT_SPECIFIC,
+			type: 0,
+			constructed: true,
+			optional: true,
+			captureAsn1: "content"
+		}]
+	};
+	p7v.contentInfoValidator = contentInfoValidator;
+	var encryptedContentInfoValidator = {
+		name: "EncryptedContentInfo",
+		tagClass: asn1.Class.UNIVERSAL,
+		type: asn1.Type.SEQUENCE,
+		constructed: true,
+		value: [
+			{
+				name: "EncryptedContentInfo.contentType",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.OID,
+				constructed: false,
+				capture: "contentType"
+			},
+			{
+				name: "EncryptedContentInfo.contentEncryptionAlgorithm",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SEQUENCE,
+				constructed: true,
+				value: [{
+					name: "EncryptedContentInfo.contentEncryptionAlgorithm.algorithm",
+					tagClass: asn1.Class.UNIVERSAL,
+					type: asn1.Type.OID,
+					constructed: false,
+					capture: "encAlgorithm"
+				}, {
+					name: "EncryptedContentInfo.contentEncryptionAlgorithm.parameter",
+					tagClass: asn1.Class.UNIVERSAL,
+					captureAsn1: "encParameter"
+				}]
+			},
+			{
+				name: "EncryptedContentInfo.encryptedContent",
+				tagClass: asn1.Class.CONTEXT_SPECIFIC,
+				type: 0,
+				capture: "encryptedContent",
+				captureAsn1: "encryptedContentAsn1"
+			}
+		]
+	};
+	p7v.envelopedDataValidator = {
+		name: "EnvelopedData",
+		tagClass: asn1.Class.UNIVERSAL,
+		type: asn1.Type.SEQUENCE,
+		constructed: true,
+		value: [{
+			name: "EnvelopedData.Version",
+			tagClass: asn1.Class.UNIVERSAL,
+			type: asn1.Type.INTEGER,
+			constructed: false,
+			capture: "version"
+		}, {
+			name: "EnvelopedData.RecipientInfos",
+			tagClass: asn1.Class.UNIVERSAL,
+			type: asn1.Type.SET,
+			constructed: true,
+			captureAsn1: "recipientInfos"
+		}].concat(encryptedContentInfoValidator)
+	};
+	p7v.encryptedDataValidator = {
+		name: "EncryptedData",
+		tagClass: asn1.Class.UNIVERSAL,
+		type: asn1.Type.SEQUENCE,
+		constructed: true,
+		value: [{
+			name: "EncryptedData.Version",
+			tagClass: asn1.Class.UNIVERSAL,
+			type: asn1.Type.INTEGER,
+			constructed: false,
+			capture: "version"
+		}].concat(encryptedContentInfoValidator)
+	};
+	var signerValidator = {
+		name: "SignerInfo",
+		tagClass: asn1.Class.UNIVERSAL,
+		type: asn1.Type.SEQUENCE,
+		constructed: true,
+		value: [
+			{
+				name: "SignerInfo.version",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.INTEGER,
+				constructed: false
+			},
+			{
+				name: "SignerInfo.issuerAndSerialNumber",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SEQUENCE,
+				constructed: true,
+				value: [{
+					name: "SignerInfo.issuerAndSerialNumber.issuer",
+					tagClass: asn1.Class.UNIVERSAL,
+					type: asn1.Type.SEQUENCE,
+					constructed: true,
+					captureAsn1: "issuer"
+				}, {
+					name: "SignerInfo.issuerAndSerialNumber.serialNumber",
+					tagClass: asn1.Class.UNIVERSAL,
+					type: asn1.Type.INTEGER,
+					constructed: false,
+					capture: "serial"
+				}]
+			},
+			{
+				name: "SignerInfo.digestAlgorithm",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SEQUENCE,
+				constructed: true,
+				value: [{
+					name: "SignerInfo.digestAlgorithm.algorithm",
+					tagClass: asn1.Class.UNIVERSAL,
+					type: asn1.Type.OID,
+					constructed: false,
+					capture: "digestAlgorithm"
+				}, {
+					name: "SignerInfo.digestAlgorithm.parameter",
+					tagClass: asn1.Class.UNIVERSAL,
+					constructed: false,
+					captureAsn1: "digestParameter",
+					optional: true
+				}]
+			},
+			{
+				name: "SignerInfo.authenticatedAttributes",
+				tagClass: asn1.Class.CONTEXT_SPECIFIC,
+				type: 0,
+				constructed: true,
+				optional: true,
+				capture: "authenticatedAttributes"
+			},
+			{
+				name: "SignerInfo.digestEncryptionAlgorithm",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SEQUENCE,
+				constructed: true,
+				capture: "signatureAlgorithm"
+			},
+			{
+				name: "SignerInfo.encryptedDigest",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.OCTETSTRING,
+				constructed: false,
+				capture: "signature"
+			},
+			{
+				name: "SignerInfo.unauthenticatedAttributes",
+				tagClass: asn1.Class.CONTEXT_SPECIFIC,
+				type: 1,
+				constructed: true,
+				optional: true,
+				capture: "unauthenticatedAttributes"
+			}
+		]
+	};
+	p7v.signedDataValidator = {
+		name: "SignedData",
+		tagClass: asn1.Class.UNIVERSAL,
+		type: asn1.Type.SEQUENCE,
+		constructed: true,
+		value: [
+			{
+				name: "SignedData.Version",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.INTEGER,
+				constructed: false,
+				capture: "version"
+			},
+			{
+				name: "SignedData.DigestAlgorithms",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SET,
+				constructed: true,
+				captureAsn1: "digestAlgorithms"
+			},
+			contentInfoValidator,
+			{
+				name: "SignedData.Certificates",
+				tagClass: asn1.Class.CONTEXT_SPECIFIC,
+				type: 0,
+				optional: true,
+				captureAsn1: "certificates"
+			},
+			{
+				name: "SignedData.CertificateRevocationLists",
+				tagClass: asn1.Class.CONTEXT_SPECIFIC,
+				type: 1,
+				optional: true,
+				captureAsn1: "crls"
+			},
+			{
+				name: "SignedData.SignerInfos",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SET,
+				capture: "signerInfos",
+				optional: true,
+				value: [signerValidator]
+			}
+		]
+	};
+	p7v.recipientInfoValidator = {
+		name: "RecipientInfo",
+		tagClass: asn1.Class.UNIVERSAL,
+		type: asn1.Type.SEQUENCE,
+		constructed: true,
+		value: [
+			{
+				name: "RecipientInfo.version",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.INTEGER,
+				constructed: false,
+				capture: "version"
+			},
+			{
+				name: "RecipientInfo.issuerAndSerial",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SEQUENCE,
+				constructed: true,
+				value: [{
+					name: "RecipientInfo.issuerAndSerial.issuer",
+					tagClass: asn1.Class.UNIVERSAL,
+					type: asn1.Type.SEQUENCE,
+					constructed: true,
+					captureAsn1: "issuer"
+				}, {
+					name: "RecipientInfo.issuerAndSerial.serialNumber",
+					tagClass: asn1.Class.UNIVERSAL,
+					type: asn1.Type.INTEGER,
+					constructed: false,
+					capture: "serial"
+				}]
+			},
+			{
+				name: "RecipientInfo.keyEncryptionAlgorithm",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.SEQUENCE,
+				constructed: true,
+				value: [{
+					name: "RecipientInfo.keyEncryptionAlgorithm.algorithm",
+					tagClass: asn1.Class.UNIVERSAL,
+					type: asn1.Type.OID,
+					constructed: false,
+					capture: "encAlgorithm"
+				}, {
+					name: "RecipientInfo.keyEncryptionAlgorithm.parameter",
+					tagClass: asn1.Class.UNIVERSAL,
+					constructed: false,
+					captureAsn1: "encParameter",
+					optional: true
+				}]
+			},
+			{
+				name: "RecipientInfo.encryptedKey",
+				tagClass: asn1.Class.UNIVERSAL,
+				type: asn1.Type.OCTETSTRING,
+				constructed: false,
+				capture: "encKey"
+			}
+		]
+	};
+}));
+//#endregion
+export default require_pkcs7asn1();
+export { require_pkcs7asn1 };

package/dist/node_modules/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/pki.mjs

@@ -0,0 +1,101 @@
+import { __commonJSMin } 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/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/pki.js
+var require_pki = /* @__PURE__ */ __commonJSMin(((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, maxline) {
+		var msg = {
+			type: "PRIVATE KEY",
+			body: asn1.toDer(pki).getBytes()
+		};
+		return forge.pem.encode(msg, { maxline });
+	};
+}));
+//#endregion
+export default require_pki();
+export { require_pki };

package/dist/node_modules/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/prime.mjs

@@ -0,0 +1,193 @@
+import { __commonJSMin } 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/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/prime.js
+var require_prime = /* @__PURE__ */ __commonJSMin(((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 = 0; i < workers.length; ++i) workers[i].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 };