dexbot 1.4.12 → 1.4.13

package/claw/node_modules/sha.js/README.md

@@ -0,0 +1,44 @@
+# sha.js
+[![NPM Package](https://img.shields.io/npm/v/sha.js.svg?style=flat-square)](https://www.npmjs.org/package/sha.js)
+[![Build Status](https://img.shields.io/travis/crypto-browserify/sha.js.svg?branch=master&style=flat-square)](https://travis-ci.org/crypto-browserify/sha.js)
+[![Dependency status](https://img.shields.io/david/crypto-browserify/sha.js.svg?style=flat-square)](https://david-dm.org/crypto-browserify/sha.js#info=dependencies)
+
+[![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
+
+Node style `SHA` on pure JavaScript.
+
+```js
+var shajs = require('sha.js')
+
+console.log(shajs('sha256').update('42').digest('hex'))
+// => 73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049
+console.log(new shajs.sha256().update('42').digest('hex'))
+// => 73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049
+
+var sha256stream = shajs('sha256')
+sha256stream.end('42')
+console.log(sha256stream.read().toString('hex'))
+// => 73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049
+```
+
+## supported hashes
+`sha.js` currently implements:
+
+  - SHA (SHA-0) -- **legacy, do not use in new systems**
+  - SHA-1 -- **legacy, do not use in new systems**
+  - SHA-224
+  - SHA-256
+  - SHA-384
+  - SHA-512
+
+
+## Not an actual stream
+Note, this doesn't actually implement a stream, but wrapping this in a stream is trivial.
+It does update incrementally, so you can hash things larger than RAM, as it uses a constant amount of memory (except when using base64 or utf8 encoding, see code comments).
+
+
+## Acknowledgements
+This work is derived from Paul Johnston's [A JavaScript implementation of the Secure Hash Algorithm](http://pajhome.org.uk/crypt/md5/sha1.html).
+
+
+## LICENSE [MIT AND BSD-3-Clause](LICENSE)

package/claw/node_modules/sha.js/bin.js

@@ -0,0 +1,44 @@
+#! /usr/bin/env node
+
+'use strict';
+
+var createHash = require('./browserify');
+var argv = process.argv.slice(2);
+
+function pipe(algorithm, s) {
+	var start = Date.now();
+	var hash = createHash(algorithm || 'sha1');
+
+	s.on('data', function (data) {
+		hash.update(data);
+	});
+
+	s.on('end', function () {
+		if (process.env.DEBUG) {
+			console.log(hash.digest('hex'), Date.now() - start);
+		} else {
+			console.log(hash.digest('hex'));
+		}
+	});
+}
+
+function usage() {
+	console.error('sha.js [algorithm=sha1] [filename] # hash filename with algorithm');
+	console.error('input | sha.js [algorithm=sha1]    # hash stdin with algorithm');
+	console.error('sha.js --help                      # display this message');
+}
+
+if (!process.stdin.isTTY) {
+	pipe(argv[0], process.stdin);
+} else if (argv.length) {
+	if ((/--help|-h/).test(argv[0])) {
+		usage();
+	} else {
+		var filename = argv.pop();
+		var algorithm = argv.pop();
+		// eslint-disable-next-line global-require
+		pipe(algorithm, require('fs').createReadStream(filename));
+	}
+} else {
+	usage();
+}

package/claw/node_modules/sha.js/hash.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var Buffer = require('safe-buffer').Buffer;
+var toBuffer = require('to-buffer');
+
+// prototype class for hash functions
+function Hash(blockSize, finalSize) {
+	this._block = Buffer.alloc(blockSize);
+	this._finalSize = finalSize;
+	this._blockSize = blockSize;
+	this._len = 0;
+}
+
+Hash.prototype.update = function (data, enc) {
+	/* eslint no-param-reassign: 0 */
+	data = toBuffer(data, enc || 'utf8');
+
+	var block = this._block;
+	var blockSize = this._blockSize;
+	var length = data.length;
+	var accum = this._len;
+
+	for (var offset = 0; offset < length;) {
+		var assigned = accum % blockSize;
+		var remainder = Math.min(length - offset, blockSize - assigned);
+
+		for (var i = 0; i < remainder; i++) {
+			block[assigned + i] = data[offset + i];
+		}
+
+		accum += remainder;
+		offset += remainder;
+
+		if ((accum % blockSize) === 0) {
+			this._update(block);
+		}
+	}
+
+	this._len += length;
+	return this;
+};
+
+Hash.prototype.digest = function (enc) {
+	var rem = this._len % this._blockSize;
+
+	this._block[rem] = 0x80;
+
+	/*
+	 * zero (rem + 1) trailing bits, where (rem + 1) is the smallest
+	 * non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
+	 */
+	this._block.fill(0, rem + 1);
+
+	if (rem >= this._finalSize) {
+		this._update(this._block);
+		this._block.fill(0);
+	}
+
+	var bits = this._len * 8;
+
+	// uint32
+	if (bits <= 0xffffffff) {
+		this._block.writeUInt32BE(bits, this._blockSize - 4);
+
+		// uint64
+	} else {
+		var lowBits = (bits & 0xffffffff) >>> 0;
+		var highBits = (bits - lowBits) / 0x100000000;
+
+		this._block.writeUInt32BE(highBits, this._blockSize - 8);
+		this._block.writeUInt32BE(lowBits, this._blockSize - 4);
+	}
+
+	this._update(this._block);
+	var hash = this._hash();
+
+	return enc ? hash.toString(enc) : hash;
+};
+
+Hash.prototype._update = function () {
+	throw new Error('_update must be implemented by subclass');
+};
+
+module.exports = Hash;

package/claw/node_modules/sha.js/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = function SHA(algorithm) {
+	var alg = algorithm.toLowerCase();
+
+	var Algorithm = module.exports[alg];
+	if (!Algorithm) {
+		throw new Error(alg + ' is not supported (we accept pull requests)');
+	}
+
+	return new Algorithm();
+};
+
+module.exports.sha = require('./sha');
+module.exports.sha1 = require('./sha1');
+module.exports.sha224 = require('./sha224');
+module.exports.sha256 = require('./sha256');
+module.exports.sha384 = require('./sha384');
+module.exports.sha512 = require('./sha512');

package/claw/node_modules/sha.js/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "sha.js",
+	"description": "Streamable SHA hashes in pure javascript",
+	"version": "2.4.12",
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/crypto-browserify/sha.js.git"
+	},
+	"bin": "./bin.js",
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated",
+		"lint": "eslint --ext=js,mjs .",
+		"pretest": "npm run lint",
+		"test": "npm run tests-only",
+		"tests-only": "tape 'test/**/*.js'",
+		"posttest": "npx npm@'>= 10.2' audit --production",
+		"version": "auto-changelog && git add CHANGELOG.md",
+		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+	},
+	"license": "(MIT AND BSD-3-Clause)",
+	"author": "Dominic Tarr <dominic.tarr@gmail.com> (dominictarr.com)",
+	"funding": {
+		"url": "https://github.com/sponsors/ljharb"
+	},
+	"homepage": "https://github.com/crypto-browserify/sha.js",
+	"dependencies": {
+		"inherits": "^2.0.4",
+		"safe-buffer": "^5.2.1",
+		"to-buffer": "^1.2.0"
+	},
+	"devDependencies": {
+		"@ljharb/eslint-config": "^21.2.0",
+		"auto-changelog": "^2.5.0",
+		"encoding": "^0.1.13",
+		"eslint": "=8.8.0",
+		"hash-test-vectors": "^1.3.2",
+		"npmignore": "^0.3.1",
+		"tape": "^5.9.0",
+		"typedarray": "^0.0.7"
+	},
+	"auto-changelog": {
+		"output": "CHANGELOG.md",
+		"template": "keepachangelog",
+		"unreleased": false,
+		"commitLimit": false,
+		"backfillLimit": false,
+		"hideCredit": true
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows",
+			".github"
+		]
+	},
+	"engines": {
+		"node": ">= 0.10"
+	}
+}

package/claw/node_modules/sha.js/sha.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
+ * in FIPS PUB 180-1
+ * This source code is derived from sha1.js of the same repository.
+ * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
+ * operation was added.
+ */
+
+var inherits = require('inherits');
+var Hash = require('./hash');
+var Buffer = require('safe-buffer').Buffer;
+
+var K = [
+	0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+];
+
+var W = new Array(80);
+
+function Sha() {
+	this.init();
+	this._w = W;
+
+	Hash.call(this, 64, 56);
+}
+
+inherits(Sha, Hash);
+
+Sha.prototype.init = function () {
+	this._a = 0x67452301;
+	this._b = 0xefcdab89;
+	this._c = 0x98badcfe;
+	this._d = 0x10325476;
+	this._e = 0xc3d2e1f0;
+
+	return this;
+};
+
+function rotl5(num) {
+	return (num << 5) | (num >>> 27);
+}
+
+function rotl30(num) {
+	return (num << 30) | (num >>> 2);
+}
+
+function ft(s, b, c, d) {
+	if (s === 0) {
+		return (b & c) | (~b & d);
+	}
+	if (s === 2) {
+		return (b & c) | (b & d) | (c & d);
+	}
+	return b ^ c ^ d;
+}
+
+Sha.prototype._update = function (M) {
+	var w = this._w;
+
+	var a = this._a | 0;
+	var b = this._b | 0;
+	var c = this._c | 0;
+	var d = this._d | 0;
+	var e = this._e | 0;
+
+	for (var i = 0; i < 16; ++i) {
+		w[i] = M.readInt32BE(i * 4);
+	}
+	for (; i < 80; ++i) {
+		w[i] = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
+	}
+
+	for (var j = 0; j < 80; ++j) {
+		var s = ~~(j / 20);
+		var t = (rotl5(a) + ft(s, b, c, d) + e + w[j] + K[s]) | 0;
+
+		e = d;
+		d = c;
+		c = rotl30(b);
+		b = a;
+		a = t;
+	}
+
+	this._a = (a + this._a) | 0;
+	this._b = (b + this._b) | 0;
+	this._c = (c + this._c) | 0;
+	this._d = (d + this._d) | 0;
+	this._e = (e + this._e) | 0;
+};
+
+Sha.prototype._hash = function () {
+	var H = Buffer.allocUnsafe(20);
+
+	H.writeInt32BE(this._a | 0, 0);
+	H.writeInt32BE(this._b | 0, 4);
+	H.writeInt32BE(this._c | 0, 8);
+	H.writeInt32BE(this._d | 0, 12);
+	H.writeInt32BE(this._e | 0, 16);
+
+	return H;
+};
+
+module.exports = Sha;

package/claw/node_modules/sha.js/sha1.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/*
+ * 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.
+ */
+
+var inherits = require('inherits');
+var Hash = require('./hash');
+var Buffer = require('safe-buffer').Buffer;
+
+var K = [
+	0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+];
+
+var W = new Array(80);
+
+function Sha1() {
+	this.init();
+	this._w = W;
+
+	Hash.call(this, 64, 56);
+}
+
+inherits(Sha1, Hash);
+
+Sha1.prototype.init = function () {
+	this._a = 0x67452301;
+	this._b = 0xefcdab89;
+	this._c = 0x98badcfe;
+	this._d = 0x10325476;
+	this._e = 0xc3d2e1f0;
+
+	return this;
+};
+
+function rotl1(num) {
+	return (num << 1) | (num >>> 31);
+}
+
+function rotl5(num) {
+	return (num << 5) | (num >>> 27);
+}
+
+function rotl30(num) {
+	return (num << 30) | (num >>> 2);
+}
+
+function ft(s, b, c, d) {
+	if (s === 0) {
+		return (b & c) | (~b & d);
+	}
+	if (s === 2) {
+		return (b & c) | (b & d) | (c & d);
+	}
+	return b ^ c ^ d;
+}
+
+Sha1.prototype._update = function (M) {
+	var w = this._w;
+
+	var a = this._a | 0;
+	var b = this._b | 0;
+	var c = this._c | 0;
+	var d = this._d | 0;
+	var e = this._e | 0;
+
+	for (var i = 0; i < 16; ++i) {
+		w[i] = M.readInt32BE(i * 4);
+	}
+	for (; i < 80; ++i) {
+		w[i] = rotl1(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]);
+	}
+
+	for (var j = 0; j < 80; ++j) {
+		var s = ~~(j / 20);
+		var t = (rotl5(a) + ft(s, b, c, d) + e + w[j] + K[s]) | 0;
+
+		e = d;
+		d = c;
+		c = rotl30(b);
+		b = a;
+		a = t;
+	}
+
+	this._a = (a + this._a) | 0;
+	this._b = (b + this._b) | 0;
+	this._c = (c + this._c) | 0;
+	this._d = (d + this._d) | 0;
+	this._e = (e + this._e) | 0;
+};
+
+Sha1.prototype._hash = function () {
+	var H = Buffer.allocUnsafe(20);
+
+	H.writeInt32BE(this._a | 0, 0);
+	H.writeInt32BE(this._b | 0, 4);
+	H.writeInt32BE(this._c | 0, 8);
+	H.writeInt32BE(this._d | 0, 12);
+	H.writeInt32BE(this._e | 0, 16);
+
+	return H;
+};
+
+module.exports = Sha1;

package/claw/node_modules/sha.js/sha224.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ *
+ */
+
+var inherits = require('inherits');
+var Sha256 = require('./sha256');
+var Hash = require('./hash');
+var Buffer = require('safe-buffer').Buffer;
+
+var W = new Array(64);
+
+function Sha224() {
+	this.init();
+
+	this._w = W; // new Array(64)
+
+	Hash.call(this, 64, 56);
+}
+
+inherits(Sha224, Sha256);
+
+Sha224.prototype.init = function () {
+	this._a = 0xc1059ed8;
+	this._b = 0x367cd507;
+	this._c = 0x3070dd17;
+	this._d = 0xf70e5939;
+	this._e = 0xffc00b31;
+	this._f = 0x68581511;
+	this._g = 0x64f98fa7;
+	this._h = 0xbefa4fa4;
+
+	return this;
+};
+
+Sha224.prototype._hash = function () {
+	var H = Buffer.allocUnsafe(28);
+
+	H.writeInt32BE(this._a, 0);
+	H.writeInt32BE(this._b, 4);
+	H.writeInt32BE(this._c, 8);
+	H.writeInt32BE(this._d, 12);
+	H.writeInt32BE(this._e, 16);
+	H.writeInt32BE(this._f, 20);
+	H.writeInt32BE(this._g, 24);
+
+	return H;
+};
+
+module.exports = Sha224;

package/claw/node_modules/sha.js/sha256.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ *
+ */
+
+var inherits = require('inherits');
+var Hash = require('./hash');
+var Buffer = require('safe-buffer').Buffer;
+
+var K = [
+	0x428A2F98,
+	0x71374491,
+	0xB5C0FBCF,
+	0xE9B5DBA5,
+	0x3956C25B,
+	0x59F111F1,
+	0x923F82A4,
+	0xAB1C5ED5,
+	0xD807AA98,
+	0x12835B01,
+	0x243185BE,
+	0x550C7DC3,
+	0x72BE5D74,
+	0x80DEB1FE,
+	0x9BDC06A7,
+	0xC19BF174,
+	0xE49B69C1,
+	0xEFBE4786,
+	0x0FC19DC6,
+	0x240CA1CC,
+	0x2DE92C6F,
+	0x4A7484AA,
+	0x5CB0A9DC,
+	0x76F988DA,
+	0x983E5152,
+	0xA831C66D,
+	0xB00327C8,
+	0xBF597FC7,
+	0xC6E00BF3,
+	0xD5A79147,
+	0x06CA6351,
+	0x14292967,
+	0x27B70A85,
+	0x2E1B2138,
+	0x4D2C6DFC,
+	0x53380D13,
+	0x650A7354,
+	0x766A0ABB,
+	0x81C2C92E,
+	0x92722C85,
+	0xA2BFE8A1,
+	0xA81A664B,
+	0xC24B8B70,
+	0xC76C51A3,
+	0xD192E819,
+	0xD6990624,
+	0xF40E3585,
+	0x106AA070,
+	0x19A4C116,
+	0x1E376C08,
+	0x2748774C,
+	0x34B0BCB5,
+	0x391C0CB3,
+	0x4ED8AA4A,
+	0x5B9CCA4F,
+	0x682E6FF3,
+	0x748F82EE,
+	0x78A5636F,
+	0x84C87814,
+	0x8CC70208,
+	0x90BEFFFA,
+	0xA4506CEB,
+	0xBEF9A3F7,
+	0xC67178F2
+];
+
+var W = new Array(64);
+
+function Sha256() {
+	this.init();
+
+	this._w = W; // new Array(64)
+
+	Hash.call(this, 64, 56);
+}
+
+inherits(Sha256, Hash);
+
+Sha256.prototype.init = function () {
+	this._a = 0x6a09e667;
+	this._b = 0xbb67ae85;
+	this._c = 0x3c6ef372;
+	this._d = 0xa54ff53a;
+	this._e = 0x510e527f;
+	this._f = 0x9b05688c;
+	this._g = 0x1f83d9ab;
+	this._h = 0x5be0cd19;
+
+	return this;
+};
+
+function ch(x, y, z) {
+	return z ^ (x & (y ^ z));
+}
+
+function maj(x, y, z) {
+	return (x & y) | (z & (x | y));
+}
+
+function sigma0(x) {
+	return ((x >>> 2) | (x << 30)) ^ ((x >>> 13) | (x << 19)) ^ ((x >>> 22) | (x << 10));
+}
+
+function sigma1(x) {
+	return ((x >>> 6) | (x << 26)) ^ ((x >>> 11) | (x << 21)) ^ ((x >>> 25) | (x << 7));
+}
+
+function gamma0(x) {
+	return ((x >>> 7) | (x << 25)) ^ ((x >>> 18) | (x << 14)) ^ (x >>> 3);
+}
+
+function gamma1(x) {
+	return ((x >>> 17) | (x << 15)) ^ ((x >>> 19) | (x << 13)) ^ (x >>> 10);
+}
+
+Sha256.prototype._update = function (M) {
+	var w = this._w;
+
+	var a = this._a | 0;
+	var b = this._b | 0;
+	var c = this._c | 0;
+	var d = this._d | 0;
+	var e = this._e | 0;
+	var f = this._f | 0;
+	var g = this._g | 0;
+	var h = this._h | 0;
+
+	for (var i = 0; i < 16; ++i) {
+		w[i] = M.readInt32BE(i * 4);
+	}
+	for (; i < 64; ++i) {
+		w[i] = (gamma1(w[i - 2]) + w[i - 7] + gamma0(w[i - 15]) + w[i - 16]) | 0;
+	}
+
+	for (var j = 0; j < 64; ++j) {
+		var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + w[j]) | 0;
+		var T2 = (sigma0(a) + maj(a, b, c)) | 0;
+
+		h = g;
+		g = f;
+		f = e;
+		e = (d + T1) | 0;
+		d = c;
+		c = b;
+		b = a;
+		a = (T1 + T2) | 0;
+	}
+
+	this._a = (a + this._a) | 0;
+	this._b = (b + this._b) | 0;
+	this._c = (c + this._c) | 0;
+	this._d = (d + this._d) | 0;
+	this._e = (e + this._e) | 0;
+	this._f = (f + this._f) | 0;
+	this._g = (g + this._g) | 0;
+	this._h = (h + this._h) | 0;
+};
+
+Sha256.prototype._hash = function () {
+	var H = Buffer.allocUnsafe(32);
+
+	H.writeInt32BE(this._a, 0);
+	H.writeInt32BE(this._b, 4);
+	H.writeInt32BE(this._c, 8);
+	H.writeInt32BE(this._d, 12);
+	H.writeInt32BE(this._e, 16);
+	H.writeInt32BE(this._f, 20);
+	H.writeInt32BE(this._g, 24);
+	H.writeInt32BE(this._h, 28);
+
+	return H;
+};
+
+module.exports = Sha256;