@better-update/cli 0.33.0 → 0.33.1

package/dist/index.mjs

@@ -34,7 +34,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.33.0";
+var version = "0.33.1";
 
 //#endregion
 //#region src/lib/interactive-mode.ts
@@ -925,7 +925,7 @@ var AuditLog = class extends Schema.Class("AuditLog")({
 //#region ../../packages/api/src/groups/audit-logs.ts
 var AuditLogsGroup = class extends HttpApiGroup.make("audit-logs").add(HttpApiEndpoint.get("list", "/api/audit-logs").setUrlParams(Schema.Struct({
 	projectId: Schema.optional(Schema.String),
-	resourceType: Schema.optional(Schema.String),
+	resourceType: Schema.optional(AuditLogResourceType),
 	from: Schema.optional(Schema.String),
 	to: Schema.optional(Schema.String),
 	...CursorPaginationParams.fields
@@ -5316,7 +5316,7 @@ const findAndroidArtifact = ({ projectRoot, format, flavor, buildType, minMtimeM
 * isBytes(new Uint8Array());
 * ```
 */
-function isBytes$5(a) {
+function isBytes$4(a) {
 	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
 }
 /**
@@ -5330,7 +5330,7 @@ function isBytes$5(a) {
 * abool(true);
 * ```
 */
-function abool$3(b) {
+function abool$2(b) {
 	if (typeof b !== "boolean") throw new TypeError(`boolean expected, not ${b}`);
 }
 /**
@@ -5345,7 +5345,7 @@ function abool$3(b) {
 * anumber(1);
 * ```
 */
-function anumber$5(n) {
+function anumber$4(n) {
 	if (typeof n !== "number") throw new TypeError("number expected, got " + typeof n);
 	if (!Number.isSafeInteger(n) || n < 0) throw new RangeError("positive integer expected, got " + n);
 }
@@ -5365,8 +5365,8 @@ function anumber$5(n) {
 * abytes(new Uint8Array([1, 2]), 2);
 * ```
 */
-function abytes$5(value, length, title = "") {
-	const bytes = isBytes$5(value);
+function abytes$4(value, length, title = "") {
+	const bytes = isBytes$4(value);
 	const len = value?.length;
 	const needsLen = length !== void 0;
 	if (!bytes || needsLen && len !== length) {
@@ -5392,7 +5392,7 @@ function abytes$5(value, length, title = "") {
 * aexists({ destroyed: false, finished: false });
 * ```
 */
-function aexists$3(instance, checkFinished = true) {
+function aexists$2(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");
 }
@@ -5413,11 +5413,11 @@ function aexists$3(instance, checkFinished = true) {
 * aoutput(new Uint8Array(16), { outputLen: 16 });
 * ```
 */
-function aoutput$3(out, instance, onlyAligned = false) {
-	abytes$5(out, void 0, "output");
+function aoutput$2(out, instance, onlyAligned = false) {
+	abytes$4(out, void 0, "output");
 	const min = instance.outputLen;
 	if (out.length < min) throw new RangeError("digestInto() expects output buffer of length at least " + min);
-	if (onlyAligned && !isAligned32$2(out)) throw new Error("invalid output, must be aligned");
+	if (onlyAligned && !isAligned32(out)) throw new Error("invalid output, must be aligned");
 }
 /**
 * Casts a typed-array view to Uint32Array.
@@ -5431,7 +5431,7 @@ function aoutput$3(out, instance, onlyAligned = false) {
 * u32(new Uint8Array(4));
 * ```
 */
-function u32$3(arr) {
+function u32$2(arr) {
 	return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 }
 /**
@@ -5446,7 +5446,7 @@ function u32$3(arr) {
 * clean(bytes);
 * ```
 */
-function clean$3(...arrays) {
+function clean$2(...arrays) {
 	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
 }
 /**
@@ -5460,14 +5460,14 @@ function clean$3(...arrays) {
 * createView(new Uint8Array(4));
 * ```
 */
-function createView$3(arr) {
+function createView$2(arr) {
 	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
 /**
 * Whether the current platform is little-endian.
 * Most are; some IBM systems are not.
 */
-const isLE$3 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+const isLE$2 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
 /**
 * Reverses byte order of one 32-bit word.
 * @param word - Unsigned 32-bit word to swap.
@@ -5491,7 +5491,7 @@ const byteSwap$2 = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | wo
 * swap8IfBE(0x11223344);
 * ```
 */
-const swap8IfBE$1 = isLE$3 ? (n) => n : (n) => byteSwap$2(n) >>> 0;
+const swap8IfBE$1 = isLE$2 ? (n) => n : (n) => byteSwap$2(n) >>> 0;
 /**
 * Byte-swaps every word of a Uint32Array in place.
 * @param arr - Uint32Array whose words should be swapped.
@@ -5518,7 +5518,7 @@ const byteSwap32$2 = (arr) => {
 * swap32IfBE(new Uint32Array([0x11223344]));
 * ```
 */
-const swap32IfBE$2 = isLE$3 ? (u) => u : byteSwap32$2;
+const swap32IfBE$2 = isLE$2 ? (u) => u : byteSwap32$2;
 /**
 * Checks if two U8A use same underlying buffer and overlaps.
 * This is invalid and can corrupt data.
@@ -5552,7 +5552,7 @@ function concatBytes$3(...arrays) {
 	let sum = 0;
 	for (let i = 0; i < arrays.length; i++) {
 		const a = arrays[i];
-		abytes$5(a);
+		abytes$4(a);
 		sum += a.length;
 	}
 	const res = new Uint8Array(sum);
@@ -5577,7 +5577,7 @@ function concatBytes$3(...arrays) {
 * checkOpts({ rounds: 20 }, { rounds: 8 });
 * ```
 */
-function checkOpts$2(defaults, opts) {
+function checkOpts$1(defaults, opts) {
 	if (opts == null || typeof opts !== "object") throw new Error("options must be defined");
 	return Object.assign(defaults, opts);
 }
@@ -5593,7 +5593,7 @@ function checkOpts$2(defaults, opts) {
 * equalBytes(new Uint8Array([1]), new Uint8Array([1]));
 * ```
 */
-function equalBytes$3(a, b) {
+function equalBytes$2(a, b) {
 	if (a.length !== b.length) return false;
 	let diff = 0;
 	for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
@@ -5629,20 +5629,20 @@ function wrapMacConstructor(keyLen, macCons, fromMsg) {
 * @param constructor - Cipher constructor.
 * @returns Wrapped constructor with validation.
 */
-const wrapCipher$1 = (params, constructor) => {
+const wrapCipher = (params, constructor) => {
 	function wrappedCipher(key, ...args) {
-		abytes$5(key, void 0, "key");
+		abytes$4(key, void 0, "key");
 		if (params.nonceLength !== void 0) {
 			const nonce = args[0];
-			abytes$5(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
+			abytes$4(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
 		}
 		const tagl = params.tagLength;
-		if (tagl && args[1] !== void 0) abytes$5(args[1], void 0, "AAD");
+		if (tagl && args[1] !== void 0) abytes$4(args[1], void 0, "AAD");
 		const cipher = constructor(key, ...args);
 		const checkOutput = (fnLength, output) => {
 			if (output !== void 0) {
 				if (fnLength !== 2) throw new Error("cipher output not supported");
-				abytes$5(output, void 0, "output");
+				abytes$4(output, void 0, "output");
 			}
 		};
 		let called = false;
@@ -5650,12 +5650,12 @@ const wrapCipher$1 = (params, constructor) => {
 			encrypt(data, output) {
 				if (called) throw new Error("cannot encrypt() twice with same key + nonce");
 				called = true;
-				abytes$5(data);
+				abytes$4(data);
 				checkOutput(cipher.encrypt.length, output);
 				return cipher.encrypt(data, output);
 			},
 			decrypt(data, output) {
-				abytes$5(data);
+				abytes$4(data);
 				if (tagl && data.length < tagl) throw new Error("\"ciphertext\" expected length bigger than tagLength=" + tagl);
 				checkOutput(cipher.decrypt.length, output);
 				return cipher.decrypt(data, output);
@@ -5681,11 +5681,11 @@ const wrapCipher$1 = (params, constructor) => {
 * getOutput(16, new Uint8Array(16));
 * ```
 */
-function getOutput$1(expectedLength, out, onlyAligned = true) {
+function getOutput(expectedLength, out, onlyAligned = true) {
 	if (out === void 0) return new Uint8Array(expectedLength);
-	abytes$5(out, void 0, "output");
+	abytes$4(out, void 0, "output");
 	if (out.length !== expectedLength) throw new Error("\"output\" expected Uint8Array of length " + expectedLength + ", got: " + out.length);
-	if (onlyAligned && !isAligned32$2(out)) throw new Error("invalid output, must be aligned");
+	if (onlyAligned && !isAligned32(out)) throw new Error("invalid output, must be aligned");
 	return out;
 }
 /**
@@ -5705,12 +5705,12 @@ function getOutput$1(expectedLength, out, onlyAligned = true) {
 * u64Lengths(16, 8, true);
 * ```
 */
-function u64Lengths$1(dataLength, aadLength, isLE) {
-	anumber$5(dataLength);
-	anumber$5(aadLength);
-	abool$3(isLE);
+function u64Lengths(dataLength, aadLength, isLE) {
+	anumber$4(dataLength);
+	anumber$4(aadLength);
+	abool$2(isLE);
 	const num = new Uint8Array(16);
-	const view = createView$3(num);
+	const view = createView$2(num);
 	view.setBigUint64(0, BigInt(aadLength), isLE);
 	view.setBigUint64(8, BigInt(dataLength), isLE);
 	return num;
@@ -5726,7 +5726,7 @@ function u64Lengths$1(dataLength, aadLength, isLE) {
 * isAligned32(new Uint8Array(4));
 * ```
 */
-function isAligned32$2(bytes) {
+function isAligned32(bytes) {
 	return bytes.byteOffset % 4 === 0;
 }
 /**
@@ -5741,8 +5741,8 @@ function isAligned32$2(bytes) {
 * copyBytes(new Uint8Array([1, 2]));
 * ```
 */
-function copyBytes$4(bytes) {
-	return Uint8Array.from(abytes$5(bytes));
+function copyBytes$3(bytes) {
+	return Uint8Array.from(abytes$4(bytes));
 }
 /**
 * Cryptographically secure PRNG.
@@ -5762,7 +5762,7 @@ function copyBytes$4(bytes) {
 * ```
 */
 function randomBytes$5(bytesLength = 32) {
-	anumber$5(bytesLength);
+	anumber$4(bytesLength);
 	const cr = typeof globalThis === "object" ? globalThis.crypto : null;
 	if (typeof cr?.getRandomValues !== "function") throw new Error("crypto.getRandomValues must be defined");
 	return cr.getRandomValues(new Uint8Array(bytesLength));
@@ -5799,7 +5799,7 @@ function randomBytes$5(bytesLength = 32) {
 */
 function managedNonce(fn, randomBytes_ = randomBytes$5) {
 	const { nonceLength } = fn;
-	anumber$5(nonceLength);
+	anumber$4(nonceLength);
 	const addNonce = (nonce, ciphertext, plaintext) => {
 		const out = concatBytes$3(nonce, ciphertext);
 		if (!overlapBytes(plaintext, ciphertext)) ciphertext.fill(0);
@@ -5807,14 +5807,14 @@ function managedNonce(fn, randomBytes_ = randomBytes$5) {
 	};
 	const res = ((key, ...args) => ({
 		encrypt(plaintext) {
-			abytes$5(plaintext);
+			abytes$4(plaintext);
 			const nonce = randomBytes_(nonceLength);
 			const encrypted = fn(key, nonce, ...args).encrypt(plaintext);
 			if (encrypted instanceof Promise) return encrypted.then((ct) => addNonce(nonce, ct, plaintext));
 			return addNonce(nonce, encrypted, plaintext);
 		},
 		decrypt(ciphertext) {
-			abytes$5(ciphertext);
+			abytes$4(ciphertext);
 			const nonce = ciphertext.subarray(0, nonceLength);
 			const decrypted = ciphertext.subarray(nonceLength);
 			return fn(key, nonce, ...args).decrypt(decrypted);
@@ -5867,9 +5867,9 @@ See {@link https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha#appendi
 
 * @module
 */
-const encodeStr$1 = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
-const sigma16_32$1 = /* @__PURE__ */ (() => swap32IfBE$2(u32$3(encodeStr$1("expand 16-byte k"))))();
-const sigma32_32$1 = /* @__PURE__ */ (() => swap32IfBE$2(u32$3(encodeStr$1("expand 32-byte k"))))();
+const encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
+const sigma16_32 = /* @__PURE__ */ (() => swap32IfBE$2(u32$2(encodeStr("expand 16-byte k"))))();
+const sigma32_32 = /* @__PURE__ */ (() => swap32IfBE$2(u32$2(encodeStr("expand 32-byte k"))))();
 /**
 * Rotates a 32-bit word left.
 * @param a - Input word.
@@ -5881,26 +5881,26 @@ const sigma32_32$1 = /* @__PURE__ */ (() => swap32IfBE$2(u32$3(encodeStr$1("expa
 * rotl(0x12345678, 8);
 * ```
 */
-function rotl$2(a, b) {
+function rotl$1(a, b) {
 	return a << b | a >>> 32 - b;
 }
-const BLOCK_LEN$1 = 64;
-const BLOCK_LEN32$1 = 16;
-const MAX_COUNTER$1 = /* @__PURE__ */ (() => 2 ** 32 - 1)();
-const U32_EMPTY$1 = /* @__PURE__ */ Uint32Array.of();
-function runCipher$1(core, sigma, key, nonce, data, output, counter, rounds) {
+const BLOCK_LEN = 64;
+const BLOCK_LEN32 = 16;
+const MAX_COUNTER = /* @__PURE__ */ (() => 2 ** 32 - 1)();
+const U32_EMPTY = /* @__PURE__ */ Uint32Array.of();
+function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
 	const len = data.length;
-	const block = new Uint8Array(BLOCK_LEN$1);
-	const b32 = u32$3(block);
-	const isAligned = isLE$3 && isAligned32$2(data) && isAligned32$2(output);
-	const d32 = isAligned ? u32$3(data) : U32_EMPTY$1;
-	const o32 = isAligned ? u32$3(output) : U32_EMPTY$1;
-	if (!isLE$3) {
+	const block = new Uint8Array(BLOCK_LEN);
+	const b32 = u32$2(block);
+	const isAligned = isLE$2 && isAligned32(data) && isAligned32(output);
+	const d32 = isAligned ? u32$2(data) : U32_EMPTY;
+	const o32 = isAligned ? u32$2(output) : U32_EMPTY;
+	if (!isLE$2) {
 		for (let pos = 0; pos < len; counter++) {
 			core(sigma, key, nonce, b32, counter, rounds);
 			swap32IfBE$2(b32);
-			if (counter >= MAX_COUNTER$1) throw new Error("arx: counter overflow");
-			const take = Math.min(BLOCK_LEN$1, len - pos);
+			if (counter >= MAX_COUNTER) throw new Error("arx: counter overflow");
+			const take = Math.min(BLOCK_LEN, len - pos);
 			for (let j = 0, posj; j < take; j++) {
 				posj = pos + j;
 				output[posj] = data[posj] ^ block[j];
@@ -5911,16 +5911,16 @@ function runCipher$1(core, sigma, key, nonce, data, output, counter, rounds) {
 	}
 	for (let pos = 0; pos < len; counter++) {
 		core(sigma, key, nonce, b32, counter, rounds);
-		if (counter >= MAX_COUNTER$1) throw new Error("arx: counter overflow");
-		const take = Math.min(BLOCK_LEN$1, len - pos);
-		if (isAligned && take === BLOCK_LEN$1) {
+		if (counter >= MAX_COUNTER) throw new Error("arx: counter overflow");
+		const take = Math.min(BLOCK_LEN, len - pos);
+		if (isAligned && take === BLOCK_LEN) {
 			const pos32 = pos / 4;
 			if (pos % 4 !== 0) throw new Error("arx: invalid block position");
-			for (let j = 0, posj; j < BLOCK_LEN32$1; j++) {
+			for (let j = 0, posj; j < BLOCK_LEN32; j++) {
 				posj = pos32 + j;
 				o32[posj] = d32[posj] ^ b32[j];
 			}
-			pos += BLOCK_LEN$1;
+			pos += BLOCK_LEN;
 			continue;
 		}
 		for (let j = 0, posj; j < take; j++) {
@@ -5938,57 +5938,57 @@ function runCipher$1(core, sigma, key, nonce, data, output, counter, rounds) {
 * @returns Stream cipher function over byte arrays.
 * @throws If the core callback, key size, counter, or output sizing is invalid. {@link Error}
 */
-function createCipher$1(core, opts) {
-	const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts$2({
+function createCipher(core, opts) {
+	const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts$1({
 		allowShortKeys: false,
 		counterLength: 8,
 		counterRight: false,
 		rounds: 20
 	}, opts);
 	if (typeof core !== "function") throw new Error("core must be a function");
-	anumber$5(counterLength);
-	anumber$5(rounds);
-	abool$3(counterRight);
-	abool$3(allowShortKeys);
+	anumber$4(counterLength);
+	anumber$4(rounds);
+	abool$2(counterRight);
+	abool$2(allowShortKeys);
 	return (key, nonce, data, output, counter = 0) => {
-		abytes$5(key, void 0, "key");
-		abytes$5(nonce, void 0, "nonce");
-		abytes$5(data, void 0, "data");
+		abytes$4(key, void 0, "key");
+		abytes$4(nonce, void 0, "nonce");
+		abytes$4(data, void 0, "data");
 		const len = data.length;
-		output = getOutput$1(len, output, false);
-		anumber$5(counter);
-		if (counter < 0 || counter >= MAX_COUNTER$1) throw new Error("arx: counter overflow");
+		output = getOutput(len, output, false);
+		anumber$4(counter);
+		if (counter < 0 || counter >= MAX_COUNTER) throw new Error("arx: counter overflow");
 		const toClean = [];
 		let l = key.length;
 		let k;
 		let sigma;
 		if (l === 32) {
-			toClean.push(k = copyBytes$4(key));
-			sigma = sigma32_32$1;
+			toClean.push(k = copyBytes$3(key));
+			sigma = sigma32_32;
 		} else if (l === 16 && allowShortKeys) {
 			k = new Uint8Array(32);
 			k.set(key);
 			k.set(key, 16);
-			sigma = sigma16_32$1;
+			sigma = sigma16_32;
 			toClean.push(k);
 		} else {
-			abytes$5(key, 32, "arx key");
+			abytes$4(key, 32, "arx key");
 			throw new Error("invalid key size");
 		}
-		if (!isLE$3 || !isAligned32$2(nonce)) toClean.push(nonce = copyBytes$4(nonce));
-		let k32 = u32$3(k);
+		if (!isLE$2 || !isAligned32(nonce)) toClean.push(nonce = copyBytes$3(nonce));
+		let k32 = u32$2(k);
 		if (extendNonceFn) {
 			if (nonce.length !== 24) throw new Error(`arx: extended nonce must be 24 bytes`);
 			const n16 = nonce.subarray(0, 16);
-			if (isLE$3) extendNonceFn(sigma, k32, u32$3(n16), k32);
+			if (isLE$2) extendNonceFn(sigma, k32, u32$2(n16), k32);
 			else {
 				const sigmaRaw = swap32IfBE$2(Uint32Array.from(sigma));
-				extendNonceFn(sigmaRaw, k32, u32$3(n16), k32);
-				clean$3(sigmaRaw);
+				extendNonceFn(sigmaRaw, k32, u32$2(n16), k32);
+				clean$2(sigmaRaw);
 				swap32IfBE$2(k32);
 			}
 			nonce = nonce.subarray(16);
-		} else if (!isLE$3) swap32IfBE$2(k32);
+		} else if (!isLE$2) swap32IfBE$2(k32);
 		const nonceNcLen = 16 - counterLength;
 		if (nonceNcLen !== nonce.length) throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
 		if (nonceNcLen !== 12) {
@@ -5997,12 +5997,12 @@ function createCipher$1(core, opts) {
 			nonce = nc;
 			toClean.push(nonce);
 		}
-		const n32 = swap32IfBE$2(u32$3(nonce));
+		const n32 = swap32IfBE$2(u32$2(nonce));
 		try {
-			runCipher$1(core, sigma, k32, n32, data, output, counter, rounds);
+			runCipher(core, sigma, k32, n32, data, output, counter, rounds);
 			return output;
 		} finally {
-			clean$3(...toClean);
+			clean$2(...toClean);
 		}
 	};
 }
@@ -6028,7 +6028,7 @@ function createCipher$1(core, opts) {
 * Based on public-domain {@link https://github.com/floodyberry/poly1305-donna | poly1305-donna}.
 * @module
 */
-function u8to16$1(a, i) {
+function u8to16(a, i) {
 	return a[i++] & 255 | (a[i++] & 255) << 8;
 }
 /**
@@ -6047,7 +6047,7 @@ function u8to16$1(a, i) {
 * mac.digest();
 * ```
 */
-var Poly1305$1 = class {
+var Poly1305 = class {
 	blockLen = 16;
 	outputLen = 16;
 	buffer = new Uint8Array(16);
@@ -6058,15 +6058,15 @@ var Poly1305$1 = class {
 	finished = false;
 	destroyed = false;
 	constructor(key) {
-		key = copyBytes$4(abytes$5(key, 32, "key"));
-		const t0 = u8to16$1(key, 0);
-		const t1 = u8to16$1(key, 2);
-		const t2 = u8to16$1(key, 4);
-		const t3 = u8to16$1(key, 6);
-		const t4 = u8to16$1(key, 8);
-		const t5 = u8to16$1(key, 10);
-		const t6 = u8to16$1(key, 12);
-		const t7 = u8to16$1(key, 14);
+		key = copyBytes$3(abytes$4(key, 32, "key"));
+		const t0 = u8to16(key, 0);
+		const t1 = u8to16(key, 2);
+		const t2 = u8to16(key, 4);
+		const t3 = u8to16(key, 6);
+		const t4 = u8to16(key, 8);
+		const t5 = u8to16(key, 10);
+		const t6 = u8to16(key, 12);
+		const t7 = u8to16(key, 14);
 		this.r[0] = t0 & 8191;
 		this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
 		this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
@@ -6077,7 +6077,7 @@ var Poly1305$1 = class {
 		this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
 		this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
 		this.r[9] = t7 >>> 5 & 127;
-		for (let i = 0; i < 8; i++) this.pad[i] = u8to16$1(key, 16 + 2 * i);
+		for (let i = 0; i < 8; i++) this.pad[i] = u8to16(key, 16 + 2 * i);
 	}
 	process(data, offset, isLast = false) {
 		const hibit = isLast ? 0 : 2048;
@@ -6092,14 +6092,14 @@ var Poly1305$1 = class {
 		const r7 = r[7];
 		const r8 = r[8];
 		const r9 = r[9];
-		const t0 = u8to16$1(data, offset + 0);
-		const t1 = u8to16$1(data, offset + 2);
-		const t2 = u8to16$1(data, offset + 4);
-		const t3 = u8to16$1(data, offset + 6);
-		const t4 = u8to16$1(data, offset + 8);
-		const t5 = u8to16$1(data, offset + 10);
-		const t6 = u8to16$1(data, offset + 12);
-		const t7 = u8to16$1(data, offset + 14);
+		const t0 = u8to16(data, offset + 0);
+		const t1 = u8to16(data, offset + 2);
+		const t2 = u8to16(data, offset + 4);
+		const t3 = u8to16(data, offset + 6);
+		const t4 = u8to16(data, offset + 8);
+		const t5 = u8to16(data, offset + 10);
+		const t6 = u8to16(data, offset + 12);
+		const t7 = u8to16(data, offset + 14);
 		let h0 = h[0] + (t0 & 8191);
 		let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191);
 		let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191);
@@ -6231,12 +6231,12 @@ var Poly1305$1 = class {
 			f = (h[i] + pad[i] | 0) + (f >>> 16) | 0;
 			h[i] = f & 65535;
 		}
-		clean$3(g);
+		clean$2(g);
 	}
 	update(data) {
-		aexists$3(this);
-		abytes$5(data);
-		data = copyBytes$4(data);
+		aexists$2(this);
+		abytes$4(data);
+		data = copyBytes$3(data);
 		const { buffer, blockLen } = this;
 		const len = data.length;
 		for (let pos = 0; pos < len;) {
@@ -6257,11 +6257,11 @@ var Poly1305$1 = class {
 	}
 	destroy() {
 		this.destroyed = true;
-		clean$3(this.h, this.r, this.buffer, this.pad);
+		clean$2(this.h, this.r, this.buffer, this.pad);
 	}
 	digestInto(out) {
-		aexists$3(this);
-		aoutput$3(out, this);
+		aexists$2(this);
+		aoutput$2(out, this);
 		this.finished = true;
 		const { buffer, h } = this;
 		let { pos } = this;
@@ -6300,7 +6300,7 @@ var Poly1305$1 = class {
 * poly1305(new Uint8Array(), key);
 * ```
 */
-const poly1305$1 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305$1(key));
+const poly1305 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305(key));
 
 //#endregion
 //#region ../../node_modules/.bun/@noble+ciphers@2.2.0/node_modules/@noble/ciphers/chacha.js
@@ -6323,74 +6323,74 @@ const poly1305$1 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305$
 * @module
 */
 /** RFC 8439 §2.3 block core for `state = constants | key | counter | nonce`. */
-function chachaCore$1(s, k, n, out, cnt, rounds = 20) {
+function chachaCore(s, k, n, out, cnt, rounds = 20) {
 	let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2];
 	let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
 	for (let r = 0; r < rounds; r += 2) {
 		x00 = x00 + x04 | 0;
-		x12 = rotl$2(x12 ^ x00, 16);
+		x12 = rotl$1(x12 ^ x00, 16);
 		x08 = x08 + x12 | 0;
-		x04 = rotl$2(x04 ^ x08, 12);
+		x04 = rotl$1(x04 ^ x08, 12);
 		x00 = x00 + x04 | 0;
-		x12 = rotl$2(x12 ^ x00, 8);
+		x12 = rotl$1(x12 ^ x00, 8);
 		x08 = x08 + x12 | 0;
-		x04 = rotl$2(x04 ^ x08, 7);
+		x04 = rotl$1(x04 ^ x08, 7);
 		x01 = x01 + x05 | 0;
-		x13 = rotl$2(x13 ^ x01, 16);
+		x13 = rotl$1(x13 ^ x01, 16);
 		x09 = x09 + x13 | 0;
-		x05 = rotl$2(x05 ^ x09, 12);
+		x05 = rotl$1(x05 ^ x09, 12);
 		x01 = x01 + x05 | 0;
-		x13 = rotl$2(x13 ^ x01, 8);
+		x13 = rotl$1(x13 ^ x01, 8);
 		x09 = x09 + x13 | 0;
-		x05 = rotl$2(x05 ^ x09, 7);
+		x05 = rotl$1(x05 ^ x09, 7);
 		x02 = x02 + x06 | 0;
-		x14 = rotl$2(x14 ^ x02, 16);
+		x14 = rotl$1(x14 ^ x02, 16);
 		x10 = x10 + x14 | 0;
-		x06 = rotl$2(x06 ^ x10, 12);
+		x06 = rotl$1(x06 ^ x10, 12);
 		x02 = x02 + x06 | 0;
-		x14 = rotl$2(x14 ^ x02, 8);
+		x14 = rotl$1(x14 ^ x02, 8);
 		x10 = x10 + x14 | 0;
-		x06 = rotl$2(x06 ^ x10, 7);
+		x06 = rotl$1(x06 ^ x10, 7);
 		x03 = x03 + x07 | 0;
-		x15 = rotl$2(x15 ^ x03, 16);
+		x15 = rotl$1(x15 ^ x03, 16);
 		x11 = x11 + x15 | 0;
-		x07 = rotl$2(x07 ^ x11, 12);
+		x07 = rotl$1(x07 ^ x11, 12);
 		x03 = x03 + x07 | 0;
-		x15 = rotl$2(x15 ^ x03, 8);
+		x15 = rotl$1(x15 ^ x03, 8);
 		x11 = x11 + x15 | 0;
-		x07 = rotl$2(x07 ^ x11, 7);
+		x07 = rotl$1(x07 ^ x11, 7);
 		x00 = x00 + x05 | 0;
-		x15 = rotl$2(x15 ^ x00, 16);
+		x15 = rotl$1(x15 ^ x00, 16);
 		x10 = x10 + x15 | 0;
-		x05 = rotl$2(x05 ^ x10, 12);
+		x05 = rotl$1(x05 ^ x10, 12);
 		x00 = x00 + x05 | 0;
-		x15 = rotl$2(x15 ^ x00, 8);
+		x15 = rotl$1(x15 ^ x00, 8);
 		x10 = x10 + x15 | 0;
-		x05 = rotl$2(x05 ^ x10, 7);
+		x05 = rotl$1(x05 ^ x10, 7);
 		x01 = x01 + x06 | 0;
-		x12 = rotl$2(x12 ^ x01, 16);
+		x12 = rotl$1(x12 ^ x01, 16);
 		x11 = x11 + x12 | 0;
-		x06 = rotl$2(x06 ^ x11, 12);
+		x06 = rotl$1(x06 ^ x11, 12);
 		x01 = x01 + x06 | 0;
-		x12 = rotl$2(x12 ^ x01, 8);
+		x12 = rotl$1(x12 ^ x01, 8);
 		x11 = x11 + x12 | 0;
-		x06 = rotl$2(x06 ^ x11, 7);
+		x06 = rotl$1(x06 ^ x11, 7);
 		x02 = x02 + x07 | 0;
-		x13 = rotl$2(x13 ^ x02, 16);
+		x13 = rotl$1(x13 ^ x02, 16);
 		x08 = x08 + x13 | 0;
-		x07 = rotl$2(x07 ^ x08, 12);
+		x07 = rotl$1(x07 ^ x08, 12);
 		x02 = x02 + x07 | 0;
-		x13 = rotl$2(x13 ^ x02, 8);
+		x13 = rotl$1(x13 ^ x02, 8);
 		x08 = x08 + x13 | 0;
-		x07 = rotl$2(x07 ^ x08, 7);
+		x07 = rotl$1(x07 ^ x08, 7);
 		x03 = x03 + x04 | 0;
-		x14 = rotl$2(x14 ^ x03, 16);
+		x14 = rotl$1(x14 ^ x03, 16);
 		x09 = x09 + x14 | 0;
-		x04 = rotl$2(x04 ^ x09, 12);
+		x04 = rotl$1(x04 ^ x09, 12);
 		x03 = x03 + x04 | 0;
-		x14 = rotl$2(x14 ^ x03, 8);
+		x14 = rotl$1(x14 ^ x03, 8);
 		x09 = x09 + x14 | 0;
-		x04 = rotl$2(x04 ^ x09, 7);
+		x04 = rotl$1(x04 ^ x09, 7);
 	}
 	let oi = 0;
 	out[oi++] = y00 + x00 | 0;
@@ -6430,73 +6430,73 @@ function chachaCore$1(s, k, n, out, cnt, rounds = 20) {
 * hchacha(sigma, key, nonce, out);
 * ```
 */
-function hchacha$1(s, k, i, out) {
+function hchacha(s, k, i, out) {
 	let x00 = swap8IfBE$1(s[0]), x01 = swap8IfBE$1(s[1]), x02 = swap8IfBE$1(s[2]), x03 = swap8IfBE$1(s[3]), x04 = swap8IfBE$1(k[0]), x05 = swap8IfBE$1(k[1]), x06 = swap8IfBE$1(k[2]), x07 = swap8IfBE$1(k[3]), x08 = swap8IfBE$1(k[4]), x09 = swap8IfBE$1(k[5]), x10 = swap8IfBE$1(k[6]), x11 = swap8IfBE$1(k[7]), x12 = swap8IfBE$1(i[0]), x13 = swap8IfBE$1(i[1]), x14 = swap8IfBE$1(i[2]), x15 = swap8IfBE$1(i[3]);
 	for (let r = 0; r < 20; r += 2) {
 		x00 = x00 + x04 | 0;
-		x12 = rotl$2(x12 ^ x00, 16);
+		x12 = rotl$1(x12 ^ x00, 16);
 		x08 = x08 + x12 | 0;
-		x04 = rotl$2(x04 ^ x08, 12);
+		x04 = rotl$1(x04 ^ x08, 12);
 		x00 = x00 + x04 | 0;
-		x12 = rotl$2(x12 ^ x00, 8);
+		x12 = rotl$1(x12 ^ x00, 8);
 		x08 = x08 + x12 | 0;
-		x04 = rotl$2(x04 ^ x08, 7);
+		x04 = rotl$1(x04 ^ x08, 7);
 		x01 = x01 + x05 | 0;
-		x13 = rotl$2(x13 ^ x01, 16);
+		x13 = rotl$1(x13 ^ x01, 16);
 		x09 = x09 + x13 | 0;
-		x05 = rotl$2(x05 ^ x09, 12);
+		x05 = rotl$1(x05 ^ x09, 12);
 		x01 = x01 + x05 | 0;
-		x13 = rotl$2(x13 ^ x01, 8);
+		x13 = rotl$1(x13 ^ x01, 8);
 		x09 = x09 + x13 | 0;
-		x05 = rotl$2(x05 ^ x09, 7);
+		x05 = rotl$1(x05 ^ x09, 7);
 		x02 = x02 + x06 | 0;
-		x14 = rotl$2(x14 ^ x02, 16);
+		x14 = rotl$1(x14 ^ x02, 16);
 		x10 = x10 + x14 | 0;
-		x06 = rotl$2(x06 ^ x10, 12);
+		x06 = rotl$1(x06 ^ x10, 12);
 		x02 = x02 + x06 | 0;
-		x14 = rotl$2(x14 ^ x02, 8);
+		x14 = rotl$1(x14 ^ x02, 8);
 		x10 = x10 + x14 | 0;
-		x06 = rotl$2(x06 ^ x10, 7);
+		x06 = rotl$1(x06 ^ x10, 7);
 		x03 = x03 + x07 | 0;
-		x15 = rotl$2(x15 ^ x03, 16);
+		x15 = rotl$1(x15 ^ x03, 16);
 		x11 = x11 + x15 | 0;
-		x07 = rotl$2(x07 ^ x11, 12);
+		x07 = rotl$1(x07 ^ x11, 12);
 		x03 = x03 + x07 | 0;
-		x15 = rotl$2(x15 ^ x03, 8);
+		x15 = rotl$1(x15 ^ x03, 8);
 		x11 = x11 + x15 | 0;
-		x07 = rotl$2(x07 ^ x11, 7);
+		x07 = rotl$1(x07 ^ x11, 7);
 		x00 = x00 + x05 | 0;
-		x15 = rotl$2(x15 ^ x00, 16);
+		x15 = rotl$1(x15 ^ x00, 16);
 		x10 = x10 + x15 | 0;
-		x05 = rotl$2(x05 ^ x10, 12);
+		x05 = rotl$1(x05 ^ x10, 12);
 		x00 = x00 + x05 | 0;
-		x15 = rotl$2(x15 ^ x00, 8);
+		x15 = rotl$1(x15 ^ x00, 8);
 		x10 = x10 + x15 | 0;
-		x05 = rotl$2(x05 ^ x10, 7);
+		x05 = rotl$1(x05 ^ x10, 7);
 		x01 = x01 + x06 | 0;
-		x12 = rotl$2(x12 ^ x01, 16);
+		x12 = rotl$1(x12 ^ x01, 16);
 		x11 = x11 + x12 | 0;
-		x06 = rotl$2(x06 ^ x11, 12);
+		x06 = rotl$1(x06 ^ x11, 12);
 		x01 = x01 + x06 | 0;
-		x12 = rotl$2(x12 ^ x01, 8);
+		x12 = rotl$1(x12 ^ x01, 8);
 		x11 = x11 + x12 | 0;
-		x06 = rotl$2(x06 ^ x11, 7);
+		x06 = rotl$1(x06 ^ x11, 7);
 		x02 = x02 + x07 | 0;
-		x13 = rotl$2(x13 ^ x02, 16);
+		x13 = rotl$1(x13 ^ x02, 16);
 		x08 = x08 + x13 | 0;
-		x07 = rotl$2(x07 ^ x08, 12);
+		x07 = rotl$1(x07 ^ x08, 12);
 		x02 = x02 + x07 | 0;
-		x13 = rotl$2(x13 ^ x02, 8);
+		x13 = rotl$1(x13 ^ x02, 8);
 		x08 = x08 + x13 | 0;
-		x07 = rotl$2(x07 ^ x08, 7);
+		x07 = rotl$1(x07 ^ x08, 7);
 		x03 = x03 + x04 | 0;
-		x14 = rotl$2(x14 ^ x03, 16);
+		x14 = rotl$1(x14 ^ x03, 16);
 		x09 = x09 + x14 | 0;
-		x04 = rotl$2(x04 ^ x09, 12);
+		x04 = rotl$1(x04 ^ x09, 12);
 		x03 = x03 + x04 | 0;
-		x14 = rotl$2(x14 ^ x03, 8);
+		x14 = rotl$1(x14 ^ x03, 8);
 		x09 = x09 + x14 | 0;
-		x04 = rotl$2(x04 ^ x09, 7);
+		x04 = rotl$1(x04 ^ x09, 7);
 	}
 	let oi = 0;
 	out[oi++] = x00;
@@ -6510,6 +6510,31 @@ function hchacha$1(s, k, i, out) {
 	swap32IfBE$2(out);
 }
 /**
+* ChaCha stream cipher. Conforms to RFC 8439 (IETF, TLS). 12-byte nonce, 4-byte counter.
+* With smaller nonce, it's not safe to make it random (CSPRNG), due to collision chance.
+* @param key - 32-byte key.
+* @param nonce - 12-byte nonce.
+* @param data - Input bytes to xor with the keystream.
+* @param output - Optional destination buffer.
+* @param counter - Initial block counter.
+* @returns Encrypted or decrypted bytes.
+* @example
+* Encrypts bytes with the RFC 8439 ChaCha20 stream cipher and a fresh key/nonce.
+*
+* ```ts
+* import { chacha20 } from '@noble/ciphers/chacha.js';
+* import { randomBytes } from '@noble/ciphers/utils.js';
+* const key = randomBytes(32);
+* const nonce = randomBytes(12);
+* chacha20(key, nonce, new Uint8Array(4));
+* ```
+*/
+const chacha20 = /* @__PURE__ */ createCipher(chachaCore, {
+	counterRight: false,
+	counterLength: 4,
+	allowShortKeys: false
+});
+/**
 * XChaCha eXtended-nonce ChaCha. With 24-byte nonce, it's safe to make it random (CSPRNG).
 * See {@link https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha | the IRTF draft}.
 * The nonce/counter layout still reserves 8 counter bytes internally, but the shared public
@@ -6532,29 +6557,29 @@ function hchacha$1(s, k, i, out) {
 * xchacha20(key, nonce, new Uint8Array(4));
 * ```
 */
-const xchacha20$1 = /* @__PURE__ */ createCipher$1(chachaCore$1, {
+const xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
 	counterRight: false,
 	counterLength: 8,
-	extendNonceFn: hchacha$1,
+	extendNonceFn: hchacha,
 	allowShortKeys: false
 });
-const ZEROS16$1 = /* @__PURE__ */ new Uint8Array(16);
-const updatePadded$1 = (h, msg) => {
+const ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+const updatePadded = (h, msg) => {
 	h.update(msg);
 	const leftover = msg.length % 16;
-	if (leftover) h.update(ZEROS16$1.subarray(leftover));
-};
-const ZEROS32$1 = /* @__PURE__ */ new Uint8Array(32);
-function computeTag$1(fn, key, nonce, ciphertext, AAD) {
-	if (AAD !== void 0) abytes$5(AAD, void 0, "AAD");
-	const authKey = fn(key, nonce, ZEROS32$1);
-	const lengths = u64Lengths$1(ciphertext.length, AAD ? AAD.length : 0, true);
-	const h = poly1305$1.create(authKey);
-	if (AAD) updatePadded$1(h, AAD);
-	updatePadded$1(h, ciphertext);
+	if (leftover) h.update(ZEROS16.subarray(leftover));
+};
+const ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
+function computeTag(fn, key, nonce, ciphertext, AAD) {
+	if (AAD !== void 0) abytes$4(AAD, void 0, "AAD");
+	const authKey = fn(key, nonce, ZEROS32);
+	const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);
+	const h = poly1305.create(authKey);
+	if (AAD) updatePadded(h, AAD);
+	updatePadded(h, ciphertext);
 	h.update(lengths);
 	const res = h.digest();
-	clean$3(authKey, lengths);
+	clean$2(authKey, lengths);
 	return res;
 }
 /**
@@ -6564,37 +6589,63 @@ function computeTag$1(fn, key, nonce, ciphertext, AAD) {
 * In salsa20, authKey changes position in salsa stream.
 * In chacha, authKey can't be computed inside computeTag, it modifies the counter.
 */
-const _poly1305_aead$1 = (xorStream) => (key, nonce, AAD) => {
+const _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
 	const tagLength = 16;
 	return {
 		encrypt(plaintext, output) {
 			const plength = plaintext.length;
-			output = getOutput$1(plength + tagLength, output, false);
+			output = getOutput(plength + tagLength, output, false);
 			output.set(plaintext);
 			const oPlain = output.subarray(0, -16);
 			xorStream(key, nonce, oPlain, oPlain, 1);
-			const tag = computeTag$1(xorStream, key, nonce, oPlain, AAD);
+			const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
 			output.set(tag, plength);
-			clean$3(tag);
+			clean$2(tag);
 			return output;
 		},
 		decrypt(ciphertext, output) {
-			output = getOutput$1(ciphertext.length - tagLength, output, false);
+			output = getOutput(ciphertext.length - tagLength, output, false);
 			const data = ciphertext.subarray(0, -16);
 			const passedTag = ciphertext.subarray(-16);
-			const tag = computeTag$1(xorStream, key, nonce, data, AAD);
-			if (!equalBytes$3(passedTag, tag)) {
-				clean$3(tag);
+			const tag = computeTag(xorStream, key, nonce, data, AAD);
+			if (!equalBytes$2(passedTag, tag)) {
+				clean$2(tag);
 				throw new Error("invalid tag");
 			}
 			output.set(ciphertext.subarray(0, -16));
 			xorStream(key, nonce, output, output, 1);
-			clean$3(tag);
+			clean$2(tag);
 			return output;
 		}
 	};
 };
 /**
+* ChaCha20-Poly1305 from RFC 8439.
+*
+* Unsafe to use random nonces under the same key, due to collision chance.
+* Prefer XChaCha instead.
+* @param key - 32-byte key.
+* @param nonce - 12-byte nonce.
+* @param AAD - Additional authenticated data.
+* @returns AEAD cipher instance.
+* @example
+* Encrypts and authenticates plaintext with a fresh key and nonce.
+*
+* ```ts
+* import { chacha20poly1305 } from '@noble/ciphers/chacha.js';
+* import { randomBytes } from '@noble/ciphers/utils.js';
+* const key = randomBytes(32);
+* const nonce = randomBytes(12);
+* const cipher = chacha20poly1305(key, nonce);
+* cipher.encrypt(new Uint8Array([1, 2, 3]));
+* ```
+*/
+const chacha20poly1305 = /* @__PURE__ */ wrapCipher({
+	blockSize: 64,
+	nonceLength: 12,
+	tagLength: 16
+}, /* @__PURE__ */ _poly1305_aead(chacha20));
+/**
 * XChaCha20-Poly1305 extended-nonce chacha.
 *
 * Can be safely used with random nonces (CSPRNG).
@@ -6615,11 +6666,11 @@ const _poly1305_aead$1 = (xorStream) => (key, nonce, AAD) => {
 * cipher.encrypt(new Uint8Array([1, 2, 3]));
 * ```
 */
-const xchacha20poly1305$1 = /* @__PURE__ */ wrapCipher$1({
+const xchacha20poly1305 = /* @__PURE__ */ wrapCipher({
 	blockSize: 64,
 	nonceLength: 24,
 	tagLength: 16
-}, /* @__PURE__ */ _poly1305_aead$1(xchacha20$1));
+}, /* @__PURE__ */ _poly1305_aead(xchacha20));
 
 //#endregion
 //#region ../../node_modules/.bun/@noble+hashes@2.2.0/node_modules/@noble/hashes/utils.js
@@ -6633,7 +6684,7 @@ const xchacha20poly1305$1 = /* @__PURE__ */ wrapCipher$1({
 * isBytes(new Uint8Array([1, 2, 3]));
 * ```
 */
-function isBytes$4(a) {
+function isBytes$3(a) {
 	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
 }
 /**
@@ -6648,7 +6699,7 @@ function isBytes$4(a) {
 * anumber(32, 'length');
 * ```
 */
-function anumber$4(n, title = "") {
+function anumber$3(n, title = "") {
 	if (typeof n !== "number") {
 		const prefix = title && `"${title}" `;
 		throw new TypeError(`${prefix}expected number, got ${typeof n}`);
@@ -6672,8 +6723,8 @@ function anumber$4(n, title = "") {
 * abytes(new Uint8Array([1, 2, 3]));
 * ```
 */
-function abytes$4(value, length, title = "") {
-	const bytes = isBytes$4(value);
+function abytes$3(value, length, title = "") {
+	const bytes = isBytes$3(value);
 	const len = value?.length;
 	const needsLen = length !== void 0;
 	if (!bytes || needsLen && len !== length) {
@@ -6702,8 +6753,8 @@ function abytes$4(value, length, title = "") {
 */
 function ahash$1(h) {
 	if (typeof h !== "function" || typeof h.create !== "function") throw new TypeError("Hash must wrapped by utils.createHasher");
-	anumber$4(h.outputLen);
-	anumber$4(h.blockLen);
+	anumber$3(h.outputLen);
+	anumber$3(h.blockLen);
 	if (h.outputLen < 1) throw new Error("\"outputLen\" must be >= 1");
 	if (h.blockLen < 1) throw new Error("\"blockLen\" must be >= 1");
 }
@@ -6721,7 +6772,7 @@ function ahash$1(h) {
 * aexists(hash);
 * ```
 */
-function aexists$2(instance, checkFinished = true) {
+function aexists$1(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");
 }
@@ -6741,8 +6792,8 @@ function aexists$2(instance, checkFinished = true) {
 * aoutput(new Uint8Array(hash.outputLen), hash);
 * ```
 */
-function aoutput$2(out, instance) {
-	abytes$4(out, void 0, "digestInto() output");
+function aoutput$1(out, instance) {
+	abytes$3(out, void 0, "digestInto() output");
 	const min = instance.outputLen;
 	if (out.length < min) throw new RangeError("\"digestInto() output\" expected to be of length >=" + min);
 }
@@ -6771,7 +6822,7 @@ function u8(arr) {
 * u32(new Uint8Array(8));
 * ```
 */
-function u32$2(arr) {
+function u32$1(arr) {
 	return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 }
 /**
@@ -6783,7 +6834,7 @@ function u32$2(arr) {
 * clean(new Uint8Array([1, 2, 3]));
 * ```
 */
-function clean$2(...arrays) {
+function clean$1(...arrays) {
 	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
 }
 /**
@@ -6796,7 +6847,7 @@ function clean$2(...arrays) {
 * createView(new Uint8Array(4));
 * ```
 */
-function createView$2(arr) {
+function createView$1(arr) {
 	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
 /**
@@ -6824,11 +6875,11 @@ function rotr$1(word, shift) {
 * rotl(0x12345678, 8);
 * ```
 */
-function rotl$1(word, shift) {
+function rotl(word, shift) {
 	return word << shift | word >>> 32 - shift >>> 0;
 }
 /** Whether the current platform is little-endian. */
-const isLE$2 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+const isLE$1 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
 /**
 * Byte-swap operation for uint32 values.
 * @param word - source word
@@ -6852,7 +6903,7 @@ function byteSwap$1(word) {
 * swap8IfBE(0x11223344);
 * ```
 */
-const swap8IfBE = isLE$2 ? (n) => n : (n) => byteSwap$1(n) >>> 0;
+const swap8IfBE = isLE$1 ? (n) => n : (n) => byteSwap$1(n) >>> 0;
 /**
 * Byte-swaps every word of a Uint32Array in place.
 * @param arr - array to mutate
@@ -6878,7 +6929,7 @@ function byteSwap32$1(arr) {
 * swap32IfBE(new Uint32Array([0x11223344]));
 * ```
 */
-const swap32IfBE$1 = isLE$2 ? (u) => u : byteSwap32$1;
+const swap32IfBE$1 = isLE$1 ? (u) => u : byteSwap32$1;
 const hasHexBuiltin$2 = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
 const hexes$1 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 /**
@@ -6895,7 +6946,7 @@ const hexes$1 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString
 * ```
 */
 function bytesToHex$2(bytes) {
-	abytes$4(bytes);
+	abytes$3(bytes);
 	if (hasHexBuiltin$2) return bytes.toHex();
 	let hex = "";
 	for (let i = 0; i < bytes.length; i++) hex += hexes$1[bytes[i]];
@@ -6981,7 +7032,7 @@ function utf8ToBytes(str) {
 */
 function kdfInputToBytes(data, errorTitle = "") {
 	if (typeof data === "string") return utf8ToBytes(data);
-	return abytes$4(data, void 0, errorTitle);
+	return abytes$3(data, void 0, errorTitle);
 }
 /**
 * Copies several Uint8Arrays into one.
@@ -6998,7 +7049,7 @@ function concatBytes$2(...arrays) {
 	let sum = 0;
 	for (let i = 0; i < arrays.length; i++) {
 		const a = arrays[i];
-		abytes$4(a);
+		abytes$3(a);
 		sum += a.length;
 	}
 	const res = new Uint8Array(sum);
@@ -7021,7 +7072,7 @@ function concatBytes$2(...arrays) {
 * checkOpts({ dkLen: 32 }, { asyncTick: 10 });
 * ```
 */
-function checkOpts$1(defaults, opts) {
+function checkOpts(defaults, opts) {
 	if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") throw new TypeError("options must be object or undefined");
 	return Object.assign(defaults, opts);
 }
@@ -7069,7 +7120,7 @@ function createHasher$1(hashCons, info = {}) {
 * ```
 */
 function randomBytes$4(bytesLength = 32) {
-	anumber$4(bytesLength, "bytesLength");
+	anumber$3(bytesLength, "bytesLength");
 	const cr = typeof globalThis === "object" ? globalThis.crypto : null;
 	if (typeof cr?.getRandomValues !== "function") throw new Error("crypto.getRandomValues must be defined");
 	if (bytesLength > 65536) throw new RangeError(`"bytesLength" expected <= 65536, got ${bytesLength}`);
@@ -7177,17 +7228,17 @@ var HashMD$1 = class {
 		this.padOffset = padOffset;
 		this.isLE = isLE;
 		this.buffer = new Uint8Array(blockLen);
-		this.view = createView$2(this.buffer);
+		this.view = createView$1(this.buffer);
 	}
 	update(data) {
-		aexists$2(this);
-		abytes$4(data);
+		aexists$1(this);
+		abytes$3(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$2(data);
+				const dataView = createView$1(data);
 				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
 				continue;
 			}
@@ -7204,13 +7255,13 @@ var HashMD$1 = class {
 		return this;
 	}
 	digestInto(out) {
-		aexists$2(this);
-		aoutput$2(out, this);
+		aexists$1(this);
+		aoutput$1(out, this);
 		this.finished = true;
 		const { buffer, view, blockLen, isLE } = this;
 		let { pos } = this;
 		buffer[pos++] = 128;
-		clean$2(this.buffer.subarray(pos));
+		clean$1(this.buffer.subarray(pos));
 		if (this.padOffset > blockLen - pos) {
 			this.process(view, 0);
 			pos = 0;
@@ -7218,7 +7269,7 @@ var HashMD$1 = class {
 		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
 		view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
 		this.process(view, 0);
-		const oview = createView$2(out);
+		const oview = createView$1(out);
 		const len = this.outputLen;
 		if (len % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
 		const outLen = len / 4;
@@ -7476,12 +7527,12 @@ var SHA2_32B$1 = class extends HashMD$1 {
 		this.set(A, B, C, D, E, F, G, H);
 	}
 	roundClean() {
-		clean$2(SHA256_W$1);
+		clean$1(SHA256_W$1);
 	}
 	destroy() {
 		this.destroyed = true;
 		this.set(0, 0, 0, 0, 0, 0, 0, 0);
-		clean$2(this.buffer);
+		clean$1(this.buffer);
 	}
 };
 /** Internal SHA-256 hash class grounded in RFC 6234 §6.2. */
@@ -7687,11 +7738,11 @@ var SHA2_64B$1 = class extends HashMD$1 {
 		this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
 	}
 	roundClean() {
-		clean$2(SHA512_W_H$1, SHA512_W_L$1);
+		clean$1(SHA512_W_H$1, SHA512_W_L$1);
 	}
 	destroy() {
 		this.destroyed = true;
-		clean$2(this.buffer);
+		clean$1(this.buffer);
 		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 	}
 };
@@ -7747,7 +7798,7 @@ const sha512 = /* @__PURE__ */ createHasher$1(() => new _SHA512(), /* @__PURE__
 
 //#endregion
 //#region ../../packages/credentials-crypto/src/aead.ts
-const aead = managedNonce(xchacha20poly1305$1);
+const aead = managedNonce(xchacha20poly1305);
 const textEncoder$2 = new TextEncoder();
 const KEY_BYTES$1 = 32;
 const LENGTH_PREFIX_BYTES = 4;
@@ -8140,12 +8191,12 @@ function G2b(a, b, c, d, msg, x) {
 	BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
 }
 function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
-	anumber$4(keyLen);
+	anumber$3(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\" expected to be undefined or of length=1.." + keyLen);
-	if (salt !== void 0) abytes$4(salt, saltLen, "salt");
-	if (personalization !== void 0) abytes$4(personalization, persLen, "personalization");
+	if (salt !== void 0) abytes$3(salt, saltLen, "salt");
+	if (personalization !== void 0) abytes$3(personalization, persLen, "personalization");
 }
 /** Internal base class for BLAKE2. */
 var _BLAKE2 = class {
@@ -8159,16 +8210,16 @@ var _BLAKE2 = class {
 	outputLen;
 	canXOF = false;
 	constructor(blockLen, outputLen) {
-		anumber$4(blockLen);
-		anumber$4(outputLen);
+		anumber$3(blockLen);
+		anumber$3(outputLen);
 		this.blockLen = blockLen;
 		this.outputLen = outputLen;
 		this.buffer = new Uint8Array(blockLen);
-		this.buffer32 = u32$2(this.buffer);
+		this.buffer32 = u32$1(this.buffer);
 	}
 	update(data) {
-		aexists$2(this);
-		abytes$4(data);
+		aexists$1(this);
+		abytes$3(data);
 		const { blockLen, buffer, buffer32 } = this;
 		const len = data.length;
 		const offset = data.byteOffset;
@@ -8200,17 +8251,17 @@ var _BLAKE2 = class {
 		return this;
 	}
 	digestInto(out) {
-		aexists$2(this);
-		aoutput$2(out, this);
+		aexists$1(this);
+		aoutput$1(out, this);
 		const { pos, buffer32 } = this;
 		this.finished = true;
-		clean$2(this.buffer.subarray(pos));
+		clean$1(this.buffer.subarray(pos));
 		swap32IfBE$1(buffer32);
 		this.compress(buffer32, 0, true);
 		swap32IfBE$1(buffer32);
 		if (out.byteOffset & 3) throw new RangeError("\"digestInto() output\" expected 4-byte aligned byteOffset, got " + out.byteOffset);
 		const state = this.get();
-		const out32 = u32$2(out);
+		const out32 = u32$1(out);
 		const full = Math.floor(this.outputLen / 4);
 		for (let i = 0; i < full; i++) out32[i] = swap8IfBE(state[i]);
 		const tail = this.outputLen % 4;
@@ -8267,21 +8318,21 @@ var _BLAKE2b = class extends _BLAKE2 {
 		let { key, personalization, salt } = opts;
 		let keyLength = 0;
 		if (key !== void 0) {
-			abytes$4(key, void 0, "key");
+			abytes$3(key, void 0, "key");
 			keyLength = key.length;
 		}
 		this.v0l ^= this.outputLen | keyLength << 8 | 16842752;
 		if (salt !== void 0) {
-			abytes$4(salt, void 0, "salt");
-			const slt = u32$2(salt);
+			abytes$3(salt, void 0, "salt");
+			const slt = u32$1(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) {
-			abytes$4(personalization, void 0, "personalization");
-			const pers = u32$2(personalization);
+			abytes$3(personalization, void 0, "personalization");
+			const pers = u32$1(personalization);
 			this.v6l ^= swap8IfBE(pers[0]);
 			this.v6h ^= swap8IfBE(pers[1]);
 			this.v7l ^= swap8IfBE(pers[2]);
@@ -8378,11 +8429,11 @@ var _BLAKE2b = class extends _BLAKE2 {
 		this.v6h ^= BBUF[13] ^ BBUF[29];
 		this.v7l ^= BBUF[14] ^ BBUF[30];
 		this.v7h ^= BBUF[15] ^ BBUF[31];
-		clean$2(BBUF);
+		clean$1(BBUF);
 	}
 	destroy() {
 		this.destroyed = true;
-		clean$2(this.buffer32);
+		clean$1(this.buffer32);
 		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 	}
 };
@@ -8516,7 +8567,7 @@ function block(x, xPos, yPos, outPos, needXor) {
 	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$2(A2_BUF);
+	clean$1(A2_BUF);
 }
 function Hp(A, dkLen) {
 	const A8 = u8(A);
@@ -8536,7 +8587,7 @@ function Hp(A, dkLen) {
 		out.set(V.subarray(0, 32), pos);
 	}
 	out.set(blake2b(V, { dkLen: dkLen - pos }), pos);
-	clean$2(V, T);
+	clean$1(V, T);
 	return out;
 }
 function indexAlpha(r, s, laneLen, segmentLen, index, randL, sameLane = false) {
@@ -8566,7 +8617,7 @@ function argon2Opts(opts) {
 	if (!isU32(m)) throw new Error("\"m\" must be 0..2^32");
 	if (!isU32(t) || t < 1) throw new Error("\"t\" (iterations) must be 1..2^32");
 	if (onProgress !== void 0 && typeof onProgress !== "function") throw new Error("\"progressCb\" must be a function");
-	anumber$4(asyncTick, "asyncTick");
+	anumber$3(asyncTick, "asyncTick");
 	if (!isU32(m) || m < 8 * p) throw new Error("\"m\" (memory) must be at least 8*p bytes");
 	if (version !== 16 && version !== 19) throw new Error("\"version\" must be 0x10 or 0x13, got " + version);
 	return merged;
@@ -8618,9 +8669,9 @@ function argon2Init(password, salt, type, opts) {
 		const i = 256 * laneLen * l;
 		H0[17] = swap8IfBE(l);
 		H0[16] = swap8IfBE(0);
-		B.set(swap32IfBE$1(u32$2(Hp(H0, 1024))), i);
+		B.set(swap32IfBE$1(u32$1(Hp(H0, 1024))), i);
 		H0[16] = swap8IfBE(1);
-		B.set(swap32IfBE$1(u32$2(Hp(H0, 1024))), i + 256);
+		B.set(swap32IfBE$1(u32$1(Hp(H0, 1024))), i + 256);
 	}
 	let perBlock = () => {};
 	if (onProgress) {
@@ -8632,7 +8683,7 @@ function argon2Init(password, salt, type, opts) {
 			if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock)) onProgress(blockCnt / totalBlock);
 		};
 	}
-	clean$2(BUF, H0);
+	clean$1(BUF, H0);
 	return {
 		type,
 		mP,
@@ -8652,7 +8703,7 @@ 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 = Hp(swap32IfBE$1(B_final), dkLen);
-	clean$2(B, B_final);
+	clean$1(B, B_final);
 	return res;
 }
 function processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor) {
@@ -8710,7 +8761,7 @@ function argon2(type, password, salt, opts) {
 			}
 		}
 	}
-	clean$2(address);
+	clean$1(address);
 	return argon2Output(B, p, laneLen, dkLen);
 }
 /**
@@ -8749,7 +8800,7 @@ var _HMAC$1 = class {
 	destroyed = false;
 	constructor(hash, key) {
 		ahash$1(hash);
-		abytes$4(key, void 0, "key");
+		abytes$3(key, void 0, "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;
@@ -8762,16 +8813,16 @@ var _HMAC$1 = class {
 		this.oHash = hash.create();
 		for (let i = 0; i < pad.length; i++) pad[i] ^= 106;
 		this.oHash.update(pad);
-		clean$2(pad);
+		clean$1(pad);
 	}
 	update(buf) {
-		aexists$2(this);
+		aexists$1(this);
 		this.iHash.update(buf);
 		return this;
 	}
 	digestInto(out) {
-		aexists$2(this);
-		aoutput$2(out, this);
+		aexists$1(this);
+		aoutput$1(out, this);
 		this.finished = true;
 		const buf = out.subarray(0, this.outputLen);
 		this.iHash.digestInto(buf);
@@ -8862,14 +8913,14 @@ const EMPTY_BUFFER$1 = /* @__PURE__ */ Uint8Array.of();
 */
 function expand$1(hash, prk, info, length = 32) {
 	ahash$1(hash);
-	anumber$4(length, "length");
-	abytes$4(prk, void 0, "prk");
+	anumber$3(length, "length");
+	abytes$3(prk, void 0, "prk");
 	const olen = hash.outputLen;
 	if (prk.length < olen) throw new Error("\"prk\" must be at least HashLen octets");
 	if (length > 255 * olen) throw new Error("Length must be <= 255*HashLen");
 	const blocks = Math.ceil(length / olen);
 	if (info === void 0) info = EMPTY_BUFFER$1;
-	else abytes$4(info, void 0, "info");
+	else abytes$3(info, void 0, "info");
 	const okm = new Uint8Array(blocks * olen);
 	const HMAC = hmac$1.create(hash, prk);
 	const HMACTmp = HMAC._cloneInto();
@@ -8882,7 +8933,7 @@ function expand$1(hash, prk, info, length = 32) {
 	}
 	HMAC.destroy();
 	HMACTmp.destroy();
-	clean$2(T, HKDF_COUNTER$1);
+	clean$1(T, HKDF_COUNTER$1);
 	return okm.slice(0, length);
 }
 /**
@@ -8914,12 +8965,12 @@ const hkdf = (hash, ikm, salt, info, length) => expand$1(hash, extract$1(hash, i
 //#endregion
 //#region ../../node_modules/.bun/@scure+base@2.2.0/node_modules/@scure/base/index.js
 /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function isBytes$3(a) {
+function isBytes$2(a) {
 	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
 }
 /** Asserts something is Uint8Array. */
-function abytes$3(b) {
-	if (!isBytes$3(b)) throw new TypeError("Uint8Array expected");
+function abytes$2(b) {
+	if (!isBytes$2(b)) throw new TypeError("Uint8Array expected");
 }
 function isArrayOf(isString, arr) {
 	if (!Array.isArray(arr)) return false;
@@ -8935,7 +8986,7 @@ function astr(label, input) {
 	if (typeof input !== "string") throw new TypeError(`${label}: string expected`);
 	return true;
 }
-function anumber$3(n) {
+function anumber$2(n) {
 	if (typeof n !== "number") throw new TypeError(`number expected, got ${typeof n}`);
 	if (!Number.isSafeInteger(n)) throw new RangeError(`invalid integer: ${n}`);
 }
@@ -9009,7 +9060,7 @@ function join(separator = "") {
 * @__NO_SIDE_EFFECTS__
 */
 function padding(bits, chr = "=") {
-	anumber$3(bits);
+	anumber$2(bits);
 	astr("padding", chr);
 	return {
 		encode(data) {
@@ -9057,7 +9108,7 @@ function convertRadix2(data, from, to, padding) {
 	const mask = powers[to] - 1;
 	const res = [];
 	for (const n of data) {
-		anumber$3(n);
+		anumber$2(n);
 		if (n >= max) throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
 		carry = carry << from | n;
 		if (pos + from > 32) throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
@@ -9079,12 +9130,12 @@ function convertRadix2(data, from, to, padding) {
 * @__NO_SIDE_EFFECTS__
 */
 function radix2(bits, revPadding = false) {
-	anumber$3(bits);
+	anumber$2(bits);
 	if (bits <= 0 || bits > 32) throw new RangeError("radix2: bits should be in (0..32]");
 	if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32) throw new RangeError("radix2: carry overflow");
 	return {
 		encode: (bytes) => {
-			if (!isBytes$3(bytes)) throw new TypeError("radix2.encode input should be Uint8Array");
+			if (!isBytes$2(bytes)) throw new TypeError("radix2.encode input should be Uint8Array");
 			return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
 		},
 		decode: (digits) => {
@@ -9206,7 +9257,7 @@ const decodeBase64Builtin = (s, isUrl) => {
 */
 const base64 = /* @__PURE__ */ Object.freeze(hasBase64Builtin ? {
 	encode(b) {
-		abytes$3(b);
+		abytes$2(b);
 		return b.toBase64();
 	},
 	decode(s) {
@@ -9239,7 +9290,7 @@ const base64nopad = /* @__PURE__ */ Object.freeze(chain(radix2(6), alphabet("ABC
 */
 const base64url = /* @__PURE__ */ Object.freeze(hasBase64Builtin ? {
 	encode(b) {
-		abytes$3(b);
+		abytes$2(b);
 		return b.toBase64({ alphabet: "base64url" });
 	},
 	decode(s) {
@@ -9298,7 +9349,7 @@ function genBech32(encoding) {
 	const fromWordsUnsafe = unsafeWrapper(fromWords);
 	function encode(prefix, words, limit = 90) {
 		astr("bech32.encode prefix", prefix);
-		if (isBytes$3(words)) words = Array.from(words);
+		if (isBytes$2(words)) words = Array.from(words);
 		anumArr("bech32.encode", words);
 		const plen = prefix.length;
 		if (plen === 0) throw new TypeError(`Invalid prefix length ${plen}`);
@@ -9378,7 +9429,7 @@ const bech32m = /* @__PURE__ */ Object.freeze(genBech32("bech32m"));
 const hasHexBuiltin$1 = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
 const hexBuiltin = {
 	encode(data) {
-		abytes$3(data);
+		abytes$2(data);
 		return data.toHex();
 	},
 	decode(s) {
@@ -9408,13 +9459,13 @@ const hex = /* @__PURE__ */ Object.freeze(hasHexBuiltin$1 ? hexBuiltin : chain(r
 */
 function pbkdf2Init(hash, _password, _salt, _opts) {
 	ahash$1(hash);
-	const { c, dkLen, asyncTick } = checkOpts$1({
+	const { c, dkLen, asyncTick } = checkOpts({
 		dkLen: 32,
 		asyncTick: 10
 	}, _opts);
-	anumber$4(c, "c");
-	anumber$4(dkLen, "dkLen");
-	anumber$4(asyncTick, "asyncTick");
+	anumber$3(c, "c");
+	anumber$3(dkLen, "dkLen");
+	anumber$3(asyncTick, "asyncTick");
 	if (c < 1) throw new Error("iterations (c) must be >= 1");
 	if (dkLen < 1) throw new Error("\"dkLen\" must be >= 1");
 	if (dkLen > (2 ** 32 - 1) * hash.outputLen) throw new Error("derived key too long");
@@ -9435,7 +9486,7 @@ function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
 	PRF.destroy();
 	PRFSalt.destroy();
 	if (prfW) prfW.destroy();
-	clean$2(u);
+	clean$1(u);
 	return DK;
 }
 /**
@@ -9460,7 +9511,7 @@ 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$2(arr);
+	const view = createView$1(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);
@@ -9492,38 +9543,38 @@ function XorAndSalsa(prev, pi, input, ii, out, oi) {
 	let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
 	let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
 	for (let i = 0; i < 8; i += 2) {
-		x04 ^= rotl$1(x00 + x12 | 0, 7);
-		x08 ^= rotl$1(x04 + x00 | 0, 9);
-		x12 ^= rotl$1(x08 + x04 | 0, 13);
-		x00 ^= rotl$1(x12 + x08 | 0, 18);
-		x09 ^= rotl$1(x05 + x01 | 0, 7);
-		x13 ^= rotl$1(x09 + x05 | 0, 9);
-		x01 ^= rotl$1(x13 + x09 | 0, 13);
-		x05 ^= rotl$1(x01 + x13 | 0, 18);
-		x14 ^= rotl$1(x10 + x06 | 0, 7);
-		x02 ^= rotl$1(x14 + x10 | 0, 9);
-		x06 ^= rotl$1(x02 + x14 | 0, 13);
-		x10 ^= rotl$1(x06 + x02 | 0, 18);
-		x03 ^= rotl$1(x15 + x11 | 0, 7);
-		x07 ^= rotl$1(x03 + x15 | 0, 9);
-		x11 ^= rotl$1(x07 + x03 | 0, 13);
-		x15 ^= rotl$1(x11 + x07 | 0, 18);
-		x01 ^= rotl$1(x00 + x03 | 0, 7);
-		x02 ^= rotl$1(x01 + x00 | 0, 9);
-		x03 ^= rotl$1(x02 + x01 | 0, 13);
-		x00 ^= rotl$1(x03 + x02 | 0, 18);
-		x06 ^= rotl$1(x05 + x04 | 0, 7);
-		x07 ^= rotl$1(x06 + x05 | 0, 9);
-		x04 ^= rotl$1(x07 + x06 | 0, 13);
-		x05 ^= rotl$1(x04 + x07 | 0, 18);
-		x11 ^= rotl$1(x10 + x09 | 0, 7);
-		x08 ^= rotl$1(x11 + x10 | 0, 9);
-		x09 ^= rotl$1(x08 + x11 | 0, 13);
-		x10 ^= rotl$1(x09 + x08 | 0, 18);
-		x12 ^= rotl$1(x15 + x14 | 0, 7);
-		x13 ^= rotl$1(x12 + x15 | 0, 9);
-		x14 ^= rotl$1(x13 + x12 | 0, 13);
-		x15 ^= rotl$1(x14 + x13 | 0, 18);
+		x04 ^= rotl(x00 + x12 | 0, 7);
+		x08 ^= rotl(x04 + x00 | 0, 9);
+		x12 ^= rotl(x08 + x04 | 0, 13);
+		x00 ^= rotl(x12 + x08 | 0, 18);
+		x09 ^= rotl(x05 + x01 | 0, 7);
+		x13 ^= rotl(x09 + x05 | 0, 9);
+		x01 ^= rotl(x13 + x09 | 0, 13);
+		x05 ^= rotl(x01 + x13 | 0, 18);
+		x14 ^= rotl(x10 + x06 | 0, 7);
+		x02 ^= rotl(x14 + x10 | 0, 9);
+		x06 ^= rotl(x02 + x14 | 0, 13);
+		x10 ^= rotl(x06 + x02 | 0, 18);
+		x03 ^= rotl(x15 + x11 | 0, 7);
+		x07 ^= rotl(x03 + x15 | 0, 9);
+		x11 ^= rotl(x07 + x03 | 0, 13);
+		x15 ^= rotl(x11 + x07 | 0, 18);
+		x01 ^= rotl(x00 + x03 | 0, 7);
+		x02 ^= rotl(x01 + x00 | 0, 9);
+		x03 ^= rotl(x02 + x01 | 0, 13);
+		x00 ^= rotl(x03 + x02 | 0, 18);
+		x06 ^= rotl(x05 + x04 | 0, 7);
+		x07 ^= rotl(x06 + x05 | 0, 9);
+		x04 ^= rotl(x07 + x06 | 0, 13);
+		x05 ^= rotl(x04 + x07 | 0, 18);
+		x11 ^= rotl(x10 + x09 | 0, 7);
+		x08 ^= rotl(x11 + x10 | 0, 9);
+		x09 ^= rotl(x08 + x11 | 0, 13);
+		x10 ^= rotl(x09 + x08 | 0, 18);
+		x12 ^= rotl(x15 + x14 | 0, 7);
+		x13 ^= rotl(x12 + x15 | 0, 9);
+		x14 ^= rotl(x13 + x12 | 0, 13);
+		x15 ^= rotl(x14 + x13 | 0, 18);
 	}
 	out[oi++] = y00 + x00 | 0;
 	out[oi++] = y01 + x01 | 0;
@@ -9553,17 +9604,17 @@ function BlockMix(input, ii, out, oi, r) {
 	}
 }
 function scryptInit(password, salt, _opts) {
-	const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = checkOpts$1({
+	const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = checkOpts({
 		dkLen: 32,
 		asyncTick: 10,
 		maxmem: 1024 ** 3 + 1024
 	}, _opts);
-	anumber$4(N, "N");
-	anumber$4(r, "r");
-	anumber$4(p, "p");
-	anumber$4(dkLen, "dkLen");
-	anumber$4(asyncTick, "asyncTick");
-	anumber$4(maxmem, "maxmem");
+	anumber$3(N, "N");
+	anumber$3(r, "r");
+	anumber$3(p, "p");
+	anumber$3(dkLen, "dkLen");
+	anumber$3(asyncTick, "asyncTick");
+	anumber$3(maxmem, "maxmem");
 	if (onProgress !== void 0 && typeof onProgress !== "function") throw new Error("progressCb must be a function");
 	const blockSize = 128 * r;
 	const blockSize32 = blockSize / 4;
@@ -9577,9 +9628,9 @@ function scryptInit(password, salt, _opts) {
 		c: 1,
 		dkLen: blockSize * p
 	});
-	const B32 = u32$2(B);
-	const V = u32$2(new Uint8Array(blockSize * N));
-	const tmp = u32$2(new Uint8Array(blockSize));
+	const B32 = u32$1(B);
+	const V = u32$1(new Uint8Array(blockSize * N));
+	const tmp = u32$1(new Uint8Array(blockSize));
 	let blockMixCb = () => {};
 	if (onProgress) {
 		const totalBlockMix = 2 * N * p;
@@ -9609,7 +9660,7 @@ function scryptOutput(password, dkLen, B, V, tmp) {
 		c: 1,
 		dkLen
 	});
-	clean$2(B, V, tmp);
+	clean$1(B, V, tmp);
 	return res;
 }
 /**
@@ -9650,843 +9701,6 @@ function scrypt(password, salt, opts) {
 	return scryptOutput(password, dkLen, B, V, tmp);
 }
 
-//#endregion
-//#region ../../node_modules/.bun/@noble+ciphers@2.1.1/node_modules/@noble/ciphers/utils.js
-/**
-* Utilities for hex, bytes, CSPRNG.
-* @module
-*/
-/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
-/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
-function isBytes$2(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-/** Asserts something is boolean. */
-function abool$2(b) {
-	if (typeof b !== "boolean") throw new Error(`boolean expected, not ${b}`);
-}
-/** Asserts something is positive integer. */
-function anumber$2(n) {
-	if (!Number.isSafeInteger(n) || n < 0) throw new Error("positive integer expected, got " + n);
-}
-/** Asserts something is Uint8Array. */
-function abytes$2(value, length, title = "") {
-	const bytes = isBytes$2(value);
-	const len = value?.length;
-	const needsLen = length !== void 0;
-	if (!bytes || needsLen && len !== length) {
-		const prefix = title && `"${title}" `;
-		const ofLen = needsLen ? ` of length ${length}` : "";
-		const got = bytes ? `length=${len}` : `type=${typeof value}`;
-		throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
-	}
-	return value;
-}
-/** Asserts a hash instance has not been destroyed / finished */
-function aexists$1(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$1(out, instance) {
-	abytes$2(out, void 0, "output");
-	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 u32. */
-function u32$1(arr) {
-	return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-/** Zeroize a byte array. Warning: JS provides no guarantees. */
-function clean$1(...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$1(arr) {
-	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
-const isLE$1 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function checkOpts(defaults, opts) {
-	if (opts == null || typeof opts !== "object") throw new Error("options must be defined");
-	return Object.assign(defaults, opts);
-}
-/** Compares 2 uint8array-s in kinda constant time. */
-function equalBytes$2(a, b) {
-	if (a.length !== b.length) return false;
-	let diff = 0;
-	for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
-	return diff === 0;
-}
-/**
-* Wraps a cipher: validates args, ensures encrypt() can only be called once.
-* @__NO_SIDE_EFFECTS__
-*/
-const wrapCipher = (params, constructor) => {
-	function wrappedCipher(key, ...args) {
-		abytes$2(key, void 0, "key");
-		if (!isLE$1) throw new Error("Non little-endian hardware is not yet supported");
-		if (params.nonceLength !== void 0) {
-			const nonce = args[0];
-			abytes$2(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
-		}
-		const tagl = params.tagLength;
-		if (tagl && args[1] !== void 0) abytes$2(args[1], void 0, "AAD");
-		const cipher = constructor(key, ...args);
-		const checkOutput = (fnLength, output) => {
-			if (output !== void 0) {
-				if (fnLength !== 2) throw new Error("cipher output not supported");
-				abytes$2(output, void 0, "output");
-			}
-		};
-		let called = false;
-		return {
-			encrypt(data, output) {
-				if (called) throw new Error("cannot encrypt() twice with same key + nonce");
-				called = true;
-				abytes$2(data);
-				checkOutput(cipher.encrypt.length, output);
-				return cipher.encrypt(data, output);
-			},
-			decrypt(data, output) {
-				abytes$2(data);
-				if (tagl && data.length < tagl) throw new Error("\"ciphertext\" expected length bigger than tagLength=" + tagl);
-				checkOutput(cipher.decrypt.length, output);
-				return cipher.decrypt(data, output);
-			}
-		};
-	}
-	Object.assign(wrappedCipher, params);
-	return wrappedCipher;
-};
-/**
-* By default, returns u8a of length.
-* When out is available, it checks it for validity and uses it.
-*/
-function getOutput(expectedLength, out, onlyAligned = true) {
-	if (out === void 0) return new Uint8Array(expectedLength);
-	if (out.length !== expectedLength) throw new Error("\"output\" expected Uint8Array of length " + expectedLength + ", got: " + out.length);
-	if (onlyAligned && !isAligned32$1(out)) throw new Error("invalid output, must be aligned");
-	return out;
-}
-function u64Lengths(dataLength, aadLength, isLE) {
-	abool$2(isLE);
-	const num = new Uint8Array(16);
-	const view = createView$1(num);
-	view.setBigUint64(0, BigInt(aadLength), isLE);
-	view.setBigUint64(8, BigInt(dataLength), isLE);
-	return num;
-}
-function isAligned32$1(bytes) {
-	return bytes.byteOffset % 4 === 0;
-}
-function copyBytes$3(bytes) {
-	return Uint8Array.from(bytes);
-}
-
-//#endregion
-//#region ../../node_modules/.bun/@noble+ciphers@2.1.1/node_modules/@noble/ciphers/_arx.js
-/**
-* Basic utils for ARX (add-rotate-xor) salsa and chacha ciphers.
-
-RFC8439 requires multi-step cipher stream, where
-authKey starts with counter: 0, actual msg with counter: 1.
-
-For this, we need a way to re-use nonce / counter:
-
-const counter = new Uint8Array(4);
-chacha(..., counter, ...); // counter is now 1
-chacha(..., counter, ...); // counter is now 2
-
-This is complicated:
-
-- 32-bit counters are enough, no need for 64-bit: max ArrayBuffer size in JS is 4GB
-- Original papers don't allow mutating counters
-- Counter overflow is undefined [^1]
-- Idea A: allow providing (nonce | counter) instead of just nonce, re-use it
-- Caveat: Cannot be re-used through all cases:
-- * chacha has (counter | nonce)
-- * xchacha has (nonce16 | counter | nonce16)
-- Idea B: separate nonce / counter and provide separate API for counter re-use
-- Caveat: there are different counter sizes depending on an algorithm.
-- salsa & chacha also differ in structures of key & sigma:
-salsa20:      s[0] | k(4) | s[1] | nonce(2) | cnt(2) | s[2] | k(4) | s[3]
-chacha:       s(4) | k(8) | cnt(1) | nonce(3)
-chacha20orig: s(4) | k(8) | cnt(2) | nonce(2)
-- Idea C: helper method such as `setSalsaState(key, nonce, sigma, data)`
-- Caveat: we can't re-use counter array
-
-xchacha [^2] uses the subkey and remaining 8 byte nonce with ChaCha20 as normal
-(prefixed by 4 NUL bytes, since [RFC8439] specifies a 12-byte nonce).
-
-[^1]: https://mailarchive.ietf.org/arch/msg/cfrg/gsOnTJzcbgG6OqD8Sc0GO5aR_tU/
-[^2]: https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha#appendix-A.2
-
-* @module
-*/
-const encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
-const sigma16 = encodeStr("expand 16-byte k");
-const sigma32 = encodeStr("expand 32-byte k");
-const sigma16_32 = u32$1(sigma16);
-const sigma32_32 = u32$1(sigma32);
-/** Rotate left. */
-function rotl(a, b) {
-	return a << b | a >>> 32 - b;
-}
-function isAligned32(b) {
-	return b.byteOffset % 4 === 0;
-}
-const BLOCK_LEN = 64;
-const BLOCK_LEN32 = 16;
-const MAX_COUNTER = 2 ** 32 - 1;
-const U32_EMPTY = Uint32Array.of();
-function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
-	const len = data.length;
-	const block = new Uint8Array(BLOCK_LEN);
-	const b32 = u32$1(block);
-	const isAligned = isAligned32(data) && isAligned32(output);
-	const d32 = isAligned ? u32$1(data) : U32_EMPTY;
-	const o32 = isAligned ? u32$1(output) : U32_EMPTY;
-	for (let pos = 0; pos < len; counter++) {
-		core(sigma, key, nonce, b32, counter, rounds);
-		if (counter >= MAX_COUNTER) throw new Error("arx: counter overflow");
-		const take = Math.min(BLOCK_LEN, len - pos);
-		if (isAligned && take === BLOCK_LEN) {
-			const pos32 = pos / 4;
-			if (pos % 4 !== 0) throw new Error("arx: invalid block position");
-			for (let j = 0, posj; j < BLOCK_LEN32; j++) {
-				posj = pos32 + j;
-				o32[posj] = d32[posj] ^ b32[j];
-			}
-			pos += BLOCK_LEN;
-			continue;
-		}
-		for (let j = 0, posj; j < take; j++) {
-			posj = pos + j;
-			output[posj] = data[posj] ^ block[j];
-		}
-		pos += take;
-	}
-}
-/** Creates ARX-like (ChaCha, Salsa) cipher stream from core function. */
-function createCipher(core, opts) {
-	const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({
-		allowShortKeys: false,
-		counterLength: 8,
-		counterRight: false,
-		rounds: 20
-	}, opts);
-	if (typeof core !== "function") throw new Error("core must be a function");
-	anumber$2(counterLength);
-	anumber$2(rounds);
-	abool$2(counterRight);
-	abool$2(allowShortKeys);
-	return (key, nonce, data, output, counter = 0) => {
-		abytes$2(key, void 0, "key");
-		abytes$2(nonce, void 0, "nonce");
-		abytes$2(data, void 0, "data");
-		const len = data.length;
-		if (output === void 0) output = new Uint8Array(len);
-		abytes$2(output, void 0, "output");
-		anumber$2(counter);
-		if (counter < 0 || counter >= MAX_COUNTER) throw new Error("arx: counter overflow");
-		if (output.length < len) throw new Error(`arx: output (${output.length}) is shorter than data (${len})`);
-		const toClean = [];
-		let l = key.length;
-		let k;
-		let sigma;
-		if (l === 32) {
-			toClean.push(k = copyBytes$3(key));
-			sigma = sigma32_32;
-		} else if (l === 16 && allowShortKeys) {
-			k = new Uint8Array(32);
-			k.set(key);
-			k.set(key, 16);
-			sigma = sigma16_32;
-			toClean.push(k);
-		} else {
-			abytes$2(key, 32, "arx key");
-			throw new Error("invalid key size");
-		}
-		if (!isAligned32(nonce)) toClean.push(nonce = copyBytes$3(nonce));
-		const k32 = u32$1(k);
-		if (extendNonceFn) {
-			if (nonce.length !== 24) throw new Error(`arx: extended nonce must be 24 bytes`);
-			extendNonceFn(sigma, k32, u32$1(nonce.subarray(0, 16)), k32);
-			nonce = nonce.subarray(16);
-		}
-		const nonceNcLen = 16 - counterLength;
-		if (nonceNcLen !== nonce.length) throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
-		if (nonceNcLen !== 12) {
-			const nc = new Uint8Array(12);
-			nc.set(nonce, counterRight ? 0 : 12 - nonce.length);
-			nonce = nc;
-			toClean.push(nonce);
-		}
-		const n32 = u32$1(nonce);
-		runCipher(core, sigma, k32, n32, data, output, counter, rounds);
-		clean$1(...toClean);
-		return output;
-	};
-}
-
-//#endregion
-//#region ../../node_modules/.bun/@noble+ciphers@2.1.1/node_modules/@noble/ciphers/_poly1305.js
-/**
-* Poly1305 ([PDF](https://cr.yp.to/mac/poly1305-20050329.pdf),
-* [wiki](https://en.wikipedia.org/wiki/Poly1305))
-* is a fast and parallel secret-key message-authentication code suitable for
-* a wide variety of applications. It was standardized in
-* [RFC 8439](https://www.rfc-editor.org/rfc/rfc8439) and is now used in TLS 1.3.
-*
-* Polynomial MACs are not perfect for every situation:
-* they lack Random Key Robustness: the MAC can be forged, and can't be used in PAKE schemes.
-* See [invisible salamanders attack](https://keymaterial.net/2020/09/07/invisible-salamanders-in-aes-gcm-siv/).
-* To combat invisible salamanders, `hash(key)` can be included in ciphertext,
-* however, this would violate ciphertext indistinguishability:
-* an attacker would know which key was used - so `HKDF(key, i)`
-* could be used instead.
-*
-* Check out [original website](https://cr.yp.to/mac.html).
-* Based on Public Domain [poly1305-donna](https://github.com/floodyberry/poly1305-donna).
-* @module
-*/
-function u8to16(a, i) {
-	return a[i++] & 255 | (a[i++] & 255) << 8;
-}
-/** Poly1305 class. Prefer poly1305() function instead. */
-var Poly1305 = class {
-	blockLen = 16;
-	outputLen = 16;
-	buffer = new Uint8Array(16);
-	r = new Uint16Array(10);
-	h = new Uint16Array(10);
-	pad = new Uint16Array(8);
-	pos = 0;
-	finished = false;
-	constructor(key) {
-		key = copyBytes$3(abytes$2(key, 32, "key"));
-		const t0 = u8to16(key, 0);
-		const t1 = u8to16(key, 2);
-		const t2 = u8to16(key, 4);
-		const t3 = u8to16(key, 6);
-		const t4 = u8to16(key, 8);
-		const t5 = u8to16(key, 10);
-		const t6 = u8to16(key, 12);
-		const t7 = u8to16(key, 14);
-		this.r[0] = t0 & 8191;
-		this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
-		this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
-		this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
-		this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
-		this.r[5] = t4 >>> 1 & 8190;
-		this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
-		this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
-		this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
-		this.r[9] = t7 >>> 5 & 127;
-		for (let i = 0; i < 8; i++) this.pad[i] = u8to16(key, 16 + 2 * i);
-	}
-	process(data, offset, isLast = false) {
-		const hibit = isLast ? 0 : 2048;
-		const { h, r } = this;
-		const r0 = r[0];
-		const r1 = r[1];
-		const r2 = r[2];
-		const r3 = r[3];
-		const r4 = r[4];
-		const r5 = r[5];
-		const r6 = r[6];
-		const r7 = r[7];
-		const r8 = r[8];
-		const r9 = r[9];
-		const t0 = u8to16(data, offset + 0);
-		const t1 = u8to16(data, offset + 2);
-		const t2 = u8to16(data, offset + 4);
-		const t3 = u8to16(data, offset + 6);
-		const t4 = u8to16(data, offset + 8);
-		const t5 = u8to16(data, offset + 10);
-		const t6 = u8to16(data, offset + 12);
-		const t7 = u8to16(data, offset + 14);
-		let h0 = h[0] + (t0 & 8191);
-		let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191);
-		let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191);
-		let h3 = h[3] + ((t2 >>> 7 | t3 << 9) & 8191);
-		let h4 = h[4] + ((t3 >>> 4 | t4 << 12) & 8191);
-		let h5 = h[5] + (t4 >>> 1 & 8191);
-		let h6 = h[6] + ((t4 >>> 14 | t5 << 2) & 8191);
-		let h7 = h[7] + ((t5 >>> 11 | t6 << 5) & 8191);
-		let h8 = h[8] + ((t6 >>> 8 | t7 << 8) & 8191);
-		let h9 = h[9] + (t7 >>> 5 | hibit);
-		let c = 0;
-		let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);
-		c = d0 >>> 13;
-		d0 &= 8191;
-		d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);
-		c += d0 >>> 13;
-		d0 &= 8191;
-		let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);
-		c = d1 >>> 13;
-		d1 &= 8191;
-		d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);
-		c += d1 >>> 13;
-		d1 &= 8191;
-		let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);
-		c = d2 >>> 13;
-		d2 &= 8191;
-		d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);
-		c += d2 >>> 13;
-		d2 &= 8191;
-		let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);
-		c = d3 >>> 13;
-		d3 &= 8191;
-		d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);
-		c += d3 >>> 13;
-		d3 &= 8191;
-		let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;
-		c = d4 >>> 13;
-		d4 &= 8191;
-		d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);
-		c += d4 >>> 13;
-		d4 &= 8191;
-		let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;
-		c = d5 >>> 13;
-		d5 &= 8191;
-		d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);
-		c += d5 >>> 13;
-		d5 &= 8191;
-		let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;
-		c = d6 >>> 13;
-		d6 &= 8191;
-		d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);
-		c += d6 >>> 13;
-		d6 &= 8191;
-		let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;
-		c = d7 >>> 13;
-		d7 &= 8191;
-		d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);
-		c += d7 >>> 13;
-		d7 &= 8191;
-		let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;
-		c = d8 >>> 13;
-		d8 &= 8191;
-		d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);
-		c += d8 >>> 13;
-		d8 &= 8191;
-		let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;
-		c = d9 >>> 13;
-		d9 &= 8191;
-		d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;
-		c += d9 >>> 13;
-		d9 &= 8191;
-		c = (c << 2) + c | 0;
-		c = c + d0 | 0;
-		d0 = c & 8191;
-		c = c >>> 13;
-		d1 += c;
-		h[0] = d0;
-		h[1] = d1;
-		h[2] = d2;
-		h[3] = d3;
-		h[4] = d4;
-		h[5] = d5;
-		h[6] = d6;
-		h[7] = d7;
-		h[8] = d8;
-		h[9] = d9;
-	}
-	finalize() {
-		const { h, pad } = this;
-		const g = new Uint16Array(10);
-		let c = h[1] >>> 13;
-		h[1] &= 8191;
-		for (let i = 2; i < 10; i++) {
-			h[i] += c;
-			c = h[i] >>> 13;
-			h[i] &= 8191;
-		}
-		h[0] += c * 5;
-		c = h[0] >>> 13;
-		h[0] &= 8191;
-		h[1] += c;
-		c = h[1] >>> 13;
-		h[1] &= 8191;
-		h[2] += c;
-		g[0] = h[0] + 5;
-		c = g[0] >>> 13;
-		g[0] &= 8191;
-		for (let i = 1; i < 10; i++) {
-			g[i] = h[i] + c;
-			c = g[i] >>> 13;
-			g[i] &= 8191;
-		}
-		g[9] -= 8192;
-		let mask = (c ^ 1) - 1;
-		for (let i = 0; i < 10; i++) g[i] &= mask;
-		mask = ~mask;
-		for (let i = 0; i < 10; i++) h[i] = h[i] & mask | g[i];
-		h[0] = (h[0] | h[1] << 13) & 65535;
-		h[1] = (h[1] >>> 3 | h[2] << 10) & 65535;
-		h[2] = (h[2] >>> 6 | h[3] << 7) & 65535;
-		h[3] = (h[3] >>> 9 | h[4] << 4) & 65535;
-		h[4] = (h[4] >>> 12 | h[5] << 1 | h[6] << 14) & 65535;
-		h[5] = (h[6] >>> 2 | h[7] << 11) & 65535;
-		h[6] = (h[7] >>> 5 | h[8] << 8) & 65535;
-		h[7] = (h[8] >>> 8 | h[9] << 5) & 65535;
-		let f = h[0] + pad[0];
-		h[0] = f & 65535;
-		for (let i = 1; i < 8; i++) {
-			f = (h[i] + pad[i] | 0) + (f >>> 16) | 0;
-			h[i] = f & 65535;
-		}
-		clean$1(g);
-	}
-	update(data) {
-		aexists$1(this);
-		abytes$2(data);
-		data = copyBytes$3(data);
-		const { 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) {
-				for (; blockLen <= len - pos; pos += blockLen) this.process(data, pos);
-				continue;
-			}
-			buffer.set(data.subarray(pos, pos + take), this.pos);
-			this.pos += take;
-			pos += take;
-			if (this.pos === blockLen) {
-				this.process(buffer, 0, false);
-				this.pos = 0;
-			}
-		}
-		return this;
-	}
-	destroy() {
-		clean$1(this.h, this.r, this.buffer, this.pad);
-	}
-	digestInto(out) {
-		aexists$1(this);
-		aoutput$1(out, this);
-		this.finished = true;
-		const { buffer, h } = this;
-		let { pos } = this;
-		if (pos) {
-			buffer[pos++] = 1;
-			for (; pos < 16; pos++) buffer[pos] = 0;
-			this.process(buffer, 0, true);
-		}
-		this.finalize();
-		let opos = 0;
-		for (let i = 0; i < 8; i++) {
-			out[opos++] = h[i] >>> 0;
-			out[opos++] = h[i] >>> 8;
-		}
-		return out;
-	}
-	digest() {
-		const { buffer, outputLen } = this;
-		this.digestInto(buffer);
-		const res = buffer.slice(0, outputLen);
-		this.destroy();
-		return res;
-	}
-};
-function wrapConstructorWithKey(hashCons) {
-	const hashC = (msg, key) => hashCons(key).update(msg).digest();
-	const tmp = hashCons(new Uint8Array(32));
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.create = (key) => hashCons(key);
-	return hashC;
-}
-/** Poly1305 MAC from RFC 8439. */
-const poly1305 = (() => wrapConstructorWithKey((key) => new Poly1305(key)))();
-
-//#endregion
-//#region ../../node_modules/.bun/@noble+ciphers@2.1.1/node_modules/@noble/ciphers/chacha.js
-/**
-* ChaCha stream cipher, released
-* in 2008. Developed after Salsa20, ChaCha aims to increase diffusion per round.
-* It was standardized in [RFC 8439](https://www.rfc-editor.org/rfc/rfc8439) and
-* is now used in TLS 1.3.
-*
-* [XChaCha20](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha)
-* extended-nonce variant is also provided. Similar to XSalsa, it's safe to use with
-* randomly-generated nonces.
-*
-* Check out [PDF](http://cr.yp.to/chacha/chacha-20080128.pdf) and
-* [wiki](https://en.wikipedia.org/wiki/Salsa20) and
-* [website](https://cr.yp.to/chacha.html).
-*
-* @module
-*/
-/** Identical to `chachaCore_small`. Unused. */
-function chachaCore(s, k, n, out, cnt, rounds = 20) {
-	let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2];
-	let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
-	for (let r = 0; r < rounds; r += 2) {
-		x00 = x00 + x04 | 0;
-		x12 = rotl(x12 ^ x00, 16);
-		x08 = x08 + x12 | 0;
-		x04 = rotl(x04 ^ x08, 12);
-		x00 = x00 + x04 | 0;
-		x12 = rotl(x12 ^ x00, 8);
-		x08 = x08 + x12 | 0;
-		x04 = rotl(x04 ^ x08, 7);
-		x01 = x01 + x05 | 0;
-		x13 = rotl(x13 ^ x01, 16);
-		x09 = x09 + x13 | 0;
-		x05 = rotl(x05 ^ x09, 12);
-		x01 = x01 + x05 | 0;
-		x13 = rotl(x13 ^ x01, 8);
-		x09 = x09 + x13 | 0;
-		x05 = rotl(x05 ^ x09, 7);
-		x02 = x02 + x06 | 0;
-		x14 = rotl(x14 ^ x02, 16);
-		x10 = x10 + x14 | 0;
-		x06 = rotl(x06 ^ x10, 12);
-		x02 = x02 + x06 | 0;
-		x14 = rotl(x14 ^ x02, 8);
-		x10 = x10 + x14 | 0;
-		x06 = rotl(x06 ^ x10, 7);
-		x03 = x03 + x07 | 0;
-		x15 = rotl(x15 ^ x03, 16);
-		x11 = x11 + x15 | 0;
-		x07 = rotl(x07 ^ x11, 12);
-		x03 = x03 + x07 | 0;
-		x15 = rotl(x15 ^ x03, 8);
-		x11 = x11 + x15 | 0;
-		x07 = rotl(x07 ^ x11, 7);
-		x00 = x00 + x05 | 0;
-		x15 = rotl(x15 ^ x00, 16);
-		x10 = x10 + x15 | 0;
-		x05 = rotl(x05 ^ x10, 12);
-		x00 = x00 + x05 | 0;
-		x15 = rotl(x15 ^ x00, 8);
-		x10 = x10 + x15 | 0;
-		x05 = rotl(x05 ^ x10, 7);
-		x01 = x01 + x06 | 0;
-		x12 = rotl(x12 ^ x01, 16);
-		x11 = x11 + x12 | 0;
-		x06 = rotl(x06 ^ x11, 12);
-		x01 = x01 + x06 | 0;
-		x12 = rotl(x12 ^ x01, 8);
-		x11 = x11 + x12 | 0;
-		x06 = rotl(x06 ^ x11, 7);
-		x02 = x02 + x07 | 0;
-		x13 = rotl(x13 ^ x02, 16);
-		x08 = x08 + x13 | 0;
-		x07 = rotl(x07 ^ x08, 12);
-		x02 = x02 + x07 | 0;
-		x13 = rotl(x13 ^ x02, 8);
-		x08 = x08 + x13 | 0;
-		x07 = rotl(x07 ^ x08, 7);
-		x03 = x03 + x04 | 0;
-		x14 = rotl(x14 ^ x03, 16);
-		x09 = x09 + x14 | 0;
-		x04 = rotl(x04 ^ x09, 12);
-		x03 = x03 + x04 | 0;
-		x14 = rotl(x14 ^ x03, 8);
-		x09 = x09 + x14 | 0;
-		x04 = rotl(x04 ^ x09, 7);
-	}
-	let oi = 0;
-	out[oi++] = y00 + x00 | 0;
-	out[oi++] = y01 + x01 | 0;
-	out[oi++] = y02 + x02 | 0;
-	out[oi++] = y03 + x03 | 0;
-	out[oi++] = y04 + x04 | 0;
-	out[oi++] = y05 + x05 | 0;
-	out[oi++] = y06 + x06 | 0;
-	out[oi++] = y07 + x07 | 0;
-	out[oi++] = y08 + x08 | 0;
-	out[oi++] = y09 + x09 | 0;
-	out[oi++] = y10 + x10 | 0;
-	out[oi++] = y11 + x11 | 0;
-	out[oi++] = y12 + x12 | 0;
-	out[oi++] = y13 + x13 | 0;
-	out[oi++] = y14 + x14 | 0;
-	out[oi++] = y15 + x15 | 0;
-}
-/**
-* hchacha hashes key and nonce into key' and nonce' for xchacha20.
-* Identical to `hchacha_small`.
-* Need to find a way to merge it with `chachaCore` without 25% performance hit.
-*/
-function hchacha(s, k, i, out) {
-	let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3], x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3], x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7], x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3];
-	for (let r = 0; r < 20; r += 2) {
-		x00 = x00 + x04 | 0;
-		x12 = rotl(x12 ^ x00, 16);
-		x08 = x08 + x12 | 0;
-		x04 = rotl(x04 ^ x08, 12);
-		x00 = x00 + x04 | 0;
-		x12 = rotl(x12 ^ x00, 8);
-		x08 = x08 + x12 | 0;
-		x04 = rotl(x04 ^ x08, 7);
-		x01 = x01 + x05 | 0;
-		x13 = rotl(x13 ^ x01, 16);
-		x09 = x09 + x13 | 0;
-		x05 = rotl(x05 ^ x09, 12);
-		x01 = x01 + x05 | 0;
-		x13 = rotl(x13 ^ x01, 8);
-		x09 = x09 + x13 | 0;
-		x05 = rotl(x05 ^ x09, 7);
-		x02 = x02 + x06 | 0;
-		x14 = rotl(x14 ^ x02, 16);
-		x10 = x10 + x14 | 0;
-		x06 = rotl(x06 ^ x10, 12);
-		x02 = x02 + x06 | 0;
-		x14 = rotl(x14 ^ x02, 8);
-		x10 = x10 + x14 | 0;
-		x06 = rotl(x06 ^ x10, 7);
-		x03 = x03 + x07 | 0;
-		x15 = rotl(x15 ^ x03, 16);
-		x11 = x11 + x15 | 0;
-		x07 = rotl(x07 ^ x11, 12);
-		x03 = x03 + x07 | 0;
-		x15 = rotl(x15 ^ x03, 8);
-		x11 = x11 + x15 | 0;
-		x07 = rotl(x07 ^ x11, 7);
-		x00 = x00 + x05 | 0;
-		x15 = rotl(x15 ^ x00, 16);
-		x10 = x10 + x15 | 0;
-		x05 = rotl(x05 ^ x10, 12);
-		x00 = x00 + x05 | 0;
-		x15 = rotl(x15 ^ x00, 8);
-		x10 = x10 + x15 | 0;
-		x05 = rotl(x05 ^ x10, 7);
-		x01 = x01 + x06 | 0;
-		x12 = rotl(x12 ^ x01, 16);
-		x11 = x11 + x12 | 0;
-		x06 = rotl(x06 ^ x11, 12);
-		x01 = x01 + x06 | 0;
-		x12 = rotl(x12 ^ x01, 8);
-		x11 = x11 + x12 | 0;
-		x06 = rotl(x06 ^ x11, 7);
-		x02 = x02 + x07 | 0;
-		x13 = rotl(x13 ^ x02, 16);
-		x08 = x08 + x13 | 0;
-		x07 = rotl(x07 ^ x08, 12);
-		x02 = x02 + x07 | 0;
-		x13 = rotl(x13 ^ x02, 8);
-		x08 = x08 + x13 | 0;
-		x07 = rotl(x07 ^ x08, 7);
-		x03 = x03 + x04 | 0;
-		x14 = rotl(x14 ^ x03, 16);
-		x09 = x09 + x14 | 0;
-		x04 = rotl(x04 ^ x09, 12);
-		x03 = x03 + x04 | 0;
-		x14 = rotl(x14 ^ x03, 8);
-		x09 = x09 + x14 | 0;
-		x04 = rotl(x04 ^ x09, 7);
-	}
-	let oi = 0;
-	out[oi++] = x00;
-	out[oi++] = x01;
-	out[oi++] = x02;
-	out[oi++] = x03;
-	out[oi++] = x12;
-	out[oi++] = x13;
-	out[oi++] = x14;
-	out[oi++] = x15;
-}
-/**
-* ChaCha stream cipher. Conforms to RFC 8439 (IETF, TLS). 12-byte nonce, 4-byte counter.
-* With smaller nonce, it's not safe to make it random (CSPRNG), due to collision chance.
-*/
-const chacha20 = /* @__PURE__ */ createCipher(chachaCore, {
-	counterRight: false,
-	counterLength: 4,
-	allowShortKeys: false
-});
-/**
-* XChaCha eXtended-nonce ChaCha. With 24-byte nonce, it's safe to make it random (CSPRNG).
-* See [IRTF draft](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha).
-*/
-const xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
-	counterRight: false,
-	counterLength: 8,
-	extendNonceFn: hchacha,
-	allowShortKeys: false
-});
-const ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
-const updatePadded = (h, msg) => {
-	h.update(msg);
-	const leftover = msg.length % 16;
-	if (leftover) h.update(ZEROS16.subarray(leftover));
-};
-const ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
-function computeTag(fn, key, nonce, ciphertext, AAD) {
-	if (AAD !== void 0) abytes$2(AAD, void 0, "AAD");
-	const authKey = fn(key, nonce, ZEROS32);
-	const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);
-	const h = poly1305.create(authKey);
-	if (AAD) updatePadded(h, AAD);
-	updatePadded(h, ciphertext);
-	h.update(lengths);
-	const res = h.digest();
-	clean$1(authKey, lengths);
-	return res;
-}
-/**
-* AEAD algorithm from RFC 8439.
-* Salsa20 and chacha (RFC 8439) use poly1305 differently.
-* We could have composed them, but it's hard because of authKey:
-* In salsa20, authKey changes position in salsa stream.
-* In chacha, authKey can't be computed inside computeTag, it modifies the counter.
-*/
-const _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
-	const tagLength = 16;
-	return {
-		encrypt(plaintext, output) {
-			const plength = plaintext.length;
-			output = getOutput(plength + tagLength, output, false);
-			output.set(plaintext);
-			const oPlain = output.subarray(0, -16);
-			xorStream(key, nonce, oPlain, oPlain, 1);
-			const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
-			output.set(tag, plength);
-			clean$1(tag);
-			return output;
-		},
-		decrypt(ciphertext, output) {
-			output = getOutput(ciphertext.length - tagLength, output, false);
-			const data = ciphertext.subarray(0, -16);
-			const passedTag = ciphertext.subarray(-16);
-			const tag = computeTag(xorStream, key, nonce, data, AAD);
-			if (!equalBytes$2(passedTag, tag)) throw new Error("invalid tag");
-			output.set(ciphertext.subarray(0, -16));
-			xorStream(key, nonce, output, output, 1);
-			clean$1(tag);
-			return output;
-		}
-	};
-};
-/**
-* ChaCha20-Poly1305 from RFC 8439.
-*
-* Unsafe to use random nonces under the same key, due to collision chance.
-* Prefer XChaCha instead.
-*/
-const chacha20poly1305 = /* @__PURE__ */ wrapCipher({
-	blockSize: 64,
-	nonceLength: 12,
-	tagLength: 16
-}, _poly1305_aead(chacha20));
-/**
-* XChaCha20-Poly1305 extended-nonce chacha.
-*
-* Can be safely used with random nonces (CSPRNG).
-* See [IRTF draft](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha).
-*/
-const xchacha20poly1305 = /* @__PURE__ */ wrapCipher({
-	blockSize: 64,
-	nonceLength: 24,
-	tagLength: 16
-}, _poly1305_aead(xchacha20));
-
 //#endregion
 //#region ../../node_modules/.bun/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js
 /**
@@ -14461,7 +13675,7 @@ const MLKEM768P256 = ml_kem768_p256;
 * abytes(new Uint8Array(1));
 * ```
 */
-const abytes = (value, length, title) => abytes$4(value, length, title);
+const abytes = (value, length, title) => abytes$3(value, length, title);
 /**
 * Validates that a value is a non-negative safe integer.
 * @param n - Value to validate.
@@ -14473,7 +13687,7 @@ const abytes = (value, length, title) => abytes$4(value, length, title);
 * anumber(1);
 * ```
 */
-const anumber = anumber$4;
+const anumber = anumber$3;
 /**
 * Encodes bytes as lowercase hex.
 * @param bytes - Bytes to encode.
@@ -14521,7 +13735,7 @@ const hexToBytes = (hex) => hexToBytes$2(hex);
 * isBytes(new Uint8Array(1));
 * ```
 */
-const isBytes = isBytes$4;
+const isBytes = isBytes$3;
 /**
 * Reads random bytes from the platform CSPRNG.
 * @param bytesLength - Number of random bytes to read.
@@ -14661,7 +13875,7 @@ function bytesToNumberBE(bytes) {
 * ```
 */
 function bytesToNumberLE(bytes) {
-	return hexToNumber(bytesToHex$2(copyBytes(abytes$4(bytes)).reverse()));
+	return hexToNumber(bytesToHex$2(copyBytes(abytes$3(bytes)).reverse()));
 }
 /**
 * Encodes a bigint into fixed-length big-endian bytes.
@@ -14677,7 +13891,7 @@ function bytesToNumberLE(bytes) {
 * ```
 */
 function numberToBytesBE(n, len) {
-	anumber$4(len);
+	anumber$3(len);
 	if (len === 0) throw new RangeError("zero length");
 	n = abignumber(n);
 	const hex = n.toString(16);
@@ -14849,8 +14063,8 @@ const bitMask = (n) => (_1n$6 << BigInt(n)) - _1n$6;
 * ```
 */
 function createHmacDrbg(hashLen, qByteLen, hmacFn) {
-	anumber$4(hashLen, "hashLen");
-	anumber$4(qByteLen, "qByteLen");
+	anumber$3(hashLen, "hashLen");
+	anumber$3(qByteLen, "qByteLen");
 	if (typeof hmacFn !== "function") throw new TypeError("hmacFn must be a function");
 	const u8n = (len) => new Uint8Array(len);
 	const NULL = Uint8Array.of();
@@ -17705,7 +16919,7 @@ var _RistrettoPoint = class _RistrettoPoint extends PrimeEdwardsPoint {
 		return new _RistrettoPoint(ep);
 	}
 	static fromBytes(bytes) {
-		abytes$4(bytes, 32);
+		abytes$3(bytes, 32);
 		const { a, d } = ed25519_CURVE;
 		const P = ed25519_CURVE_p;
 		const mod = (n) => Fp.create(n);
@@ -17829,7 +17043,7 @@ const ristretto255_hasher = Object.freeze({
 	* `hash_to_ristretto255` function defined in RFC 9380.
 	*/
 	deriveToCurve(bytes) {
-		abytes$4(bytes, 64);
+		abytes$3(bytes, 64);
 		const R1 = calcElligatorRistrettoMap(bytes255ToNumberLE(bytes.subarray(0, 32)));
 		const R2 = calcElligatorRistrettoMap(bytes255ToNumberLE(bytes.subarray(32, 64)));
 		return new _RistrettoPoint(R1.add(R2));