@hot-updater/server 0.30.11 → 0.31.0

package/dist/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/_u64.mjs

@@ -0,0 +1,108 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/_u64.js
+var require__u64 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.toBig = exports.shrSL = exports.shrSH = exports.rotrSL = exports.rotrSH = exports.rotrBL = exports.rotrBH = exports.rotr32L = exports.rotr32H = exports.rotlSL = exports.rotlSH = exports.rotlBL = exports.rotlBH = exports.add5L = exports.add5H = exports.add4L = exports.add4H = exports.add3L = exports.add3H = void 0;
+	exports.add = add;
+	exports.fromBig = fromBig;
+	exports.split = split;
+	/**
+	* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+	* @todo re-check https://issues.chromium.org/issues/42212588
+	* @module
+	*/
+	const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+	const _32n = /* @__PURE__ */ BigInt(32);
+	function fromBig(n, le = false) {
+		if (le) return {
+			h: Number(n & U32_MASK64),
+			l: Number(n >> _32n & U32_MASK64)
+		};
+		return {
+			h: Number(n >> _32n & U32_MASK64) | 0,
+			l: Number(n & U32_MASK64) | 0
+		};
+	}
+	function split(lst, le = false) {
+		const len = lst.length;
+		let Ah = new Uint32Array(len);
+		let Al = new Uint32Array(len);
+		for (let i = 0; i < len; i++) {
+			const { h, l } = fromBig(lst[i], le);
+			[Ah[i], Al[i]] = [h, l];
+		}
+		return [Ah, Al];
+	}
+	const toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+	exports.toBig = toBig;
+	const shrSH = (h, _l, s) => h >>> s;
+	exports.shrSH = shrSH;
+	const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+	exports.shrSL = shrSL;
+	const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+	exports.rotrSH = rotrSH;
+	const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+	exports.rotrSL = rotrSL;
+	const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+	exports.rotrBH = rotrBH;
+	const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+	exports.rotrBL = rotrBL;
+	const rotr32H = (_h, l) => l;
+	exports.rotr32H = rotr32H;
+	const rotr32L = (h, _l) => h;
+	exports.rotr32L = rotr32L;
+	const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+	exports.rotlSH = rotlSH;
+	const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+	exports.rotlSL = rotlSL;
+	const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+	exports.rotlBH = rotlBH;
+	const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+	exports.rotlBL = rotlBL;
+	function add(Ah, Al, Bh, Bl) {
+		const l = (Al >>> 0) + (Bl >>> 0);
+		return {
+			h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
+			l: l | 0
+		};
+	}
+	const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+	exports.add3L = add3L;
+	const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+	exports.add3H = add3H;
+	const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+	exports.add4L = add4L;
+	const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+	exports.add4H = add4H;
+	const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+	exports.add5L = add5L;
+	const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+	exports.add5H = add5H;
+	exports.default = {
+		fromBig,
+		split,
+		toBig,
+		shrSH,
+		shrSL,
+		rotrSH,
+		rotrSL,
+		rotrBH,
+		rotrBL,
+		rotr32H,
+		rotr32L,
+		rotlSH,
+		rotlSL,
+		rotlBH,
+		rotlBL,
+		add,
+		add3L,
+		add3H,
+		add4L,
+		add4H,
+		add5H,
+		add5L
+	};
+}));
+//#endregion
+export default require__u64();
+export { require__u64 };

package/dist/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/cryptoNode.cjs

@@ -0,0 +1,22 @@
+"use strict";
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/cryptoNode.js
+var require_cryptoNode = /* @__PURE__ */ require("../../../../../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.crypto = void 0;
+	/**
+	* Internal webcrypto alias.
+	* We prefer WebCrypto aka globalThis.crypto, which exists in node.js 16+.
+	* Falls back to Node.js built-in crypto for Node.js <=v14.
+	* See utils.ts for details.
+	* @module
+	*/
+	const nc = require("node:crypto");
+	exports.crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_cryptoNode();
+	}
+});

package/dist/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/cryptoNode.mjs

@@ -0,0 +1,18 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/cryptoNode.js
+var require_cryptoNode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.crypto = void 0;
+	/**
+	* Internal webcrypto alias.
+	* We prefer WebCrypto aka globalThis.crypto, which exists in node.js 16+.
+	* Falls back to Node.js built-in crypto for Node.js <=v14.
+	* See utils.ts for details.
+	* @module
+	*/
+	const nc = __require("node:crypto");
+	exports.crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+}));
+//#endregion
+export default require_cryptoNode();
+export { require_cryptoNode };

package/dist/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/sha3.cjs

@@ -0,0 +1,219 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require__u64$1 = require("./_u64.cjs");
+const require_utils$1 = require("./utils.cjs");
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/sha3.js
+var require_sha3 = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.shake256 = exports.shake128 = exports.keccak_512 = exports.keccak_384 = exports.keccak_256 = exports.keccak_224 = exports.sha3_512 = exports.sha3_384 = exports.sha3_256 = exports.sha3_224 = exports.Keccak = void 0;
+	exports.keccakP = keccakP;
+	/**
+	* SHA3 (keccak) hash function, based on a new "Sponge function" design.
+	* Different from older hashes, the internal state is bigger than output size.
+	*
+	* Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+	* [Website](https://keccak.team/keccak.html),
+	* [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+	*
+	* Check out `sha3-addons` module for cSHAKE, k12, and others.
+	* @module
+	*/
+	const _u64_ts_1 = require__u64$1.default;
+	const utils_ts_1 = require_utils$1.default;
+	const _0n = BigInt(0);
+	const _1n = BigInt(1);
+	const _2n = BigInt(2);
+	const _7n = BigInt(7);
+	const _256n = BigInt(256);
+	const _0x71n = BigInt(113);
+	const SHA3_PI = [];
+	const SHA3_ROTL = [];
+	const _SHA3_IOTA = [];
+	for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+		[x, y] = [y, (2 * x + 3 * y) % 5];
+		SHA3_PI.push(2 * (5 * y + x));
+		SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+		let t = _0n;
+		for (let j = 0; j < 7; j++) {
+			R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+			if (R & _2n) t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+		}
+		_SHA3_IOTA.push(t);
+	}
+	const IOTAS = (0, _u64_ts_1.split)(_SHA3_IOTA, true);
+	const SHA3_IOTA_H = IOTAS[0];
+	const SHA3_IOTA_L = IOTAS[1];
+	const rotlH = (h, l, s) => s > 32 ? (0, _u64_ts_1.rotlBH)(h, l, s) : (0, _u64_ts_1.rotlSH)(h, l, s);
+	const rotlL = (h, l, s) => s > 32 ? (0, _u64_ts_1.rotlBL)(h, l, s) : (0, _u64_ts_1.rotlSL)(h, l, s);
+	/** `keccakf1600` internal function, additionally allows to adjust round count. */
+	function keccakP(s, rounds = 24) {
+		const B = new Uint32Array(10);
+		for (let round = 24 - rounds; round < 24; round++) {
+			for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+			for (let x = 0; x < 10; x += 2) {
+				const idx1 = (x + 8) % 10;
+				const idx0 = (x + 2) % 10;
+				const B0 = B[idx0];
+				const B1 = B[idx0 + 1];
+				const Th = rotlH(B0, B1, 1) ^ B[idx1];
+				const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+				for (let y = 0; y < 50; y += 10) {
+					s[x + y] ^= Th;
+					s[x + y + 1] ^= Tl;
+				}
+			}
+			let curH = s[2];
+			let curL = s[3];
+			for (let t = 0; t < 24; t++) {
+				const shift = SHA3_ROTL[t];
+				const Th = rotlH(curH, curL, shift);
+				const Tl = rotlL(curH, curL, shift);
+				const PI = SHA3_PI[t];
+				curH = s[PI];
+				curL = s[PI + 1];
+				s[PI] = Th;
+				s[PI + 1] = Tl;
+			}
+			for (let y = 0; y < 50; y += 10) {
+				for (let x = 0; x < 10; x++) B[x] = s[y + x];
+				for (let x = 0; x < 10; x++) s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+			}
+			s[0] ^= SHA3_IOTA_H[round];
+			s[1] ^= SHA3_IOTA_L[round];
+		}
+		(0, utils_ts_1.clean)(B);
+	}
+	/** Keccak sponge function. */
+	var Keccak = class Keccak extends utils_ts_1.Hash {
+		constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+			super();
+			this.pos = 0;
+			this.posOut = 0;
+			this.finished = false;
+			this.destroyed = false;
+			this.enableXOF = false;
+			this.blockLen = blockLen;
+			this.suffix = suffix;
+			this.outputLen = outputLen;
+			this.enableXOF = enableXOF;
+			this.rounds = rounds;
+			(0, utils_ts_1.anumber)(outputLen);
+			if (!(0 < blockLen && blockLen < 200)) throw new Error("only keccak-f1600 function is supported");
+			this.state = new Uint8Array(200);
+			this.state32 = (0, utils_ts_1.u32)(this.state);
+		}
+		clone() {
+			return this._cloneInto();
+		}
+		keccak() {
+			(0, utils_ts_1.swap32IfBE)(this.state32);
+			keccakP(this.state32, this.rounds);
+			(0, utils_ts_1.swap32IfBE)(this.state32);
+			this.posOut = 0;
+			this.pos = 0;
+		}
+		update(data) {
+			(0, utils_ts_1.aexists)(this);
+			data = (0, utils_ts_1.toBytes)(data);
+			(0, utils_ts_1.abytes)(data);
+			const { blockLen, state } = this;
+			const len = data.length;
+			for (let pos = 0; pos < len;) {
+				const take = Math.min(blockLen - this.pos, len - pos);
+				for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
+				if (this.pos === blockLen) this.keccak();
+			}
+			return this;
+		}
+		finish() {
+			if (this.finished) return;
+			this.finished = true;
+			const { state, suffix, pos, blockLen } = this;
+			state[pos] ^= suffix;
+			if ((suffix & 128) !== 0 && pos === blockLen - 1) this.keccak();
+			state[blockLen - 1] ^= 128;
+			this.keccak();
+		}
+		writeInto(out) {
+			(0, utils_ts_1.aexists)(this, false);
+			(0, utils_ts_1.abytes)(out);
+			this.finish();
+			const bufferOut = this.state;
+			const { blockLen } = this;
+			for (let pos = 0, len = out.length; pos < len;) {
+				if (this.posOut >= blockLen) this.keccak();
+				const take = Math.min(blockLen - this.posOut, len - pos);
+				out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+				this.posOut += take;
+				pos += take;
+			}
+			return out;
+		}
+		xofInto(out) {
+			if (!this.enableXOF) throw new Error("XOF is not possible for this instance");
+			return this.writeInto(out);
+		}
+		xof(bytes) {
+			(0, utils_ts_1.anumber)(bytes);
+			return this.xofInto(new Uint8Array(bytes));
+		}
+		digestInto(out) {
+			(0, utils_ts_1.aoutput)(out, this);
+			if (this.finished) throw new Error("digest() was already called");
+			this.writeInto(out);
+			this.destroy();
+			return out;
+		}
+		digest() {
+			return this.digestInto(new Uint8Array(this.outputLen));
+		}
+		destroy() {
+			this.destroyed = true;
+			(0, utils_ts_1.clean)(this.state);
+		}
+		_cloneInto(to) {
+			const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+			to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+			to.state32.set(this.state32);
+			to.pos = this.pos;
+			to.posOut = this.posOut;
+			to.finished = this.finished;
+			to.rounds = rounds;
+			to.suffix = suffix;
+			to.outputLen = outputLen;
+			to.enableXOF = enableXOF;
+			to.destroyed = this.destroyed;
+			return to;
+		}
+	};
+	exports.Keccak = Keccak;
+	const gen = (suffix, blockLen, outputLen) => (0, utils_ts_1.createHasher)(() => new Keccak(blockLen, suffix, outputLen));
+	/** SHA3-224 hash function. */
+	exports.sha3_224 = gen(6, 144, 224 / 8);
+	/** SHA3-256 hash function. Different from keccak-256. */
+	exports.sha3_256 = gen(6, 136, 256 / 8);
+	/** SHA3-384 hash function. */
+	exports.sha3_384 = gen(6, 104, 384 / 8);
+	/** SHA3-512 hash function. */
+	exports.sha3_512 = gen(6, 72, 512 / 8);
+	/** keccak-224 hash function. */
+	exports.keccak_224 = gen(1, 144, 224 / 8);
+	/** keccak-256 hash function. Different from SHA3-256. */
+	exports.keccak_256 = gen(1, 136, 256 / 8);
+	/** keccak-384 hash function. */
+	exports.keccak_384 = gen(1, 104, 384 / 8);
+	/** keccak-512 hash function. */
+	exports.keccak_512 = gen(1, 72, 512 / 8);
+	const genShake = (suffix, blockLen, outputLen) => (0, utils_ts_1.createXOFer)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+	/** SHAKE128 XOF with 128-bit security. */
+	exports.shake128 = genShake(31, 168, 128 / 8);
+	/** SHAKE256 XOF with 256-bit security. */
+	exports.shake256 = genShake(31, 136, 256 / 8);
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_sha3();
+	}
+});

package/dist/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/sha3.mjs

@@ -0,0 +1,214 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require__u64 } from "./_u64.mjs";
+import { require_utils } from "./utils.mjs";
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/sha3.js
+var require_sha3 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.shake256 = exports.shake128 = exports.keccak_512 = exports.keccak_384 = exports.keccak_256 = exports.keccak_224 = exports.sha3_512 = exports.sha3_384 = exports.sha3_256 = exports.sha3_224 = exports.Keccak = void 0;
+	exports.keccakP = keccakP;
+	/**
+	* SHA3 (keccak) hash function, based on a new "Sponge function" design.
+	* Different from older hashes, the internal state is bigger than output size.
+	*
+	* Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+	* [Website](https://keccak.team/keccak.html),
+	* [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+	*
+	* Check out `sha3-addons` module for cSHAKE, k12, and others.
+	* @module
+	*/
+	const _u64_ts_1 = require__u64();
+	const utils_ts_1 = require_utils();
+	const _0n = BigInt(0);
+	const _1n = BigInt(1);
+	const _2n = BigInt(2);
+	const _7n = BigInt(7);
+	const _256n = BigInt(256);
+	const _0x71n = BigInt(113);
+	const SHA3_PI = [];
+	const SHA3_ROTL = [];
+	const _SHA3_IOTA = [];
+	for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+		[x, y] = [y, (2 * x + 3 * y) % 5];
+		SHA3_PI.push(2 * (5 * y + x));
+		SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+		let t = _0n;
+		for (let j = 0; j < 7; j++) {
+			R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+			if (R & _2n) t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+		}
+		_SHA3_IOTA.push(t);
+	}
+	const IOTAS = (0, _u64_ts_1.split)(_SHA3_IOTA, true);
+	const SHA3_IOTA_H = IOTAS[0];
+	const SHA3_IOTA_L = IOTAS[1];
+	const rotlH = (h, l, s) => s > 32 ? (0, _u64_ts_1.rotlBH)(h, l, s) : (0, _u64_ts_1.rotlSH)(h, l, s);
+	const rotlL = (h, l, s) => s > 32 ? (0, _u64_ts_1.rotlBL)(h, l, s) : (0, _u64_ts_1.rotlSL)(h, l, s);
+	/** `keccakf1600` internal function, additionally allows to adjust round count. */
+	function keccakP(s, rounds = 24) {
+		const B = new Uint32Array(10);
+		for (let round = 24 - rounds; round < 24; round++) {
+			for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+			for (let x = 0; x < 10; x += 2) {
+				const idx1 = (x + 8) % 10;
+				const idx0 = (x + 2) % 10;
+				const B0 = B[idx0];
+				const B1 = B[idx0 + 1];
+				const Th = rotlH(B0, B1, 1) ^ B[idx1];
+				const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+				for (let y = 0; y < 50; y += 10) {
+					s[x + y] ^= Th;
+					s[x + y + 1] ^= Tl;
+				}
+			}
+			let curH = s[2];
+			let curL = s[3];
+			for (let t = 0; t < 24; t++) {
+				const shift = SHA3_ROTL[t];
+				const Th = rotlH(curH, curL, shift);
+				const Tl = rotlL(curH, curL, shift);
+				const PI = SHA3_PI[t];
+				curH = s[PI];
+				curL = s[PI + 1];
+				s[PI] = Th;
+				s[PI + 1] = Tl;
+			}
+			for (let y = 0; y < 50; y += 10) {
+				for (let x = 0; x < 10; x++) B[x] = s[y + x];
+				for (let x = 0; x < 10; x++) s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+			}
+			s[0] ^= SHA3_IOTA_H[round];
+			s[1] ^= SHA3_IOTA_L[round];
+		}
+		(0, utils_ts_1.clean)(B);
+	}
+	/** Keccak sponge function. */
+	var Keccak = class Keccak extends utils_ts_1.Hash {
+		constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+			super();
+			this.pos = 0;
+			this.posOut = 0;
+			this.finished = false;
+			this.destroyed = false;
+			this.enableXOF = false;
+			this.blockLen = blockLen;
+			this.suffix = suffix;
+			this.outputLen = outputLen;
+			this.enableXOF = enableXOF;
+			this.rounds = rounds;
+			(0, utils_ts_1.anumber)(outputLen);
+			if (!(0 < blockLen && blockLen < 200)) throw new Error("only keccak-f1600 function is supported");
+			this.state = new Uint8Array(200);
+			this.state32 = (0, utils_ts_1.u32)(this.state);
+		}
+		clone() {
+			return this._cloneInto();
+		}
+		keccak() {
+			(0, utils_ts_1.swap32IfBE)(this.state32);
+			keccakP(this.state32, this.rounds);
+			(0, utils_ts_1.swap32IfBE)(this.state32);
+			this.posOut = 0;
+			this.pos = 0;
+		}
+		update(data) {
+			(0, utils_ts_1.aexists)(this);
+			data = (0, utils_ts_1.toBytes)(data);
+			(0, utils_ts_1.abytes)(data);
+			const { blockLen, state } = this;
+			const len = data.length;
+			for (let pos = 0; pos < len;) {
+				const take = Math.min(blockLen - this.pos, len - pos);
+				for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
+				if (this.pos === blockLen) this.keccak();
+			}
+			return this;
+		}
+		finish() {
+			if (this.finished) return;
+			this.finished = true;
+			const { state, suffix, pos, blockLen } = this;
+			state[pos] ^= suffix;
+			if ((suffix & 128) !== 0 && pos === blockLen - 1) this.keccak();
+			state[blockLen - 1] ^= 128;
+			this.keccak();
+		}
+		writeInto(out) {
+			(0, utils_ts_1.aexists)(this, false);
+			(0, utils_ts_1.abytes)(out);
+			this.finish();
+			const bufferOut = this.state;
+			const { blockLen } = this;
+			for (let pos = 0, len = out.length; pos < len;) {
+				if (this.posOut >= blockLen) this.keccak();
+				const take = Math.min(blockLen - this.posOut, len - pos);
+				out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+				this.posOut += take;
+				pos += take;
+			}
+			return out;
+		}
+		xofInto(out) {
+			if (!this.enableXOF) throw new Error("XOF is not possible for this instance");
+			return this.writeInto(out);
+		}
+		xof(bytes) {
+			(0, utils_ts_1.anumber)(bytes);
+			return this.xofInto(new Uint8Array(bytes));
+		}
+		digestInto(out) {
+			(0, utils_ts_1.aoutput)(out, this);
+			if (this.finished) throw new Error("digest() was already called");
+			this.writeInto(out);
+			this.destroy();
+			return out;
+		}
+		digest() {
+			return this.digestInto(new Uint8Array(this.outputLen));
+		}
+		destroy() {
+			this.destroyed = true;
+			(0, utils_ts_1.clean)(this.state);
+		}
+		_cloneInto(to) {
+			const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+			to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+			to.state32.set(this.state32);
+			to.pos = this.pos;
+			to.posOut = this.posOut;
+			to.finished = this.finished;
+			to.rounds = rounds;
+			to.suffix = suffix;
+			to.outputLen = outputLen;
+			to.enableXOF = enableXOF;
+			to.destroyed = this.destroyed;
+			return to;
+		}
+	};
+	exports.Keccak = Keccak;
+	const gen = (suffix, blockLen, outputLen) => (0, utils_ts_1.createHasher)(() => new Keccak(blockLen, suffix, outputLen));
+	/** SHA3-224 hash function. */
+	exports.sha3_224 = gen(6, 144, 224 / 8);
+	/** SHA3-256 hash function. Different from keccak-256. */
+	exports.sha3_256 = gen(6, 136, 256 / 8);
+	/** SHA3-384 hash function. */
+	exports.sha3_384 = gen(6, 104, 384 / 8);
+	/** SHA3-512 hash function. */
+	exports.sha3_512 = gen(6, 72, 512 / 8);
+	/** keccak-224 hash function. */
+	exports.keccak_224 = gen(1, 144, 224 / 8);
+	/** keccak-256 hash function. Different from SHA3-256. */
+	exports.keccak_256 = gen(1, 136, 256 / 8);
+	/** keccak-384 hash function. */
+	exports.keccak_384 = gen(1, 104, 384 / 8);
+	/** keccak-512 hash function. */
+	exports.keccak_512 = gen(1, 72, 512 / 8);
+	const genShake = (suffix, blockLen, outputLen) => (0, utils_ts_1.createXOFer)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+	/** SHAKE128 XOF with 128-bit security. */
+	exports.shake128 = genShake(31, 168, 128 / 8);
+	/** SHAKE256 XOF with 256-bit security. */
+	exports.shake256 = genShake(31, 136, 256 / 8);
+}));
+//#endregion
+export default require_sha3();
+export { require_sha3 };