initial commit

node_modules/crypto-browserify/.eslintrc

@@ -0,0 +1,24 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"rules": {
+		"func-style": "off",
+		"multiline-comment-style": "off",
+		"sort-keys": "off",
+	},
+
+	"ignorePatterns": [
+		"example/bundle.js",
+	],
+
+	"overrides": [
+		{
+			"files": "example/**",
+			"rules": {
+				"no-console": "off",
+			},
+		},
+	],
+}

node_modules/crypto-browserify/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/crypto-browserify
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

node_modules/crypto-browserify/.github/workflows/node-aught.yml

@@ -0,0 +1,12 @@
+name: 'Tests: node.js < 10'
+
+on: [pull_request, push]
+
+jobs:
+  tests:
+    uses: ljharb/actions/.github/workflows/node.yml@main
+    with:
+      range: '>= 0.10 < 10'
+      type: minors
+      command: npm run tests-only
+      skip-ls-check: true

node_modules/crypto-browserify/.github/workflows/node-pretest.yml

@@ -0,0 +1,9 @@
+name: 'Tests: pretest/posttest'
+
+on: [pull_request, push]
+
+jobs:
+  tests:
+    uses: ljharb/actions/.github/workflows/pretest.yml@main
+    with:
+      skip-engines: true # see https://github.com/browserify/browserify-sign/pull/49

node_modules/crypto-browserify/.github/workflows/node-tens.yml

@@ -0,0 +1,11 @@
+name: 'Tests: node.js >= 10'
+
+on: [pull_request, push]
+
+jobs:
+  tests:
+    uses: ljharb/actions/.github/workflows/node.yml@main
+    with:
+      range: '>= 10'
+      type: minors
+      command: npm run tests-only

node_modules/crypto-browserify/.github/workflows/rebase.yml

@@ -0,0 +1,9 @@
+name: Automatic Rebase
+
+on: [pull_request_target]
+
+jobs:
+  _:
+    uses: ljharb/actions/.github/workflows/rebase.yml@main
+    secrets:
+      token: ${{ secrets.GITHUB_TOKEN }}

node_modules/crypto-browserify/.github/workflows/require-allow-edits.yml

@@ -0,0 +1,12 @@
+name: Require “Allow Edits”
+
+on: [pull_request_target]
+
+jobs:
+  _:
+    name: "Require “Allow Edits”"
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: ljharb/require-allow-edits@main

node_modules/crypto-browserify/.nycrc

@@ -0,0 +1,9 @@
+{
+  "exclude": [
+    "test/**"
+  ],
+  "reporter": [
+    "html",
+    "text"
+  ]
+}

node_modules/crypto-browserify/.travis.yml

@@ -0,0 +1,18 @@
+sudo: false
+language: node_js
+matrix:
+  include:
+      env: TEST_SUITE=browser BROWSER_NAME=ie BROWSER_VERSION="10..latest"
+    - node_js: '4'
+      env: TEST_SUITE=browser BROWSER_NAME=chrome BROWSER_VERSION="-2..beta"
+    - node_js: '4'
+      env: TEST_SUITE=browser BROWSER_NAME=firefox BROWSER_VERSION="-2..latest"
+    - node_js: '4'
+      env: TEST_SUITE=browser BROWSER_NAME=safari BROWSER_VERSION="7..latest"
+    - node_js: '4'
+      env: TEST_SUITE=browser BROWSER_NAME=android BROWSER_VERSION="5.0..latest"
+script: "npm run-script $TEST_SUITE"
+env:
+  global:
+  - secure: YHNUDQmx/WiW3gmDcRCfb6KLDeio7Mr5tqPY2kHPdZlBSytsQjNk75ytM4U6Cu8Uk8iEIoj/aFlxiVMpJNA8J4QSUyW/YkbVaIz0+1oywoV0Ht8aRBfZ1jvXfX6789+1Q9c4xaMkYYbJpXSh9JcirsiwmqWd4+IDd7hcESodsDQ=
+  - secure: Nhj5yejKZxUbtHGZta+GjYWqXGaOZB7ainTkOuGcpXM+OwwjeDpYlTBrwS90Q7hqens7KXVzQM09aDbadpsDCsOo1nyaEigMtomAorZ1UC1CpEoVz1ZuikF9bEhb+/7M9pzuL1fX+Ke9Dx4mPPeb8sf/2SrAu1RqXkSwZV/duAc=

node_modules/crypto-browserify/LICENSE

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

node_modules/crypto-browserify/README.md

@@ -0,0 +1,67 @@
+# crypto-browserify <sup>[![Version Badge][npm-version-svg]][package-url]</sup>
+
+A port of node's `crypto` module to the browser.
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+[![Sauce Test Status](https://saucelabs.com/browser-matrix/crypto-browserify.svg)](https://saucelabs.com/u/crypto-browserify)
+
+[![npm badge][npm-badge-png]][package-url]
+
+The goal of this module is to reimplement node's crypto module, in pure javascript so that it can run in the browser.
+
+Here is the subset that is currently implemented:
+
+* createHash (sha1, sha224, sha256, sha384, sha512, md5, rmd160)
+* createHmac (sha1, sha224, sha256, sha384, sha512, md5, rmd160)
+* pbkdf2
+* pbkdf2Sync
+* randomBytes
+* pseudoRandomBytes
+* createCipher (aes)
+* createDecipher (aes)
+* createDiffieHellman
+* createSign (rsa, ecdsa)
+* createVerify (rsa, ecdsa)
+* createECDH (secp256k1)
+* publicEncrypt/privateDecrypt (rsa)
+* privateEncrypt/publicDecrypt (rsa)
+
+## todo
+
+these features from node's `crypto` are still unimplemented.
+
+* createCredentials
+
+## contributions
+
+If you are interested in writing a feature, please implement as a new module,
+which will be incorporated into crypto-browserify as a dependency.
+
+All deps must be compatible with node's crypto
+(generate example inputs and outputs with node, and save base64 strings inside JSON, so that tests can run in the browser)
+see [sha.js](https://github.com/dominictarr/sha.js)
+
+Crypto is _extra serious_ so please do not hesitate to review the code, and post comments if you do.
+
+## License
+
+MIT
+
+[package-url]: https://npmjs.org/package/crypto-browserify
+[npm-version-svg]: https://versionbadg.es/browserify/crypto-browserify.svg
+[deps-svg]: https://david-dm.org/browserify/crypto-browserify.svg
+[deps-url]: https://david-dm.org/browserify/crypto-browserify
+[dev-deps-svg]: https://david-dm.org/browserify/crypto-browserify/dev-status.svg
+[dev-deps-url]: https://david-dm.org/browserify/crypto-browserify#info=devDependencies
+[npm-badge-png]: https://nodei.co/npm/crypto-browserify.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/crypto-browserify.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/crypto-browserify.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=crypto-browserify
+[codecov-image]: https://codecov.io/gh/browserify/crypto-browserify/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/browserify/crypto-browserify/
+[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/browserify/crypto-browserify
+[actions-url]: https://github.com/browserify/crypto-browserify/actions

node_modules/crypto-browserify/example/bundle.js

@@ -0,0 +1,605 @@
+'use strict';
+
+var require = function (file, cwd) {
+	var resolved = require.resolve(file, cwd || '/');
+	var mod = require.modules[resolved];
+	if (!mod) {
+		throw new Error('Failed to resolve module ' + file + ', tried ' + resolved);
+	}
+	var res = mod._cached ? mod._cached : mod();
+	return res;
+};
+
+require.paths = [];
+require.modules = {};
+require.extensions = ['.js', '.coffee'];
+
+require._core = {
+	assert: true,
+	events: true,
+	fs: true,
+	path: true,
+	vm: true
+};
+
+require.resolve = (function () {
+	return function (x, cwd) {
+		if (!cwd) { cwd = '/'; }
+
+		if (require._core[x]) { return x; }
+		var path = require.modules.path();
+		cwd = path.resolve('/', cwd);
+		var y = cwd || '/';
+
+		if (x.match(/^(?:\.\.?\/|\/)/)) {
+			var m = loadAsFileSync(path.resolve(y, x))
+				|| loadAsDirectorySync(path.resolve(y, x));
+			if (m) { return m; }
+		}
+
+		var n = loadNodeModulesSync(x, y);
+		if (n) { return n; }
+
+		throw new Error("Cannot find module '" + x + "'");
+
+		function loadAsFileSync(x) {
+			if (require.modules[x]) {
+				return x;
+			}
+
+			for (var i = 0; i < require.extensions.length; i++) {
+				var ext = require.extensions[i];
+				if (require.modules[x + ext]) { return x + ext; }
+			}
+		}
+
+		function loadAsDirectorySync(x) {
+			x = x.replace(/\/+$/, '');
+			var pkgfile = x + '/package.json';
+			if (require.modules[pkgfile]) {
+				var pkg = require.modules[pkgfile]();
+				var b = pkg.browserify;
+				if (typeof b === 'object' && b.main) {
+					var m = loadAsFileSync(path.resolve(x, b.main));
+					if (m) { return m; }
+				} else if (typeof b === 'string') {
+					var m = loadAsFileSync(path.resolve(x, b));
+					if (m) { return m; }
+				} else if (pkg.main) {
+					var m = loadAsFileSync(path.resolve(x, pkg.main));
+					if (m) { return m; }
+				}
+			}
+
+			return loadAsFileSync(x + '/index');
+		}
+
+		function loadNodeModulesSync(x, start) {
+			var dirs = nodeModulesPathsSync(start);
+			for (var i = 0; i < dirs.length; i++) {
+				var dir = dirs[i];
+				var m = loadAsFileSync(dir + '/' + x);
+				if (m) { return m; }
+				var n = loadAsDirectorySync(dir + '/' + x);
+				if (n) { return n; }
+			}
+
+			var m = loadAsFileSync(x);
+			if (m) { return m; }
+		}
+
+		function nodeModulesPathsSync(start) {
+			var parts;
+			if (start === '/') { parts = ['']; } else { parts = path.normalize(start).split('/'); }
+
+			var dirs = [];
+			for (var i = parts.length - 1; i >= 0; i--) {
+				if (parts[i] === 'node_modules') { continue; }
+				var dir = parts.slice(0, i + 1).join('/') + '/node_modules';
+				dirs.push(dir);
+			}
+
+			return dirs;
+		}
+	};
+}());
+
+require.alias = function (from, to) {
+	var path = require.modules.path();
+	var res = null;
+	try {
+		res = require.resolve(from + '/package.json', '/');
+	} catch (err) {
+		res = require.resolve(from, '/');
+	}
+	var basedir = path.dirname(res);
+
+	var keys = (Object.keys || function (obj) {
+		var res = [];
+		for (var key in obj) { res.push(key); }
+		return res;
+	})(require.modules);
+
+	for (var i = 0; i < keys.length; i++) {
+		var key = keys[i];
+		if (key.slice(0, basedir.length + 1) === basedir + '/') {
+			var f = key.slice(basedir.length);
+			require.modules[to + f] = require.modules[basedir + f];
+		} else if (key === basedir) {
+			require.modules[to] = require.modules[basedir];
+		}
+	}
+};
+
+require.define = function (filename, fn) {
+	var dirname = require._core[filename]
+		? ''
+		: require.modules.path().dirname(filename);
+	var require_ = function (file) {
+		return require(file, dirname);
+	};
+	require_.resolve = function (name) {
+		return require.resolve(name, dirname);
+	};
+	require_.modules = require.modules;
+	require_.define = require.define;
+	var module_ = { exports: {} };
+
+	require.modules[filename] = function () {
+		require.modules[filename]._cached = module_.exports;
+		fn.call(
+			module_.exports,
+			require_,
+			module_,
+			module_.exports,
+			dirname,
+			filename
+		);
+		require.modules[filename]._cached = module_.exports;
+		return module_.exports;
+	};
+};
+
+if (typeof process === 'undefined') { process = {}; }
+
+if (!process.nextTick) {
+	process.nextTick = (function () {
+		var queue = [];
+		var canPost = typeof window !== 'undefined'
+			&& window.postMessage && window.addEventListener;
+		if (canPost) {
+			window.addEventListener('message', function (ev) {
+				if (ev.source === window && ev.data === 'browserify-tick') {
+					ev.stopPropagation();
+					if (queue.length > 0) {
+						var fn = queue.shift();
+						fn();
+					}
+				}
+			}, true);
+		}
+
+		return function (fn) {
+			if (canPost) {
+				queue.push(fn);
+				window.postMessage('browserify-tick', '*');
+			} else { setTimeout(fn, 0); }
+		};
+	}());
+}
+
+if (!process.title) { process.title = 'browser'; }
+
+if (!process.binding) {
+	process.binding = function (name) {
+		if (name === 'evals') { return require('vm'); }
+		throw new Error('No such module');
+	};
+}
+
+if (!process.cwd) { process.cwd = function () { return '.'; }; }
+
+if (!process.env) { process.env = {}; }
+if (!process.argv) { process.argv = []; }
+
+require.define('path', function (require, module, exports, __dirname, __filename) {
+	function filter(xs, fn) {
+		var res = [];
+		for (var i = 0; i < xs.length; i++) {
+			if (fn(xs[i], i, xs)) { res.push(xs[i]); }
+		}
+		return res;
+	}
+
+	// resolves . and .. elements in a path array with directory names there
+	// must be no slashes, empty elements, or device names (c:\) in the array
+	// (so also no leading and trailing slashes - it does not distinguish
+	// relative and absolute paths)
+	function normalizeArray(parts, allowAboveRoot) {
+		// if the path tries to go above the root, `up` ends up > 0
+		var up = 0;
+		for (var i = parts.length; i >= 0; i--) {
+			var last = parts[i];
+			if (last == '.') {
+				parts.splice(i, 1);
+			} else if (last === '..') {
+				parts.splice(i, 1);
+				up++;
+			} else if (up) {
+				parts.splice(i, 1);
+				up--;
+			}
+		}
+
+		// if the path is allowed to go above the root, restore leading ..s
+		if (allowAboveRoot) {
+			for (; up--; up) {
+				parts.unshift('..');
+			}
+		}
+
+		return parts;
+	}
+
+	// Regex to split a filename into [*, dir, basename, ext]
+	// posix version
+	var splitPathRe = /^(.+\/(?!$)|\/)?((?:.+?)?(\.[^.]*)?)$/;
+
+	// path.resolve([from ...], to)
+	// posix version
+	exports.resolve = function () {
+		var resolvedPath = '',
+			resolvedAbsolute = false;
+
+		for (var i = arguments.length; i >= -1 && !resolvedAbsolute; i--) {
+			var path = i >= 0
+				? arguments[i]
+				: process.cwd();
+
+			// Skip empty and invalid entries
+			if (typeof path !== 'string' || !path) {
+				continue;
+			}
+
+			resolvedPath = path + '/' + resolvedPath;
+			resolvedAbsolute = path.charAt(0) === '/';
+		}
+
+		// At this point the path should be resolved to a full absolute path, but
+		// handle relative paths to be safe (might happen when process.cwd() fails)
+
+		// Normalize the path
+		resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function (p) {
+			return !!p;
+		}), !resolvedAbsolute).join('/');
+
+		return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+	};
+
+	// path.normalize(path)
+	// posix version
+	exports.normalize = function (path) {
+		var isAbsolute = path.charAt(0) === '/',
+			trailingSlash = path.slice(-1) === '/';
+
+		// Normalize the path
+		path = normalizeArray(filter(path.split('/'), function (p) {
+			return !!p;
+		}), !isAbsolute).join('/');
+
+		if (!path && !isAbsolute) {
+			path = '.';
+		}
+		if (path && trailingSlash) {
+			path += '/';
+		}
+
+		return (isAbsolute ? '/' : '') + path;
+	};
+
+	// posix version
+	exports.join = function () {
+		var paths = Array.prototype.slice.call(arguments, 0);
+		return exports.normalize(filter(paths, function (p, index) {
+			return p && typeof p === 'string';
+		}).join('/'));
+	};
+
+	exports.dirname = function (path) {
+		var dir = splitPathRe.exec(path)[1] || '';
+		var isWindows = false;
+		if (!dir) {
+			// No dirname
+			return '.';
+		} else if (
+			dir.length === 1
+			|| (isWindows && dir.length <= 3 && dir.charAt(1) === ':')
+		) {
+			// It is just a slash or a drive letter with a slash
+			return dir;
+		}
+		// It is a full dirname, strip trailing slash
+		return dir.substring(0, dir.length - 1);
+
+	};
+
+	exports.basename = function (path, ext) {
+		var f = splitPathRe.exec(path)[2] || '';
+		// TODO: make this comparison case-insensitive on windows?
+		if (ext && f.substr(-1 * ext.length) === ext) {
+			f = f.substr(0, f.length - ext.length);
+		}
+		return f;
+	};
+
+	exports.extname = function (path) {
+		return splitPathRe.exec(path)[3] || '';
+	};
+
+});
+
+require.define('crypto', function (require, module, exports, __dirname, __filename) {
+	module.exports = require('crypto-browserify');
+});
+
+require.define('/node_modules/crypto-browserify/package.json', function (require, module, exports, __dirname, __filename) {
+	module.exports = {};
+});
+
+require.define('/node_modules/crypto-browserify/index.js', function (require, module, exports, __dirname, __filename) {
+	var sha = require('./sha');
+
+	var algorithms = {
+		sha1: {
+			hex: sha.hex_sha1,
+			binary: sha.b64_sha1,
+			ascii: sha.str_sha1
+		}
+	};
+
+	function error() {
+		var m = Array.prototype.slice.call(arguments).join(' ');
+		throw new Error(m+'\nwe accept pull requests\nhttp://github.com/browserify/crypto-browserify'.join('\n'));
+	}
+
+	exports.createHash = function (alg) {
+		alg = alg || 'sha1';
+		if (!algorithms[alg]) { error('algorithm:', alg, 'is not yet supported'); }
+		var s = '';
+		_alg = algorithms[alg];
+		return {
+			update: function (data) {
+				s += data;
+				return this;
+			},
+			digest: function (enc) {
+				enc = enc || 'binary';
+				var fn;
+				if (!(fn = _alg[enc])) { error('encoding:', enc, 'is not yet supported for algorithm', alg); }
+				var r = fn(s);
+				s = null; // not meant to use the hash after you've called digest.
+				return r;
+			}
+		};
+	}
+	// the least I can do is make error messages for the rest of the node.js/crypto api.
+	;[
+		'createCredentials',
+		'createHmac',
+		'createCypher',
+		'createCypheriv',
+		'createDecipher',
+		'createDecipheriv',
+		'createSign',
+		'createVerify',
+		'createDeffieHellman',,
+		'pbkdf2',,
+		'randomBytes'
+	].forEach(function (name) {
+		exports[name] = function () {
+			error('sorry,', name, 'is not implemented yet');
+		};
+	});
+
+});
+
+require.define('/node_modules/crypto-browserify/sha.js', function (require, module, exports, __dirname, __filename) {
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+	exports.hex_sha1 = hex_sha1;
+	exports.b64_sha1 = b64_sha1;
+	exports.str_sha1 = str_sha1;
+	exports.hex_hmac_sha1 = hex_hmac_sha1;
+	exports.b64_hmac_sha1 = b64_hmac_sha1;
+	exports.str_hmac_sha1 = str_hmac_sha1;
+
+	/*
+ * Configurable variables. You may need to tweak these to be compatible with
+ * the server-side, but the defaults work in most cases.
+ */
+	var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
+	var b64pad = ''; /* base-64 pad character. "=" for strict RFC compliance */
+	var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */
+
+	/*
+ * These are the functions you'll usually want to call
+ * They take string arguments and return either hex or base-64 encoded strings
+ */
+	function hex_sha1(s) { return binb2hex(core_sha1(str2binb(s), s.length * chrsz)); }
+	function b64_sha1(s) { return binb2b64(core_sha1(str2binb(s), s.length * chrsz)); }
+	function str_sha1(s) { return binb2str(core_sha1(str2binb(s), s.length * chrsz)); }
+	function hex_hmac_sha1(key, data) { return binb2hex(core_hmac_sha1(key, data)); }
+	function b64_hmac_sha1(key, data) { return binb2b64(core_hmac_sha1(key, data)); }
+	function str_hmac_sha1(key, data) { return binb2str(core_hmac_sha1(key, data)); }
+
+	/*
+ * Perform a simple self-test to see if the VM is working
+ */
+	function sha1_vm_test() 	{
+		return hex_sha1('abc') == 'a9993e364706816aba3e25717850c26c9cd0d89d';
+	}
+
+	/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+	function core_sha1(x, len) 	{
+		/* append padding */
+		x[len >> 5] |= 0x80 << (24 - len % 32);
+		x[((len + 64 >> 9) << 4) + 15] = len;
+
+		var w = Array(80);
+		var a = 1732584193;
+		var b = -271733879;
+		var c = -1732584194;
+		var d = 271733878;
+		var e = -1009589776;
+
+		for (var i = 0; i < x.length; i += 16) {
+			var olda = a;
+			var oldb = b;
+			var oldc = c;
+			var oldd = d;
+			var olde = e;
+
+			for (var j = 0; j < 80; j++) {
+				if (j < 16) { w[j] = x[i + j]; } else { w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1); }
+				var t = safe_add(
+					safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+					safe_add(safe_add(e, w[j]), sha1_kt(j))
+				);
+				e = d;
+				d = c;
+				c = rol(b, 30);
+				b = a;
+				a = t;
+			}
+
+			a = safe_add(a, olda);
+			b = safe_add(b, oldb);
+			c = safe_add(c, oldc);
+			d = safe_add(d, oldd);
+			e = safe_add(e, olde);
+		}
+		return Array(a, b, c, d, e);
+
+	}
+
+	/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+	function sha1_ft(t, b, c, d) 	{
+		if (t < 20) { return (b & c) | (~b & d); }
+		if (t < 40) { return b ^ c ^ d; }
+		if (t < 60) { return (b & c) | (b & d) | (c & d); }
+		return b ^ c ^ d;
+	}
+
+	/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+	function sha1_kt(t) 	{
+		return t < 20 ? 1518500249 : t < 40 ? 1859775393
+			: t < 60 ? -1894007588 : -899497514;
+	}
+
+	/*
+ * Calculate the HMAC-SHA1 of a key and some data
+ */
+	function core_hmac_sha1(key, data) 	{
+		var bkey = str2binb(key);
+		if (bkey.length > 16) { bkey = core_sha1(bkey, key.length * chrsz); }
+
+		var ipad = Array(16),
+			opad = Array(16);
+		for (var i = 0; i < 16; i++) {
+			ipad[i] = bkey[i] ^ 0x36363636;
+			opad[i] = bkey[i] ^ 0x5C5C5C5C;
+		}
+
+		var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
+		return core_sha1(opad.concat(hash), 512 + 160);
+	}
+
+	/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+	function safe_add(x, y) 	{
+		var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+		var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+		return (msw << 16) | (lsw & 0xFFFF);
+	}
+
+	/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+	function rol(num, cnt) 	{
+		return (num << cnt) | (num >>> (32 - cnt));
+	}
+
+	/*
+ * Convert an 8-bit or 16-bit string to an array of big-endian words
+ * In 8-bit function, characters >255 have their hi-byte silently ignored.
+ */
+	function str2binb(str) 	{
+		var bin = Array();
+		var mask = (1 << chrsz) - 1;
+		for (var i = 0; i < str.length * chrsz; i += chrsz) { bin[i >> 5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i % 32); }
+		return bin;
+	}
+
+	/*
+ * Convert an array of big-endian words to a string
+ */
+	function binb2str(bin) 	{
+		var str = '';
+		var mask = (1 << chrsz) - 1;
+		for (var i = 0; i < bin.length * 32; i += chrsz) { str += String.fromCharCode((bin[i >> 5] >>> (32 - chrsz - i % 32)) & mask); }
+		return str;
+	}
+
+	/*
+ * Convert an array of big-endian words to a hex string.
+ */
+	function binb2hex(binarray) 	{
+		var hex_tab = hexcase ? '0123456789ABCDEF' : '0123456789abcdef';
+		var str = '';
+		for (var i = 0; i < binarray.length * 4; i++) {
+			str += hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xF) + hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8)) & 0xF);
+		}
+		return str;
+	}
+
+	/*
+ * Convert an array of big-endian words to a base-64 string
+ */
+	function binb2b64(binarray) 	{
+		var tab = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+		var str = '';
+		for (var i = 0; i < binarray.length * 4; i += 3) {
+			var triplet = (((binarray[i >> 2] >> 8 * (3 - i % 4)) & 0xFF) << 16) | (((binarray[i + 1 >> 2] >> 8 * (3 - (i + 1) % 4)) & 0xFF) << 8) | ((binarray[i + 2 >> 2] >> 8 * (3 - (i + 2) % 4)) & 0xFF);
+			for (var j = 0; j < 4; j++) {
+				if (i * 8 + j * 6 > binarray.length * 32) { str += b64pad; } else { str += tab.charAt((triplet >> 6 * (3 - j)) & 0x3F); }
+			}
+		}
+		return str;
+	}
+
+});
+
+require.define('/test.js', function (require, module, exports, __dirname, __filename) {
+	var crypto = require('crypto');
+	var abc = crypto.createHash('sha1').update('abc').digest('hex');
+	console.log(abc);
+	// require('hello').inlineCall().call2()
+
+});
+require('/test.js');

node_modules/crypto-browserify/example/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+<script src=bundle.js></script>
+<body>
+	<pre>
+		require('crypto').createHash('sha1').update('abc').digest('hex') == '<span id=ans></span>'
+	</pre>
+</body>
+<script>
+	document.getElementById('ans').innerHTML = require('crypto').createHash('sha1').update('abc').digest('hex')
+</script>
+</html>

node_modules/crypto-browserify/example/test.js

@@ -0,0 +1,6 @@
+'use strict';
+
+var crypto = require('crypto');
+var abc = crypto.createHash('sha1').update('abc').digest('hex');
+console.log(abc);
+// require('hello').inlineCall().call2()

node_modules/crypto-browserify/index.js

@@ -0,0 +1,103 @@
+'use strict';
+
+// eslint-disable-next-line no-multi-assign
+exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes');
+
+// eslint-disable-next-line no-multi-assign
+exports.createHash = exports.Hash = require('create-hash');
+
+// eslint-disable-next-line no-multi-assign
+exports.createHmac = exports.Hmac = require('create-hmac');
+
+var algos = require('browserify-sign/algos');
+var algoKeys = Object.keys(algos);
+var hashes = [
+	'sha1',
+	'sha224',
+	'sha256',
+	'sha384',
+	'sha512',
+	'md5',
+	'rmd160'
+].concat(algoKeys);
+
+exports.getHashes = function () {
+	return hashes;
+};
+
+var p = require('pbkdf2');
+exports.pbkdf2 = p.pbkdf2;
+exports.pbkdf2Sync = p.pbkdf2Sync;
+
+var aes = require('browserify-cipher');
+
+exports.Cipher = aes.Cipher;
+exports.createCipher = aes.createCipher;
+exports.Cipheriv = aes.Cipheriv;
+exports.createCipheriv = aes.createCipheriv;
+exports.Decipher = aes.Decipher;
+exports.createDecipher = aes.createDecipher;
+exports.Decipheriv = aes.Decipheriv;
+exports.createDecipheriv = aes.createDecipheriv;
+exports.getCiphers = aes.getCiphers;
+exports.listCiphers = aes.listCiphers;
+
+var dh = require('diffie-hellman');
+
+exports.DiffieHellmanGroup = dh.DiffieHellmanGroup;
+exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
+exports.getDiffieHellman = dh.getDiffieHellman;
+exports.createDiffieHellman = dh.createDiffieHellman;
+exports.DiffieHellman = dh.DiffieHellman;
+
+var sign = require('browserify-sign');
+
+exports.createSign = sign.createSign;
+exports.Sign = sign.Sign;
+exports.createVerify = sign.createVerify;
+exports.Verify = sign.Verify;
+
+exports.createECDH = require('create-ecdh');
+
+var publicEncrypt = require('public-encrypt');
+
+exports.publicEncrypt = publicEncrypt.publicEncrypt;
+exports.privateEncrypt = publicEncrypt.privateEncrypt;
+exports.publicDecrypt = publicEncrypt.publicDecrypt;
+exports.privateDecrypt = publicEncrypt.privateDecrypt;
+
+// the least I can do is make error messages for the rest of the node.js/crypto api.
+// [
+//   'createCredentials'
+// ].forEach(function (name) {
+//   exports[name] = function () {
+//     throw new Error('sorry, ' + name + ' is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
+//   };
+// });
+
+var rf = require('randomfill');
+
+exports.randomFill = rf.randomFill;
+exports.randomFillSync = rf.randomFillSync;
+
+exports.createCredentials = function () {
+	throw new Error('sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
+};
+
+exports.constants = {
+	DH_CHECK_P_NOT_SAFE_PRIME: 2,
+	DH_CHECK_P_NOT_PRIME: 1,
+	DH_UNABLE_TO_CHECK_GENERATOR: 4,
+	DH_NOT_SUITABLE_GENERATOR: 8,
+	NPN_ENABLED: 1,
+	ALPN_ENABLED: 1,
+	RSA_PKCS1_PADDING: 1,
+	RSA_SSLV23_PADDING: 2,
+	RSA_NO_PADDING: 3,
+	RSA_PKCS1_OAEP_PADDING: 4,
+	RSA_X931_PADDING: 5,
+	RSA_PKCS1_PSS_PADDING: 6,
+	POINT_CONVERSION_COMPRESSED: 2,
+	POINT_CONVERSION_UNCOMPRESSED: 4,
+	POINT_CONVERSION_HYBRID: 6
+};

node_modules/crypto-browserify/package.json

@@ -0,0 +1,54 @@
+{
+	"author": "Dominic Tarr <dominic.tarr@gmail.com> (dominictarr.com)",
+	"name": "crypto-browserify",
+	"description": "implementation of crypto for the browser",
+	"version": "3.12.1",
+	"homepage": "https://github.com/browserify/crypto-browserify",
+	"sideEffects": false,
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/browserify/crypto-browserify.git"
+	},
+	"scripts": {
+		"lint": "eslint --ext=js,mjs .",
+		"pretest": "npm run lint",
+		"tests-only": "nyc tape 'test/**/*.js'",
+		"test": "npm run tests-only",
+		"posttest": "npx npm@'>=10.2' audit --production"
+	},
+	"funding": {
+		"url": "https://github.com/sponsors/ljharb"
+	},
+	"engines": {
+		"node": ">= 0.10"
+	},
+	"dependencies": {
+		"browserify-cipher": "^1.0.1",
+		"browserify-sign": "^4.2.3",
+		"create-ecdh": "^4.0.4",
+		"create-hash": "^1.2.0",
+		"create-hmac": "^1.1.7",
+		"diffie-hellman": "^5.0.3",
+		"hash-base": "~3.0.4",
+		"inherits": "^2.0.4",
+		"pbkdf2": "^3.1.2",
+		"public-encrypt": "^4.0.3",
+		"randombytes": "^2.1.0",
+		"randomfill": "^1.0.4"
+	},
+	"devDependencies": {
+		"@ljharb/eslint-config": "^21.1.1",
+		"eslint": "=8.8.0",
+		"hash-test-vectors": "^1.3.2",
+		"nyc": "^10.3.2",
+		"object.entries": "^1.1.8",
+		"pseudorandombytes": "^2.0.0",
+		"safe-buffer": "^5.2.1",
+		"semver": "^6.3.1",
+		"tape": "^5.9.0"
+	},
+	"browser": {
+		"crypto": false
+	},
+	"license": "MIT"
+}

node_modules/crypto-browserify/test/aes.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var test = require('tape');
+var bcCrypto = require('browserify-cipher/browser');
+var bcCyphers = bcCrypto.getCiphers();
+var randomBytes = require('pseudorandombytes');
+
+for (var i = 0; i < 4; i += 1) {
+	bcCrypto.listCiphers().forEach(function (cipher) {
+		test('run: ' + i, function (t) {
+			/* eslint no-loop-func: 0 */
+			t.test('ciphers: ' + cipher, function (st) {
+				st.plan(1);
+				var data = randomBytes(562);
+				var password = randomBytes(20);
+				var crypter = bcCrypto.createCipher(cipher, password);
+				var decrypter = bcCrypto.createDecipher(cipher, password);
+				var out = [];
+				out.push(decrypter.update(crypter.update(data)));
+				out.push(decrypter.update(crypter['final']()));
+				if (cipher.indexOf('gcm') > -1) {
+					decrypter.setAuthTag(crypter.getAuthTag());
+				}
+				out.push(decrypter['final']());
+
+				st.equals(data.toString('hex'), Buffer.concat(out).toString('hex'));
+			});
+		});
+	});
+}
+
+test('getCiphers', function (t) {
+	t.plan(1);
+	t.ok(bcCyphers.length, 'get ciphers returns an array');
+});
+
+// eslint-disable-next-line global-require
+test('through crypto browserify works', { skip: !require('crypto').createCipher && 'node 22+ removes createCipher' }, function (t) {
+	t.plan(2);
+	var crypto = require('../'); // eslint-disable-line global-require
+	var cipher = 'aes-128-ctr';
+	var data = randomBytes(562);
+	var password = randomBytes(20);
+	var crypter = crypto.createCipher(cipher, password);
+	var decrypter = crypto.createDecipher(cipher, password);
+	var out = [];
+	out.push(decrypter.update(crypter.update(data)));
+	out.push(decrypter.update(crypter['final']()));
+	out.push(decrypter['final']());
+
+	t.equals(data.toString('hex'), Buffer.concat(out).toString('hex'));
+
+	t.ok(crypto.getCiphers().length, 'get ciphers returns an array');
+});

node_modules/crypto-browserify/test/create-hash.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var test = require('tape');
+var satisfies = require('semver').satisfies;
+
+var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'];
+var encodings = ['hex', 'base64']; // FIXME: test binary
+var vectors = require('hash-test-vectors');
+
+function runTest(name, createHash, algorithm) {
+	var isUnsupported = satisfies(process.version, '^17') && (
+		algorithm === 'rmd160'
+		|| algorithm === 'hmac(rmd160)'
+	);
+	test(
+		name + ' test ' + algorithm + ' against test vectors',
+		{ skip: isUnsupported && 'this node version does not support ' + algorithm },
+		function (t) {
+			vectors.forEach(function (obj, i) {
+				var input = new Buffer(obj.input, 'base64');
+				var node = obj[algorithm];
+				var js = createHash(algorithm).update(input).digest('hex');
+				t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node);
+
+				encodings.forEach(function (encoding) {
+					var eInput = new Buffer(obj.input, 'base64').toString(encoding);
+					var eNode = obj[algorithm];
+					var eJS = createHash(algorithm).update(eInput, encoding).digest('hex');
+					t.equal(eJS, eNode, algorithm + '(testVector[' + i + '], ' + encoding + ') == ' + eNode);
+				});
+				input = new Buffer(obj.input, 'base64');
+				node = obj[algorithm];
+				var hash = createHash(algorithm);
+				hash.end(input);
+				js = hash.read().toString('hex');
+				t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node);
+			});
+
+			t.end();
+		}
+	);
+}
+
+function testLib(name, createHash) {
+	algorithms.forEach(function (algorithm) {
+		runTest(name, createHash, algorithm);
+	});
+}
+
+testLib('createHash in crypto-browserify', require('../').createHash);
+testLib('create-hash/browser', require('create-hash/browser'));

node_modules/crypto-browserify/test/create-hmac.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var test = require('tape');
+var satisfies = require('semver').satisfies;
+
+var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'];
+var vectors = require('hash-test-vectors/hmac');
+
+function testLib(name, createHmac) {
+	algorithms.forEach(function (alg) {
+		var isUnsupported = satisfies(process.version, '^17') && (
+			alg === 'rmd160'
+			|| alg === 'hmac(rmd160)'
+		);
+		test(
+			name + ' hmac(' + alg + ')',
+			{ skip: isUnsupported && 'this node version does not support ' + alg },
+			function (t) {
+				vectors.forEach(function (input) {
+					var output = createHmac(alg, new Buffer(input.key, 'hex'))
+						.update(input.data, 'hex').digest();
+
+					output = input.truncate ? output.slice(0, input.truncate) : output;
+					output = output.toString('hex');
+					t.equal(output, input[alg]);
+				});
+
+				t.end();
+			}
+		);
+
+		test(
+			'hmac(' + alg + ')',
+			{ skip: isUnsupported && 'this node version does not support ' + alg },
+			function (t) {
+				vectors.forEach(function (input) {
+					var hmac = createHmac(alg, new Buffer(input.key, 'hex'));
+
+					hmac.end(input.data, 'hex');
+					var output = hmac.read();
+
+					output = input.truncate ? output.slice(0, input.truncate) : output;
+					output = output.toString('hex');
+					t.equal(output, input[alg]);
+				});
+
+				t.end();
+			}
+		);
+	});
+}
+
+testLib('createHmac in crypto-browserify', require('../').createHmac);
+testLib('create-hmac/browser', require('create-hmac/browser'));

node_modules/crypto-browserify/test/dh.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var test = require('tape');
+var crypto = require('diffie-hellman/browser');
+
+test('diffie-hellman mod groups', function (t) {
+	[
+		'modp1',
+		'modp2',
+		'modp5',
+		'modp14',
+		'modp15',
+		'modp16'
+	].forEach(function (mod) {
+		t.test(mod, function (st) {
+			st.plan(3);
+			var dh1 = crypto.getDiffieHellman(mod);
+			var p1 = dh1.getPrime().toString('hex');
+			dh1.generateKeys();
+			var dh2 = crypto.getDiffieHellman(mod);
+			var p2 = dh2.getPrime().toString('hex');
+			dh2.generateKeys();
+			st.equals(p1, p2, 'equal primes');
+			var pubk1 = dh1.getPublicKey();
+			var pubk2 = dh2.getPublicKey();
+			st.notEquals(pubk1, pubk2, 'diff public keys');
+			var pub1 = dh1.computeSecret(pubk2).toString('hex');
+			var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
+			st.equals(pub1, pub2, 'equal secrets');
+		});
+	});
+});
+
+test('diffie-hellman key lengths', function (t) {
+	[
+		64,
+		65,
+		192
+	].forEach(function (len) {
+		t.test(String(len), function (st) {
+			st.plan(3);
+			var dh2 = crypto.createDiffieHellman(len);
+			var prime2 = dh2.getPrime();
+			var p2 = prime2.toString('hex');
+			var dh1 = crypto.createDiffieHellman(prime2);
+			var p1 = dh1.getPrime().toString('hex');
+			dh1.generateKeys();
+			dh2.generateKeys();
+			st.equals(p1, p2, 'equal primes');
+
+			var pubk1 = dh1.getPublicKey();
+			var pubk2 = dh2.getPublicKey();
+			st.notEquals(pubk1, pubk2, 'diff public keys');
+
+			var pub1 = dh1.computeSecret(pubk2).toString('hex');
+			var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
+			st.equals(pub1, pub2, 'equal secrets');
+		});
+	});
+});

node_modules/crypto-browserify/test/ecdh.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var mods = [
+	'secp256k1',
+	'secp224r1',
+	'prime256v1',
+	'prime192v1'
+];
+var test = require('tape');
+var createECDH1 = require('../').createECDH;
+var createECDH2 = require('create-ecdh/browser');
+
+mods.forEach(function (mod) {
+	test('createECDH: ' + mod + ' uncompressed', function (t) {
+		t.plan(2);
+		var dh1 = createECDH1(mod);
+		dh1.generateKeys();
+		var dh2 = createECDH2(mod);
+		dh2.generateKeys();
+		var pubk1 = dh1.getPublicKey();
+		var pubk2 = dh2.getPublicKey();
+		t.notEquals(pubk1.toString('hex'), pubk2.toString('hex'), 'diff public keys');
+		var pub1 = dh1.computeSecret(pubk2).toString('hex');
+		var pub2 = dh2.computeSecret(pubk1).toString('hex');
+		t.equals(pub1, pub2, 'equal secrets');
+	});
+
+	test('createECDH: ' + mod + ' compressed', function (t) {
+		t.plan(2);
+		var dh1 = createECDH1(mod);
+		dh1.generateKeys();
+		var dh2 = createECDH2(mod);
+		dh2.generateKeys();
+		var pubk1 = dh1.getPublicKey(null, 'compressed');
+		var pubk2 = dh2.getPublicKey(null, 'compressed');
+		t.notEquals(pubk1.toString('hex'), pubk2.toString('hex'), 'diff public keys');
+		var pub1 = dh1.computeSecret(pubk2).toString('hex');
+		var pub2 = dh2.computeSecret(pubk1).toString('hex');
+		t.equals(pub1, pub2, 'equal secrets');
+	});
+
+	test('createECDH: ' + mod + ' set stuff', function (t) {
+		t.plan(5);
+		var dh1 = createECDH1(mod);
+		var dh2 = createECDH2(mod);
+		dh1.generateKeys();
+		dh2.generateKeys();
+		dh1.setPrivateKey(dh2.getPrivateKey());
+		dh1.setPublicKey(dh2.getPublicKey());
+		var priv1 = dh1.getPrivateKey('hex');
+		var priv2 = dh2.getPrivateKey('hex');
+		t.equals(priv1, priv2, 'same private key');
+		var pubk1 = dh1.getPublicKey();
+		var pubk2 = dh2.getPublicKey();
+		t.equals(pubk1.toString('hex'), pubk2.toString('hex'), 'same public keys, uncompressed');
+		t.equals(dh1.getPublicKey('hex', 'compressed'), dh2.getPublicKey('hex', 'compressed'), 'same public keys compressed');
+		t.equals(dh1.getPublicKey('hex', 'hybrid'), dh2.getPublicKey('hex', 'hybrid'), 'same public keys hybrid');
+		var pub1 = dh1.computeSecret(pubk2).toString('hex');
+		var pub2 = dh2.computeSecret(pubk1).toString('hex');
+		t.equals(pub1, pub2, 'equal secrets');
+	});
+});

node_modules/crypto-browserify/test/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/* eslint-disable global-require */
+
+require('./create-hash');
+require('./create-hmac');
+if (!process.browser) {
+	require('./dh');
+}
+
+require('./pbkdf2');
+try {
+	require('randombytes')(8);
+	require('./ecdh');
+	require('./public-encrypt');
+	require('./random-bytes');
+	require('./sign');
+	require('./random-fill');
+} catch (e) {
+	console.log('no secure rng avaiable');
+}
+require('./aes');

node_modules/crypto-browserify/test/node/dh.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var test = require('tape');
+var cryptoB = require('../../');
+var crypto = require('crypto');
+var satisfies = require('semver').satisfies;
+
+test('diffie-hellman mod groups', function (t) {
+	[
+		'modp1',
+		'modp2',
+		'modp5',
+		'modp14',
+		'modp15',
+		'modp16'
+	].forEach(function (mod) {
+		t.test(mod, function (st) {
+			st.plan(3);
+			var dh1 = cryptoB.getDiffieHellman(mod);
+			var p1 = dh1.getPrime().toString('hex');
+			dh1.generateKeys();
+
+			var dh2 = crypto.getDiffieHellman(mod);
+			var p2 = dh2.getPrime().toString('hex');
+			dh2.generateKeys();
+			st.equals(p1, p2, 'equal primes');
+
+			var pubk1 = dh1.getPublicKey();
+			var pubk2 = dh2.getPublicKey();
+			st.notEquals(pubk1, pubk2, 'diff public keys');
+
+			var pub1 = dh1.computeSecret(pubk2).toString('hex');
+			var pub2 = dh2.computeSecret(pubk1).toString('hex');
+			st.equals(pub1, pub2, 'equal secrets');
+		});
+	});
+});
+
+test('diffie-hellman key lengths', function (t) {
+	[
+		64,
+		65,
+		192,
+		512,
+		1024
+	].forEach(function (len) {
+		var modulusTooSmall = satisfies(process.version, '>= 17') && len < 512;
+		t.test(String(len), { skip: modulusTooSmall && 'node 17+ requires a length >= 512' }, function (st) {
+			var dh2 = cryptoB.createDiffieHellman(len);
+			var prime2 = dh2.getPrime();
+			var p2 = prime2.toString('hex');
+			var dh1 = crypto.createDiffieHellman(prime2);
+			var p1 = dh1.getPrime().toString('hex');
+			dh1.generateKeys();
+			dh2.generateKeys();
+			st.equals(p1, p2, 'equal primes');
+
+			var pubk1 = dh1.getPublicKey();
+			var pubk2 = dh2.getPublicKey();
+			st.notEquals(pubk1, pubk2, 'diff public keys');
+
+			var pub1 = dh1.computeSecret(pubk2).toString('hex');
+			var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
+			st.equals(pub1, pub2, 'equal secrets');
+
+			st.end();
+		});
+	});
+});

node_modules/crypto-browserify/test/pbkdf2.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var tape = require('tape');
+var crypto = require('pbkdf2/browser');
+
+var vectors = require('hash-test-vectors/pbkdf2');
+
+tape('pbkdf2', function (t) {
+	vectors.forEach(function (input) {
+		// skip inputs that will take way too long
+		if (input.iterations > 10000) { return; }
+
+		var key = crypto.pbkdf2Sync(input.password, input.salt, input.iterations, input.length);
+
+		if (key.toString('hex') !== input.sha1) {
+			console.log(input);
+		}
+
+		t.equal(key.toString('hex'), input.sha1);
+	});
+
+	t.end();
+});

node_modules/crypto-browserify/test/public-encrypt.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var test = require('tape');
+var crypto1 = require('../');
+var rsa = {
+	'private': '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',
+	'public': '2d2d2d2d2d424547494e20525341205055424c4943204b45592d2d2d2d2d0a4d49494242674b422f6779376d6a615767506546645659445a5752434139424e69763370506230657332372b464b593068737a4c614f773437457843744157700a4473483438545841667948425977424c67756179666b344c4749757078622b43474d62526f337845703043626659314a62793236543976476a524331666f48440a44554a4738347561526279487161663469367a74346756522b786c4145496a6b614641414b38634f6f58415431435671474c4c6c6a554363684c38506a61486a0a2f7972695a2f53377264776c49334c6e41427877776d4c726d522f7637315774706d4f2f614e47384e2b31706f2b5177616768546b79513539452f5a7641754f0a6b4657486f6b32712f523650594161326a645a397a696d3046714f502b6e6b5161454452624246426d4271547635664647666b32577341664b662f5247302f560a46642b5a654d353235315465547658483639356e6c53476175566c3941674d424141453d0a2d2d2d2d2d454e4420525341205055424c4943204b45592d2d2d2d2d0a'
+};
+var crypto2 = require('public-encrypt/browser');
+rsa['private'] = new Buffer(rsa['private'], 'hex');
+rsa['public'] = new Buffer(rsa['public'], 'hex');
+
+var encrypted = '0bcd6462ad7a563be2d42b0b73e0b0a163886304e7723b025f97605144fe1781e84acdc4031327d6bccd67fe13183e8fbdc8c5fe947b49d011ce3ebb08b11e83b87a77328ca57ee77cfdc78743b0749366643d7a21b2abcd4aa32dee9832938445540ee3007b7a70191c8dc9ff2ad76fe8dfaa5362d9d2c4b31a67b816d7b7970a293cb95bf3437a301bedb9f431b7075aa2f9df77b4385bea2a37982beda467260b384a58258b5eb4e36a0e0bf7dff83589636f5f97bf542084f0f76868c9f3f989a27fee5b8cd2bfee0bae1eae958df7c3184e5a40fda101196214f371606feca4330b221f30577804bbd4f61578a84e85dcd298849f509e630d275280';
+
+test('publicEncrypt/privateDecrypt', function (t) {
+	t.test('can decrypt', function (st) {
+		st.plan(2);
+		// note encryption is ranomized so can't test to see if they encrypt the same
+		st.equals(crypto1.privateDecrypt(rsa['private'], new Buffer(encrypted, 'hex')).toString(), 'hello there I am a nice message', 'decrypt it properly');
+		st.equals(crypto2.privateDecrypt(rsa['private'], new Buffer(encrypted, 'hex')).toString(), 'hello there I am a nice message', 'decrypt it properly');
+	});
+	t.test('can round trip', function (st) {
+		st.plan(2);
+		var msg = 'this is a message';
+		// note encryption is ranomized so can't test to see if they encrypt the same
+		st.equals(crypto1.privateDecrypt(rsa['private'], crypto2.publicEncrypt(rsa['public'], new Buffer(msg))).toString(), msg, 'round trip it');
+		st.equals(crypto2.privateDecrypt(rsa['private'], crypto1.publicEncrypt(rsa['public'], new Buffer(msg))).toString(), msg, 'round trip it');
+	});
+});
+
+test('privateEncrypt/publicDecrypt', function (t) {
+	t.test('can round trip', function (st) {
+		st.plan(2);
+		var msg = 'this is a message';
+		// note encryption is ranomized so can't test to see if they encrypt the same
+		st.equals(crypto1.publicDecrypt(rsa['public'], crypto2.privateEncrypt(rsa['private'], new Buffer(msg))).toString(), msg, 'round trip it');
+		st.equals(crypto2.publicDecrypt(rsa['public'], crypto1.privateEncrypt(rsa['private'], new Buffer(msg))).toString(), msg, 'round trip it');
+	});
+});

node_modules/crypto-browserify/test/random-bytes.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var test = require('tape');
+var crypto = require('../');
+var randomBytes = require('randombytes');
+var entries = require('object.entries');
+
+var randomBytesFunctions = {
+	randomBytes: randomBytes,
+	pseudoRandomBytes: crypto.pseudoRandomBytes
+};
+
+// Both randomBytes and pseudoRandomBytes should provide the same interface
+entries(randomBytesFunctions).forEach(function (entry) {
+	var randomBytesName = entry[0];
+	var randomBytesFn = entry[1];
+
+	test('get error message', function (t) {
+		try {
+			var b = randomBytesFn(10);
+			t.ok(Buffer.isBuffer(b));
+			t.end();
+		} catch (err) {
+			t.ok((/not supported/).test(err.message), '"not supported" is in error message');
+			t.end();
+		}
+	});
+
+	test(randomBytesName, function (t) {
+		t.plan(5);
+		t.equal(randomBytesFn(10).length, 10);
+		t.ok(Buffer.isBuffer(randomBytesFn(10)));
+		randomBytesFn(10, function (ex, bytes) {
+			t.error(ex);
+			t.equal(bytes.length, 10);
+			t.ok(Buffer.isBuffer(bytes));
+			t.end();
+		});
+	});
+
+	test(randomBytesName + ' seem random', function (t) {
+		var L = 1000;
+		var buffer = randomBytesFn(L);
+
+		var mean = Array.prototype.reduce.call(buffer, function (a, b) { return a + b; }, 0) / L;
+
+		// test that the random numbers are plausably random.
+		// Math.random() will pass this, but this will catch
+		// terrible mistakes such as this blunder:
+		// https://github.com/browserify/crypto-browserify/commit/3267955e1df7edd1680e52aeede9a89506ed2464#commitcomment-7916835
+
+		// this doesn't check that the bytes are in a random *order*
+		// but it's better than nothing.
+
+		var expected = 256 / 2;
+		var smean = Math.sqrt(mean);
+
+		// console.log doesn't work right on testling, *grumble grumble*
+		console.log(JSON.stringify([expected - smean, mean, expected + smean]));
+		t.ok(mean < expected + smean);
+		t.ok(mean > expected - smean);
+
+		t.end();
+	});
+});

node_modules/crypto-browserify/test/random-fill.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var test = require('tape');
+var crypto = require('../');
+var Buffer = require('safe-buffer').Buffer;
+
+test('get error message', function (t) {
+	try {
+		var b = crypto.randomFillSync(Buffer.alloc(10));
+		t.ok(Buffer.isBuffer(b));
+		t.end();
+	} catch (err) {
+		t.ok((/not supported/).test(err.message), '"not supported" is in error message');
+		t.end();
+	}
+});
+
+test('randomfill', function (t) {
+	t.plan(5);
+	t.equal(crypto.randomFillSync(Buffer.alloc(10)).length, 10);
+	t.ok(Buffer.isBuffer(crypto.randomFillSync(Buffer.alloc(10))));
+	crypto.randomFill(Buffer.alloc(10), function (ex, bytes) {
+		t.error(ex);
+		t.equal(bytes.length, 10);
+		t.ok(Buffer.isBuffer(bytes));
+		t.end();
+	});
+});
+
+test('seems random', function (t) {
+	var L = 1000;
+	var buffer = crypto.randomFillSync(Buffer.alloc(L));
+
+	var mean = Array.prototype.reduce.call(buffer, function (a, b) {
+		return a + b;
+	}, 0) / L;
+
+	// test that the random numbers are plausably random.
+	// Math.random() will pass this, but this will catch
+	// terrible mistakes such as this blunder:
+	// https://github.com/browserify/crypto-browserify/commit/3267955e1df7edd1680e52aeede9a89506ed2464#commitcomment-7916835
+
+	// this doesn't check that the bytes are in a random *order*
+	// but it's better than nothing.
+
+	var expected = 256 / 2;
+	var smean = Math.sqrt(mean);
+
+	// console.log doesn't work right on testling, *grumble grumble*
+	console.log(JSON.stringify([expected - smean, mean, expected + smean]));
+	t.ok(mean < expected + smean);
+	t.ok(mean > expected - smean);
+
+	t.end();
+});

node_modules/crypto-browserify/test/sign.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var test = require('tape');
+var nodeCrypto = require('../');
+var ourCrypto = require('browserify-sign/browser');
+
+var rsa = {
+	'private': '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',
+	'public': '2d2d2d2d2d424547494e20525341205055424c4943204b45592d2d2d2d2d0a4d49494242674b422f6779376d6a615767506546645659445a5752434139424e69763370506230657332372b464b593068737a4c614f773437457843744157700a4473483438545841667948425977424c67756179666b344c4749757078622b43474d62526f337845703043626659314a62793236543976476a524331666f48440a44554a4738347561526279487161663469367a74346756522b786c4145496a6b614641414b38634f6f58415431435671474c4c6c6a554363684c38506a61486a0a2f7972695a2f53377264776c49334c6e41427877776d4c726d522f7637315774706d4f2f614e47384e2b31706f2b5177616768546b79513539452f5a7641754f0a6b4657486f6b32712f523650594161326a645a397a696d3046714f502b6e6b5161454452624246426d4271547635664647666b32577341664b662f5247302f560a46642b5a654d353235315465547658483639356e6c53476175566c3941674d424141453d0a2d2d2d2d2d454e4420525341205055424c4943204b45592d2d2d2d2d0a'
+};
+
+var ec = {
+	'private': '2d2d2d2d2d424547494e2045432050524956415445204b45592d2d2d2d2d0a4d485143415145454944463658763853762f2f77475557442b6337383070704772553051645a5743417a78415150515838722f756f416347425375424241414b0a6f55514451674145495a656f7744796c6c73344b2f7766426a4f313862596f37674778386e595152696a6134652f71454d696b4f484a616937676565557265550a7235586b792f4178377332644774656773504e7350674765354d705176673d3d0a2d2d2d2d2d454e442045432050524956415445204b45592d2d2d2d2d0a',
+	'public': '2d2d2d2d2d424547494e205055424c4943204b45592d2d2d2d2d0a4d465977454159484b6f5a497a6a3043415159464b34454541416f4451674145495a656f7744796c6c73344b2f7766426a4f313862596f37674778386e5951520a696a6134652f71454d696b4f484a616937676565557265557235586b792f4178377332644774656773504e7350674765354d705176673d3d0a2d2d2d2d2d454e44205055424c4943204b45592d2d2d2d2d0a'
+};
+
+rsa['private'] = new Buffer(rsa['private'], 'hex');
+rsa['public'] = new Buffer(rsa['public'], 'hex');
+ec['private'] = new Buffer(ec['private'], 'hex');
+ec['public'] = new Buffer(ec['public'], 'hex');
+
+function testit(keys, message, scheme) {
+	var pub = keys['public'];
+	var priv = keys['private'];
+	test(message.toString(), function (t) {
+		t.test('js sign and verify', function (st) {
+			st.plan(1);
+			var mySign = ourCrypto.createSign(scheme);
+			var mySig = mySign.update(message).sign(priv);
+			var myVer = ourCrypto.createVerify(scheme);
+			st.ok(myVer.update(message).verify(pub, mySig), 'validates');
+		});
+
+		t.test('node sign and verify', function (st) {
+			st.plan(1);
+			var mySign = nodeCrypto.createSign(scheme);
+			var mySig = mySign.update(message).sign(priv);
+			var myVer = nodeCrypto.createVerify(scheme);
+			st.ok(myVer.update(message).verify(pub, mySig), 'validates');
+		});
+
+		t.test('node sign and js verify', function (st) {
+			st.plan(1);
+			var mySign = nodeCrypto.createSign(scheme);
+			var mySig = mySign.update(message).sign(priv);
+			var myVer = ourCrypto.createVerify(scheme);
+			st.ok(myVer.update(message).verify(pub, mySig), 'validates');
+		});
+
+		t.test('js sign and node verify', function (st) {
+			st.plan(1);
+			var mySign = ourCrypto.createSign(scheme);
+			var mySig = mySign.update(message).sign(priv);
+			var myVer = nodeCrypto.createVerify(scheme);
+			st.ok(myVer.update(message).verify(pub, mySig), 'validates');
+		});
+	});
+}
+
+testit(rsa, new Buffer('rsa with sha256'), 'RSA-SHA256');
+testit(ec, new Buffer('ec with sha1'), 'sha256');