@ocap/mcrypto 1.29.5 → 1.29.6

package/esm/node_modules/hash.js/lib/hash/sha/common.mjs

@@ -0,0 +1,46 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_utils } from "../utils.mjs";
+
+//#region ../../node_modules/hash.js/lib/hash/sha/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var rotr32 = require_utils().rotr32;
+	function ft_1(s, x, y, z) {
+		if (s === 0) return ch32(x, y, z);
+		if (s === 1 || s === 3) return p32(x, y, z);
+		if (s === 2) return maj32(x, y, z);
+	}
+	exports.ft_1 = ft_1;
+	function ch32(x, y, z) {
+		return x & y ^ ~x & z;
+	}
+	exports.ch32 = ch32;
+	function maj32(x, y, z) {
+		return x & y ^ x & z ^ y & z;
+	}
+	exports.maj32 = maj32;
+	function p32(x, y, z) {
+		return x ^ y ^ z;
+	}
+	exports.p32 = p32;
+	function s0_256(x) {
+		return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
+	}
+	exports.s0_256 = s0_256;
+	function s1_256(x) {
+		return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
+	}
+	exports.s1_256 = s1_256;
+	function g0_256(x) {
+		return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
+	}
+	exports.g0_256 = g0_256;
+	function g1_256(x) {
+		return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
+	}
+	exports.g1_256 = g1_256;
+}));
+
+//#endregion
+export default require_common();
+
+export { require_common };

package/esm/node_modules/hash.js/lib/hash/sha.mjs

@@ -0,0 +1,20 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require__1 } from "./sha/1.mjs";
+import { require__256 } from "./sha/256.mjs";
+import { require__224 } from "./sha/224.mjs";
+import { require__512 } from "./sha/512.mjs";
+import { require__384 } from "./sha/384.mjs";
+
+//#region ../../node_modules/hash.js/lib/hash/sha.js
+var require_sha = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.sha1 = require__1();
+	exports.sha224 = require__224();
+	exports.sha256 = require__256();
+	exports.sha384 = require__384();
+	exports.sha512 = require__512();
+}));
+
+//#endregion
+export default require_sha();
+
+export { require_sha };

package/esm/node_modules/hash.js/lib/hash/utils.mjs

@@ -0,0 +1,211 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_minimalistic_assert } from "../../../minimalistic-assert/index.mjs";
+import { require_inherits } from "../../../inherits/inherits.mjs";
+
+//#region ../../node_modules/hash.js/lib/hash/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var assert = require_minimalistic_assert();
+	var inherits = require_inherits();
+	exports.inherits = inherits;
+	function isSurrogatePair(msg, i) {
+		if ((msg.charCodeAt(i) & 64512) !== 55296) return false;
+		if (i < 0 || i + 1 >= msg.length) return false;
+		return (msg.charCodeAt(i + 1) & 64512) === 56320;
+	}
+	function toArray(msg, enc) {
+		if (Array.isArray(msg)) return msg.slice();
+		if (!msg) return [];
+		var res = [];
+		if (typeof msg === "string") {
+			if (!enc) {
+				var p = 0;
+				for (var i = 0; i < msg.length; i++) {
+					var c = msg.charCodeAt(i);
+					if (c < 128) res[p++] = c;
+					else if (c < 2048) {
+						res[p++] = c >> 6 | 192;
+						res[p++] = c & 63 | 128;
+					} else if (isSurrogatePair(msg, i)) {
+						c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
+						res[p++] = c >> 18 | 240;
+						res[p++] = c >> 12 & 63 | 128;
+						res[p++] = c >> 6 & 63 | 128;
+						res[p++] = c & 63 | 128;
+					} else {
+						res[p++] = c >> 12 | 224;
+						res[p++] = c >> 6 & 63 | 128;
+						res[p++] = c & 63 | 128;
+					}
+				}
+			} else if (enc === "hex") {
+				msg = msg.replace(/[^a-z0-9]+/gi, "");
+				if (msg.length % 2 !== 0) msg = "0" + msg;
+				for (i = 0; i < msg.length; i += 2) res.push(parseInt(msg[i] + msg[i + 1], 16));
+			}
+		} else for (i = 0; i < msg.length; i++) res[i] = msg[i] | 0;
+		return res;
+	}
+	exports.toArray = toArray;
+	function toHex(msg) {
+		var res = "";
+		for (var i = 0; i < msg.length; i++) res += zero2(msg[i].toString(16));
+		return res;
+	}
+	exports.toHex = toHex;
+	function htonl(w) {
+		return (w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24) >>> 0;
+	}
+	exports.htonl = htonl;
+	function toHex32(msg, endian) {
+		var res = "";
+		for (var i = 0; i < msg.length; i++) {
+			var w = msg[i];
+			if (endian === "little") w = htonl(w);
+			res += zero8(w.toString(16));
+		}
+		return res;
+	}
+	exports.toHex32 = toHex32;
+	function zero2(word) {
+		if (word.length === 1) return "0" + word;
+		else return word;
+	}
+	exports.zero2 = zero2;
+	function zero8(word) {
+		if (word.length === 7) return "0" + word;
+		else if (word.length === 6) return "00" + word;
+		else if (word.length === 5) return "000" + word;
+		else if (word.length === 4) return "0000" + word;
+		else if (word.length === 3) return "00000" + word;
+		else if (word.length === 2) return "000000" + word;
+		else if (word.length === 1) return "0000000" + word;
+		else return word;
+	}
+	exports.zero8 = zero8;
+	function join32(msg, start, end, endian) {
+		var len = end - start;
+		assert(len % 4 === 0);
+		var res = new Array(len / 4);
+		for (var i = 0, k = start; i < res.length; i++, k += 4) {
+			var w;
+			if (endian === "big") w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];
+			else w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
+			res[i] = w >>> 0;
+		}
+		return res;
+	}
+	exports.join32 = join32;
+	function split32(msg, endian) {
+		var res = new Array(msg.length * 4);
+		for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
+			var m = msg[i];
+			if (endian === "big") {
+				res[k] = m >>> 24;
+				res[k + 1] = m >>> 16 & 255;
+				res[k + 2] = m >>> 8 & 255;
+				res[k + 3] = m & 255;
+			} else {
+				res[k + 3] = m >>> 24;
+				res[k + 2] = m >>> 16 & 255;
+				res[k + 1] = m >>> 8 & 255;
+				res[k] = m & 255;
+			}
+		}
+		return res;
+	}
+	exports.split32 = split32;
+	function rotr32(w, b) {
+		return w >>> b | w << 32 - b;
+	}
+	exports.rotr32 = rotr32;
+	function rotl32(w, b) {
+		return w << b | w >>> 32 - b;
+	}
+	exports.rotl32 = rotl32;
+	function sum32(a, b) {
+		return a + b >>> 0;
+	}
+	exports.sum32 = sum32;
+	function sum32_3(a, b, c) {
+		return a + b + c >>> 0;
+	}
+	exports.sum32_3 = sum32_3;
+	function sum32_4(a, b, c, d) {
+		return a + b + c + d >>> 0;
+	}
+	exports.sum32_4 = sum32_4;
+	function sum32_5(a, b, c, d, e) {
+		return a + b + c + d + e >>> 0;
+	}
+	exports.sum32_5 = sum32_5;
+	function sum64(buf, pos, ah, al) {
+		var bh = buf[pos];
+		var lo = al + buf[pos + 1] >>> 0;
+		buf[pos] = (lo < al ? 1 : 0) + ah + bh >>> 0;
+		buf[pos + 1] = lo;
+	}
+	exports.sum64 = sum64;
+	function sum64_hi(ah, al, bh, bl) {
+		return (al + bl >>> 0 < al ? 1 : 0) + ah + bh >>> 0;
+	}
+	exports.sum64_hi = sum64_hi;
+	function sum64_lo(ah, al, bh, bl) {
+		return al + bl >>> 0;
+	}
+	exports.sum64_lo = sum64_lo;
+	function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
+		var carry = 0;
+		var lo = al;
+		lo = lo + bl >>> 0;
+		carry += lo < al ? 1 : 0;
+		lo = lo + cl >>> 0;
+		carry += lo < cl ? 1 : 0;
+		lo = lo + dl >>> 0;
+		carry += lo < dl ? 1 : 0;
+		return ah + bh + ch + dh + carry >>> 0;
+	}
+	exports.sum64_4_hi = sum64_4_hi;
+	function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
+		return al + bl + cl + dl >>> 0;
+	}
+	exports.sum64_4_lo = sum64_4_lo;
+	function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+		var carry = 0;
+		var lo = al;
+		lo = lo + bl >>> 0;
+		carry += lo < al ? 1 : 0;
+		lo = lo + cl >>> 0;
+		carry += lo < cl ? 1 : 0;
+		lo = lo + dl >>> 0;
+		carry += lo < dl ? 1 : 0;
+		lo = lo + el >>> 0;
+		carry += lo < el ? 1 : 0;
+		return ah + bh + ch + dh + eh + carry >>> 0;
+	}
+	exports.sum64_5_hi = sum64_5_hi;
+	function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+		return al + bl + cl + dl + el >>> 0;
+	}
+	exports.sum64_5_lo = sum64_5_lo;
+	function rotr64_hi(ah, al, num) {
+		return (al << 32 - num | ah >>> num) >>> 0;
+	}
+	exports.rotr64_hi = rotr64_hi;
+	function rotr64_lo(ah, al, num) {
+		return (ah << 32 - num | al >>> num) >>> 0;
+	}
+	exports.rotr64_lo = rotr64_lo;
+	function shr64_hi(ah, al, num) {
+		return ah >>> num;
+	}
+	exports.shr64_hi = shr64_hi;
+	function shr64_lo(ah, al, num) {
+		return (ah << 32 - num | al >>> num) >>> 0;
+	}
+	exports.shr64_lo = shr64_lo;
+}));
+
+//#endregion
+export default require_utils();
+
+export { require_utils };

package/esm/node_modules/hash.js/lib/hash.mjs

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../../_virtual/rolldown_runtime.mjs";
+import { require_utils } from "./hash/utils.mjs";
+import { require_common } from "./hash/common.mjs";
+import { require_sha } from "./hash/sha.mjs";
+import { require_ripemd } from "./hash/ripemd.mjs";
+import { require_hmac } from "./hash/hmac.mjs";
+
+//#region ../../node_modules/hash.js/lib/hash.js
+var require_hash = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var hash = exports;
+	hash.utils = require_utils();
+	hash.common = require_common();
+	hash.sha = require_sha();
+	hash.ripemd = require_ripemd();
+	hash.hmac = require_hmac();
+	hash.sha1 = hash.sha.sha1;
+	hash.sha256 = hash.sha.sha256;
+	hash.sha224 = hash.sha.sha224;
+	hash.sha384 = hash.sha.sha384;
+	hash.sha512 = hash.sha.sha512;
+	hash.ripemd160 = hash.ripemd.ripemd160;
+}));
+
+//#endregion
+export default require_hash();
+
+export { require_hash };

package/esm/node_modules/inherits/inherits.mjs

@@ -0,0 +1,20 @@
+import { __commonJSMin, __require } from "../../_virtual/rolldown_runtime.mjs";
+import { require_inherits_browser } from "./inherits_browser.mjs";
+
+//#region ../../node_modules/inherits/inherits.js
+var require_inherits = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	try {
+		var util = __require("util");
+		/* istanbul ignore next */
+		if (typeof util.inherits !== "function") throw "";
+		module.exports = util.inherits;
+	} catch (e) {
+		/* istanbul ignore next */
+		module.exports = require_inherits_browser();
+	}
+}));
+
+//#endregion
+export default require_inherits();
+
+export { require_inherits };

package/esm/node_modules/inherits/inherits_browser.mjs

@@ -0,0 +1,30 @@
+import { __commonJSMin } from "../../_virtual/rolldown_runtime.mjs";
+
+//#region ../../node_modules/inherits/inherits_browser.js
+var require_inherits_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (typeof Object.create === "function") module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			ctor.prototype = Object.create(superCtor.prototype, { constructor: {
+				value: ctor,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			} });
+		}
+	};
+	else module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			var TempCtor = function() {};
+			TempCtor.prototype = superCtor.prototype;
+			ctor.prototype = new TempCtor();
+			ctor.prototype.constructor = ctor;
+		}
+	};
+}));
+
+//#endregion
+export default require_inherits_browser();
+
+export { require_inherits_browser };

package/esm/node_modules/minimalistic-assert/index.mjs

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../_virtual/rolldown_runtime.mjs";
+
+//#region ../../node_modules/minimalistic-assert/index.js
+var require_minimalistic_assert = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = assert;
+	function assert(val, msg) {
+		if (!val) throw new Error(msg || "Assertion failed");
+	}
+	assert.equal = function assertEqual(l, r, msg) {
+		if (l != r) throw new Error(msg || "Assertion failed: " + l + " != " + r);
+	};
+}));
+
+//#endregion
+export default require_minimalistic_assert();
+
+export { require_minimalistic_assert };

package/esm/signer/ed25519.mjs

@@ -1,12 +1,14 @@
+import { __toESM } from "../_virtual/rolldown_runtime.mjs";
 import { encode } from "../encode.mjs";
+import { require_hash } from "../node_modules/hash.js/lib/hash.mjs";
 import signer_default from "../protocols/signer.mjs";
 import { toUint8Array } from "@ocap/util";
 import randomBytes from "randombytes";
-import hashjs from "hash.js";
 import * as ed from "@noble/ed25519";
 
 //#region src/signer/ed25519.ts
-ed.hashes.sha512 = (msg) => new Uint8Array(hashjs.sha512().update(msg).digest());
+var import_hash = /* @__PURE__ */ __toESM(require_hash(), 1);
+ed.hashes.sha512 = (msg) => new Uint8Array(import_hash.default.sha512().update(msg).digest());
 /**
 * Signer implementation for ed25519, based on `@noble/ed25519`
 *

package/lib/_virtual/rolldown_runtime.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
 		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -26,4 +27,5 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 
+exports.__commonJSMin = __commonJSMin;
 exports.__toESM = __toESM;

package/lib/hasher/keccak.cjs

@@ -2,12 +2,19 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_encode = require('../encode.cjs');
 let _ocap_util = require("@ocap/util");
-let js_sha3 = require("js-sha3");
-js_sha3 = require_rolldown_runtime.__toESM(js_sha3);
+let _noble_hashes_sha3_js = require("@noble/hashes/sha3.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 
 //#region src/hasher/keccak.ts
+const hashFns = {
+	keccak_224: _noble_hashes_sha3_js.keccak_224,
+	keccak_256: _noble_hashes_sha3_js.keccak_256,
+	keccak_384: _noble_hashes_sha3_js.keccak_384,
+	keccak_512: _noble_hashes_sha3_js.keccak_512
+};
 /**
 * Keccak support with different hash length
+* Uses @noble/hashes for unified implementation
 *
 * @class KeccakHasher
 */
@@ -20,17 +27,19 @@ var KeccakHasher = class {
 			512
 		].forEach((x) => {
 			const name = `hash${x}`;
-			const hasher = (data) => js_sha3.default[`keccak${x}`](data);
+			const hasher = hashFns[`keccak_${x}`];
 			const hashFn = (input, round) => {
 				if (round === 1) return hasher(input);
 				return hashFn(hasher(input), round - 1);
 			};
 			this[name] = (data, round = 1, encoding = "hex") => {
-				let input = data;
+				let input;
 				try {
 					input = (0, _ocap_util.toUint8Array)(data);
-				} catch (_err) {}
-				return require_encode.encode(`0x${hashFn(input, round)}`, encoding);
+				} catch (_err) {
+					input = data;
+				}
+				return require_encode.encode(`0x${(0, _noble_hashes_utils_js.bytesToHex)(hashFn(input, round))}`, encoding);
 			};
 		});
 	}

package/lib/hasher/keccak.d.cts

@@ -4,6 +4,7 @@ import { BytesType, EncodingType } from "@ocap/util";
 
 /**
  * Keccak support with different hash length
+ * Uses @noble/hashes for unified implementation
  *
  * @class KeccakHasher
  */

package/lib/hasher/sha2.cjs

@@ -2,17 +2,19 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_encode = require('../encode.cjs');
 let _ocap_util = require("@ocap/util");
-let hash_js = require("hash.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
 
 //#region src/hasher/sha2.ts
 const hashFns = {
-	sha224: hash_js.sha224,
-	sha256: hash_js.sha256,
-	sha384: hash_js.sha384,
-	sha512: hash_js.sha512
+	sha224: _noble_hashes_sha2_js.sha224,
+	sha256: _noble_hashes_sha2_js.sha256,
+	sha384: _noble_hashes_sha2_js.sha384,
+	sha512: _noble_hashes_sha2_js.sha512
 };
 /**
 * Sha2 support with different hash length
+* Uses @noble/hashes for better performance
 *
 * @class
 */
@@ -27,11 +29,13 @@ var Sha2Hasher = class {
 			const name = `hash${x}`;
 			const hasher = hashFns[`sha${x}`];
 			const hashFn = (input, round) => {
-				let inputBytes = input;
+				let inputBytes;
 				try {
 					inputBytes = (0, _ocap_util.toUint8Array)(input);
-				} catch (_err) {}
-				if (round === 1) return `0x${hasher().update(inputBytes).digest("hex")}`;
+				} catch (_err) {
+					inputBytes = input;
+				}
+				if (round === 1) return `0x${(0, _noble_hashes_utils_js.bytesToHex)(hasher(inputBytes))}`;
 				return hashFn(hashFn(inputBytes, 1), round - 1);
 			};
 			this[name] = (data, round = 2, encoding = "hex") => {

package/lib/hasher/sha2.d.cts

@@ -4,6 +4,7 @@ import { BytesType, EncodingType } from "@ocap/util";
 
 /**
  * Sha2 support with different hash length
+ * Uses @noble/hashes for better performance
  *
  * @class
  */

package/lib/hasher/sha3.cjs

@@ -2,12 +2,19 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_encode = require('../encode.cjs');
 let _ocap_util = require("@ocap/util");
-let js_sha3 = require("js-sha3");
-js_sha3 = require_rolldown_runtime.__toESM(js_sha3);
+let _noble_hashes_sha3_js = require("@noble/hashes/sha3.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 
 //#region src/hasher/sha3.ts
+const hashFns = {
+	sha3_224: _noble_hashes_sha3_js.sha3_224,
+	sha3_256: _noble_hashes_sha3_js.sha3_256,
+	sha3_384: _noble_hashes_sha3_js.sha3_384,
+	sha3_512: _noble_hashes_sha3_js.sha3_512
+};
 /**
 * Sha3 support with different hash length
+* Uses @noble/hashes for unified implementation
 *
 * @class Sha3Hasher
 */
@@ -20,17 +27,19 @@ var Sha3Hasher = class {
 			512
 		].forEach((x) => {
 			const name = `hash${x}`;
-			const hasher = js_sha3.default[`sha3_${x}`];
+			const hasher = hashFns[`sha3_${x}`];
 			const hashFn = (input, round) => {
 				if (round === 1) return hasher(input);
 				return hashFn(hasher(input), round - 1);
 			};
 			this[name] = (data, round = 1, encoding = "hex") => {
-				let input = data;
+				let input;
 				try {
 					input = (0, _ocap_util.toUint8Array)(data);
-				} catch (_err) {}
-				return require_encode.encode(`0x${hashFn(input, round)}`, encoding);
+				} catch (_err) {
+					input = data;
+				}
+				return require_encode.encode(`0x${(0, _noble_hashes_utils_js.bytesToHex)(hashFn(input, round))}`, encoding);
 			};
 		});
 	}

package/lib/hasher/sha3.d.cts

@@ -4,6 +4,7 @@ import { BytesType, EncodingType } from "@ocap/util";
 
 /**
  * Sha3 support with different hash length
+ * Uses @noble/hashes for unified implementation
  *
  * @class Sha3Hasher
  */

package/lib/node_modules/hash.js/lib/hash/common.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../minimalistic-assert/index.cjs');
+const require_utils$1 = require('./utils.cjs');
+
+//#region ../../node_modules/hash.js/lib/hash/common.js
+var require_common = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports) => {
+	var utils = require_utils$1.default;
+	var assert = require_index.default;
+	function BlockHash() {
+		this.pending = null;
+		this.pendingTotal = 0;
+		this.blockSize = this.constructor.blockSize;
+		this.outSize = this.constructor.outSize;
+		this.hmacStrength = this.constructor.hmacStrength;
+		this.padLength = this.constructor.padLength / 8;
+		this.endian = "big";
+		this._delta8 = this.blockSize / 8;
+		this._delta32 = this.blockSize / 32;
+	}
+	exports.BlockHash = BlockHash;
+	BlockHash.prototype.update = function update(msg, enc) {
+		msg = utils.toArray(msg, enc);
+		if (!this.pending) this.pending = msg;
+		else this.pending = this.pending.concat(msg);
+		this.pendingTotal += msg.length;
+		if (this.pending.length >= this._delta8) {
+			msg = this.pending;
+			var r = msg.length % this._delta8;
+			this.pending = msg.slice(msg.length - r, msg.length);
+			if (this.pending.length === 0) this.pending = null;
+			msg = utils.join32(msg, 0, msg.length - r, this.endian);
+			for (var i = 0; i < msg.length; i += this._delta32) this._update(msg, i, i + this._delta32);
+		}
+		return this;
+	};
+	BlockHash.prototype.digest = function digest(enc) {
+		this.update(this._pad());
+		assert(this.pending === null);
+		return this._digest(enc);
+	};
+	BlockHash.prototype._pad = function pad() {
+		var len = this.pendingTotal;
+		var bytes = this._delta8;
+		var k = bytes - (len + this.padLength) % bytes;
+		var res = new Array(k + this.padLength);
+		res[0] = 128;
+		for (var i = 1; i < k; i++) res[i] = 0;
+		len <<= 3;
+		if (this.endian === "big") {
+			for (var t = 8; t < this.padLength; t++) res[i++] = 0;
+			res[i++] = 0;
+			res[i++] = 0;
+			res[i++] = 0;
+			res[i++] = 0;
+			res[i++] = len >>> 24 & 255;
+			res[i++] = len >>> 16 & 255;
+			res[i++] = len >>> 8 & 255;
+			res[i++] = len & 255;
+		} else {
+			res[i++] = len & 255;
+			res[i++] = len >>> 8 & 255;
+			res[i++] = len >>> 16 & 255;
+			res[i++] = len >>> 24 & 255;
+			res[i++] = 0;
+			res[i++] = 0;
+			res[i++] = 0;
+			res[i++] = 0;
+			for (t = 8; t < this.padLength; t++) res[i++] = 0;
+		}
+		return res;
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_common();
+  }
+});