@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/codecs-CC1Xjntz.js

@@ -0,0 +1,1882 @@
+//#region ../../node_modules/@noble/hashes/esm/_u64.js
+/**
+* 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 shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+const rotr32H = (_h, l) => l;
+const rotr32L = (h, _l) => h;
+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);
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/crypto.js
+const crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/utils.js
+/**
+* Utilities for hex, bytes, CSPRNG.
+* @module
+*/
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+	if (!Number.isSafeInteger(n) || n < 0) throw new Error("positive integer expected, got " + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+	if (!isBytes(b)) throw new Error("Uint8Array expected");
+	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+/** Asserts something is hash */
+function ahash(h) {
+	if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash should be wrapped by utils.createHasher");
+	anumber(h.outputLen);
+	anumber(h.blockLen);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+	abytes(out);
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+}
+/** Cast u8 / u16 / u32 to u8. */
+function u8(arr) {
+	return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr) {
+	return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+	return word << 32 - shift | word >>> shift;
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+/** The byte swap operation for uint32 */
+function byteSwap(word) {
+	return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+/** Conditionally byte swap if on a big-endian platform */
+const swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n);
+/** In place byte swap for Uint32Array */
+function byteSwap32(arr) {
+	for (let i = 0; i < arr.length; i++) arr[i] = byteSwap(arr[i]);
+	return arr;
+}
+const swap32IfBE = isLE ? (u) => u : byteSwap32;
+const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+/**
+* Convert byte array to hex string. Uses built-in function, when available.
+* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+*/
+function bytesToHex(bytes) {
+	abytes(bytes);
+	if (hasHexBuiltin) return bytes.toHex();
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+	return hex;
+}
+const asciis = {
+	_0: 48,
+	_9: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+function asciiToBase16(ch) {
+	if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0;
+	if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10);
+	if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10);
+}
+/**
+* Convert hex string to byte array. Uses built-in function, when available.
+* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+*/
+function hexToBytes(hex) {
+	if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
+	if (hasHexBuiltin) return Uint8Array.fromHex(hex);
+	const hl = hex.length;
+	const al = hl / 2;
+	if (hl % 2) throw new Error("hex string expected, got unpadded hex of length " + hl);
+	const array = new Uint8Array(al);
+	for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+		const n1 = asciiToBase16(hex.charCodeAt(hi));
+		const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+		if (n1 === void 0 || n2 === void 0) {
+			const char = hex[hi] + hex[hi + 1];
+			throw new Error("hex string expected, got non-hex character \"" + char + "\" at index " + hi);
+		}
+		array[ai] = n1 * 16 + n2;
+	}
+	return array;
+}
+/**
+* There is no setImmediate in browser and setTimeout is slow.
+* Call of async fn will return Promise, which will be fullfiled only on
+* next scheduler queue processing step and this is exactly what we need.
+*/
+const nextTick = async () => {};
+/**
+* Converts string to bytes using UTF8 encoding.
+* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+*/
+function utf8ToBytes(str) {
+	if (typeof str !== "string") throw new Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(str));
+}
+/**
+* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+* Warning: when Uint8Array is passed, it would NOT get copied.
+* Keep in mind for future mutable operations.
+*/
+function toBytes(data) {
+	if (typeof data === "string") data = utf8ToBytes(data);
+	abytes(data);
+	return data;
+}
+/**
+* Helper for KDFs: consumes uint8array or string.
+* When string is passed, does utf8 decoding, using TextDecoder.
+*/
+function kdfInputToBytes(data) {
+	if (typeof data === "string") data = utf8ToBytes(data);
+	abytes(data);
+	return data;
+}
+function checkOpts(defaults, opts) {
+	if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") throw new Error("options should be object or undefined");
+	return Object.assign(defaults, opts);
+}
+/** For runtime check if class implements interface */
+var Hash = class {};
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+	const tmp = hashCons();
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = () => hashCons();
+	return hashC;
+}
+function createOptHasher(hashCons) {
+	const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+	const tmp = hashCons({});
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = (opts) => hashCons(opts);
+	return hashC;
+}
+/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+function randomBytes(bytesLength = 32) {
+	if (crypto && typeof crypto.getRandomValues === "function") return crypto.getRandomValues(new Uint8Array(bytesLength));
+	if (crypto && typeof crypto.randomBytes === "function") return Uint8Array.from(crypto.randomBytes(bytesLength));
+	throw new Error("crypto.getRandomValues must be defined");
+}
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/_blake.js
+/**
+* Internal blake variable.
+* For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+*/
+const BSIGMA = /* @__PURE__ */ Uint8Array.from([
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	10,
+	4,
+	8,
+	9,
+	15,
+	13,
+	6,
+	1,
+	12,
+	0,
+	2,
+	11,
+	7,
+	5,
+	3,
+	11,
+	8,
+	12,
+	0,
+	5,
+	2,
+	15,
+	13,
+	10,
+	14,
+	3,
+	6,
+	7,
+	1,
+	9,
+	4,
+	7,
+	9,
+	3,
+	1,
+	13,
+	12,
+	11,
+	14,
+	2,
+	6,
+	5,
+	10,
+	4,
+	0,
+	15,
+	8,
+	9,
+	0,
+	5,
+	7,
+	2,
+	4,
+	10,
+	15,
+	14,
+	1,
+	11,
+	12,
+	6,
+	8,
+	3,
+	13,
+	2,
+	12,
+	6,
+	10,
+	0,
+	11,
+	8,
+	3,
+	4,
+	13,
+	7,
+	5,
+	15,
+	14,
+	1,
+	9,
+	12,
+	5,
+	1,
+	15,
+	14,
+	13,
+	4,
+	10,
+	0,
+	7,
+	6,
+	3,
+	9,
+	2,
+	8,
+	11,
+	13,
+	11,
+	7,
+	14,
+	12,
+	1,
+	3,
+	9,
+	5,
+	0,
+	15,
+	4,
+	8,
+	6,
+	2,
+	10,
+	6,
+	15,
+	14,
+	9,
+	11,
+	3,
+	0,
+	8,
+	12,
+	2,
+	13,
+	7,
+	1,
+	4,
+	10,
+	5,
+	10,
+	2,
+	8,
+	4,
+	7,
+	6,
+	1,
+	5,
+	15,
+	11,
+	9,
+	14,
+	3,
+	12,
+	13,
+	0,
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	10,
+	4,
+	8,
+	9,
+	15,
+	13,
+	6,
+	1,
+	12,
+	0,
+	2,
+	11,
+	7,
+	5,
+	3,
+	11,
+	8,
+	12,
+	0,
+	5,
+	2,
+	15,
+	13,
+	10,
+	14,
+	3,
+	6,
+	7,
+	1,
+	9,
+	4,
+	7,
+	9,
+	3,
+	1,
+	13,
+	12,
+	11,
+	14,
+	2,
+	6,
+	5,
+	10,
+	4,
+	0,
+	15,
+	8,
+	9,
+	0,
+	5,
+	7,
+	2,
+	4,
+	10,
+	15,
+	14,
+	1,
+	11,
+	12,
+	6,
+	8,
+	3,
+	13,
+	2,
+	12,
+	6,
+	10,
+	0,
+	11,
+	8,
+	3,
+	4,
+	13,
+	7,
+	5,
+	15,
+	14,
+	1,
+	9
+]);
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+function setBigUint64(view, byteOffset, value, isLE) {
+	if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE);
+	const _32n = BigInt(32);
+	const _u32_max = BigInt(4294967295);
+	const wh = Number(value >> _32n & _u32_max);
+	const wl = Number(value & _u32_max);
+	const h = isLE ? 4 : 0;
+	const l = isLE ? 0 : 4;
+	view.setUint32(byteOffset + h, wh, isLE);
+	view.setUint32(byteOffset + l, wl, isLE);
+}
+/** Choice: a ? b : c */
+function Chi(a, b, c) {
+	return a & b ^ ~a & c;
+}
+/** Majority function, true if any two inputs is true. */
+function Maj(a, b, c) {
+	return a & b ^ a & c ^ b & c;
+}
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+*/
+var HashMD = class extends Hash {
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		super();
+		this.finished = false;
+		this.length = 0;
+		this.pos = 0;
+		this.destroyed = false;
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		data = toBytes(data);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+			}
+		}
+		this.length += data.length;
+		this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		clean(this.buffer.subarray(pos));
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			pos = 0;
+		}
+		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+		setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+		this.process(view, 0);
+		const oview = createView(out);
+		const len = this.outputLen;
+		if (len % 4) throw new Error("_sha2: outputLen should be aligned to 32bit");
+		const outLen = len / 4;
+		const state = this.get();
+		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		to || (to = new this.constructor());
+		to.set(...this.get());
+		const { blockLen, buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (length % blockLen) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/**
+* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+*/
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]);
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/blake2.js
+/**
+* blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
+* b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
+* @module
+*/
+const B2B_IV = /* @__PURE__ */ Uint32Array.from([
+	4089235720,
+	1779033703,
+	2227873595,
+	3144134277,
+	4271175723,
+	1013904242,
+	1595750129,
+	2773480762,
+	2917565137,
+	1359893119,
+	725511199,
+	2600822924,
+	4215389547,
+	528734635,
+	327033209,
+	1541459225
+]);
+const BBUF = /* @__PURE__ */ new Uint32Array(32);
+function G1b(a, b, c, d, msg, x) {
+	const Xl = msg[x], Xh = msg[x + 1];
+	let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+	let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+	let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+	let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+	let ll = add3L(Al, Bl, Xl);
+	Ah = add3H(ll, Ah, Bh, Xh);
+	Al = ll | 0;
+	({Dh, Dl} = {
+		Dh: Dh ^ Ah,
+		Dl: Dl ^ Al
+	});
+	({Dh, Dl} = {
+		Dh: rotr32H(Dh, Dl),
+		Dl: rotr32L(Dh, Dl)
+	});
+	({h: Ch, l: Cl} = add(Ch, Cl, Dh, Dl));
+	({Bh, Bl} = {
+		Bh: Bh ^ Ch,
+		Bl: Bl ^ Cl
+	});
+	({Bh, Bl} = {
+		Bh: rotrSH(Bh, Bl, 24),
+		Bl: rotrSL(Bh, Bl, 24)
+	});
+	BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+	BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+	BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+	BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function G2b(a, b, c, d, msg, x) {
+	const Xl = msg[x], Xh = msg[x + 1];
+	let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+	let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+	let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+	let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+	let ll = add3L(Al, Bl, Xl);
+	Ah = add3H(ll, Ah, Bh, Xh);
+	Al = ll | 0;
+	({Dh, Dl} = {
+		Dh: Dh ^ Ah,
+		Dl: Dl ^ Al
+	});
+	({Dh, Dl} = {
+		Dh: rotrSH(Dh, Dl, 16),
+		Dl: rotrSL(Dh, Dl, 16)
+	});
+	({h: Ch, l: Cl} = add(Ch, Cl, Dh, Dl));
+	({Bh, Bl} = {
+		Bh: Bh ^ Ch,
+		Bl: Bl ^ Cl
+	});
+	({Bh, Bl} = {
+		Bh: rotrBH(Bh, Bl, 63),
+		Bl: rotrBL(Bh, Bl, 63)
+	});
+	BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+	BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+	BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+	BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
+	anumber(keyLen);
+	if (outputLen < 0 || outputLen > keyLen) throw new Error("outputLen bigger than keyLen");
+	const { key, salt, personalization } = opts;
+	if (key !== void 0 && (key.length < 1 || key.length > keyLen)) throw new Error("key length must be undefined or 1.." + keyLen);
+	if (salt !== void 0 && salt.length !== saltLen) throw new Error("salt must be undefined or " + saltLen);
+	if (personalization !== void 0 && personalization.length !== persLen) throw new Error("personalization must be undefined or " + persLen);
+}
+/** Class, from which others are subclassed. */
+var BLAKE2 = class extends Hash {
+	constructor(blockLen, outputLen) {
+		super();
+		this.finished = false;
+		this.destroyed = false;
+		this.length = 0;
+		this.pos = 0;
+		anumber(blockLen);
+		anumber(outputLen);
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.buffer = new Uint8Array(blockLen);
+		this.buffer32 = u32(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		data = toBytes(data);
+		abytes(data);
+		const { blockLen, buffer, buffer32 } = this;
+		const len = data.length;
+		const offset = data.byteOffset;
+		const buf = data.buffer;
+		for (let pos = 0; pos < len;) {
+			if (this.pos === blockLen) {
+				swap32IfBE(buffer32);
+				this.compress(buffer32, 0, false);
+				swap32IfBE(buffer32);
+				this.pos = 0;
+			}
+			const take = Math.min(blockLen - this.pos, len - pos);
+			const dataOffset = offset + pos;
+			if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+				const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+				swap32IfBE(data32);
+				for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+					this.length += blockLen;
+					this.compress(data32, pos32, false);
+				}
+				swap32IfBE(data32);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			this.length += take;
+			pos += take;
+		}
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		const { pos, buffer32 } = this;
+		this.finished = true;
+		clean(this.buffer.subarray(pos));
+		swap32IfBE(buffer32);
+		this.compress(buffer32, 0, true);
+		swap32IfBE(buffer32);
+		const out32 = u32(out);
+		this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		const { buffer, length, finished, destroyed, outputLen, pos } = this;
+		to || (to = new this.constructor({ dkLen: outputLen }));
+		to.set(...this.get());
+		to.buffer.set(buffer);
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		to.outputLen = outputLen;
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+var BLAKE2b = class extends BLAKE2 {
+	constructor(opts = {}) {
+		const olen = opts.dkLen === void 0 ? 64 : opts.dkLen;
+		super(128, olen);
+		this.v0l = B2B_IV[0] | 0;
+		this.v0h = B2B_IV[1] | 0;
+		this.v1l = B2B_IV[2] | 0;
+		this.v1h = B2B_IV[3] | 0;
+		this.v2l = B2B_IV[4] | 0;
+		this.v2h = B2B_IV[5] | 0;
+		this.v3l = B2B_IV[6] | 0;
+		this.v3h = B2B_IV[7] | 0;
+		this.v4l = B2B_IV[8] | 0;
+		this.v4h = B2B_IV[9] | 0;
+		this.v5l = B2B_IV[10] | 0;
+		this.v5h = B2B_IV[11] | 0;
+		this.v6l = B2B_IV[12] | 0;
+		this.v6h = B2B_IV[13] | 0;
+		this.v7l = B2B_IV[14] | 0;
+		this.v7h = B2B_IV[15] | 0;
+		checkBlake2Opts(olen, opts, 64, 16, 16);
+		let { key, personalization, salt } = opts;
+		let keyLength = 0;
+		if (key !== void 0) {
+			key = toBytes(key);
+			keyLength = key.length;
+		}
+		this.v0l ^= this.outputLen | keyLength << 8 | 16842752;
+		if (salt !== void 0) {
+			salt = toBytes(salt);
+			const slt = u32(salt);
+			this.v4l ^= swap8IfBE(slt[0]);
+			this.v4h ^= swap8IfBE(slt[1]);
+			this.v5l ^= swap8IfBE(slt[2]);
+			this.v5h ^= swap8IfBE(slt[3]);
+		}
+		if (personalization !== void 0) {
+			personalization = toBytes(personalization);
+			const pers = u32(personalization);
+			this.v6l ^= swap8IfBE(pers[0]);
+			this.v6h ^= swap8IfBE(pers[1]);
+			this.v7l ^= swap8IfBE(pers[2]);
+			this.v7h ^= swap8IfBE(pers[3]);
+		}
+		if (key !== void 0) {
+			const tmp = new Uint8Array(this.blockLen);
+			tmp.set(key);
+			this.update(tmp);
+		}
+	}
+	get() {
+		let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+		return [
+			v0l,
+			v0h,
+			v1l,
+			v1h,
+			v2l,
+			v2h,
+			v3l,
+			v3h,
+			v4l,
+			v4h,
+			v5l,
+			v5h,
+			v6l,
+			v6h,
+			v7l,
+			v7h
+		];
+	}
+	set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+		this.v0l = v0l | 0;
+		this.v0h = v0h | 0;
+		this.v1l = v1l | 0;
+		this.v1h = v1h | 0;
+		this.v2l = v2l | 0;
+		this.v2h = v2h | 0;
+		this.v3l = v3l | 0;
+		this.v3h = v3h | 0;
+		this.v4l = v4l | 0;
+		this.v4h = v4h | 0;
+		this.v5l = v5l | 0;
+		this.v5h = v5h | 0;
+		this.v6l = v6l | 0;
+		this.v6h = v6h | 0;
+		this.v7l = v7l | 0;
+		this.v7h = v7h | 0;
+	}
+	compress(msg, offset, isLast) {
+		this.get().forEach((v, i) => BBUF[i] = v);
+		BBUF.set(B2B_IV, 16);
+		let { h, l } = fromBig(BigInt(this.length));
+		BBUF[24] = B2B_IV[8] ^ l;
+		BBUF[25] = B2B_IV[9] ^ h;
+		if (isLast) {
+			BBUF[28] = ~BBUF[28];
+			BBUF[29] = ~BBUF[29];
+		}
+		let j = 0;
+		const s = BSIGMA;
+		for (let i = 0; i < 12; i++) {
+			G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+			G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+			G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+			G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+			G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+			G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+			G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+			G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+			G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+			G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+			G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+			G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+			G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+			G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+			G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+			G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+		}
+		this.v0l ^= BBUF[0] ^ BBUF[16];
+		this.v0h ^= BBUF[1] ^ BBUF[17];
+		this.v1l ^= BBUF[2] ^ BBUF[18];
+		this.v1h ^= BBUF[3] ^ BBUF[19];
+		this.v2l ^= BBUF[4] ^ BBUF[20];
+		this.v2h ^= BBUF[5] ^ BBUF[21];
+		this.v3l ^= BBUF[6] ^ BBUF[22];
+		this.v3h ^= BBUF[7] ^ BBUF[23];
+		this.v4l ^= BBUF[8] ^ BBUF[24];
+		this.v4h ^= BBUF[9] ^ BBUF[25];
+		this.v5l ^= BBUF[10] ^ BBUF[26];
+		this.v5h ^= BBUF[11] ^ BBUF[27];
+		this.v6l ^= BBUF[12] ^ BBUF[28];
+		this.v6h ^= BBUF[13] ^ BBUF[29];
+		this.v7l ^= BBUF[14] ^ BBUF[30];
+		this.v7h ^= BBUF[15] ^ BBUF[31];
+		clean(BBUF);
+	}
+	destroy() {
+		this.destroyed = true;
+		clean(this.buffer32);
+		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+};
+/**
+* Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
+* @param msg - message that would be hashed
+* @param opts - dkLen output length, key for MAC mode, salt, personalization
+*/
+const blake2b = /* @__PURE__ */ createOptHasher((opts) => new BLAKE2b(opts));
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/argon2.js
+/**
+* Argon2 KDF from RFC 9106. Can be used to create a key from password and salt.
+* We suggest to use Scrypt. JS Argon is 2-10x slower than native code because of 64-bitness:
+* * argon uses uint64, but JS doesn't have fast uint64array
+* * uint64 multiplication is 1/3 of time
+* * `P` function would be very nice with u64, because most of value will be in registers,
+*   hovewer with u32 it will require 32 registers, which is too much.
+* * JS arrays do slow bound checks, so reading from `A2_BUF` slows it down
+* @module
+*/
+const AT = {
+	Argond2d: 0,
+	Argon2i: 1,
+	Argon2id: 2
+};
+const ARGON2_SYNC_POINTS = 4;
+const abytesOrZero = (buf) => {
+	if (buf === void 0) return Uint8Array.of();
+	return kdfInputToBytes(buf);
+};
+function mul(a, b) {
+	const aL = a & 65535;
+	const aH = a >>> 16;
+	const bL = b & 65535;
+	const bH = b >>> 16;
+	const ll = Math.imul(aL, bL);
+	const hl = Math.imul(aH, bL);
+	const lh = Math.imul(aL, bH);
+	const hh = Math.imul(aH, bH);
+	const carry = (ll >>> 16) + (hl & 65535) + lh;
+	return {
+		h: hh + (hl >>> 16) + (carry >>> 16) | 0,
+		l: carry << 16 | ll & 65535
+	};
+}
+function mul2(a, b) {
+	const { h, l } = mul(a, b);
+	return {
+		h: (h << 1 | l >>> 31) & 4294967295,
+		l: l << 1 & 4294967295
+	};
+}
+function blamka(Ah, Al, Bh, Bl) {
+	const { h: Ch, l: Cl } = mul2(Al, Bl);
+	const Rll = add3L(Al, Bl, Cl);
+	return {
+		h: add3H(Rll, Ah, Bh, Ch),
+		l: Rll | 0
+	};
+}
+const A2_BUF = new Uint32Array(256);
+function G(a, b, c, d) {
+	let Al = A2_BUF[2 * a], Ah = A2_BUF[2 * a + 1];
+	let Bl = A2_BUF[2 * b], Bh = A2_BUF[2 * b + 1];
+	let Cl = A2_BUF[2 * c], Ch = A2_BUF[2 * c + 1];
+	let Dl = A2_BUF[2 * d], Dh = A2_BUF[2 * d + 1];
+	({h: Ah, l: Al} = blamka(Ah, Al, Bh, Bl));
+	({Dh, Dl} = {
+		Dh: Dh ^ Ah,
+		Dl: Dl ^ Al
+	});
+	({Dh, Dl} = {
+		Dh: rotr32H(Dh, Dl),
+		Dl: rotr32L(Dh, Dl)
+	});
+	({h: Ch, l: Cl} = blamka(Ch, Cl, Dh, Dl));
+	({Bh, Bl} = {
+		Bh: Bh ^ Ch,
+		Bl: Bl ^ Cl
+	});
+	({Bh, Bl} = {
+		Bh: rotrSH(Bh, Bl, 24),
+		Bl: rotrSL(Bh, Bl, 24)
+	});
+	({h: Ah, l: Al} = blamka(Ah, Al, Bh, Bl));
+	({Dh, Dl} = {
+		Dh: Dh ^ Ah,
+		Dl: Dl ^ Al
+	});
+	({Dh, Dl} = {
+		Dh: rotrSH(Dh, Dl, 16),
+		Dl: rotrSL(Dh, Dl, 16)
+	});
+	({h: Ch, l: Cl} = blamka(Ch, Cl, Dh, Dl));
+	({Bh, Bl} = {
+		Bh: Bh ^ Ch,
+		Bl: Bl ^ Cl
+	});
+	({Bh, Bl} = {
+		Bh: rotrBH(Bh, Bl, 63),
+		Bl: rotrBL(Bh, Bl, 63)
+	});
+	A2_BUF[2 * a] = Al, A2_BUF[2 * a + 1] = Ah;
+	A2_BUF[2 * b] = Bl, A2_BUF[2 * b + 1] = Bh;
+	A2_BUF[2 * c] = Cl, A2_BUF[2 * c + 1] = Ch;
+	A2_BUF[2 * d] = Dl, A2_BUF[2 * d + 1] = Dh;
+}
+function P(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14, v15) {
+	G(v00, v04, v08, v12);
+	G(v01, v05, v09, v13);
+	G(v02, v06, v10, v14);
+	G(v03, v07, v11, v15);
+	G(v00, v05, v10, v15);
+	G(v01, v06, v11, v12);
+	G(v02, v07, v08, v13);
+	G(v03, v04, v09, v14);
+}
+function block(x, xPos, yPos, outPos, needXor) {
+	for (let i = 0; i < 256; i++) A2_BUF[i] = x[xPos + i] ^ x[yPos + i];
+	for (let i = 0; i < 128; i += 16) P(i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15);
+	for (let i = 0; i < 16; i += 2) P(i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49, i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113);
+	if (needXor) for (let i = 0; i < 256; i++) x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+	else for (let i = 0; i < 256; i++) x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+	clean(A2_BUF);
+}
+function Hp(A, dkLen) {
+	const A8 = u8(A);
+	const T = new Uint32Array(1);
+	const T8 = u8(T);
+	T[0] = dkLen;
+	if (dkLen <= 64) return blake2b.create({ dkLen }).update(T8).update(A8).digest();
+	const out = new Uint8Array(dkLen);
+	let V = blake2b.create({}).update(T8).update(A8).digest();
+	let pos = 0;
+	out.set(V.subarray(0, 32));
+	pos += 32;
+	for (; dkLen - pos > 64; pos += 32) {
+		const Vh = blake2b.create({}).update(V);
+		Vh.digestInto(V);
+		Vh.destroy();
+		out.set(V.subarray(0, 32), pos);
+	}
+	out.set(blake2b(V, { dkLen: dkLen - pos }), pos);
+	clean(V, T);
+	return u32(out);
+}
+function indexAlpha(r, s, laneLen, segmentLen, index, randL, sameLane = false) {
+	let area;
+	if (r === 0) if (s === 0) area = index - 1;
+	else if (sameLane) area = s * segmentLen + index - 1;
+	else area = s * segmentLen + (index == 0 ? -1 : 0);
+	else if (sameLane) area = laneLen - segmentLen + index - 1;
+	else area = laneLen - segmentLen + (index == 0 ? -1 : 0);
+	return ((r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0) + (area - 1 - mul(area, mul(randL, randL).h).h)) % laneLen;
+}
+const maxUint32 = Math.pow(2, 32);
+function isU32(num) {
+	return Number.isSafeInteger(num) && num >= 0 && num < maxUint32;
+}
+function argon2Opts(opts) {
+	const merged = {
+		version: 19,
+		dkLen: 32,
+		maxmem: maxUint32 - 1,
+		asyncTick: 10
+	};
+	for (let [k, v] of Object.entries(opts)) if (v != null) merged[k] = v;
+	const { dkLen, p, m, t, version, onProgress } = merged;
+	if (!isU32(dkLen) || dkLen < 4) throw new Error("dkLen should be at least 4 bytes");
+	if (!isU32(p) || p < 1 || p >= Math.pow(2, 24)) throw new Error("p should be 1 <= p < 2^24");
+	if (!isU32(m)) throw new Error("m should be 0 <= m < 2^32");
+	if (!isU32(t) || t < 1) throw new Error("t (iterations) should be 1 <= t < 2^32");
+	if (onProgress !== void 0 && typeof onProgress !== "function") throw new Error("progressCb should be function");
+	if (!isU32(m) || m < 8 * p) throw new Error("memory should be at least 8*p bytes");
+	if (version !== 16 && version !== 19) throw new Error("unknown version=" + version);
+	return merged;
+}
+function argon2Init(password, salt, type, opts) {
+	password = kdfInputToBytes(password);
+	salt = kdfInputToBytes(salt);
+	abytes(password);
+	abytes(salt);
+	if (!isU32(password.length)) throw new Error("password should be less than 4 GB");
+	if (!isU32(salt.length) || salt.length < 8) throw new Error("salt should be at least 8 bytes and less than 4 GB");
+	if (!Object.values(AT).includes(type)) throw new Error("invalid type");
+	let { p, dkLen, m, t, version, key, personalization, maxmem, onProgress, asyncTick } = argon2Opts(opts);
+	key = abytesOrZero(key);
+	personalization = abytesOrZero(personalization);
+	const h = blake2b.create({});
+	const BUF = new Uint32Array(1);
+	const BUF8 = u8(BUF);
+	for (let item of [
+		p,
+		dkLen,
+		m,
+		t,
+		version,
+		type
+	]) {
+		BUF[0] = item;
+		h.update(BUF8);
+	}
+	for (let i of [
+		password,
+		salt,
+		key,
+		personalization
+	]) {
+		BUF[0] = i.length;
+		h.update(BUF8).update(i);
+	}
+	const H0 = new Uint32Array(18);
+	const H0_8 = u8(H0);
+	h.digestInto(H0_8);
+	const lanes = p;
+	const mP = 4 * p * Math.floor(m / (ARGON2_SYNC_POINTS * p));
+	const laneLen = Math.floor(mP / p);
+	const segmentLen = Math.floor(laneLen / ARGON2_SYNC_POINTS);
+	const memUsed = mP * 256;
+	if (!isU32(maxmem) || memUsed > maxmem) throw new Error("mem should be less than 2**32, got: maxmem=" + maxmem + ", memused=" + memUsed);
+	const B = new Uint32Array(memUsed);
+	for (let l = 0; l < p; l++) {
+		const i = 256 * laneLen * l;
+		H0[17] = l;
+		H0[16] = 0;
+		B.set(Hp(H0, 1024), i);
+		H0[16] = 1;
+		B.set(Hp(H0, 1024), i + 256);
+	}
+	let perBlock = () => {};
+	if (onProgress) {
+		const totalBlock = t * ARGON2_SYNC_POINTS * p * segmentLen;
+		const callbackPer = Math.max(Math.floor(totalBlock / 1e4), 1);
+		let blockCnt = 0;
+		perBlock = () => {
+			blockCnt++;
+			if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock)) onProgress(blockCnt / totalBlock);
+		};
+	}
+	clean(BUF, H0);
+	return {
+		type,
+		mP,
+		p,
+		t,
+		version,
+		B,
+		laneLen,
+		lanes,
+		segmentLen,
+		dkLen,
+		perBlock,
+		asyncTick
+	};
+}
+function argon2Output(B, p, laneLen, dkLen) {
+	const B_final = new Uint32Array(256);
+	for (let l = 0; l < p; l++) for (let j = 0; j < 256; j++) B_final[j] ^= B[256 * (laneLen * l + laneLen - 1) + j];
+	const res = u8(Hp(B_final, dkLen));
+	clean(B_final);
+	return res;
+}
+function processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor) {
+	if (offset % laneLen) prev = offset - 1;
+	let randL, randH;
+	if (dataIndependent) {
+		let i128 = index % 128;
+		if (i128 === 0) {
+			address[268]++;
+			block(address, 256, 2 * 256, 0, false);
+			block(address, 0, 2 * 256, 0, false);
+		}
+		randL = address[2 * i128];
+		randH = address[2 * i128 + 1];
+	} else {
+		const T = 256 * prev;
+		randL = B[T];
+		randH = B[T + 1];
+	}
+	const refLane = r === 0 && s === 0 ? l : randH % lanes;
+	const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane == l);
+	const refBlock = laneLen * refLane + refPos;
+	block(B, 256 * prev, 256 * refBlock, offset * 256, needXor);
+}
+async function argon2Async(type, password, salt, opts) {
+	const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick } = argon2Init(password, salt, type, opts);
+	const address = new Uint32Array(3 * 256);
+	address[262] = mP;
+	address[264] = t;
+	address[266] = type;
+	let ts = Date.now();
+	for (let r = 0; r < t; r++) {
+		const needXor = r !== 0 && version === 19;
+		address[256] = r;
+		for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
+			address[260] = s;
+			const dataIndependent = type == AT.Argon2i || type == AT.Argon2id && r === 0 && s < 2;
+			for (let l = 0; l < p; l++) {
+				address[258] = l;
+				address[268] = 0;
+				let startPos = 0;
+				if (r === 0 && s === 0) {
+					startPos = 2;
+					if (dataIndependent) {
+						address[268]++;
+						block(address, 256, 2 * 256, 0, false);
+						block(address, 0, 2 * 256, 0, false);
+					}
+				}
+				let offset = l * laneLen + s * segmentLen + startPos;
+				let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
+				for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
+					perBlock();
+					processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor);
+					const diff = Date.now() - ts;
+					if (!(diff >= 0 && diff < asyncTick)) {
+						await nextTick();
+						ts += diff;
+					}
+				}
+			}
+		}
+	}
+	clean(address);
+	return argon2Output(B, p, laneLen, dkLen);
+}
+/** argon2id async, combining i+d, the most popular version from RFC 9106 */
+const argon2idAsync = (password, salt, opts) => argon2Async(AT.Argon2id, password, salt, opts);
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/hmac.js
+/**
+* HMAC: RFC2104 message authentication code.
+* @module
+*/
+var HMAC = class extends Hash {
+	constructor(hash, _key) {
+		super();
+		this.finished = false;
+		this.destroyed = false;
+		ahash(hash);
+		const key = toBytes(_key);
+		this.iHash = hash.create();
+		if (typeof this.iHash.update !== "function") throw new Error("Expected instance of class which extends utils.Hash");
+		this.blockLen = this.iHash.blockLen;
+		this.outputLen = this.iHash.outputLen;
+		const blockLen = this.blockLen;
+		const pad = new Uint8Array(blockLen);
+		pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+		for (let i = 0; i < pad.length; i++) pad[i] ^= 54;
+		this.iHash.update(pad);
+		this.oHash = hash.create();
+		for (let i = 0; i < pad.length; i++) pad[i] ^= 106;
+		this.oHash.update(pad);
+		clean(pad);
+	}
+	update(buf) {
+		aexists(this);
+		this.iHash.update(buf);
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		abytes(out, this.outputLen);
+		this.finished = true;
+		this.iHash.digestInto(out);
+		this.oHash.update(out);
+		this.oHash.digestInto(out);
+		this.destroy();
+	}
+	digest() {
+		const out = new Uint8Array(this.oHash.outputLen);
+		this.digestInto(out);
+		return out;
+	}
+	_cloneInto(to) {
+		to || (to = Object.create(Object.getPrototypeOf(this), {}));
+		const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+		to = to;
+		to.finished = finished;
+		to.destroyed = destroyed;
+		to.blockLen = blockLen;
+		to.outputLen = outputLen;
+		to.oHash = oHash._cloneInto(to.oHash);
+		to.iHash = iHash._cloneInto(to.iHash);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+	destroy() {
+		this.destroyed = true;
+		this.oHash.destroy();
+		this.iHash.destroy();
+	}
+};
+/**
+* HMAC: RFC2104 message authentication code.
+* @param hash - function that would be used e.g. sha256
+* @param key - message key
+* @param message - message data
+* @example
+* import { hmac } from '@noble/hashes/hmac';
+* import { sha256 } from '@noble/hashes/sha2';
+* const mac1 = hmac(sha256, 'key', 'message');
+*/
+const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new HMAC(hash, key);
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/hkdf.js
+/**
+* HKDF (RFC 5869): extract + expand in one step.
+* See https://soatok.blog/2021/11/17/understanding-hkdf/.
+* @module
+*/
+/**
+* HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
+* Arguments position differs from spec (IKM is first one, since it is not optional)
+* @param hash - hash function that would be used (e.g. sha256)
+* @param ikm - input keying material, the initial key
+* @param salt - optional salt value (a non-secret random value)
+*/
+function extract(hash, ikm, salt) {
+	ahash(hash);
+	if (salt === void 0) salt = new Uint8Array(hash.outputLen);
+	return hmac(hash, toBytes(salt), toBytes(ikm));
+}
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.from([0]);
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+/**
+* HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+* @param hash - hash function that would be used (e.g. sha256)
+* @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
+* @param info - optional context and application specific information (can be a zero-length string)
+* @param length - length of output keying material in bytes
+*/
+function expand(hash, prk, info, length = 32) {
+	ahash(hash);
+	anumber(length);
+	const olen = hash.outputLen;
+	if (length > 255 * olen) throw new Error("Length should be <= 255*HashLen");
+	const blocks = Math.ceil(length / olen);
+	if (info === void 0) info = EMPTY_BUFFER;
+	const okm = new Uint8Array(blocks * olen);
+	const HMAC = hmac.create(hash, prk);
+	const HMACTmp = HMAC._cloneInto();
+	const T = new Uint8Array(HMAC.outputLen);
+	for (let counter = 0; counter < blocks; counter++) {
+		HKDF_COUNTER[0] = counter + 1;
+		HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T).update(info).update(HKDF_COUNTER).digestInto(T);
+		okm.set(T, olen * counter);
+		HMAC._cloneInto(HMACTmp);
+	}
+	HMAC.destroy();
+	HMACTmp.destroy();
+	clean(T, HKDF_COUNTER);
+	return okm.slice(0, length);
+}
+/**
+* HKDF (RFC 5869): derive keys from an initial input.
+* Combines hkdf_extract + hkdf_expand in one step
+* @param hash - hash function that would be used (e.g. sha256)
+* @param ikm - input keying material, the initial key
+* @param salt - optional salt value (a non-secret random value)
+* @param info - optional context and application specific information (can be a zero-length string)
+* @param length - length of output keying material in bytes
+* @example
+* import { hkdf } from '@noble/hashes/hkdf';
+* import { sha256 } from '@noble/hashes/sha2';
+* import { randomBytes } from '@noble/hashes/utils';
+* const inputKey = randomBytes(32);
+* const salt = randomBytes(32);
+* const info = 'application-key';
+* const hk1 = hkdf(sha256, inputKey, salt, info, 32);
+*/
+const hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/sha2.js
+/**
+* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+* Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+*/
+/**
+* Round constants:
+* First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+*/
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** Reusable temporary buffer. "W" comes straight from spec. */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+	constructor(outputLen = 32) {
+		super(64, outputLen, 8, false);
+		this.A = SHA256_IV[0] | 0;
+		this.B = SHA256_IV[1] | 0;
+		this.C = SHA256_IV[2] | 0;
+		this.D = SHA256_IV[3] | 0;
+		this.E = SHA256_IV[4] | 0;
+		this.F = SHA256_IV[5] | 0;
+		this.G = SHA256_IV[6] | 0;
+		this.H = SHA256_IV[7] | 0;
+	}
+	get() {
+		const { A, B, C, D, E, F, G, H } = this;
+		return [
+			A,
+			B,
+			C,
+			D,
+			E,
+			F,
+			G,
+			H
+		];
+	}
+	set(A, B, C, D, E, F, G, H) {
+		this.A = A | 0;
+		this.B = B | 0;
+		this.C = C | 0;
+		this.D = D | 0;
+		this.E = E | 0;
+		this.F = F | 0;
+		this.G = G | 0;
+		this.H = H | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
+		for (let i = 16; i < 64; i++) {
+			const W15 = SHA256_W[i - 15];
+			const W2 = SHA256_W[i - 2];
+			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+			SHA256_W[i] = (rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10) + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+		}
+		let { A, B, C, D, E, F, G, H } = this;
+		for (let i = 0; i < 64; i++) {
+			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + 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;
+		}
+		A = A + this.A | 0;
+		B = B + this.B | 0;
+		C = C + this.C | 0;
+		D = D + this.D | 0;
+		E = E + this.E | 0;
+		F = F + this.F | 0;
+		G = G + this.G | 0;
+		H = H + this.H | 0;
+		this.set(A, B, C, D, E, F, G, H);
+	}
+	roundClean() {
+		clean(SHA256_W);
+	}
+	destroy() {
+		this.set(0, 0, 0, 0, 0, 0, 0, 0);
+		clean(this.buffer);
+	}
+};
+const K512 = split([
+	"0x428a2f98d728ae22",
+	"0x7137449123ef65cd",
+	"0xb5c0fbcfec4d3b2f",
+	"0xe9b5dba58189dbbc",
+	"0x3956c25bf348b538",
+	"0x59f111f1b605d019",
+	"0x923f82a4af194f9b",
+	"0xab1c5ed5da6d8118",
+	"0xd807aa98a3030242",
+	"0x12835b0145706fbe",
+	"0x243185be4ee4b28c",
+	"0x550c7dc3d5ffb4e2",
+	"0x72be5d74f27b896f",
+	"0x80deb1fe3b1696b1",
+	"0x9bdc06a725c71235",
+	"0xc19bf174cf692694",
+	"0xe49b69c19ef14ad2",
+	"0xefbe4786384f25e3",
+	"0x0fc19dc68b8cd5b5",
+	"0x240ca1cc77ac9c65",
+	"0x2de92c6f592b0275",
+	"0x4a7484aa6ea6e483",
+	"0x5cb0a9dcbd41fbd4",
+	"0x76f988da831153b5",
+	"0x983e5152ee66dfab",
+	"0xa831c66d2db43210",
+	"0xb00327c898fb213f",
+	"0xbf597fc7beef0ee4",
+	"0xc6e00bf33da88fc2",
+	"0xd5a79147930aa725",
+	"0x06ca6351e003826f",
+	"0x142929670a0e6e70",
+	"0x27b70a8546d22ffc",
+	"0x2e1b21385c26c926",
+	"0x4d2c6dfc5ac42aed",
+	"0x53380d139d95b3df",
+	"0x650a73548baf63de",
+	"0x766a0abb3c77b2a8",
+	"0x81c2c92e47edaee6",
+	"0x92722c851482353b",
+	"0xa2bfe8a14cf10364",
+	"0xa81a664bbc423001",
+	"0xc24b8b70d0f89791",
+	"0xc76c51a30654be30",
+	"0xd192e819d6ef5218",
+	"0xd69906245565a910",
+	"0xf40e35855771202a",
+	"0x106aa07032bbd1b8",
+	"0x19a4c116b8d2d0c8",
+	"0x1e376c085141ab53",
+	"0x2748774cdf8eeb99",
+	"0x34b0bcb5e19b48a8",
+	"0x391c0cb3c5c95a63",
+	"0x4ed8aa4ae3418acb",
+	"0x5b9cca4f7763e373",
+	"0x682e6ff3d6b2b8a3",
+	"0x748f82ee5defb2fc",
+	"0x78a5636f43172f60",
+	"0x84c87814a1f0ab72",
+	"0x8cc702081a6439ec",
+	"0x90befffa23631e28",
+	"0xa4506cebde82bde9",
+	"0xbef9a3f7b2c67915",
+	"0xc67178f2e372532b",
+	"0xca273eceea26619c",
+	"0xd186b8c721c0c207",
+	"0xeada7dd6cde0eb1e",
+	"0xf57d4f7fee6ed178",
+	"0x06f067aa72176fba",
+	"0x0a637dc5a2c898a6",
+	"0x113f9804bef90dae",
+	"0x1b710b35131c471b",
+	"0x28db77f523047d84",
+	"0x32caab7b40c72493",
+	"0x3c9ebe0a15c9bebc",
+	"0x431d67c49c100d4c",
+	"0x4cc5d4becb3e42b6",
+	"0x597f299cfc657e2a",
+	"0x5fcb6fab3ad6faec",
+	"0x6c44198c4a475817"
+].map((n) => BigInt(n)));
+const SHA512_Kh = K512[0];
+const SHA512_Kl = K512[1];
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+var SHA512 = class extends HashMD {
+	constructor(outputLen = 64) {
+		super(128, outputLen, 16, false);
+		this.Ah = SHA512_IV[0] | 0;
+		this.Al = SHA512_IV[1] | 0;
+		this.Bh = SHA512_IV[2] | 0;
+		this.Bl = SHA512_IV[3] | 0;
+		this.Ch = SHA512_IV[4] | 0;
+		this.Cl = SHA512_IV[5] | 0;
+		this.Dh = SHA512_IV[6] | 0;
+		this.Dl = SHA512_IV[7] | 0;
+		this.Eh = SHA512_IV[8] | 0;
+		this.El = SHA512_IV[9] | 0;
+		this.Fh = SHA512_IV[10] | 0;
+		this.Fl = SHA512_IV[11] | 0;
+		this.Gh = SHA512_IV[12] | 0;
+		this.Gl = SHA512_IV[13] | 0;
+		this.Hh = SHA512_IV[14] | 0;
+		this.Hl = SHA512_IV[15] | 0;
+	}
+	get() {
+		const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		return [
+			Ah,
+			Al,
+			Bh,
+			Bl,
+			Ch,
+			Cl,
+			Dh,
+			Dl,
+			Eh,
+			El,
+			Fh,
+			Fl,
+			Gh,
+			Gl,
+			Hh,
+			Hl
+		];
+	}
+	set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+		this.Ah = Ah | 0;
+		this.Al = Al | 0;
+		this.Bh = Bh | 0;
+		this.Bl = Bl | 0;
+		this.Ch = Ch | 0;
+		this.Cl = Cl | 0;
+		this.Dh = Dh | 0;
+		this.Dl = Dl | 0;
+		this.Eh = Eh | 0;
+		this.El = El | 0;
+		this.Fh = Fh | 0;
+		this.Fl = Fl | 0;
+		this.Gh = Gh | 0;
+		this.Gl = Gl | 0;
+		this.Hh = Hh | 0;
+		this.Hl = Hl | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) {
+			SHA512_W_H[i] = view.getUint32(offset);
+			SHA512_W_L[i] = view.getUint32(offset += 4);
+		}
+		for (let i = 16; i < 80; i++) {
+			const W15h = SHA512_W_H[i - 15] | 0;
+			const W15l = SHA512_W_L[i - 15] | 0;
+			const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+			const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+			const W2h = SHA512_W_H[i - 2] | 0;
+			const W2l = SHA512_W_L[i - 2] | 0;
+			const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+			const SUMl = add4L(s0l, rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6), SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+			SHA512_W_H[i] = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]) | 0;
+			SHA512_W_L[i] = SUMl | 0;
+		}
+		let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		for (let i = 0; i < 80; i++) {
+			const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+			const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+			const CHIh = Eh & Fh ^ ~Eh & Gh;
+			const CHIl = El & Fl ^ ~El & Gl;
+			const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+			const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+			const T1l = T1ll | 0;
+			const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+			const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+			const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+			const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+			Hh = Gh | 0;
+			Hl = Gl | 0;
+			Gh = Fh | 0;
+			Gl = Fl | 0;
+			Fh = Eh | 0;
+			Fl = El | 0;
+			({h: Eh, l: El} = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+			Dh = Ch | 0;
+			Dl = Cl | 0;
+			Ch = Bh | 0;
+			Cl = Bl | 0;
+			Bh = Ah | 0;
+			Bl = Al | 0;
+			const All = add3L(T1l, sigma0l, MAJl);
+			Ah = add3H(All, T1h, sigma0h, MAJh);
+			Al = All | 0;
+		}
+		({h: Ah, l: Al} = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+		({h: Bh, l: Bl} = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+		({h: Ch, l: Cl} = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+		({h: Dh, l: Dl} = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+		({h: Eh, l: El} = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+		({h: Fh, l: Fl} = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+		({h: Gh, l: Gl} = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+		({h: Hh, l: Hl} = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+		this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+	}
+	roundClean() {
+		clean(SHA512_W_H, SHA512_W_L);
+	}
+	destroy() {
+		clean(this.buffer);
+		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+};
+/**
+* SHA2-256 hash function from RFC 4634.
+*
+* It is the fastest JS hash, even faster than Blake3.
+* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+*/
+const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+/** SHA2-512 hash function from RFC 4634. */
+const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/pbkdf2.js
+/**
+* PBKDF (RFC 2898). Can be used to create a key from password and salt.
+* @module
+*/
+function pbkdf2Init(hash, _password, _salt, _opts) {
+	ahash(hash);
+	const { c, dkLen, asyncTick } = checkOpts({
+		dkLen: 32,
+		asyncTick: 10
+	}, _opts);
+	anumber(c);
+	anumber(dkLen);
+	anumber(asyncTick);
+	if (c < 1) throw new Error("iterations (c) should be >= 1");
+	const password = kdfInputToBytes(_password);
+	const salt = kdfInputToBytes(_salt);
+	const DK = new Uint8Array(dkLen);
+	const PRF = hmac.create(hash, password);
+	return {
+		c,
+		dkLen,
+		asyncTick,
+		DK,
+		PRF,
+		PRFSalt: PRF._cloneInto().update(salt)
+	};
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+	PRF.destroy();
+	PRFSalt.destroy();
+	if (prfW) prfW.destroy();
+	clean(u);
+	return DK;
+}
+/**
+* PBKDF2-HMAC: RFC 2898 key derivation function
+* @param hash - hash function that would be used e.g. sha256
+* @param password - password from which a derived key is generated
+* @param salt - cryptographic salt
+* @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+* @example
+* const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+*/
+function pbkdf2(hash, password, salt, opts) {
+	const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+	let prfW;
+	const arr = new Uint8Array(4);
+	const view = createView(arr);
+	const u = new Uint8Array(PRF.outputLen);
+	for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+		const Ti = DK.subarray(pos, pos + PRF.outputLen);
+		view.setInt32(0, ti, false);
+		(prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+		Ti.set(u.subarray(0, Ti.length));
+		for (let ui = 1; ui < c; ui++) {
+			PRF._cloneInto(prfW).update(u).digestInto(u);
+			for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
+		}
+	}
+	return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+//#endregion
+export { argon2idAsync as a, hexToBytes as c, hkdf as i, randomBytes as l, sha256 as n, abytes as o, sha512 as r, bytesToHex as s, pbkdf2 as t };