@ocap/mcrypto 1.29.5 → 1.29.6

package/esm/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,32 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __commonJSMin, __require, __toESM };

package/esm/hasher/keccak.d.mts

@@ -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/esm/hasher/keccak.mjs

@@ -1,10 +1,18 @@
 import { encode } from "../encode.mjs";
 import { toUint8Array } from "@ocap/util";
-import sha3 from "js-sha3";
+import { keccak_224, keccak_256, keccak_384, keccak_512 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
 
 //#region src/hasher/keccak.ts
+const hashFns = {
+	keccak_224,
+	keccak_256,
+	keccak_384,
+	keccak_512
+};
 /**
 * Keccak support with different hash length
+* Uses @noble/hashes for unified implementation
 *
 * @class KeccakHasher
 */
@@ -17,17 +25,19 @@ var KeccakHasher = class {
 			512
 		].forEach((x) => {
 			const name = `hash${x}`;
-			const hasher = (data) => sha3[`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 = toUint8Array(data);
-				} catch (_err) {}
-				return encode(`0x${hashFn(input, round)}`, encoding);
+				} catch (_err) {
+					input = data;
+				}
+				return encode(`0x${bytesToHex(hashFn(input, round))}`, encoding);
 			};
 		});
 	}

package/esm/hasher/sha2.d.mts

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

package/esm/hasher/sha2.mjs

@@ -1,7 +1,7 @@
 import { encode } from "../encode.mjs";
 import { toUint8Array } from "@ocap/util";
-import _hash_js from "hash.js";
-const { sha224, sha256, sha384, sha512 } = _hash_js;
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { sha224, sha256, sha384, sha512 } from "@noble/hashes/sha2.js";
 
 //#region src/hasher/sha2.ts
 const hashFns = {
@@ -12,6 +12,7 @@ const hashFns = {
 };
 /**
 * Sha2 support with different hash length
+* Uses @noble/hashes for better performance
 *
 * @class
 */
@@ -26,11 +27,13 @@ var Sha2Hasher = class {
 			const name = `hash${x}`;
 			const hasher = hashFns[`sha${x}`];
 			const hashFn = (input, round) => {
-				let inputBytes = input;
+				let inputBytes;
 				try {
 					inputBytes = toUint8Array(input);
-				} catch (_err) {}
-				if (round === 1) return `0x${hasher().update(inputBytes).digest("hex")}`;
+				} catch (_err) {
+					inputBytes = input;
+				}
+				if (round === 1) return `0x${bytesToHex(hasher(inputBytes))}`;
 				return hashFn(hashFn(inputBytes, 1), round - 1);
 			};
 			this[name] = (data, round = 2, encoding = "hex") => {

package/esm/hasher/sha3.d.mts

@@ -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/esm/hasher/sha3.mjs

@@ -1,10 +1,18 @@
 import { encode } from "../encode.mjs";
 import { toUint8Array } from "@ocap/util";
-import sha3 from "js-sha3";
+import { sha3_224, sha3_256, sha3_384, sha3_512 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
 
 //#region src/hasher/sha3.ts
+const hashFns = {
+	sha3_224,
+	sha3_256,
+	sha3_384,
+	sha3_512
+};
 /**
 * Sha3 support with different hash length
+* Uses @noble/hashes for unified implementation
 *
 * @class Sha3Hasher
 */
@@ -17,17 +25,19 @@ var Sha3Hasher = class {
 			512
 		].forEach((x) => {
 			const name = `hash${x}`;
-			const hasher = sha3[`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 = toUint8Array(data);
-				} catch (_err) {}
-				return encode(`0x${hashFn(input, round)}`, encoding);
+				} catch (_err) {
+					input = data;
+				}
+				return encode(`0x${bytesToHex(hashFn(input, round))}`, encoding);
 			};
 		});
 	}

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

@@ -0,0 +1,77 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_minimalistic_assert } from "../../../minimalistic-assert/index.mjs";
+import { require_utils } from "./utils.mjs";
+
+//#region ../../node_modules/hash.js/lib/hash/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var utils = require_utils();
+	var assert = require_minimalistic_assert();
+	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
+export default require_common();
+
+export { require_common };

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

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_minimalistic_assert } from "../../../minimalistic-assert/index.mjs";
+import { require_utils } from "./utils.mjs";
+
+//#region ../../node_modules/hash.js/lib/hash/hmac.js
+var require_hmac = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var utils = require_utils();
+	var assert = require_minimalistic_assert();
+	function Hmac(hash, key, enc) {
+		if (!(this instanceof Hmac)) return new Hmac(hash, key, enc);
+		this.Hash = hash;
+		this.blockSize = hash.blockSize / 8;
+		this.outSize = hash.outSize / 8;
+		this.inner = null;
+		this.outer = null;
+		this._init(utils.toArray(key, enc));
+	}
+	module.exports = Hmac;
+	Hmac.prototype._init = function init(key) {
+		if (key.length > this.blockSize) key = new this.Hash().update(key).digest();
+		assert(key.length <= this.blockSize);
+		for (var i = key.length; i < this.blockSize; i++) key.push(0);
+		for (i = 0; i < key.length; i++) key[i] ^= 54;
+		this.inner = new this.Hash().update(key);
+		for (i = 0; i < key.length; i++) key[i] ^= 106;
+		this.outer = new this.Hash().update(key);
+	};
+	Hmac.prototype.update = function update(msg, enc) {
+		this.inner.update(msg, enc);
+		return this;
+	};
+	Hmac.prototype.digest = function digest(enc) {
+		this.outer.update(this.inner.digest());
+		return this.outer.digest(enc);
+	};
+}));
+
+//#endregion
+export default require_hmac();
+
+export { require_hmac };

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

@@ -0,0 +1,422 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_utils } from "./utils.mjs";
+import { require_common } from "./common.mjs";
+
+//#region ../../node_modules/hash.js/lib/hash/ripemd.js
+var require_ripemd = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var utils = require_utils();
+	var common = require_common();
+	var rotl32 = utils.rotl32;
+	var sum32 = utils.sum32;
+	var sum32_3 = utils.sum32_3;
+	var sum32_4 = utils.sum32_4;
+	var BlockHash = common.BlockHash;
+	function RIPEMD160() {
+		if (!(this instanceof RIPEMD160)) return new RIPEMD160();
+		BlockHash.call(this);
+		this.h = [
+			1732584193,
+			4023233417,
+			2562383102,
+			271733878,
+			3285377520
+		];
+		this.endian = "little";
+	}
+	utils.inherits(RIPEMD160, BlockHash);
+	exports.ripemd160 = RIPEMD160;
+	RIPEMD160.blockSize = 512;
+	RIPEMD160.outSize = 160;
+	RIPEMD160.hmacStrength = 192;
+	RIPEMD160.padLength = 64;
+	RIPEMD160.prototype._update = function update(msg, start) {
+		var A = this.h[0];
+		var B = this.h[1];
+		var C = this.h[2];
+		var D = this.h[3];
+		var E = this.h[4];
+		var Ah = A;
+		var Bh = B;
+		var Ch = C;
+		var Dh = D;
+		var Eh = E;
+		for (var j = 0; j < 80; j++) {
+			var T = sum32(rotl32(sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), s[j]), E);
+			A = E;
+			E = D;
+			D = rotl32(C, 10);
+			C = B;
+			B = T;
+			T = sum32(rotl32(sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), sh[j]), Eh);
+			Ah = Eh;
+			Eh = Dh;
+			Dh = rotl32(Ch, 10);
+			Ch = Bh;
+			Bh = T;
+		}
+		T = sum32_3(this.h[1], C, Dh);
+		this.h[1] = sum32_3(this.h[2], D, Eh);
+		this.h[2] = sum32_3(this.h[3], E, Ah);
+		this.h[3] = sum32_3(this.h[4], A, Bh);
+		this.h[4] = sum32_3(this.h[0], B, Ch);
+		this.h[0] = T;
+	};
+	RIPEMD160.prototype._digest = function digest(enc) {
+		if (enc === "hex") return utils.toHex32(this.h, "little");
+		else return utils.split32(this.h, "little");
+	};
+	function f(j, x, y, z) {
+		if (j <= 15) return x ^ y ^ z;
+		else if (j <= 31) return x & y | ~x & z;
+		else if (j <= 47) return (x | ~y) ^ z;
+		else if (j <= 63) return x & z | y & ~z;
+		else return x ^ (y | ~z);
+	}
+	function K(j) {
+		if (j <= 15) return 0;
+		else if (j <= 31) return 1518500249;
+		else if (j <= 47) return 1859775393;
+		else if (j <= 63) return 2400959708;
+		else return 2840853838;
+	}
+	function Kh(j) {
+		if (j <= 15) return 1352829926;
+		else if (j <= 31) return 1548603684;
+		else if (j <= 47) return 1836072691;
+		else if (j <= 63) return 2053994217;
+		else return 0;
+	}
+	var r = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		13,
+		14,
+		15,
+		7,
+		4,
+		13,
+		1,
+		10,
+		6,
+		15,
+		3,
+		12,
+		0,
+		9,
+		5,
+		2,
+		14,
+		11,
+		8,
+		3,
+		10,
+		14,
+		4,
+		9,
+		15,
+		8,
+		1,
+		2,
+		7,
+		0,
+		6,
+		13,
+		11,
+		5,
+		12,
+		1,
+		9,
+		11,
+		10,
+		0,
+		8,
+		12,
+		4,
+		13,
+		3,
+		7,
+		15,
+		14,
+		5,
+		6,
+		2,
+		4,
+		0,
+		5,
+		9,
+		7,
+		12,
+		2,
+		10,
+		14,
+		1,
+		3,
+		8,
+		11,
+		6,
+		15,
+		13
+	];
+	var rh = [
+		5,
+		14,
+		7,
+		0,
+		9,
+		2,
+		11,
+		4,
+		13,
+		6,
+		15,
+		8,
+		1,
+		10,
+		3,
+		12,
+		6,
+		11,
+		3,
+		7,
+		0,
+		13,
+		5,
+		10,
+		14,
+		15,
+		8,
+		12,
+		4,
+		9,
+		1,
+		2,
+		15,
+		5,
+		1,
+		3,
+		7,
+		14,
+		6,
+		9,
+		11,
+		8,
+		12,
+		2,
+		10,
+		0,
+		4,
+		13,
+		8,
+		6,
+		4,
+		1,
+		3,
+		11,
+		15,
+		0,
+		5,
+		12,
+		2,
+		13,
+		9,
+		7,
+		10,
+		14,
+		12,
+		15,
+		10,
+		4,
+		1,
+		5,
+		8,
+		7,
+		6,
+		2,
+		13,
+		14,
+		0,
+		3,
+		9,
+		11
+	];
+	var s = [
+		11,
+		14,
+		15,
+		12,
+		5,
+		8,
+		7,
+		9,
+		11,
+		13,
+		14,
+		15,
+		6,
+		7,
+		9,
+		8,
+		7,
+		6,
+		8,
+		13,
+		11,
+		9,
+		7,
+		15,
+		7,
+		12,
+		15,
+		9,
+		11,
+		7,
+		13,
+		12,
+		11,
+		13,
+		6,
+		7,
+		14,
+		9,
+		13,
+		15,
+		14,
+		8,
+		13,
+		6,
+		5,
+		12,
+		7,
+		5,
+		11,
+		12,
+		14,
+		15,
+		14,
+		15,
+		9,
+		8,
+		9,
+		14,
+		5,
+		6,
+		8,
+		6,
+		5,
+		12,
+		9,
+		15,
+		5,
+		11,
+		6,
+		8,
+		13,
+		12,
+		5,
+		12,
+		13,
+		14,
+		11,
+		8,
+		5,
+		6
+	];
+	var sh = [
+		8,
+		9,
+		9,
+		11,
+		13,
+		15,
+		15,
+		5,
+		7,
+		7,
+		8,
+		11,
+		14,
+		14,
+		12,
+		6,
+		9,
+		13,
+		15,
+		7,
+		12,
+		8,
+		9,
+		11,
+		7,
+		7,
+		12,
+		7,
+		6,
+		15,
+		13,
+		11,
+		9,
+		7,
+		15,
+		11,
+		8,
+		6,
+		6,
+		14,
+		12,
+		13,
+		5,
+		14,
+		13,
+		13,
+		7,
+		5,
+		15,
+		5,
+		8,
+		11,
+		14,
+		14,
+		6,
+		14,
+		6,
+		9,
+		12,
+		9,
+		12,
+		5,
+		15,
+		8,
+		8,
+		5,
+		12,
+		9,
+		12,
+		5,
+		14,
+		6,
+		8,
+		13,
+		6,
+		5,
+		15,
+		13,
+		11,
+		11
+	];
+}));
+
+//#endregion
+export default require_ripemd();
+
+export { require_ripemd };