@honeybbq/teamspeak-client 0.0.0 → 0.1.0

package/dist/primitives-CmIK1O7L.js

@@ -0,0 +1,1836 @@
+import { createECDH as e, createHash as t, createPrivateKey as n, createPublicKey as r, createSign as i, createVerify as a, generateKeyPairSync as o, randomBytes as s } from "node:crypto";
+//#region src/errors.ts
+var c = class extends Error {
+	constructor(e, t) {
+		super(e, t), this.name = "TeamspeakError";
+	}
+}, l = class extends c {
+	id;
+	serverMessage;
+	constructor(e, t) {
+		super(`TeamSpeak server error: ${t} (id=${e})`), this.name = "ServerError", this.id = e, this.serverMessage = t;
+	}
+}, u = class extends c {
+	command;
+	constructor(e) {
+		super(`command timeout: ${e}`), this.name = "CommandTimeoutError", this.command = e;
+	}
+}, d = class extends c {
+	constructor() {
+		super("already connecting or connected"), this.name = "AlreadyConnectedError";
+	}
+}, f = class extends c {
+	constructor() {
+		super("EAX tag mismatch"), this.name = "EAXTagMismatchError";
+	}
+}, p = class extends c {
+	constructor() {
+		super("fake signature mismatch"), this.name = "FakeSignatureMismatchError";
+	}
+}, m = class extends c {
+	constructor(e, t) {
+		super(e, t), this.name = "FileTransferError";
+	}
+}, h = class extends c {
+	constructor() {
+		super("timeout waiting for file transfer notification"), this.name = "FileTransferTimeoutError";
+	}
+}, g = class extends c {
+	constructor(e, t) {
+		super(e, t), this.name = "CryptoInitError";
+	}
+}, _ = class extends c {
+	constructor(e = "invalid identity format") {
+		super(e), this.name = "InvalidIdentityError";
+	}
+}, v = 32, y = 65, b = 4, x = class {
+	privateKey;
+	offset;
+	constructor(e, t) {
+		this.privateKey = e, this.offset = t;
+	}
+	publicKeyBase64() {
+		let e = r(this.privateKey).export({ format: "jwk" });
+		return e.x === void 0 || e.y === void 0 || typeof e.x != "string" || typeof e.y != "string" ? "" : te(de(e.x, v), de(e.y, v));
+	}
+	toString() {
+		let e = this.privateKey.export({ format: "jwk" });
+		if (!e.d) return `:${this.offset}`;
+		let t = de(e.d, v);
+		return `${Buffer.from(t).toString("base64")}:${this.offset}`;
+	}
+	securityLevel() {
+		let e = t("sha1");
+		return e.update(this.publicKeyBase64()), e.update(this.offset.toString(10)), fe(e.digest());
+	}
+	async upgradeToLevel(e, n) {
+		let r = this.publicKeyBase64();
+		for (;;) {
+			if (n?.aborted) throw n.reason;
+			let i = t("sha1");
+			if (i.update(r), i.update(this.offset.toString(10)), fe(i.digest()) >= e) return;
+			this.offset++, this.offset % 10000n == 0n && await new Promise((e) => setImmediate(e));
+		}
+	}
+};
+function S(t) {
+	let r = t.lastIndexOf(":");
+	if (r < 0) throw new _();
+	let i = t.slice(0, r), a = t.slice(r + 1), o = Buffer.from(i, "base64"), s = BigInt(a);
+	if (o.length > v) throw new _("private key scalar too large");
+	let c = Buffer.alloc(v);
+	o.copy(c, v - o.length);
+	let l = e("prime256v1");
+	l.setPrivateKey(c);
+	let u = l.getPublicKey(null, "uncompressed"), d = Buffer.from(u.slice(1, 33)).toString("base64url"), f = Buffer.from(u.slice(33, 65)).toString("base64url");
+	return new x(n({
+		key: {
+			kty: "EC",
+			crv: "P-256",
+			d: c.toString("base64url"),
+			x: d,
+			y: f
+		},
+		format: "jwk"
+	}), s);
+}
+function C(e) {
+	let { privateKey: n } = o("ec", { namedCurve: "prime256v1" }), r = new x(n, 0n), i = r.publicKeyBase64();
+	for (;;) {
+		let n = t("sha1");
+		if (n.update(i), n.update(r.offset.toString(10)), fe(n.digest()) >= e) return r;
+		r.offset++;
+	}
+}
+function w(e) {
+	let n = t("sha1").update(e).digest();
+	return Buffer.from(n).toString("base64");
+}
+function ee(e) {
+	return t("sha512").update(e).digest();
+}
+function te(e, t) {
+	let n = se(3, Buffer.from([0])), r = se(2, le(32)), i = se(2, le(e)), a = se(2, le(t));
+	return se(48, Buffer.concat([
+		n,
+		r,
+		i,
+		a
+	])).toString("base64");
+}
+function ne(e) {
+	let t = re(e);
+	return r({
+		key: {
+			kty: "EC",
+			crv: "P-256",
+			x: Buffer.from(t.slice(1, 33)).toString("base64url"),
+			y: Buffer.from(t.slice(33, 65)).toString("base64url")
+		},
+		format: "jwk"
+	});
+}
+function re(e) {
+	try {
+		return ie(e);
+	} catch {}
+	return ae(e);
+}
+function ie(e) {
+	let t = T(e, 48).value, n = 0, r = T(t, 3, n);
+	n += r.consumed;
+	let i = T(t, 2, n);
+	n += i.consumed;
+	let a = T(t, 2, n);
+	n += a.consumed;
+	let o = T(t, 2, n);
+	return oe(ue(a.value, v), ue(o.value, v));
+}
+function ae(e) {
+	let t = T(e, 48).value, n = 0, r = T(t, 2, n);
+	n += r.consumed;
+	let i = T(t, 2, n);
+	return oe(ue(r.value, v), ue(i.value, v));
+}
+function oe(e, t) {
+	if (e.length > v || t.length > v) throw Error("invalid public key point encoding");
+	let n = new Uint8Array(y);
+	return n[0] = b, n.set(e, 1 + v - e.length), n.set(t, 1 + 2 * v - t.length), n;
+}
+function se(e, t) {
+	let n = ce(t.length);
+	return Buffer.concat([
+		Buffer.from([e]),
+		n,
+		t
+	]);
+}
+function ce(e) {
+	return e < 128 ? Buffer.from([e]) : e < 256 ? Buffer.from([129, e]) : Buffer.from([
+		130,
+		e >> 8 & 255,
+		e & 255
+	]);
+}
+function le(e) {
+	if (typeof e == "number") {
+		let t = [], n = e;
+		do
+			t.unshift(n & 255), n >>= 8;
+		while (n > 0);
+		return t[0] & 128 && t.unshift(0), Buffer.from(t);
+	}
+	let t = 0;
+	for (; t < e.length - 1 && e[t] === 0;) t++;
+	let n = e.slice(t);
+	return n[0] & 128 ? Buffer.concat([Buffer.from([0]), n]) : Buffer.from(n);
+}
+function T(e, t, n = 0) {
+	if (e[n] !== t) throw Error(`expected DER tag 0x${t.toString(16)}, got 0x${(e[n] ?? 0).toString(16)}`);
+	let r = n + 1, i, a = e[r++];
+	if (a < 128) i = a;
+	else if (a === 129) i = e[r++];
+	else if (a === 130) i = (e[r] << 8 | e[r + 1]) >>> 0, r += 2;
+	else throw Error("unsupported DER length encoding");
+	return {
+		value: e.slice(r, r + i),
+		consumed: r - n + i
+	};
+}
+function ue(e, t) {
+	let n = 0;
+	for (; n < e.length - 1 && e[n] === 0;) n++;
+	let r = e.slice(n);
+	if (r.length > t) throw Error("integer too large");
+	if (r.length === t) return r;
+	let i = new Uint8Array(t);
+	return i.set(r, t - r.length), i;
+}
+function de(e, t) {
+	let n = Buffer.from(e, "base64url");
+	if (n.length === t) return n;
+	let r = Buffer.alloc(t);
+	return n.copy(r, t - n.length), r;
+}
+function fe(e) {
+	let t = 0;
+	for (let n of e) if (n === 0) t += 8;
+	else for (let e = 0; e < 8; e++) if (!(n & 1 << e)) t++;
+	else return t;
+	return t;
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js
+function pe(e) {
+	return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function me(e, t = "") {
+	if (!Number.isSafeInteger(e) || e < 0) {
+		let n = t && `"${t}" `;
+		throw Error(`${n}expected integer >= 0, got ${e}`);
+	}
+}
+function E(e, t, n = "") {
+	let r = pe(e), i = e?.length, a = t !== void 0;
+	if (!r || a && i !== t) {
+		let o = n && `"${n}" `, s = a ? ` of length ${t}` : "", c = r ? `length=${i}` : `type=${typeof e}`;
+		throw Error(o + "expected Uint8Array" + s + ", got " + c);
+	}
+	return e;
+}
+function he(e, t = !0) {
+	if (e.destroyed) throw Error("Hash instance has been destroyed");
+	if (t && e.finished) throw Error("Hash#digest() has already been called");
+}
+function ge(e, t) {
+	E(e, void 0, "digestInto() output");
+	let n = t.outputLen;
+	if (e.length < n) throw Error("\"digestInto() output\" expected to be of length >=" + n);
+}
+function _e(...e) {
+	for (let t = 0; t < e.length; t++) e[t].fill(0);
+}
+function ve(e) {
+	return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+new Uint8Array(new Uint32Array([287454020]).buffer)[0];
+var ye = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", be = /* @__PURE__ */ Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+function xe(e) {
+	if (E(e), ye) return e.toHex();
+	let t = "";
+	for (let n = 0; n < e.length; n++) t += be[e[n]];
+	return t;
+}
+var D = {
+	_0: 48,
+	_9: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+function Se(e) {
+	if (e >= D._0 && e <= D._9) return e - D._0;
+	if (e >= D.A && e <= D.F) return e - (D.A - 10);
+	if (e >= D.a && e <= D.f) return e - (D.a - 10);
+}
+function Ce(e) {
+	if (typeof e != "string") throw Error("hex string expected, got " + typeof e);
+	if (ye) return Uint8Array.fromHex(e);
+	let t = e.length, n = t / 2;
+	if (t % 2) throw Error("hex string expected, got unpadded hex of length " + t);
+	let r = new Uint8Array(n);
+	for (let t = 0, i = 0; t < n; t++, i += 2) {
+		let n = Se(e.charCodeAt(i)), a = Se(e.charCodeAt(i + 1));
+		if (n === void 0 || a === void 0) {
+			let t = e[i] + e[i + 1];
+			throw Error("hex string expected, got non-hex character \"" + t + "\" at index " + i);
+		}
+		r[t] = n * 16 + a;
+	}
+	return r;
+}
+function O(...e) {
+	let t = 0;
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		E(r), t += r.length;
+	}
+	let n = new Uint8Array(t);
+	for (let t = 0, r = 0; t < e.length; t++) {
+		let i = e[t];
+		n.set(i, r), r += i.length;
+	}
+	return n;
+}
+function we(e, t = {}) {
+	let n = (t, n) => e(n).update(t).digest(), r = e(void 0);
+	return n.outputLen = r.outputLen, n.blockLen = r.blockLen, n.create = (t) => e(t), Object.assign(n, t), Object.freeze(n);
+}
+function k(e = 32) {
+	let t = typeof globalThis == "object" ? globalThis.crypto : null;
+	if (typeof t?.getRandomValues != "function") throw Error("crypto.getRandomValues must be defined");
+	return t.getRandomValues(new Uint8Array(e));
+}
+var Te = (e) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	e
+]) }), Ee = class {
+	blockLen;
+	outputLen;
+	padOffset;
+	isLE;
+	buffer;
+	view;
+	finished = !1;
+	length = 0;
+	pos = 0;
+	destroyed = !1;
+	constructor(e, t, n, r) {
+		this.blockLen = e, this.outputLen = t, this.padOffset = n, this.isLE = r, this.buffer = new Uint8Array(e), this.view = ve(this.buffer);
+	}
+	update(e) {
+		he(this), E(e);
+		let { view: t, buffer: n, blockLen: r } = this, i = e.length;
+		for (let a = 0; a < i;) {
+			let o = Math.min(r - this.pos, i - a);
+			if (o === r) {
+				let t = ve(e);
+				for (; r <= i - a; a += r) this.process(t, a);
+				continue;
+			}
+			n.set(e.subarray(a, a + o), this.pos), this.pos += o, a += o, this.pos === r && (this.process(t, 0), this.pos = 0);
+		}
+		return this.length += e.length, this.roundClean(), this;
+	}
+	digestInto(e) {
+		he(this), ge(e, this), this.finished = !0;
+		let { buffer: t, view: n, blockLen: r, isLE: i } = this, { pos: a } = this;
+		t[a++] = 128, _e(this.buffer.subarray(a)), this.padOffset > r - a && (this.process(n, 0), a = 0);
+		for (let e = a; e < r; e++) t[e] = 0;
+		n.setBigUint64(r - 8, BigInt(this.length * 8), i), this.process(n, 0);
+		let o = ve(e), s = this.outputLen;
+		if (s % 4) throw Error("_sha2: outputLen must be aligned to 32bit");
+		let c = s / 4, l = this.get();
+		if (c > l.length) throw Error("_sha2: outputLen bigger than state");
+		for (let e = 0; e < c; e++) o.setUint32(4 * e, l[e], i);
+	}
+	digest() {
+		let { buffer: e, outputLen: t } = this;
+		this.digestInto(e);
+		let n = e.slice(0, t);
+		return this.destroy(), n;
+	}
+	_cloneInto(e) {
+		e ||= new this.constructor(), e.set(...this.get());
+		let { blockLen: t, buffer: n, length: r, finished: i, destroyed: a, pos: o } = this;
+		return e.destroyed = a, e.finished = i, e.length = r, e.pos = o, r % t && e.buffer.set(n), e;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+}, A = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]), De = /* @__PURE__ */ BigInt(2 ** 32 - 1), Oe = /* @__PURE__ */ BigInt(32);
+function ke(e, t = !1) {
+	return t ? {
+		h: Number(e & De),
+		l: Number(e >> Oe & De)
+	} : {
+		h: Number(e >> Oe & De) | 0,
+		l: Number(e & De) | 0
+	};
+}
+function Ae(e, t = !1) {
+	let n = e.length, r = new Uint32Array(n), i = new Uint32Array(n);
+	for (let a = 0; a < n; a++) {
+		let { h: n, l: o } = ke(e[a], t);
+		[r[a], i[a]] = [n, o];
+	}
+	return [r, i];
+}
+var je = (e, t, n) => e >>> n, Me = (e, t, n) => e << 32 - n | t >>> n, j = (e, t, n) => e >>> n | t << 32 - n, M = (e, t, n) => e << 32 - n | t >>> n, Ne = (e, t, n) => e << 64 - n | t >>> n - 32, Pe = (e, t, n) => e >>> n - 32 | t << 64 - n;
+function N(e, t, n, r) {
+	let i = (t >>> 0) + (r >>> 0);
+	return {
+		h: e + n + (i / 2 ** 32 | 0) | 0,
+		l: i | 0
+	};
+}
+var Fe = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), Ie = (e, t, n, r) => t + n + r + (e / 2 ** 32 | 0) | 0, Le = (e, t, n, r) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (r >>> 0), Re = (e, t, n, r, i) => t + n + r + i + (e / 2 ** 32 | 0) | 0, ze = (e, t, n, r, i) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (r >>> 0) + (i >>> 0), Be = (e, t, n, r, i, a) => t + n + r + i + a + (e / 2 ** 32 | 0) | 0, Ve = Ae((/* @__PURE__ */ "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".split(".")).map((e) => BigInt(e))), He = Ve[0], Ue = Ve[1], P = /* @__PURE__ */ new Uint32Array(80), F = /* @__PURE__ */ new Uint32Array(80), We = class extends Ee {
+	constructor(e) {
+		super(128, e, 16, !1);
+	}
+	get() {
+		let { Ah: e, Al: t, Bh: n, Bl: r, Ch: i, Cl: a, Dh: o, Dl: s, Eh: c, El: l, Fh: u, Fl: d, Gh: f, Gl: p, Hh: m, Hl: h } = this;
+		return [
+			e,
+			t,
+			n,
+			r,
+			i,
+			a,
+			o,
+			s,
+			c,
+			l,
+			u,
+			d,
+			f,
+			p,
+			m,
+			h
+		];
+	}
+	set(e, t, n, r, i, a, o, s, c, l, u, d, f, p, m, h) {
+		this.Ah = e | 0, this.Al = t | 0, this.Bh = n | 0, this.Bl = r | 0, this.Ch = i | 0, this.Cl = a | 0, this.Dh = o | 0, this.Dl = s | 0, this.Eh = c | 0, this.El = l | 0, this.Fh = u | 0, this.Fl = d | 0, this.Gh = f | 0, this.Gl = p | 0, this.Hh = m | 0, this.Hl = h | 0;
+	}
+	process(e, t) {
+		for (let n = 0; n < 16; n++, t += 4) P[n] = e.getUint32(t), F[n] = e.getUint32(t += 4);
+		for (let e = 16; e < 80; e++) {
+			let t = P[e - 15] | 0, n = F[e - 15] | 0, r = j(t, n, 1) ^ j(t, n, 8) ^ je(t, n, 7), i = M(t, n, 1) ^ M(t, n, 8) ^ Me(t, n, 7), a = P[e - 2] | 0, o = F[e - 2] | 0, s = j(a, o, 19) ^ Ne(a, o, 61) ^ je(a, o, 6), c = Le(i, M(a, o, 19) ^ Pe(a, o, 61) ^ Me(a, o, 6), F[e - 7], F[e - 16]);
+			P[e] = Re(c, r, s, P[e - 7], P[e - 16]) | 0, F[e] = c | 0;
+		}
+		let { Ah: n, Al: r, Bh: i, Bl: a, Ch: o, Cl: s, Dh: c, Dl: l, Eh: u, El: d, Fh: f, Fl: p, Gh: m, Gl: h, Hh: g, Hl: _ } = this;
+		for (let e = 0; e < 80; e++) {
+			let t = j(u, d, 14) ^ j(u, d, 18) ^ Ne(u, d, 41), v = M(u, d, 14) ^ M(u, d, 18) ^ Pe(u, d, 41), y = u & f ^ ~u & m, b = d & p ^ ~d & h, x = ze(_, v, b, Ue[e], F[e]), S = Be(x, g, t, y, He[e], P[e]), C = x | 0, w = j(n, r, 28) ^ Ne(n, r, 34) ^ Ne(n, r, 39), ee = M(n, r, 28) ^ Pe(n, r, 34) ^ Pe(n, r, 39), te = n & i ^ n & o ^ i & o, ne = r & a ^ r & s ^ a & s;
+			g = m | 0, _ = h | 0, m = f | 0, h = p | 0, f = u | 0, p = d | 0, {h: u, l: d} = N(c | 0, l | 0, S | 0, C | 0), c = o | 0, l = s | 0, o = i | 0, s = a | 0, i = n | 0, a = r | 0;
+			let re = Fe(C, ee, ne);
+			n = Ie(re, S, w, te), r = re | 0;
+		}
+		({h: n, l: r} = N(this.Ah | 0, this.Al | 0, n | 0, r | 0)), {h: i, l: a} = N(this.Bh | 0, this.Bl | 0, i | 0, a | 0), {h: o, l: s} = N(this.Ch | 0, this.Cl | 0, o | 0, s | 0), {h: c, l: l} = N(this.Dh | 0, this.Dl | 0, c | 0, l | 0), {h: u, l: d} = N(this.Eh | 0, this.El | 0, u | 0, d | 0), {h: f, l: p} = N(this.Fh | 0, this.Fl | 0, f | 0, p | 0), {h: m, l: h} = N(this.Gh | 0, this.Gl | 0, m | 0, h | 0), {h: g, l: _} = N(this.Hh | 0, this.Hl | 0, g | 0, _ | 0), this.set(n, r, i, a, o, s, c, l, u, d, f, p, m, h, g, _);
+	}
+	roundClean() {
+		_e(P, F);
+	}
+	destroy() {
+		_e(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+}, Ge = class extends We {
+	Ah = A[0] | 0;
+	Al = A[1] | 0;
+	Bh = A[2] | 0;
+	Bl = A[3] | 0;
+	Ch = A[4] | 0;
+	Cl = A[5] | 0;
+	Dh = A[6] | 0;
+	Dl = A[7] | 0;
+	Eh = A[8] | 0;
+	El = A[9] | 0;
+	Fh = A[10] | 0;
+	Fl = A[11] | 0;
+	Gh = A[12] | 0;
+	Gl = A[13] | 0;
+	Hh = A[14] | 0;
+	Hl = A[15] | 0;
+	constructor() {
+		super(64);
+	}
+}, Ke = /* @__PURE__ */ we(() => new Ge(), /* @__PURE__ */ Te(3)), qe = /* @__PURE__ */ BigInt(0), Je = /* @__PURE__ */ BigInt(1);
+function Ye(e, t = "") {
+	if (typeof e != "boolean") {
+		let n = t && `"${t}" `;
+		throw Error(n + "expected boolean, got type=" + typeof e);
+	}
+	return e;
+}
+function Xe(e) {
+	if (typeof e == "bigint") {
+		if (!rt(e)) throw Error("positive bigint expected, got " + e);
+	} else me(e);
+	return e;
+}
+function I(e, t = "") {
+	if (!Number.isSafeInteger(e)) {
+		let n = t && `"${t}" `;
+		throw Error(n + "expected safe integer, got type=" + typeof e);
+	}
+}
+function Ze(e) {
+	if (typeof e != "string") throw Error("hex string expected, got " + typeof e);
+	return e === "" ? qe : BigInt("0x" + e);
+}
+function Qe(e) {
+	return Ze(xe(e));
+}
+function L(e) {
+	return Ze(xe(nt(E(e)).reverse()));
+}
+function $e(e, t) {
+	me(t), e = Xe(e);
+	let n = Ce(e.toString(16).padStart(t * 2, "0"));
+	if (n.length !== t) throw Error("number too large");
+	return n;
+}
+function et(e, t) {
+	return $e(e, t).reverse();
+}
+function tt(e, t) {
+	if (e.length !== t.length) return !1;
+	let n = 0;
+	for (let r = 0; r < e.length; r++) n |= e[r] ^ t[r];
+	return n === 0;
+}
+function nt(e) {
+	return Uint8Array.from(e);
+}
+function R(e) {
+	return Uint8Array.from(e, (t, n) => {
+		let r = t.charCodeAt(0);
+		if (t.length !== 1 || r > 127) throw Error(`string contains non-ASCII character "${e[n]}" with code ${r} at position ${n}`);
+		return r;
+	});
+}
+var rt = (e) => typeof e == "bigint" && qe <= e;
+function it(e, t, n) {
+	return rt(e) && rt(t) && rt(n) && t <= e && e < n;
+}
+function at(e, t, n, r) {
+	if (!it(t, n, r)) throw Error("expected valid " + e + ": " + n + " <= n < " + r + ", got " + t);
+}
+function ot(e) {
+	let t;
+	for (t = 0; e > qe; e >>= Je, t += 1);
+	return t;
+}
+var st = (e) => (Je << BigInt(e)) - Je;
+function ct(e, t = {}, n = {}) {
+	if (!e || typeof e != "object") throw Error("expected valid options object");
+	function r(t, n, r) {
+		let i = e[t];
+		if (r && i === void 0) return;
+		let a = typeof i;
+		if (a !== n || i === null) throw Error(`param "${t}" is invalid: expected ${n}, got ${a}`);
+	}
+	let i = (e, t) => Object.entries(e).forEach(([e, n]) => r(e, n, t));
+	i(t, !1), i(n, !0);
+}
+var lt = () => {
+	throw Error("not implemented");
+};
+function ut(e) {
+	let t = /* @__PURE__ */ new WeakMap();
+	return (n, ...r) => {
+		let i = t.get(n);
+		if (i !== void 0) return i;
+		let a = e(n, ...r);
+		return t.set(n, a), a;
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/modular.js
+var z = /* @__PURE__ */ BigInt(0), B = /* @__PURE__ */ BigInt(1), V = /* @__PURE__ */ BigInt(2), dt = /* @__PURE__ */ BigInt(3), ft = /* @__PURE__ */ BigInt(4), pt = /* @__PURE__ */ BigInt(5), mt = /* @__PURE__ */ BigInt(7), ht = /* @__PURE__ */ BigInt(8), gt = /* @__PURE__ */ BigInt(9), _t = /* @__PURE__ */ BigInt(16);
+function H(e, t) {
+	let n = e % t;
+	return n >= z ? n : t + n;
+}
+function U(e, t, n) {
+	let r = e;
+	for (; t-- > z;) r *= r, r %= n;
+	return r;
+}
+function vt(e, t) {
+	if (e === z) throw Error("invert: expected non-zero number");
+	if (t <= z) throw Error("invert: expected positive modulus, got " + t);
+	let n = H(e, t), r = t, i = z, a = B, o = B, s = z;
+	for (; n !== z;) {
+		let e = r / n, t = r % n, c = i - o * e, l = a - s * e;
+		r = n, n = t, i = o, a = s, o = c, s = l;
+	}
+	if (r !== B) throw Error("invert: does not exist");
+	return H(i, t);
+}
+function yt(e, t, n) {
+	if (!e.eql(e.sqr(t), n)) throw Error("Cannot find square root");
+}
+function bt(e, t) {
+	let n = (e.ORDER + B) / ft, r = e.pow(t, n);
+	return yt(e, r, t), r;
+}
+function xt(e, t) {
+	let n = (e.ORDER - pt) / ht, r = e.mul(t, V), i = e.pow(r, n), a = e.mul(t, i), o = e.mul(e.mul(a, V), i), s = e.mul(a, e.sub(o, e.ONE));
+	return yt(e, s, t), s;
+}
+function St(e) {
+	let t = Mt(e), n = Ct(e), r = n(t, t.neg(t.ONE)), i = n(t, r), a = n(t, t.neg(r)), o = (e + mt) / _t;
+	return (e, t) => {
+		let n = e.pow(t, o), s = e.mul(n, r), c = e.mul(n, i), l = e.mul(n, a), u = e.eql(e.sqr(s), t), d = e.eql(e.sqr(c), t);
+		n = e.cmov(n, s, u), s = e.cmov(l, c, d);
+		let f = e.eql(e.sqr(s), t), p = e.cmov(n, s, f);
+		return yt(e, p, t), p;
+	};
+}
+function Ct(e) {
+	if (e < dt) throw Error("sqrt is not defined for small field");
+	let t = e - B, n = 0;
+	for (; t % V === z;) t /= V, n++;
+	let r = V, i = Mt(e);
+	for (; kt(i, r) === 1;) if (r++ > 1e3) throw Error("Cannot find square root: probably non-prime P");
+	if (n === 1) return bt;
+	let a = i.pow(r, t), o = (t + B) / V;
+	return function(e, r) {
+		if (e.is0(r)) return r;
+		if (kt(e, r) !== 1) throw Error("Cannot find square root");
+		let i = n, s = e.mul(e.ONE, a), c = e.pow(r, t), l = e.pow(r, o);
+		for (; !e.eql(c, e.ONE);) {
+			if (e.is0(c)) return e.ZERO;
+			let t = 1, n = e.sqr(c);
+			for (; !e.eql(n, e.ONE);) if (t++, n = e.sqr(n), t === i) throw Error("Cannot find square root");
+			let r = B << BigInt(i - t - 1), a = e.pow(s, r);
+			i = t, s = e.sqr(a), c = e.mul(c, s), l = e.mul(l, a);
+		}
+		return l;
+	};
+}
+function wt(e) {
+	return e % ft === dt ? bt : e % ht === pt ? xt : e % _t === gt ? St(e) : Ct(e);
+}
+var W = (e, t) => (H(e, t) & B) === B, Tt = [
+	"create",
+	"isValid",
+	"is0",
+	"neg",
+	"inv",
+	"sqrt",
+	"sqr",
+	"eql",
+	"add",
+	"sub",
+	"mul",
+	"pow",
+	"div",
+	"addN",
+	"subN",
+	"mulN",
+	"sqrN"
+];
+function Et(e) {
+	return ct(e, Tt.reduce((e, t) => (e[t] = "function", e), {
+		ORDER: "bigint",
+		BYTES: "number",
+		BITS: "number"
+	})), e;
+}
+function Dt(e, t, n) {
+	if (n < z) throw Error("invalid exponent, negatives unsupported");
+	if (n === z) return e.ONE;
+	if (n === B) return t;
+	let r = e.ONE, i = t;
+	for (; n > z;) n & B && (r = e.mul(r, i)), i = e.sqr(i), n >>= B;
+	return r;
+}
+function Ot(e, t, n = !1) {
+	let r = Array(t.length).fill(n ? e.ZERO : void 0), i = t.reduce((t, n, i) => e.is0(n) ? t : (r[i] = t, e.mul(t, n)), e.ONE), a = e.inv(i);
+	return t.reduceRight((t, n, i) => e.is0(n) ? t : (r[i] = e.mul(t, r[i]), e.mul(t, n)), a), r;
+}
+function kt(e, t) {
+	let n = (e.ORDER - B) / V, r = e.pow(t, n), i = e.eql(r, e.ONE), a = e.eql(r, e.ZERO), o = e.eql(r, e.neg(e.ONE));
+	if (!i && !a && !o) throw Error("invalid Legendre symbol result");
+	return i ? 1 : a ? 0 : -1;
+}
+function At(e, t) {
+	t !== void 0 && me(t);
+	let n = t === void 0 ? e.toString(2).length : t;
+	return {
+		nBitLength: n,
+		nByteLength: Math.ceil(n / 8)
+	};
+}
+var jt = class {
+	ORDER;
+	BITS;
+	BYTES;
+	isLE;
+	ZERO = z;
+	ONE = B;
+	_lengths;
+	_sqrt;
+	_mod;
+	constructor(e, t = {}) {
+		if (e <= z) throw Error("invalid field: expected ORDER > 0, got " + e);
+		let n;
+		this.isLE = !1, typeof t == "object" && t && (typeof t.BITS == "number" && (n = t.BITS), typeof t.sqrt == "function" && (this.sqrt = t.sqrt), typeof t.isLE == "boolean" && (this.isLE = t.isLE), t.allowedLengths && (this._lengths = t.allowedLengths?.slice()), typeof t.modFromBytes == "boolean" && (this._mod = t.modFromBytes));
+		let { nBitLength: r, nByteLength: i } = At(e, n);
+		if (i > 2048) throw Error("invalid field: expected ORDER of <= 2048 bytes");
+		this.ORDER = e, this.BITS = r, this.BYTES = i, this._sqrt = void 0, Object.preventExtensions(this);
+	}
+	create(e) {
+		return H(e, this.ORDER);
+	}
+	isValid(e) {
+		if (typeof e != "bigint") throw Error("invalid field element: expected bigint, got " + typeof e);
+		return z <= e && e < this.ORDER;
+	}
+	is0(e) {
+		return e === z;
+	}
+	isValidNot0(e) {
+		return !this.is0(e) && this.isValid(e);
+	}
+	isOdd(e) {
+		return (e & B) === B;
+	}
+	neg(e) {
+		return H(-e, this.ORDER);
+	}
+	eql(e, t) {
+		return e === t;
+	}
+	sqr(e) {
+		return H(e * e, this.ORDER);
+	}
+	add(e, t) {
+		return H(e + t, this.ORDER);
+	}
+	sub(e, t) {
+		return H(e - t, this.ORDER);
+	}
+	mul(e, t) {
+		return H(e * t, this.ORDER);
+	}
+	pow(e, t) {
+		return Dt(this, e, t);
+	}
+	div(e, t) {
+		return H(e * vt(t, this.ORDER), this.ORDER);
+	}
+	sqrN(e) {
+		return e * e;
+	}
+	addN(e, t) {
+		return e + t;
+	}
+	subN(e, t) {
+		return e - t;
+	}
+	mulN(e, t) {
+		return e * t;
+	}
+	inv(e) {
+		return vt(e, this.ORDER);
+	}
+	sqrt(e) {
+		return this._sqrt ||= wt(this.ORDER), this._sqrt(this, e);
+	}
+	toBytes(e) {
+		return this.isLE ? et(e, this.BYTES) : $e(e, this.BYTES);
+	}
+	fromBytes(e, t = !1) {
+		E(e);
+		let { _lengths: n, BYTES: r, isLE: i, ORDER: a, _mod: o } = this;
+		if (n) {
+			if (!n.includes(e.length) || e.length > r) throw Error("Field.fromBytes: expected " + n + " bytes, got " + e.length);
+			let t = new Uint8Array(r);
+			t.set(e, i ? 0 : t.length - e.length), e = t;
+		}
+		if (e.length !== r) throw Error("Field.fromBytes: expected " + r + " bytes, got " + e.length);
+		let s = i ? L(e) : Qe(e);
+		if (o && (s = H(s, a)), !t && !this.isValid(s)) throw Error("invalid field element: outside of range 0..ORDER");
+		return s;
+	}
+	invertBatch(e) {
+		return Ot(this, e);
+	}
+	cmov(e, t, n) {
+		return n ? t : e;
+	}
+};
+function Mt(e, t = {}) {
+	return new jt(e, t);
+}
+function Nt(e, t) {
+	if (!e.isOdd) throw Error("Field doesn't have isOdd");
+	let n = e.sqrt(t);
+	return e.isOdd(n) ? e.neg(n) : n;
+}
+function Pt(e) {
+	if (typeof e != "bigint") throw Error("field order must be bigint");
+	let t = e.toString(2).length;
+	return Math.ceil(t / 8);
+}
+function Ft(e) {
+	let t = Pt(e);
+	return t + Math.ceil(t / 2);
+}
+function It(e, t, n = !1) {
+	E(e);
+	let r = e.length, i = Pt(t), a = Ft(t);
+	if (r < 16 || r < a || r > 1024) throw Error("expected " + a + "-1024 bytes of input, got " + r);
+	let o = H(n ? L(e) : Qe(e), t - B) + B;
+	return n ? et(o, i) : $e(o, i);
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/curve.js
+var Lt = /* @__PURE__ */ BigInt(0), Rt = /* @__PURE__ */ BigInt(1);
+function zt(e, t) {
+	let n = t.negate();
+	return e ? n : t;
+}
+function Bt(e, t) {
+	let n = Ot(e.Fp, t.map((e) => e.Z));
+	return t.map((t, r) => e.fromAffine(t.toAffine(n[r])));
+}
+function Vt(e, t) {
+	if (!Number.isSafeInteger(e) || e <= 0 || e > t) throw Error("invalid window size, expected [1.." + t + "], got W=" + e);
+}
+function Ht(e, t) {
+	Vt(e, t);
+	let n = Math.ceil(t / e) + 1, r = 2 ** (e - 1), i = 2 ** e;
+	return {
+		windows: n,
+		windowSize: r,
+		mask: st(e),
+		maxNumber: i,
+		shiftBy: BigInt(e)
+	};
+}
+function Ut(e, t, n) {
+	let { windowSize: r, mask: i, maxNumber: a, shiftBy: o } = n, s = Number(e & i), c = e >> o;
+	s > r && (s -= a, c += Rt);
+	let l = t * r, u = l + Math.abs(s) - 1, d = s === 0, f = s < 0, p = t % 2 != 0;
+	return {
+		nextN: c,
+		offset: u,
+		isZero: d,
+		isNeg: f,
+		isNegF: p,
+		offsetF: l
+	};
+}
+function Wt(e, t) {
+	if (!Array.isArray(e)) throw Error("array expected");
+	e.forEach((e, n) => {
+		if (!(e instanceof t)) throw Error("invalid point at index " + n);
+	});
+}
+function Gt(e, t) {
+	if (!Array.isArray(e)) throw Error("array of scalars expected");
+	e.forEach((e, n) => {
+		if (!t.isValid(e)) throw Error("invalid scalar at index " + n);
+	});
+}
+var Kt = /* @__PURE__ */ new WeakMap(), qt = /* @__PURE__ */ new WeakMap();
+function Jt(e) {
+	return qt.get(e) || 1;
+}
+function Yt(e) {
+	if (e !== Lt) throw Error("invalid wNAF");
+}
+var Xt = class {
+	BASE;
+	ZERO;
+	Fn;
+	bits;
+	constructor(e, t) {
+		this.BASE = e.BASE, this.ZERO = e.ZERO, this.Fn = e.Fn, this.bits = t;
+	}
+	_unsafeLadder(e, t, n = this.ZERO) {
+		let r = e;
+		for (; t > Lt;) t & Rt && (n = n.add(r)), r = r.double(), t >>= Rt;
+		return n;
+	}
+	precomputeWindow(e, t) {
+		let { windows: n, windowSize: r } = Ht(t, this.bits), i = [], a = e, o = a;
+		for (let e = 0; e < n; e++) {
+			o = a, i.push(o);
+			for (let e = 1; e < r; e++) o = o.add(a), i.push(o);
+			a = o.double();
+		}
+		return i;
+	}
+	wNAF(e, t, n) {
+		if (!this.Fn.isValid(n)) throw Error("invalid scalar");
+		let r = this.ZERO, i = this.BASE, a = Ht(e, this.bits);
+		for (let e = 0; e < a.windows; e++) {
+			let { nextN: o, offset: s, isZero: c, isNeg: l, isNegF: u, offsetF: d } = Ut(n, e, a);
+			n = o, c ? i = i.add(zt(u, t[d])) : r = r.add(zt(l, t[s]));
+		}
+		return Yt(n), {
+			p: r,
+			f: i
+		};
+	}
+	wNAFUnsafe(e, t, n, r = this.ZERO) {
+		let i = Ht(e, this.bits);
+		for (let e = 0; e < i.windows && n !== Lt; e++) {
+			let { nextN: a, offset: o, isZero: s, isNeg: c } = Ut(n, e, i);
+			if (n = a, !s) {
+				let e = t[o];
+				r = r.add(c ? e.negate() : e);
+			}
+		}
+		return Yt(n), r;
+	}
+	getPrecomputes(e, t, n) {
+		let r = Kt.get(t);
+		return r || (r = this.precomputeWindow(t, e), e !== 1 && (typeof n == "function" && (r = n(r)), Kt.set(t, r))), r;
+	}
+	cached(e, t, n) {
+		let r = Jt(e);
+		return this.wNAF(r, this.getPrecomputes(r, e, n), t);
+	}
+	unsafe(e, t, n, r) {
+		let i = Jt(e);
+		return i === 1 ? this._unsafeLadder(e, t, r) : this.wNAFUnsafe(i, this.getPrecomputes(i, e, n), t, r);
+	}
+	createCache(e, t) {
+		Vt(t, this.bits), qt.set(e, t), Kt.delete(e);
+	}
+	hasCache(e) {
+		return Jt(e) !== 1;
+	}
+};
+function Zt(e, t, n) {
+	let r = e.Fn;
+	Wt(t, e), Gt(n, r);
+	let i = t.length, a = n.length;
+	if (i !== a) throw Error("arrays of points and scalars must have equal length");
+	let o = e.ZERO, s = ot(BigInt(i)), c = 1;
+	s > 12 ? c = s - 3 : s > 4 ? c = s - 2 : s > 0 && (c = 2);
+	let l = st(c), u = Array(Number(l) + 1).fill(o), d = Math.floor((r.BITS - 1) / c) * c, f = o;
+	for (let e = d; e >= 0; e -= c) {
+		u.fill(o);
+		for (let r = 0; r < a; r++) {
+			let i = n[r], a = Number(i >> BigInt(e) & l);
+			u[a] = u[a].add(t[r]);
+		}
+		let r = o;
+		for (let e = u.length - 1, t = o; e > 0; e--) t = t.add(u[e]), r = r.add(t);
+		if (f = f.add(r), e !== 0) for (let e = 0; e < c; e++) f = f.double();
+	}
+	return f;
+}
+function Qt(e, t, n) {
+	if (t) {
+		if (t.ORDER !== e) throw Error("Field.ORDER must match order: Fp == p, Fn == n");
+		return Et(t), t;
+	} else return Mt(e, { isLE: n });
+}
+function $t(e, t, n = {}, r) {
+	if (r === void 0 && (r = e === "edwards"), !t || typeof t != "object") throw Error(`expected valid ${e} CURVE object`);
+	for (let e of [
+		"p",
+		"n",
+		"h"
+	]) {
+		let n = t[e];
+		if (!(typeof n == "bigint" && n > Lt)) throw Error(`CURVE.${e} must be positive bigint`);
+	}
+	let i = Qt(t.p, n.Fp, r), a = Qt(t.n, n.Fn, r), o = [
+		"Gx",
+		"Gy",
+		"a",
+		e === "weierstrass" ? "b" : "d"
+	];
+	for (let e of o) if (!i.isValid(t[e])) throw Error(`CURVE.${e} must be valid field element of CURVE.Fp`);
+	return t = Object.freeze(Object.assign({}, t)), {
+		CURVE: t,
+		Fp: i,
+		Fn: a
+	};
+}
+function en(e, t) {
+	return function(n) {
+		let r = e(n);
+		return {
+			secretKey: r,
+			publicKey: t(r)
+		};
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/edwards.js
+var G = BigInt(0), K = BigInt(1), tn = BigInt(2), nn = BigInt(8);
+function rn(e, t, n, r) {
+	let i = e.sqr(n), a = e.sqr(r), o = e.add(e.mul(t.a, i), a), s = e.add(e.ONE, e.mul(t.d, e.mul(i, a)));
+	return e.eql(o, s);
+}
+function an(e, t = {}) {
+	let n = $t("edwards", e, t, t.FpFnLE), { Fp: r, Fn: i } = n, a = n.CURVE, { h: o } = a;
+	ct(t, {}, { uvRatio: "function" });
+	let s = tn << BigInt(i.BYTES * 8) - K, c = (e) => r.create(e), l = t.uvRatio || ((e, t) => {
+		try {
+			return {
+				isValid: !0,
+				value: r.sqrt(r.div(e, t))
+			};
+		} catch {
+			return {
+				isValid: !1,
+				value: G
+			};
+		}
+	});
+	if (!rn(r, a, a.Gx, a.Gy)) throw Error("bad curve params: generator point");
+	function u(e, t, n = !1) {
+		let r = n ? K : G;
+		return at("coordinate " + e, t, r, s), t;
+	}
+	function d(e) {
+		if (!(e instanceof m)) throw Error("EdwardsPoint expected");
+	}
+	let f = ut((e, t) => {
+		let { X: n, Y: i, Z: a } = e, o = e.is0();
+		t ??= o ? nn : r.inv(a);
+		let s = c(n * t), l = c(i * t), u = r.mul(a, t);
+		if (o) return {
+			x: G,
+			y: K
+		};
+		if (u !== K) throw Error("invZ was invalid");
+		return {
+			x: s,
+			y: l
+		};
+	}), p = ut((e) => {
+		let { a: t, d: n } = a;
+		if (e.is0()) throw Error("bad point: ZERO");
+		let { X: r, Y: i, Z: o, T: s } = e, l = c(r * r), u = c(i * i), d = c(o * o), f = c(d * d);
+		if (c(d * c(c(l * t) + u)) !== c(f + c(n * c(l * u)))) throw Error("bad point: equation left != right (1)");
+		if (c(r * i) !== c(o * s)) throw Error("bad point: equation left != right (2)");
+		return !0;
+	});
+	class m {
+		static BASE = new m(a.Gx, a.Gy, K, c(a.Gx * a.Gy));
+		static ZERO = new m(G, K, K, G);
+		static Fp = r;
+		static Fn = i;
+		X;
+		Y;
+		Z;
+		T;
+		constructor(e, t, n, r) {
+			this.X = u("x", e), this.Y = u("y", t), this.Z = u("z", n, !0), this.T = u("t", r), Object.freeze(this);
+		}
+		static CURVE() {
+			return a;
+		}
+		static fromAffine(e) {
+			if (e instanceof m) throw Error("extended point not allowed");
+			let { x: t, y: n } = e || {};
+			return u("x", t), u("y", n), new m(t, n, K, c(t * n));
+		}
+		static fromBytes(e, t = !1) {
+			let n = r.BYTES, { a: i, d: o } = a;
+			e = nt(E(e, n, "point")), Ye(t, "zip215");
+			let u = nt(e), d = e[n - 1];
+			u[n - 1] = d & -129;
+			let f = L(u);
+			at("point.y", f, G, t ? s : r.ORDER);
+			let p = c(f * f), { isValid: h, value: g } = l(c(p - K), c(o * p - i));
+			if (!h) throw Error("bad point: invalid y coordinate");
+			let _ = (g & K) === K, v = (d & 128) != 0;
+			if (!t && g === G && v) throw Error("bad point: x=0 and x_0=1");
+			return v !== _ && (g = c(-g)), m.fromAffine({
+				x: g,
+				y: f
+			});
+		}
+		static fromHex(e, t = !1) {
+			return m.fromBytes(Ce(e), t);
+		}
+		get x() {
+			return this.toAffine().x;
+		}
+		get y() {
+			return this.toAffine().y;
+		}
+		precompute(e = 8, t = !0) {
+			return h.createCache(this, e), t || this.multiply(tn), this;
+		}
+		assertValidity() {
+			p(this);
+		}
+		equals(e) {
+			d(e);
+			let { X: t, Y: n, Z: r } = this, { X: i, Y: a, Z: o } = e, s = c(t * o), l = c(i * r), u = c(n * o), f = c(a * r);
+			return s === l && u === f;
+		}
+		is0() {
+			return this.equals(m.ZERO);
+		}
+		negate() {
+			return new m(c(-this.X), this.Y, this.Z, c(-this.T));
+		}
+		double() {
+			let { a: e } = a, { X: t, Y: n, Z: r } = this, i = c(t * t), o = c(n * n), s = c(tn * c(r * r)), l = c(e * i), u = t + n, d = c(c(u * u) - i - o), f = l + o, p = f - s, h = l - o, g = c(d * p), _ = c(f * h), v = c(d * h);
+			return new m(g, _, c(p * f), v);
+		}
+		add(e) {
+			d(e);
+			let { a: t, d: n } = a, { X: r, Y: i, Z: o, T: s } = this, { X: l, Y: u, Z: f, T: p } = e, h = c(r * l), g = c(i * u), _ = c(s * n * p), v = c(o * f), y = c((r + i) * (l + u) - h - g), b = v - _, x = v + _, S = c(g - t * h), C = c(y * b), w = c(x * S), ee = c(y * S);
+			return new m(C, w, c(b * x), ee);
+		}
+		subtract(e) {
+			return this.add(e.negate());
+		}
+		multiply(e) {
+			if (!i.isValidNot0(e)) throw Error("invalid scalar: expected 1 <= sc < curve.n");
+			let { p: t, f: n } = h.cached(this, e, (e) => Bt(m, e));
+			return Bt(m, [t, n])[0];
+		}
+		multiplyUnsafe(e, t = m.ZERO) {
+			if (!i.isValid(e)) throw Error("invalid scalar: expected 0 <= sc < curve.n");
+			return e === G ? m.ZERO : this.is0() || e === K ? this : h.unsafe(this, e, (e) => Bt(m, e), t);
+		}
+		isSmallOrder() {
+			return this.multiplyUnsafe(o).is0();
+		}
+		isTorsionFree() {
+			return h.unsafe(this, a.n).is0();
+		}
+		toAffine(e) {
+			return f(this, e);
+		}
+		clearCofactor() {
+			return o === K ? this : this.multiplyUnsafe(o);
+		}
+		toBytes() {
+			let { x: e, y: t } = this.toAffine(), n = r.toBytes(t);
+			return n[n.length - 1] |= e & K ? 128 : 0, n;
+		}
+		toHex() {
+			return xe(this.toBytes());
+		}
+		toString() {
+			return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+		}
+	}
+	let h = new Xt(m, i.BITS);
+	return m.BASE.precompute(8), m;
+}
+var on = class {
+	static BASE;
+	static ZERO;
+	static Fp;
+	static Fn;
+	ep;
+	constructor(e) {
+		this.ep = e;
+	}
+	static fromBytes(e) {
+		lt();
+	}
+	static fromHex(e) {
+		lt();
+	}
+	get x() {
+		return this.toAffine().x;
+	}
+	get y() {
+		return this.toAffine().y;
+	}
+	clearCofactor() {
+		return this;
+	}
+	assertValidity() {
+		this.ep.assertValidity();
+	}
+	toAffine(e) {
+		return this.ep.toAffine(e);
+	}
+	toHex() {
+		return xe(this.toBytes());
+	}
+	toString() {
+		return this.toHex();
+	}
+	isTorsionFree() {
+		return !0;
+	}
+	isSmallOrder() {
+		return !1;
+	}
+	add(e) {
+		return this.assertSame(e), this.init(this.ep.add(e.ep));
+	}
+	subtract(e) {
+		return this.assertSame(e), this.init(this.ep.subtract(e.ep));
+	}
+	multiply(e) {
+		return this.init(this.ep.multiply(e));
+	}
+	multiplyUnsafe(e) {
+		return this.init(this.ep.multiplyUnsafe(e));
+	}
+	double() {
+		return this.init(this.ep.double());
+	}
+	negate() {
+		return this.init(this.ep.negate());
+	}
+	precompute(e, t) {
+		return this.init(this.ep.precompute(e, t));
+	}
+};
+function sn(e, t, n = {}) {
+	if (typeof t != "function") throw Error("\"hash\" function param is required");
+	ct(n, {}, {
+		adjustScalarBytes: "function",
+		randomBytes: "function",
+		domain: "function",
+		prehash: "function",
+		mapToCurve: "function"
+	});
+	let { prehash: r } = n, { BASE: i, Fp: a, Fn: o } = e, s = n.randomBytes || k, c = n.adjustScalarBytes || ((e) => e), l = n.domain || ((e, t, n) => {
+		if (Ye(n, "phflag"), t.length || n) throw Error("Contexts/pre-hash are not supported");
+		return e;
+	});
+	function u(e) {
+		return o.create(L(e));
+	}
+	function d(e) {
+		let n = y.secretKey;
+		E(e, y.secretKey, "secretKey");
+		let r = E(t(e), 2 * n, "hashedSecretKey"), i = c(r.slice(0, n));
+		return {
+			head: i,
+			prefix: r.slice(n, 2 * n),
+			scalar: u(i)
+		};
+	}
+	function f(e) {
+		let { head: t, prefix: n, scalar: r } = d(e), a = i.multiply(r);
+		return {
+			head: t,
+			prefix: n,
+			scalar: r,
+			point: a,
+			pointBytes: a.toBytes()
+		};
+	}
+	function p(e) {
+		return f(e).pointBytes;
+	}
+	function m(e = Uint8Array.of(), ...n) {
+		return u(t(l(O(...n), E(e, void 0, "context"), !!r)));
+	}
+	function h(e, t, n = {}) {
+		e = E(e, void 0, "message"), r && (e = r(e));
+		let { prefix: a, scalar: s, pointBytes: c } = f(t), l = m(n.context, a, e), u = i.multiply(l).toBytes(), d = m(n.context, u, c, e), p = o.create(l + d * s);
+		if (!o.isValid(p)) throw Error("sign failed: invalid s");
+		return E(O(u, o.toBytes(p)), y.signature, "result");
+	}
+	let g = { zip215: !0 };
+	function _(t, n, a, o = g) {
+		let { context: s, zip215: c } = o, l = y.signature;
+		t = E(t, l, "signature"), n = E(n, void 0, "message"), a = E(a, y.publicKey, "publicKey"), c !== void 0 && Ye(c, "zip215"), r && (n = r(n));
+		let u = l / 2, d = t.subarray(0, u), f = L(t.subarray(u, l)), p, h, _;
+		try {
+			p = e.fromBytes(a, c), h = e.fromBytes(d, c), _ = i.multiplyUnsafe(f);
+		} catch {
+			return !1;
+		}
+		if (!c && p.isSmallOrder()) return !1;
+		let v = m(s, h.toBytes(), p.toBytes(), n);
+		return h.add(p.multiplyUnsafe(v)).subtract(_).clearCofactor().is0();
+	}
+	let v = a.BYTES, y = {
+		secretKey: v,
+		publicKey: v,
+		signature: 2 * v,
+		seed: v
+	};
+	function b(e = s(y.seed)) {
+		return E(e, y.seed, "seed");
+	}
+	function x(e) {
+		return pe(e) && e.length === o.BYTES;
+	}
+	function S(t, n) {
+		try {
+			return !!e.fromBytes(t, n);
+		} catch {
+			return !1;
+		}
+	}
+	let C = {
+		getExtendedPublicKey: f,
+		randomSecretKey: b,
+		isValidSecretKey: x,
+		isValidPublicKey: S,
+		toMontgomery(t) {
+			let { y: n } = e.fromBytes(t), r = y.publicKey, i = r === 32;
+			if (!i && r !== 57) throw Error("only defined for 25519 and 448");
+			let o = i ? a.div(K + n, K - n) : a.div(n - K, n + K);
+			return a.toBytes(o);
+		},
+		toMontgomerySecret(e) {
+			let n = y.secretKey;
+			return E(e, n), c(t(e.subarray(0, n))).subarray(0, n);
+		}
+	};
+	return Object.freeze({
+		keygen: en(b, p),
+		getPublicKey: p,
+		sign: h,
+		verify: _,
+		utils: C,
+		Point: e,
+		lengths: y
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/hash-to-curve.js
+var cn = Qe;
+function q(e, t) {
+	if (I(e), I(t), e < 0 || e >= 1 << 8 * t) throw Error("invalid I2OSP input: " + e);
+	let n = Array.from({ length: t }).fill(0);
+	for (let r = t - 1; r >= 0; r--) n[r] = e & 255, e >>>= 8;
+	return new Uint8Array(n);
+}
+function ln(e, t) {
+	let n = new Uint8Array(e.length);
+	for (let r = 0; r < e.length; r++) n[r] = e[r] ^ t[r];
+	return n;
+}
+function un(e) {
+	if (!pe(e) && typeof e != "string") throw Error("DST must be Uint8Array or ascii string");
+	return typeof e == "string" ? R(e) : e;
+}
+function dn(e, t, n, r) {
+	E(e), I(n), t = un(t), t.length > 255 && (t = r(O(R("H2C-OVERSIZE-DST-"), t)));
+	let { outputLen: i, blockLen: a } = r, o = Math.ceil(n / i);
+	if (n > 65535 || o > 255) throw Error("expand_message_xmd: invalid lenInBytes");
+	let s = O(t, q(t.length, 1)), c = q(0, a), l = q(n, 2), u = Array(o), d = r(O(c, e, l, q(0, 1), s));
+	u[0] = r(O(d, q(1, 1), s));
+	for (let e = 1; e <= o; e++) u[e] = r(O(ln(d, u[e - 1]), q(e + 1, 1), s));
+	return O(...u).slice(0, n);
+}
+function fn(e, t, n, r, i) {
+	if (E(e), I(n), t = un(t), t.length > 255) {
+		let e = Math.ceil(2 * r / 8);
+		t = i.create({ dkLen: e }).update(R("H2C-OVERSIZE-DST-")).update(t).digest();
+	}
+	if (n > 65535 || t.length > 255) throw Error("expand_message_xof: invalid lenInBytes");
+	return i.create({ dkLen: n }).update(e).update(q(n, 2)).update(t).update(q(t.length, 1)).digest();
+}
+function pn(e, t, n) {
+	ct(n, {
+		p: "bigint",
+		m: "number",
+		k: "number",
+		hash: "function"
+	});
+	let { p: r, k: i, m: a, hash: o, expand: s, DST: c } = n;
+	I(o.outputLen, "valid hash"), E(e), I(t);
+	let l = r.toString(2).length, u = Math.ceil((l + i) / 8), d = t * a * u, f;
+	if (s === "xmd") f = dn(e, c, d, o);
+	else if (s === "xof") f = fn(e, c, d, i, o);
+	else if (s === "_internal_pass") f = e;
+	else throw Error("expand must be \"xmd\" or \"xof\"");
+	let p = Array(t);
+	for (let e = 0; e < t; e++) {
+		let t = Array(a);
+		for (let n = 0; n < a; n++) {
+			let i = u * (n + e * a);
+			t[n] = H(cn(f.subarray(i, i + u)), r);
+		}
+		p[e] = t;
+	}
+	return p;
+}
+var mn = R("HashToScalar-");
+function hn(e, t, n) {
+	if (typeof t != "function") throw Error("mapToCurve() must be defined");
+	function r(n) {
+		return e.fromAffine(t(n));
+	}
+	function i(t) {
+		let n = t.clearCofactor();
+		return n.equals(e.ZERO) ? e.ZERO : (n.assertValidity(), n);
+	}
+	return {
+		defaults: Object.freeze(n),
+		Point: e,
+		hashToCurve(e, t) {
+			let a = pn(e, 2, Object.assign({}, n, t)), o = r(a[0]), s = r(a[1]);
+			return i(o.add(s));
+		},
+		encodeToCurve(e, t) {
+			let a = n.encodeDST ? { DST: n.encodeDST } : {};
+			return i(r(pn(e, 1, Object.assign({}, n, a, t))[0]));
+		},
+		mapToCurve(e) {
+			if (n.m === 1) {
+				if (typeof e != "bigint") throw Error("expected bigint (m=1)");
+				return i(r([e]));
+			}
+			if (!Array.isArray(e)) throw Error("expected array of bigints");
+			for (let t of e) if (typeof t != "bigint") throw Error("expected array of bigints");
+			return i(r(e));
+		},
+		hashToScalar(t, r) {
+			let i = e.Fn.ORDER;
+			return pn(t, 1, Object.assign({}, n, {
+				p: i,
+				m: 1,
+				DST: mn
+			}, r))[0][0];
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/oprf.js
+function gn(e) {
+	ct(e, {
+		name: "string",
+		hash: "function",
+		hashToScalar: "function",
+		hashToGroup: "function"
+	});
+	let { name: t, Point: n, hash: r } = e, { Fn: i } = n, a = (t, n) => e.hashToGroup(t, { DST: O(R("HashToGroup-"), n) }), o = (t, n) => e.hashToScalar(t, { DST: O(mn, n) }), s = (e = k) => {
+		let t = It(e(Ft(i.ORDER)), i.ORDER, i.isLE);
+		return i.isLE ? L(t) : Qe(t);
+	}, c = (e, t) => Zt(n, e, t), l = (e) => O(R("OPRFV1-"), new Uint8Array([e]), R("-" + t)), u = l(0), d = l(1), f = l(2);
+	function p(...e) {
+		let t = [];
+		for (let n of e) typeof n == "number" ? t.push($e(n, 2)) : typeof n == "string" ? t.push(R(n)) : (E(n), t.push($e(n.length, 2), n));
+		return O(...t);
+	}
+	let m = (...e) => r(p(...e, "Finalize"));
+	function h(e, t, n, i) {
+		let a = r(p(e.toBytes(), O(R("Seed-"), i))), s = [];
+		for (let e = 0; e < t.length; e++) {
+			let r = t[e].toBytes(), c = n[e].toBytes(), l = o(p(a, e, r, c, "Composite"), i);
+			s.push(l);
+		}
+		return s;
+	}
+	function g(e, t, n, r) {
+		let i = h(e, t, n, r);
+		return {
+			M: c(t, i),
+			Z: c(n, i)
+		};
+	}
+	function _(e, t, n, r, i) {
+		let a = c(n, h(t, n, r, i));
+		return {
+			M: a,
+			Z: a.multiply(e)
+		};
+	}
+	function v(e, t, n, r, i, a) {
+		let [s, c, l, u, d] = [
+			e,
+			t,
+			n,
+			r,
+			i
+		].map((e) => e.toBytes());
+		return o(p(s, c, l, u, d, "Challenge"), a);
+	}
+	function y(e, t, r, a, o, c) {
+		let { M: l, Z: u } = _(t, r, a, o, e), d = s(c), f = v(r, l, u, n.BASE.multiply(d), l.multiply(d), e);
+		return O(...[f, i.sub(d, i.mul(f, t))].map((e) => i.toBytes(e)));
+	}
+	function b(e, t, r, a, o) {
+		E(o, 2 * i.BYTES);
+		let { M: s, Z: c } = g(t, r, a, e), [l, u] = [o.subarray(0, i.BYTES), o.subarray(i.BYTES)].map((e) => i.fromBytes(e)), d = v(t, s, c, n.BASE.multiply(u).add(t.multiply(l)), s.multiply(u).add(c.multiply(l)), e);
+		if (!i.eql(l, d)) throw Error("proof verification failed");
+	}
+	function x() {
+		let e = s(), t = n.BASE.multiply(e);
+		return {
+			secretKey: i.toBytes(e),
+			publicKey: t.toBytes()
+		};
+	}
+	function S(t, r, a) {
+		let o = O(R("DeriveKeyPair"), t), s = O(r, p(a), Uint8Array.of(0));
+		for (let t = 0; t <= 255; t++) {
+			s[s.length - 1] = t;
+			let r = e.hashToScalar(s, { DST: o });
+			if (!i.is0(r)) return {
+				secretKey: i.toBytes(r),
+				publicKey: n.BASE.multiply(r).toBytes()
+			};
+		}
+		throw Error("Cannot derive key");
+	}
+	function C(e, t, r = k) {
+		let o = s(r), c = a(t, e);
+		if (c.equals(n.ZERO)) throw Error("Input point at infinity");
+		let l = c.multiply(o);
+		return {
+			blind: i.toBytes(o),
+			blinded: l.toBytes()
+		};
+	}
+	function w(e, t, r) {
+		let o = i.fromBytes(t), s = a(r, e);
+		if (s.equals(n.ZERO)) throw Error("Input point at infinity");
+		return m(r, s.multiply(o).toBytes());
+	}
+	let ee = {
+		generateKeyPair: x,
+		deriveKeyPair: (e, t) => S(u, e, t),
+		blind: (e, t = k) => C(u, e, t),
+		blindEvaluate(e, t) {
+			let r = i.fromBytes(e);
+			return n.fromBytes(t).multiply(r).toBytes();
+		},
+		finalize(e, t, r) {
+			let a = i.fromBytes(t);
+			return m(e, n.fromBytes(r).multiply(i.inv(a)).toBytes());
+		},
+		evaluate: (e, t) => w(u, e, t)
+	};
+	return Object.freeze({
+		name: t,
+		oprf: ee,
+		voprf: {
+			generateKeyPair: x,
+			deriveKeyPair: (e, t) => S(d, e, t),
+			blind: (e, t = k) => C(d, e, t),
+			blindEvaluateBatch(e, t, r, a = k) {
+				if (!Array.isArray(r)) throw Error("expected array");
+				let o = i.fromBytes(e), s = n.fromBytes(t), c = r.map(n.fromBytes), l = c.map((e) => e.multiply(o)), u = y(d, o, s, c, l, a);
+				return {
+					evaluated: l.map((e) => e.toBytes()),
+					proof: u
+				};
+			},
+			blindEvaluate(e, t, n, r = k) {
+				let i = this.blindEvaluateBatch(e, t, [n], r);
+				return {
+					evaluated: i.evaluated[0],
+					proof: i.proof
+				};
+			},
+			finalizeBatch(e, t, r) {
+				if (!Array.isArray(e)) throw Error("expected array");
+				return b(d, n.fromBytes(t), e.map((e) => e.blinded).map(n.fromBytes), e.map((e) => e.evaluated).map(n.fromBytes), r), e.map((e) => ee.finalize(e.input, e.blind, e.evaluated));
+			},
+			finalize(e, t, n, r, i, a) {
+				return this.finalizeBatch([{
+					input: e,
+					blind: t,
+					evaluated: n,
+					blinded: r
+				}], i, a)[0];
+			},
+			evaluate: (e, t) => w(d, e, t)
+		},
+		poprf: (e) => {
+			let t = o(p("Info", e), f), r = n.BASE.multiply(t);
+			return {
+				generateKeyPair: x,
+				deriveKeyPair: (e, t) => S(f, e, t),
+				blind(e, t, o = k) {
+					let c = n.fromBytes(t), l = r.add(c);
+					if (l.equals(n.ZERO)) throw Error("tweakedKey point at infinity");
+					let u = s(o), d = a(e, f);
+					if (d.equals(n.ZERO)) throw Error("Input point at infinity");
+					let p = d.multiply(u);
+					return {
+						blind: i.toBytes(u),
+						blinded: p.toBytes(),
+						tweakedKey: l.toBytes()
+					};
+				},
+				blindEvaluateBatch(e, r, a = k) {
+					if (!Array.isArray(r)) throw Error("expected array");
+					let o = i.fromBytes(e), s = i.add(o, t), c = i.inv(s), l = r.map(n.fromBytes), u = l.map((e) => e.multiply(c)), d = y(f, s, n.BASE.multiply(s), u, l, a);
+					return {
+						evaluated: u.map((e) => e.toBytes()),
+						proof: d
+					};
+				},
+				blindEvaluate(e, t, n = k) {
+					let r = this.blindEvaluateBatch(e, [t], n);
+					return {
+						evaluated: r.evaluated[0],
+						proof: r.proof
+					};
+				},
+				finalizeBatch(t, r, a) {
+					if (!Array.isArray(t)) throw Error("expected array");
+					let o = t.map((e) => e.evaluated).map(n.fromBytes);
+					return b(f, n.fromBytes(a), o, t.map((e) => e.blinded).map(n.fromBytes), r), t.map((t, n) => {
+						let r = i.fromBytes(t.blind), a = o[n].multiply(i.inv(r)).toBytes();
+						return m(t.input, e, a);
+					});
+				},
+				finalize(e, t, n, r, i, a) {
+					return this.finalizeBatch([{
+						input: e,
+						blind: t,
+						evaluated: n,
+						blinded: r
+					}], i, a)[0];
+				},
+				evaluate(r, o) {
+					let s = i.fromBytes(r), c = a(o, f);
+					if (c.equals(n.ZERO)) throw Error("Input point at infinity");
+					let l = i.add(s, t), u = i.inv(l);
+					return m(o, e, c.multiply(u).toBytes());
+				}
+			};
+		},
+		__tests: { Fn: i }
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/ed25519.js
+var _n = /* @__PURE__ */ BigInt(0), J = BigInt(1), vn = BigInt(2), yn = /* @__PURE__ */ BigInt(3), bn = BigInt(5), xn = BigInt(8), Y = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed"), Sn = {
+	p: Y,
+	n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
+	h: xn,
+	a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
+	d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
+	Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
+	Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
+};
+function Cn(e) {
+	let t = BigInt(10), n = BigInt(20), r = BigInt(40), i = BigInt(80), a = Y, o = e * e % a * e % a, s = U(U(o, vn, a) * o % a, J, a) * e % a, c = U(s, bn, a) * s % a, l = U(c, t, a) * c % a, u = U(l, n, a) * l % a, d = U(u, r, a) * u % a;
+	return {
+		pow_p_5_8: U(U(U(U(d, i, a) * d % a, i, a) * d % a, t, a) * c % a, vn, a) * e % a,
+		b2: o
+	};
+}
+function wn(e) {
+	return e[0] &= 248, e[31] &= 127, e[31] |= 64, e;
+}
+var Tn = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
+function En(e, t) {
+	let n = Y, r = H(t * t * t, n), i = Cn(e * H(r * r * t, n)).pow_p_5_8, a = H(e * r * i, n), o = H(t * a * a, n), s = a, c = H(a * Tn, n), l = o === e, u = o === H(-e, n), d = o === H(-e * Tn, n);
+	return l && (a = s), (u || d) && (a = c), W(a, n) && (a = H(-a, n)), {
+		isValid: l || u,
+		value: a
+	};
+}
+var X = /* @__PURE__ */ an(Sn, { uvRatio: En }), Z = X.Fp, Dn = X.Fn;
+function On(e) {
+	return sn(X, Ke, Object.assign({ adjustScalarBytes: wn }, e));
+}
+var Q = /* @__PURE__ */ On({}), kn = (Y + yn) / xn, An = Z.pow(vn, kn), jn = Z.sqrt(Z.neg(Z.ONE));
+function Mn(e) {
+	let t = (Y - bn) / xn, n = BigInt(486662), r = Z.sqr(e);
+	r = Z.mul(r, vn);
+	let i = Z.add(r, Z.ONE), a = Z.neg(n), o = Z.sqr(i), s = Z.mul(o, i), c = Z.mul(r, n);
+	c = Z.mul(c, a), c = Z.add(c, o), c = Z.mul(c, a);
+	let l = Z.sqr(s);
+	o = Z.sqr(l), l = Z.mul(l, s), l = Z.mul(l, c), o = Z.mul(o, l);
+	let u = Z.pow(o, t);
+	u = Z.mul(u, l);
+	let d = Z.mul(u, jn);
+	o = Z.sqr(u), o = Z.mul(o, s);
+	let f = Z.eql(o, c), p = Z.cmov(d, u, f), m = Z.mul(a, r), h = Z.mul(u, e);
+	h = Z.mul(h, An);
+	let g = Z.mul(h, jn), _ = Z.mul(c, r);
+	o = Z.sqr(h), o = Z.mul(o, s);
+	let v = Z.eql(o, _), y = Z.cmov(g, h, v);
+	o = Z.sqr(p), o = Z.mul(o, s);
+	let b = Z.eql(o, c), x = Z.cmov(m, a, b), S = Z.cmov(y, p, b), C = Z.isOdd(S);
+	return S = Z.cmov(S, Z.neg(S), b !== C), {
+		xMn: x,
+		xMd: i,
+		yMn: S,
+		yMd: J
+	};
+}
+var Nn = Nt(Z, Z.neg(BigInt(486664)));
+function Pn(e) {
+	let { xMn: t, xMd: n, yMn: r, yMd: i } = Mn(e), a = Z.mul(t, i);
+	a = Z.mul(a, Nn);
+	let o = Z.mul(n, r), s = Z.sub(t, n), c = Z.add(t, n), l = Z.mul(o, c), u = Z.eql(l, Z.ZERO);
+	a = Z.cmov(a, Z.ZERO, u), o = Z.cmov(o, Z.ONE, u), s = Z.cmov(s, Z.ONE, u), c = Z.cmov(c, Z.ONE, u);
+	let [d, f] = Ot(Z, [o, c], !0);
+	return {
+		x: Z.mul(a, d),
+		y: Z.mul(s, f)
+	};
+}
+hn(X, (e) => Pn(e[0]), {
+	DST: "edwards25519_XMD:SHA-512_ELL2_RO_",
+	encodeDST: "edwards25519_XMD:SHA-512_ELL2_NU_",
+	p: Y,
+	m: 1,
+	k: 128,
+	expand: "xmd",
+	hash: Ke
+});
+var Fn = Tn, In = /* @__PURE__ */ BigInt("25063068953384623474111414158702152701244531502492656460079210482610430750235"), Ln = /* @__PURE__ */ BigInt("54469307008909316920995813868745141605393597292927456921205312896311721017578"), Rn = /* @__PURE__ */ BigInt("1159843021668779879193775521855586647937357759715417654439879720876111806838"), zn = /* @__PURE__ */ BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952"), Bn = (e) => En(J, e), Vn = /* @__PURE__ */ BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), Hn = (e) => Z.create(L(e) & Vn);
+function Un(e) {
+	let { d: t } = Sn, n = Y, r = (e) => Z.create(e), i = r(Fn * e * e), a = r((i + J) * Rn), o = BigInt(-1), s = r((o - t * i) * r(i + t)), { isValid: c, value: l } = En(a, s), u = r(l * e);
+	W(u, n) || (u = r(-u)), c || (l = u), c || (o = i);
+	let d = r(o * (i - J) * zn - s), f = l * l, p = r((l + l) * s), m = r(d * In), h = r(J - f), g = r(J + f);
+	return new X(r(p * g), r(h * m), r(m * g), r(p * h));
+}
+var Wn = class e extends on {
+	static BASE = new e(X.BASE);
+	static ZERO = new e(X.ZERO);
+	static Fp = Z;
+	static Fn = Dn;
+	constructor(e) {
+		super(e);
+	}
+	static fromAffine(t) {
+		return new e(X.fromAffine(t));
+	}
+	assertSame(t) {
+		if (!(t instanceof e)) throw Error("RistrettoPoint expected");
+	}
+	init(t) {
+		return new e(t);
+	}
+	static fromBytes(t) {
+		E(t, 32);
+		let { a: n, d: r } = Sn, i = Y, a = (e) => Z.create(e), o = Hn(t);
+		if (!tt(Z.toBytes(o), t) || W(o, i)) throw Error("invalid ristretto255 encoding 1");
+		let s = a(o * o), c = a(J + n * s), l = a(J - n * s), u = a(c * c), d = a(l * l), f = a(n * r * u - d), { isValid: p, value: m } = Bn(a(f * d)), h = a(m * l), g = a(m * h * f), _ = a((o + o) * h);
+		W(_, i) && (_ = a(-_));
+		let v = a(c * g), y = a(_ * v);
+		if (!p || W(y, i) || v === _n) throw Error("invalid ristretto255 encoding 2");
+		return new e(new X(_, v, J, y));
+	}
+	static fromHex(t) {
+		return e.fromBytes(Ce(t));
+	}
+	toBytes() {
+		let { X: e, Y: t, Z: n, T: r } = this.ep, i = Y, a = (e) => Z.create(e), o = a(a(n + t) * a(n - t)), s = a(e * t), { value: c } = Bn(a(o * a(s * s))), l = a(c * o), u = a(c * s), d = a(l * u * r), f;
+		if (W(r * d, i)) {
+			let n = a(t * Fn), r = a(e * Fn);
+			e = n, t = r, f = a(l * Ln);
+		} else f = u;
+		W(e * d, i) && (t = a(-t));
+		let p = a((n - t) * f);
+		return W(p, i) && (p = a(-p)), Z.toBytes(p);
+	}
+	equals(e) {
+		this.assertSame(e);
+		let { X: t, Y: n } = this.ep, { X: r, Y: i } = e.ep, a = (e) => Z.create(e), o = a(t * i) === a(n * r), s = a(n * i) === a(t * r);
+		return o || s;
+	}
+	is0() {
+		return this.equals(e.ZERO);
+	}
+}, Gn = {
+	Point: Wn,
+	hashToCurve(e, t) {
+		let n = dn(e, t?.DST || "ristretto255_XMD:SHA-512_R255MAP_RO_", 64, Ke);
+		return Gn.deriveToCurve(n);
+	},
+	hashToScalar(e, t = { DST: mn }) {
+		let n = dn(e, t.DST, 64, Ke);
+		return Dn.create(L(n));
+	},
+	deriveToCurve(e) {
+		E(e, 64);
+		let t = Un(Hn(e.subarray(0, 32))), n = Un(Hn(e.subarray(32, 64)));
+		return new Wn(t.add(n));
+	}
+};
+gn({
+	name: "ristretto255-SHA512",
+	Point: Wn,
+	hash: Ke,
+	hashToGroup: Gn.hashToCurve,
+	hashToScalar: Gn.hashToScalar
+});
+//#endregion
+//#region src/crypto/primitives.ts
+var $ = 32, Kn = 248, qn = 127, Jn = 64, Yn = 128, Xn = 127;
+function Zn(e) {
+	e.length < $ || (e[0] = (e[0] ?? 0) & Kn, e[$ - 1] = (e[$ - 1] ?? 0) & qn | Jn);
+}
+function Qn() {
+	let e = new Uint8Array(s($));
+	Zn(e);
+	let t = nr(e) % Q.Point.CURVE().n;
+	return [Q.Point.BASE.multiply(t).toBytes(), Uint8Array.from(e)];
+}
+function $n(e, t) {
+	let n = i("SHA256");
+	return n.update(t), n.sign(e);
+}
+function er(e, t, n) {
+	try {
+		let r = a("SHA256");
+		return r.update(t), r.verify(e, Buffer.from(n));
+	} catch {
+		return !1;
+	}
+}
+function tr(e, n) {
+	if (e.length !== $ || n.length !== $) throw Error("invalid key length");
+	let r = Uint8Array.from(n);
+	r[$ - 1] = (r[$ - 1] ?? 0) & Xn;
+	let i = nr(r) % Q.Point.CURVE().n, a = Q.Point.fromBytes(e).negate().multiply(i).toBytes();
+	return a[$ - 1] = (a[$ - 1] ?? 0) ^ Yn, t("sha512").update(a).digest();
+}
+function nr(e) {
+	let t = 0n;
+	for (let n = e.length - 1; n >= 0; n--) t = t << 8n | BigInt(e[n]);
+	return t;
+}
+//#endregion
+export { c as S, p as _, er as a, _ as b, C as c, S as d, ne as f, f as g, g as h, $n as i, w as l, u as m, Qn as n, Q as o, d as p, tr as r, x as s, Zn as t, ee as u, m as v, l as x, h as y };
+
+//# sourceMappingURL=primitives-CmIK1O7L.js.map