@jaw.id/ui 0.4.2 → 0.4.4

package/dist/secp256k1-BJ-4rw4A.js

@@ -0,0 +1,1187 @@
+import { A as e, B as t, C as n, D as r, E as i, F as a, G as o, I as s, J as c, K as l, L as u, M as d, O as f, P as p, R as m, S as h, T as g, X as _, Y as v, Z as y, _ as b, a as x, b as S, c as C, d as w, f as T, g as E, h as D, i as O, k, l as ee, m as A, n as j, o as M, p as te, q as N, r as P, s as ne, t as F, u as I, v as L, w as re, x as R, y as ie, z as ae } from "./utils-so0pTN_S.js";
+//#region ../../node_modules/@noble/hashes/esm/_md.js
+function oe(e, t, n, r) {
+	if (typeof e.setBigUint64 == "function") return e.setBigUint64(t, n, r);
+	let i = BigInt(32), a = BigInt(4294967295), o = Number(n >> i & a), s = Number(n & a), c = r ? 4 : 0, l = r ? 0 : 4;
+	e.setUint32(t + c, o, r), e.setUint32(t + l, s, r);
+}
+function se(e, t, n) {
+	return e & t ^ ~e & n;
+}
+function ce(e, t, n) {
+	return e & t ^ e & n ^ t & n;
+}
+var le = class extends ie {
+	constructor(e, t, n, r) {
+		super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = e, this.outputLen = t, this.padOffset = n, this.isLE = r, this.buffer = new Uint8Array(e), this.view = f(this.buffer);
+	}
+	update(e) {
+		R(this), e = d(e), S(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 = f(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) {
+		R(this), re(e, this), this.finished = !0;
+		let { buffer: t, view: n, blockLen: r, isLE: i } = this, { pos: a } = this;
+		t[a++] = 128, g(this.buffer.subarray(a)), this.padOffset > r - a && (this.process(n, 0), a = 0);
+		for (let e = a; e < r; e++) t[e] = 0;
+		oe(n, r - 8, BigInt(this.length * 8), i), this.process(n, 0);
+		let o = f(e), s = this.outputLen;
+		if (s % 4) throw Error("_sha2: outputLen should 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();
+	}
+}, z = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]), B = /* @__PURE__ */ Uint32Array.from([
+	3418070365,
+	3238371032,
+	1654270250,
+	914150663,
+	2438529370,
+	812702999,
+	355462360,
+	4144912697,
+	1731405415,
+	4290775857,
+	2394180231,
+	1750603025,
+	3675008525,
+	1694076839,
+	1203062813,
+	3204075428
+]), V = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]), ue = /* @__PURE__ */ Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]), H = /* @__PURE__ */ new Uint32Array(64), de = class extends le {
+	constructor(e = 32) {
+		super(64, e, 8, !1), this.A = z[0] | 0, this.B = z[1] | 0, this.C = z[2] | 0, this.D = z[3] | 0, this.E = z[4] | 0, this.F = z[5] | 0, this.G = z[6] | 0, this.H = z[7] | 0;
+	}
+	get() {
+		let { A: e, B: t, C: n, D: r, E: i, F: a, G: o, H: s } = this;
+		return [
+			e,
+			t,
+			n,
+			r,
+			i,
+			a,
+			o,
+			s
+		];
+	}
+	set(e, t, n, r, i, a, o, s) {
+		this.A = e | 0, this.B = t | 0, this.C = n | 0, this.D = r | 0, this.E = i | 0, this.F = a | 0, this.G = o | 0, this.H = s | 0;
+	}
+	process(t, n) {
+		for (let e = 0; e < 16; e++, n += 4) H[e] = t.getUint32(n, !1);
+		for (let t = 16; t < 64; t++) {
+			let n = H[t - 15], r = H[t - 2], i = e(n, 7) ^ e(n, 18) ^ n >>> 3;
+			H[t] = (e(r, 17) ^ e(r, 19) ^ r >>> 10) + H[t - 7] + i + H[t - 16] | 0;
+		}
+		let { A: r, B: i, C: a, D: o, E: s, F: c, G: l, H: u } = this;
+		for (let t = 0; t < 64; t++) {
+			let n = e(s, 6) ^ e(s, 11) ^ e(s, 25), d = u + n + se(s, c, l) + ue[t] + H[t] | 0, f = (e(r, 2) ^ e(r, 13) ^ e(r, 22)) + ce(r, i, a) | 0;
+			u = l, l = c, c = s, s = o + d | 0, o = a, a = i, i = r, r = d + f | 0;
+		}
+		r = r + this.A | 0, i = i + this.B | 0, a = a + this.C | 0, o = o + this.D | 0, s = s + this.E | 0, c = c + this.F | 0, l = l + this.G | 0, u = u + this.H | 0, this.set(r, i, a, o, s, c, l, u);
+	}
+	roundClean() {
+		g(H);
+	}
+	destroy() {
+		this.set(0, 0, 0, 0, 0, 0, 0, 0), g(this.buffer);
+	}
+}, fe = /* @__PURE__ */ y((/* @__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))), pe = fe[0], me = fe[1], U = /* @__PURE__ */ new Uint32Array(80), W = /* @__PURE__ */ new Uint32Array(80), he = class extends le {
+	constructor(e = 64) {
+		super(128, e, 16, !1), this.Ah = V[0] | 0, this.Al = V[1] | 0, this.Bh = V[2] | 0, this.Bl = V[3] | 0, this.Ch = V[4] | 0, this.Cl = V[5] | 0, this.Dh = V[6] | 0, this.Dl = V[7] | 0, this.Eh = V[8] | 0, this.El = V[9] | 0, this.Fh = V[10] | 0, this.Fl = V[11] | 0, this.Gh = V[12] | 0, this.Gl = V[13] | 0, this.Hh = V[14] | 0, this.Hl = V[15] | 0;
+	}
+	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, n) {
+		for (let t = 0; t < 16; t++, n += 4) U[t] = e.getUint32(n), W[t] = e.getUint32(n += 4);
+		for (let e = 16; e < 80; e++) {
+			let t = U[e - 15] | 0, n = W[e - 15] | 0, r = N(t, n, 1) ^ N(t, n, 8) ^ v(t, n, 7), i = c(t, n, 1) ^ c(t, n, 8) ^ _(t, n, 7), a = U[e - 2] | 0, s = W[e - 2] | 0, d = N(a, s, 19) ^ o(a, s, 61) ^ v(a, s, 6), f = m(i, c(a, s, 19) ^ l(a, s, 61) ^ _(a, s, 6), W[e - 7], W[e - 16]);
+			U[e] = u(f, r, d, U[e - 7], U[e - 16]) | 0, W[e] = f | 0;
+		}
+		let { Ah: r, Al: i, Bh: d, Bl: f, Ch: h, Cl: g, Dh: y, Dl: b, Eh: x, El: S, Fh: C, Fl: w, Gh: T, Gl: E, Hh: D, Hl: O } = this;
+		for (let e = 0; e < 80; e++) {
+			let n = N(x, S, 14) ^ N(x, S, 18) ^ o(x, S, 41), u = c(x, S, 14) ^ c(x, S, 18) ^ l(x, S, 41), m = x & C ^ ~x & T, _ = S & w ^ ~S & E, v = t(O, u, _, me[e], W[e]), k = ae(v, D, n, m, pe[e], U[e]), ee = v | 0, A = N(r, i, 28) ^ o(r, i, 34) ^ o(r, i, 39), j = c(r, i, 28) ^ l(r, i, 34) ^ l(r, i, 39), M = r & d ^ r & h ^ d & h, te = i & f ^ i & g ^ f & g;
+			D = T | 0, O = E | 0, T = C | 0, E = w | 0, C = x | 0, w = S | 0, {h: x, l: S} = p(y | 0, b | 0, k | 0, ee | 0), y = h | 0, b = g | 0, h = d | 0, g = f | 0, d = r | 0, f = i | 0;
+			let P = s(ee, j, te);
+			r = a(P, k, A, M), i = P | 0;
+		}
+		({h: r, l: i} = p(this.Ah | 0, this.Al | 0, r | 0, i | 0)), {h: d, l: f} = p(this.Bh | 0, this.Bl | 0, d | 0, f | 0), {h: h, l: g} = p(this.Ch | 0, this.Cl | 0, h | 0, g | 0), {h: y, l: b} = p(this.Dh | 0, this.Dl | 0, y | 0, b | 0), {h: x, l: S} = p(this.Eh | 0, this.El | 0, x | 0, S | 0), {h: C, l: w} = p(this.Fh | 0, this.Fl | 0, C | 0, w | 0), {h: T, l: E} = p(this.Gh | 0, this.Gl | 0, T | 0, E | 0), {h: D, l: O} = p(this.Hh | 0, this.Hl | 0, D | 0, O | 0), this.set(r, i, d, f, h, g, y, b, x, S, C, w, T, E, D, O);
+	}
+	roundClean() {
+		g(U, W);
+	}
+	destroy() {
+		g(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+}, ge = class extends he {
+	constructor() {
+		super(48), this.Ah = B[0] | 0, this.Al = B[1] | 0, this.Bh = B[2] | 0, this.Bl = B[3] | 0, this.Ch = B[4] | 0, this.Cl = B[5] | 0, this.Dh = B[6] | 0, this.Dl = B[7] | 0, this.Eh = B[8] | 0, this.El = B[9] | 0, this.Fh = B[10] | 0, this.Fl = B[11] | 0, this.Gh = B[12] | 0, this.Gl = B[13] | 0, this.Hh = B[14] | 0, this.Hl = B[15] | 0;
+	}
+}, _e = /* @__PURE__ */ r(() => new de()), ve = /* @__PURE__ */ r(() => new he()), ye = /* @__PURE__ */ r(() => new ge()), be = class extends ie {
+	constructor(e, t) {
+		super(), this.finished = !1, this.destroyed = !1, h(e);
+		let n = d(t);
+		if (this.iHash = e.create(), typeof this.iHash.update != "function") throw Error("Expected instance of class which extends utils.Hash");
+		this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+		let r = this.blockLen, i = new Uint8Array(r);
+		i.set(n.length > r ? e.create().update(n).digest() : n);
+		for (let e = 0; e < i.length; e++) i[e] ^= 54;
+		this.iHash.update(i), this.oHash = e.create();
+		for (let e = 0; e < i.length; e++) i[e] ^= 106;
+		this.oHash.update(i), g(i);
+	}
+	update(e) {
+		return R(this), this.iHash.update(e), this;
+	}
+	digestInto(e) {
+		R(this), S(e, this.outputLen), this.finished = !0, this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
+	}
+	digest() {
+		let e = new Uint8Array(this.oHash.outputLen);
+		return this.digestInto(e), e;
+	}
+	_cloneInto(e) {
+		e ||= Object.create(Object.getPrototypeOf(this), {});
+		let { oHash: t, iHash: n, finished: r, destroyed: i, blockLen: a, outputLen: o } = this;
+		return e = e, e.finished = r, e.destroyed = i, e.blockLen = a, e.outputLen = o, e.oHash = t._cloneInto(e.oHash), e.iHash = n._cloneInto(e.iHash), e;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+	destroy() {
+		this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+	}
+}, xe = (e, t, n) => new be(e, t).update(n).digest();
+xe.create = (e, t) => new be(e, t);
+//#endregion
+//#region ../../node_modules/@noble/curves/esm/abstract/modular.js
+var G = BigInt(0), K = BigInt(1), q = /* @__PURE__ */ BigInt(2), Se = /* @__PURE__ */ BigInt(3), Ce = /* @__PURE__ */ BigInt(4), we = /* @__PURE__ */ BigInt(5), Te = /* @__PURE__ */ BigInt(8);
+function J(e, t) {
+	let n = e % t;
+	return n >= G ? n : t + n;
+}
+function Y(e, t, n) {
+	let r = e;
+	for (; t-- > G;) r *= r, r %= n;
+	return r;
+}
+function Ee(e, t) {
+	if (e === G) throw Error("invert: expected non-zero number");
+	if (t <= G) throw Error("invert: expected positive modulus, got " + t);
+	let n = J(e, t), r = t, i = G, a = K, o = K, s = G;
+	for (; n !== G;) {
+		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 !== K) throw Error("invert: does not exist");
+	return J(i, t);
+}
+function De(e, t) {
+	let n = (e.ORDER + K) / Ce, r = e.pow(t, n);
+	if (!e.eql(e.sqr(r), t)) throw Error("Cannot find square root");
+	return r;
+}
+function Oe(e, t) {
+	let n = (e.ORDER - we) / Te, r = e.mul(t, q), i = e.pow(r, n), a = e.mul(t, i), o = e.mul(e.mul(a, q), i), s = e.mul(a, e.sub(o, e.ONE));
+	if (!e.eql(e.sqr(s), t)) throw Error("Cannot find square root");
+	return s;
+}
+function ke(e) {
+	if (e < BigInt(3)) throw Error("sqrt is not defined for small field");
+	let t = e - K, n = 0;
+	for (; t % q === G;) t /= q, n++;
+	let r = q, i = X(e);
+	for (; Fe(i, r) === 1;) if (r++ > 1e3) throw Error("Cannot find square root: probably non-prime P");
+	if (n === 1) return De;
+	let a = i.pow(r, t), o = (t + K) / q;
+	return function(e, r) {
+		if (e.is0(r)) return r;
+		if (Fe(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 = K << 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 Ae(e) {
+	return e % Ce === Se ? De : e % Te === we ? Oe : ke(e);
+}
+var je = [
+	"create",
+	"isValid",
+	"is0",
+	"neg",
+	"inv",
+	"sqrt",
+	"sqr",
+	"eql",
+	"add",
+	"sub",
+	"mul",
+	"pow",
+	"div",
+	"addN",
+	"subN",
+	"mulN",
+	"sqrN"
+];
+function Me(e) {
+	return L(e, je.reduce((e, t) => (e[t] = "function", e), {
+		ORDER: "bigint",
+		MASK: "bigint",
+		BYTES: "isSafeInteger",
+		BITS: "isSafeInteger"
+	}));
+}
+function Ne(e, t, n) {
+	if (n < G) throw Error("invalid exponent, negatives unsupported");
+	if (n === G) return e.ONE;
+	if (n === K) return t;
+	let r = e.ONE, i = t;
+	for (; n > G;) n & K && (r = e.mul(r, i)), i = e.sqr(i), n >>= K;
+	return r;
+}
+function Pe(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 Fe(e, t) {
+	let n = (e.ORDER - K) / q, 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 Ie(e, t) {
+	t !== void 0 && n(t);
+	let r = t === void 0 ? e.toString(2).length : t;
+	return {
+		nBitLength: r,
+		nByteLength: Math.ceil(r / 8)
+	};
+}
+function X(e, t, n = !1, r = {}) {
+	if (e <= G) throw Error("invalid field: expected ORDER > 0, got " + e);
+	let { nBitLength: i, nByteLength: a } = Ie(e, t);
+	if (a > 2048) throw Error("invalid field: expected ORDER of <= 2048 bytes");
+	let o, s = Object.freeze({
+		ORDER: e,
+		isLE: n,
+		BITS: i,
+		BYTES: a,
+		MASK: O(i),
+		ZERO: G,
+		ONE: K,
+		create: (t) => J(t, e),
+		isValid: (t) => {
+			if (typeof t != "bigint") throw Error("invalid field element: expected bigint, got " + typeof t);
+			return G <= t && t < e;
+		},
+		is0: (e) => e === G,
+		isOdd: (e) => (e & K) === K,
+		neg: (t) => J(-t, e),
+		eql: (e, t) => e === t,
+		sqr: (t) => J(t * t, e),
+		add: (t, n) => J(t + n, e),
+		sub: (t, n) => J(t - n, e),
+		mul: (t, n) => J(t * n, e),
+		pow: (e, t) => Ne(s, e, t),
+		div: (t, n) => J(t * Ee(n, e), e),
+		sqrN: (e) => e * e,
+		addN: (e, t) => e + t,
+		subN: (e, t) => e - t,
+		mulN: (e, t) => e * t,
+		inv: (t) => Ee(t, e),
+		sqrt: r.sqrt || ((t) => (o ||= Ae(e), o(s, t))),
+		toBytes: (e) => n ? E(e, a) : D(e, a),
+		fromBytes: (e) => {
+			if (e.length !== a) throw Error("Field.fromBytes: expected " + a + " bytes, got " + e.length);
+			return n ? ne(e) : M(e);
+		},
+		invertBatch: (e) => Pe(s, e),
+		cmov: (e, t, n) => n ? t : e
+	});
+	return Object.freeze(s);
+}
+function Le(e) {
+	if (typeof e != "bigint") throw Error("field order must be bigint");
+	let t = e.toString(2).length;
+	return Math.ceil(t / 8);
+}
+function Re(e) {
+	let t = Le(e);
+	return t + Math.ceil(t / 2);
+}
+function ze(e, t, n = !1) {
+	let r = e.length, i = Le(t), a = Re(t);
+	if (r < 16 || r < a || r > 1024) throw Error("expected " + a + "-1024 bytes of input, got " + r);
+	let o = J(n ? ne(e) : M(e), t - K) + K;
+	return n ? E(o, i) : D(o, i);
+}
+//#endregion
+//#region ../../node_modules/@noble/curves/esm/abstract/curve.js
+var Be = BigInt(0), Ve = BigInt(1);
+function He(e, t) {
+	let n = t.negate();
+	return e ? n : t;
+}
+function Ue(e, t) {
+	if (!Number.isSafeInteger(e) || e <= 0 || e > t) throw Error("invalid window size, expected [1.." + t + "], got W=" + e);
+}
+function We(e, t) {
+	Ue(e, t);
+	let n = Math.ceil(t / e) + 1, r = 2 ** (e - 1), i = 2 ** e;
+	return {
+		windows: n,
+		windowSize: r,
+		mask: O(e),
+		maxNumber: i,
+		shiftBy: BigInt(e)
+	};
+}
+function Ge(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 += Ve);
+	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 Ke(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 qe(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 Je = /* @__PURE__ */ new WeakMap(), Ye = /* @__PURE__ */ new WeakMap();
+function Xe(e) {
+	return Ye.get(e) || 1;
+}
+function Ze(e, t) {
+	return {
+		constTimeNegate: He,
+		hasPrecomputes(e) {
+			return Xe(e) !== 1;
+		},
+		unsafeLadder(t, n, r = e.ZERO) {
+			let i = t;
+			for (; n > Be;) n & Ve && (r = r.add(i)), i = i.double(), n >>= Ve;
+			return r;
+		},
+		precomputeWindow(e, n) {
+			let { windows: r, windowSize: i } = We(n, t), a = [], o = e, s = o;
+			for (let e = 0; e < r; e++) {
+				s = o, a.push(s);
+				for (let e = 1; e < i; e++) s = s.add(o), a.push(s);
+				o = s.double();
+			}
+			return a;
+		},
+		wNAF(n, r, i) {
+			let a = e.ZERO, o = e.BASE, s = We(n, t);
+			for (let e = 0; e < s.windows; e++) {
+				let { nextN: t, offset: n, isZero: c, isNeg: l, isNegF: u, offsetF: d } = Ge(i, e, s);
+				i = t, c ? o = o.add(He(u, r[d])) : a = a.add(He(l, r[n]));
+			}
+			return {
+				p: a,
+				f: o
+			};
+		},
+		wNAFUnsafe(n, r, i, a = e.ZERO) {
+			let o = We(n, t);
+			for (let e = 0; e < o.windows && i !== Be; e++) {
+				let { nextN: t, offset: n, isZero: s, isNeg: c } = Ge(i, e, o);
+				if (i = t, !s) {
+					let e = r[n];
+					a = a.add(c ? e.negate() : e);
+				}
+			}
+			return a;
+		},
+		getPrecomputes(e, t, n) {
+			let r = Je.get(t);
+			return r || (r = this.precomputeWindow(t, e), e !== 1 && Je.set(t, n(r))), r;
+		},
+		wNAFCached(e, t, n) {
+			let r = Xe(e);
+			return this.wNAF(r, this.getPrecomputes(r, e, n), t);
+		},
+		wNAFCachedUnsafe(e, t, n, r) {
+			let i = Xe(e);
+			return i === 1 ? this.unsafeLadder(e, t, r) : this.wNAFUnsafe(i, this.getPrecomputes(i, e, n), t, r);
+		},
+		setWindowSize(e, n) {
+			Ue(n, t), Ye.set(e, n), Je.delete(e);
+		}
+	};
+}
+function Qe(e, t, n, r) {
+	Ke(n, e), qe(r, t);
+	let i = n.length, a = r.length;
+	if (i !== a) throw Error("arrays of points and scalars must have equal length");
+	let o = e.ZERO, s = P(BigInt(i)), c = 1;
+	s > 12 ? c = s - 3 : s > 4 ? c = s - 2 : s > 0 && (c = 2);
+	let l = O(c), u = Array(Number(l) + 1).fill(o), d = Math.floor((t.BITS - 1) / c) * c, f = o;
+	for (let e = d; e >= 0; e -= c) {
+		u.fill(o);
+		for (let t = 0; t < a; t++) {
+			let i = r[t], a = Number(i >> BigInt(e) & l);
+			u[a] = u[a].add(n[t]);
+		}
+		let t = o;
+		for (let e = u.length - 1, n = o; e > 0; e--) n = n.add(u[e]), t = t.add(n);
+		if (f = f.add(t), e !== 0) for (let e = 0; e < c; e++) f = f.double();
+	}
+	return f;
+}
+function $e(e) {
+	return Me(e.Fp), L(e, {
+		n: "bigint",
+		h: "bigint",
+		Gx: "field",
+		Gy: "field"
+	}, {
+		nBitLength: "isSafeInteger",
+		nByteLength: "isSafeInteger"
+	}), Object.freeze({
+		...Ie(e.n, e.nBitLength),
+		...e,
+		p: e.Fp.ORDER
+	});
+}
+//#endregion
+//#region ../../node_modules/@noble/curves/esm/abstract/weierstrass.js
+function et(e) {
+	e.lowS !== void 0 && j("lowS", e.lowS), e.prehash !== void 0 && j("prehash", e.prehash);
+}
+function tt(e) {
+	let t = $e(e);
+	L(t, {
+		a: "field",
+		b: "field"
+	}, {
+		allowInfinityPoint: "boolean",
+		allowedPrivateKeyLengths: "array",
+		clearCofactor: "function",
+		fromBytes: "function",
+		isTorsionFree: "function",
+		toBytes: "function",
+		wrapPrivateKey: "boolean"
+	});
+	let { endo: n, Fp: r, a: i } = t;
+	if (n) {
+		if (!r.eql(i, r.ZERO)) throw Error("invalid endo: CURVE.a must be 0");
+		if (typeof n != "object" || typeof n.beta != "bigint" || typeof n.splitScalar != "function") throw Error("invalid endo: expected \"beta\": bigint and \"splitScalar\": function");
+	}
+	return Object.freeze({ ...t });
+}
+var Z = {
+	Err: class extends Error {
+		constructor(e = "") {
+			super(e);
+		}
+	},
+	_tlv: {
+		encode: (e, t) => {
+			let { Err: n } = Z;
+			if (e < 0 || e > 256) throw new n("tlv.encode: wrong tag");
+			if (t.length & 1) throw new n("tlv.encode: unpadded data");
+			let r = t.length / 2, i = b(r);
+			if (i.length / 2 & 128) throw new n("tlv.encode: long form length too big");
+			let a = r > 127 ? b(i.length / 2 | 128) : "";
+			return b(e) + a + i + t;
+		},
+		decode(e, t) {
+			let { Err: n } = Z, r = 0;
+			if (e < 0 || e > 256) throw new n("tlv.encode: wrong tag");
+			if (t.length < 2 || t[r++] !== e) throw new n("tlv.decode: wrong tlv");
+			let i = t[r++], a = !!(i & 128), o = 0;
+			if (!a) o = i;
+			else {
+				let e = i & 127;
+				if (!e) throw new n("tlv.decode(long): indefinite length not supported");
+				if (e > 4) throw new n("tlv.decode(long): byte length is too big");
+				let a = t.subarray(r, r + e);
+				if (a.length !== e) throw new n("tlv.decode: length bytes not complete");
+				if (a[0] === 0) throw new n("tlv.decode(long): zero leftmost byte");
+				for (let e of a) o = o << 8 | e;
+				if (r += e, o < 128) throw new n("tlv.decode(long): not minimal encoding");
+			}
+			let s = t.subarray(r, r + o);
+			if (s.length !== o) throw new n("tlv.decode: wrong value length");
+			return {
+				v: s,
+				l: t.subarray(r + o)
+			};
+		}
+	},
+	_int: {
+		encode(e) {
+			let { Err: t } = Z;
+			if (e < Q) throw new t("integer: negative integers are not allowed");
+			let n = b(e);
+			if (Number.parseInt(n[0], 16) & 8 && (n = "00" + n), n.length & 1) throw new t("unexpected DER parsing assertion: unpadded hex");
+			return n;
+		},
+		decode(e) {
+			let { Err: t } = Z;
+			if (e[0] & 128) throw new t("invalid signature integer: negative");
+			if (e[0] === 0 && !(e[1] & 128)) throw new t("invalid signature integer: unnecessary leading zero");
+			return M(e);
+		}
+	},
+	toSig(e) {
+		let { Err: t, _int: n, _tlv: r } = Z, i = I("signature", e), { v: a, l: o } = r.decode(48, i);
+		if (o.length) throw new t("invalid signature: left bytes after parsing");
+		let { v: s, l: c } = r.decode(2, a), { v: l, l: u } = r.decode(2, c);
+		if (u.length) throw new t("invalid signature: left bytes after parsing");
+		return {
+			r: n.decode(s),
+			s: n.decode(l)
+		};
+	},
+	hexFromSig(e) {
+		let { _tlv: t, _int: n } = Z, r = t.encode(2, n.encode(e.r)) + t.encode(2, n.encode(e.s));
+		return t.encode(48, r);
+	}
+};
+function nt(e, t) {
+	return x(D(e, t));
+}
+var Q = BigInt(0), $ = BigInt(1), rt = BigInt(3), it = BigInt(4);
+function at(e) {
+	let t = tt(e), { Fp: n } = t, r = X(t.n, t.nBitLength), i = t.toBytes || ((e, t, r) => {
+		let i = t.toAffine();
+		return C(Uint8Array.from([4]), n.toBytes(i.x), n.toBytes(i.y));
+	}), a = t.fromBytes || ((e) => {
+		let t = e.subarray(1);
+		return {
+			x: n.fromBytes(t.subarray(0, n.BYTES)),
+			y: n.fromBytes(t.subarray(n.BYTES, 2 * n.BYTES))
+		};
+	});
+	function o(e) {
+		let { a: r, b: i } = t, a = n.sqr(e), o = n.mul(a, e);
+		return n.add(n.add(o, n.mul(e, r)), i);
+	}
+	function s(e, t) {
+		let r = n.sqr(t), i = o(e);
+		return n.eql(r, i);
+	}
+	if (!s(t.Gx, t.Gy)) throw Error("bad curve params: generator point");
+	let c = n.mul(n.pow(t.a, rt), it), l = n.mul(n.sqr(t.b), BigInt(27));
+	if (n.is0(n.add(c, l))) throw Error("bad curve params: a or b");
+	function u(e) {
+		return T(e, $, t.n);
+	}
+	function d(e) {
+		let { allowedPrivateKeyLengths: n, nByteLength: r, wrapPrivateKey: i, n: a } = t;
+		if (n && typeof e != "bigint") {
+			if (te(e) && (e = x(e)), typeof e != "string" || !n.includes(e.length)) throw Error("invalid private key");
+			e = e.padStart(r * 2, "0");
+		}
+		let o;
+		try {
+			o = typeof e == "bigint" ? e : M(I("private key", e, r));
+		} catch {
+			throw Error("invalid private key, expected hex or " + r + " bytes, got " + typeof e);
+		}
+		return i && (o = J(o, a)), F("private key", o, $, a), o;
+	}
+	function f(e) {
+		if (!(e instanceof h)) throw Error("ProjectivePoint expected");
+	}
+	let p = A((e, t) => {
+		let { px: r, py: i, pz: a } = e;
+		if (n.eql(a, n.ONE)) return {
+			x: r,
+			y: i
+		};
+		let o = e.is0();
+		t ??= o ? n.ONE : n.inv(a);
+		let s = n.mul(r, t), c = n.mul(i, t), l = n.mul(a, t);
+		if (o) return {
+			x: n.ZERO,
+			y: n.ZERO
+		};
+		if (!n.eql(l, n.ONE)) throw Error("invZ was invalid");
+		return {
+			x: s,
+			y: c
+		};
+	}), m = A((e) => {
+		if (e.is0()) {
+			if (t.allowInfinityPoint && !n.is0(e.py)) return;
+			throw Error("bad point: ZERO");
+		}
+		let { x: r, y: i } = e.toAffine();
+		if (!n.isValid(r) || !n.isValid(i)) throw Error("bad point: x or y not FE");
+		if (!s(r, i)) throw Error("bad point: equation left != right");
+		if (!e.isTorsionFree()) throw Error("bad point: not in prime-order subgroup");
+		return !0;
+	});
+	class h {
+		constructor(e, t, r) {
+			if (e == null || !n.isValid(e)) throw Error("x required");
+			if (t == null || !n.isValid(t) || n.is0(t)) throw Error("y required");
+			if (r == null || !n.isValid(r)) throw Error("z required");
+			this.px = e, this.py = t, this.pz = r, Object.freeze(this);
+		}
+		static fromAffine(e) {
+			let { x: t, y: r } = e || {};
+			if (!e || !n.isValid(t) || !n.isValid(r)) throw Error("invalid affine point");
+			if (e instanceof h) throw Error("projective point not allowed");
+			let i = (e) => n.eql(e, n.ZERO);
+			return i(t) && i(r) ? h.ZERO : new h(t, r, n.ONE);
+		}
+		get x() {
+			return this.toAffine().x;
+		}
+		get y() {
+			return this.toAffine().y;
+		}
+		static normalizeZ(e) {
+			let t = Pe(n, e.map((e) => e.pz));
+			return e.map((e, n) => e.toAffine(t[n])).map(h.fromAffine);
+		}
+		static fromHex(e) {
+			let t = h.fromAffine(a(I("pointHex", e)));
+			return t.assertValidity(), t;
+		}
+		static fromPrivateKey(e) {
+			return h.BASE.multiply(d(e));
+		}
+		static msm(e, t) {
+			return Qe(h, r, e, t);
+		}
+		_setWindowSize(e) {
+			v.setWindowSize(this, e);
+		}
+		assertValidity() {
+			m(this);
+		}
+		hasEvenY() {
+			let { y: e } = this.toAffine();
+			if (n.isOdd) return !n.isOdd(e);
+			throw Error("Field doesn't support isOdd");
+		}
+		equals(e) {
+			f(e);
+			let { px: t, py: r, pz: i } = this, { px: a, py: o, pz: s } = e, c = n.eql(n.mul(t, s), n.mul(a, i)), l = n.eql(n.mul(r, s), n.mul(o, i));
+			return c && l;
+		}
+		negate() {
+			return new h(this.px, n.neg(this.py), this.pz);
+		}
+		double() {
+			let { a: e, b: r } = t, i = n.mul(r, rt), { px: a, py: o, pz: s } = this, c = n.ZERO, l = n.ZERO, u = n.ZERO, d = n.mul(a, a), f = n.mul(o, o), p = n.mul(s, s), m = n.mul(a, o);
+			return m = n.add(m, m), u = n.mul(a, s), u = n.add(u, u), c = n.mul(e, u), l = n.mul(i, p), l = n.add(c, l), c = n.sub(f, l), l = n.add(f, l), l = n.mul(c, l), c = n.mul(m, c), u = n.mul(i, u), p = n.mul(e, p), m = n.sub(d, p), m = n.mul(e, m), m = n.add(m, u), u = n.add(d, d), d = n.add(u, d), d = n.add(d, p), d = n.mul(d, m), l = n.add(l, d), p = n.mul(o, s), p = n.add(p, p), d = n.mul(p, m), c = n.sub(c, d), u = n.mul(p, f), u = n.add(u, u), u = n.add(u, u), new h(c, l, u);
+		}
+		add(e) {
+			f(e);
+			let { px: r, py: i, pz: a } = this, { px: o, py: s, pz: c } = e, l = n.ZERO, u = n.ZERO, d = n.ZERO, p = t.a, m = n.mul(t.b, rt), g = n.mul(r, o), _ = n.mul(i, s), v = n.mul(a, c), y = n.add(r, i), b = n.add(o, s);
+			y = n.mul(y, b), b = n.add(g, _), y = n.sub(y, b), b = n.add(r, a);
+			let x = n.add(o, c);
+			return b = n.mul(b, x), x = n.add(g, v), b = n.sub(b, x), x = n.add(i, a), l = n.add(s, c), x = n.mul(x, l), l = n.add(_, v), x = n.sub(x, l), d = n.mul(p, b), l = n.mul(m, v), d = n.add(l, d), l = n.sub(_, d), d = n.add(_, d), u = n.mul(l, d), _ = n.add(g, g), _ = n.add(_, g), v = n.mul(p, v), b = n.mul(m, b), _ = n.add(_, v), v = n.sub(g, v), v = n.mul(p, v), b = n.add(b, v), g = n.mul(_, b), u = n.add(u, g), g = n.mul(x, b), l = n.mul(y, l), l = n.sub(l, g), g = n.mul(y, _), d = n.mul(x, d), d = n.add(d, g), new h(l, u, d);
+		}
+		subtract(e) {
+			return this.add(e.negate());
+		}
+		is0() {
+			return this.equals(h.ZERO);
+		}
+		wNAF(e) {
+			return v.wNAFCached(this, e, h.normalizeZ);
+		}
+		multiplyUnsafe(e) {
+			let { endo: r, n: i } = t;
+			F("scalar", e, Q, i);
+			let a = h.ZERO;
+			if (e === Q) return a;
+			if (this.is0() || e === $) return this;
+			if (!r || v.hasPrecomputes(this)) return v.wNAFCachedUnsafe(this, e, h.normalizeZ);
+			let { k1neg: o, k1: s, k2neg: c, k2: l } = r.splitScalar(e), u = a, d = a, f = this;
+			for (; s > Q || l > Q;) s & $ && (u = u.add(f)), l & $ && (d = d.add(f)), f = f.double(), s >>= $, l >>= $;
+			return o && (u = u.negate()), c && (d = d.negate()), d = new h(n.mul(d.px, r.beta), d.py, d.pz), u.add(d);
+		}
+		multiply(e) {
+			let { endo: r, n: i } = t;
+			F("scalar", e, $, i);
+			let a, o;
+			if (r) {
+				let { k1neg: t, k1: i, k2neg: s, k2: c } = r.splitScalar(e), { p: l, f: u } = this.wNAF(i), { p: d, f } = this.wNAF(c);
+				l = v.constTimeNegate(t, l), d = v.constTimeNegate(s, d), d = new h(n.mul(d.px, r.beta), d.py, d.pz), a = l.add(d), o = u.add(f);
+			} else {
+				let { p: t, f: n } = this.wNAF(e);
+				a = t, o = n;
+			}
+			return h.normalizeZ([a, o])[0];
+		}
+		multiplyAndAddUnsafe(e, t, n) {
+			let r = h.BASE, i = (e, t) => t === Q || t === $ || !e.equals(r) ? e.multiplyUnsafe(t) : e.multiply(t), a = i(this, t).add(i(e, n));
+			return a.is0() ? void 0 : a;
+		}
+		toAffine(e) {
+			return p(this, e);
+		}
+		isTorsionFree() {
+			let { h: e, isTorsionFree: n } = t;
+			if (e === $) return !0;
+			if (n) return n(h, this);
+			throw Error("isTorsionFree() has not been declared for the elliptic curve");
+		}
+		clearCofactor() {
+			let { h: e, clearCofactor: n } = t;
+			return e === $ ? this : n ? n(h, this) : this.multiplyUnsafe(t.h);
+		}
+		toRawBytes(e = !0) {
+			return j("isCompressed", e), this.assertValidity(), i(h, this, e);
+		}
+		toHex(e = !0) {
+			return j("isCompressed", e), x(this.toRawBytes(e));
+		}
+	}
+	h.BASE = new h(t.Gx, t.Gy, n.ONE), h.ZERO = new h(n.ZERO, n.ONE, n.ZERO);
+	let { endo: g, nBitLength: _ } = t, v = Ze(h, g ? Math.ceil(_ / 2) : _);
+	return {
+		CURVE: t,
+		ProjectivePoint: h,
+		normPrivateKeyToScalar: d,
+		weierstrassEquation: o,
+		isWithinCurveOrder: u
+	};
+}
+function ot(e) {
+	let t = $e(e);
+	return L(t, {
+		hash: "hash",
+		hmac: "function",
+		randomBytes: "function"
+	}, {
+		bits2int: "function",
+		bits2int_modN: "function",
+		lowS: "boolean"
+	}), Object.freeze({
+		lowS: !0,
+		...t
+	});
+}
+function st(e) {
+	let t = ot(e), { Fp: n, n: r, nByteLength: i, nBitLength: a } = t, o = n.BYTES + 1, s = 2 * n.BYTES + 1;
+	function c(e) {
+		return J(e, r);
+	}
+	function l(e) {
+		return Ee(e, r);
+	}
+	let { ProjectivePoint: u, normPrivateKeyToScalar: d, weierstrassEquation: f, isWithinCurveOrder: p } = at({
+		...t,
+		toBytes(e, t, r) {
+			let i = t.toAffine(), a = n.toBytes(i.x), o = C;
+			return j("isCompressed", r), r ? o(Uint8Array.from([t.hasEvenY() ? 2 : 3]), a) : o(Uint8Array.from([4]), a, n.toBytes(i.y));
+		},
+		fromBytes(e) {
+			let t = e.length, r = e[0], i = e.subarray(1);
+			if (t === o && (r === 2 || r === 3)) {
+				let e = M(i);
+				if (!T(e, $, n.ORDER)) throw Error("Point is not on curve");
+				let t = f(e), a;
+				try {
+					a = n.sqrt(t);
+				} catch (e) {
+					let t = e instanceof Error ? ": " + e.message : "";
+					throw Error("Point is not on curve" + t);
+				}
+				let o = (a & $) === $;
+				return (r & 1) == 1 !== o && (a = n.neg(a)), {
+					x: e,
+					y: a
+				};
+			} else if (t === s && r === 4) return {
+				x: n.fromBytes(i.subarray(0, n.BYTES)),
+				y: n.fromBytes(i.subarray(n.BYTES, 2 * n.BYTES))
+			};
+			else {
+				let e = o, n = s;
+				throw Error("invalid Point, expected length of " + e + ", or uncompressed " + n + ", got " + t);
+			}
+		}
+	});
+	function m(e) {
+		return e > r >> $;
+	}
+	function h(e) {
+		return m(e) ? c(-e) : e;
+	}
+	let g = (e, t, n) => M(e.slice(t, n));
+	class _ {
+		constructor(e, t, n) {
+			F("r", e, $, r), F("s", t, $, r), this.r = e, this.s = t, n != null && (this.recovery = n), Object.freeze(this);
+		}
+		static fromCompact(e) {
+			let t = i;
+			return e = I("compactSignature", e, t * 2), new _(g(e, 0, t), g(e, t, 2 * t));
+		}
+		static fromDER(e) {
+			let { r: t, s: n } = Z.toSig(I("DER", e));
+			return new _(t, n);
+		}
+		assertValidity() {}
+		addRecoveryBit(e) {
+			return new _(this.r, this.s, e);
+		}
+		recoverPublicKey(e) {
+			let { r, s: i, recovery: a } = this, o = E(I("msgHash", e));
+			if (a == null || ![
+				0,
+				1,
+				2,
+				3
+			].includes(a)) throw Error("recovery id invalid");
+			let s = a === 2 || a === 3 ? r + t.n : r;
+			if (s >= n.ORDER) throw Error("recovery id 2 or 3 invalid");
+			let d = a & 1 ? "03" : "02", f = u.fromHex(d + nt(s, n.BYTES)), p = l(s), m = c(-o * p), h = c(i * p), g = u.BASE.multiplyAndAddUnsafe(f, m, h);
+			if (!g) throw Error("point at infinify");
+			return g.assertValidity(), g;
+		}
+		hasHighS() {
+			return m(this.s);
+		}
+		normalizeS() {
+			return this.hasHighS() ? new _(this.r, c(-this.s), this.recovery) : this;
+		}
+		toDERRawBytes() {
+			return w(this.toDERHex());
+		}
+		toDERHex() {
+			return Z.hexFromSig(this);
+		}
+		toCompactRawBytes() {
+			return w(this.toCompactHex());
+		}
+		toCompactHex() {
+			let e = i;
+			return nt(this.r, e) + nt(this.s, e);
+		}
+	}
+	let v = {
+		isValidPrivateKey(e) {
+			try {
+				return d(e), !0;
+			} catch {
+				return !1;
+			}
+		},
+		normPrivateKeyToScalar: d,
+		randomPrivateKey: () => {
+			let e = Re(t.n);
+			return ze(t.randomBytes(e), t.n);
+		},
+		precompute(e = 8, t = u.BASE) {
+			return t._setWindowSize(e), t.multiply(BigInt(3)), t;
+		}
+	};
+	function y(e, t = !0) {
+		return u.fromPrivateKey(e).toRawBytes(t);
+	}
+	function b(e) {
+		if (typeof e == "bigint") return !1;
+		if (e instanceof u) return !0;
+		let r = I("key", e).length, a = n.BYTES, o = a + 1, s = 2 * a + 1;
+		if (!(t.allowedPrivateKeyLengths || i === o)) return r === o || r === s;
+	}
+	function x(e, t, n = !0) {
+		if (b(e) === !0) throw Error("first arg must be private key");
+		if (b(t) === !1) throw Error("second arg must be public key");
+		return u.fromHex(t).multiply(d(e)).toRawBytes(n);
+	}
+	let S = t.bits2int || function(e) {
+		if (e.length > 8192) throw Error("input is too large");
+		let t = M(e), n = e.length * 8 - a;
+		return n > 0 ? t >> BigInt(n) : t;
+	}, E = t.bits2int_modN || function(e) {
+		return c(S(e));
+	}, k = O(a);
+	function A(e) {
+		return F("num < 2^" + a, e, Q, k), D(e, i);
+	}
+	function N(e, r, i = P) {
+		if (["recovered", "canonical"].some((e) => e in i)) throw Error("sign() legacy options not supported");
+		let { hash: a, randomBytes: o } = t, { lowS: s, prehash: f, extraEntropy: g } = i;
+		s ??= !0, e = I("msgHash", e), et(i), f && (e = I("prehashed msgHash", a(e)));
+		let v = E(e), y = d(r), b = [A(y), A(v)];
+		if (g != null && g !== !1) {
+			let e = g === !0 ? o(n.BYTES) : g;
+			b.push(I("extraEntropy", e));
+		}
+		let x = C(...b), w = v;
+		function T(e) {
+			let t = S(e);
+			if (!p(t)) return;
+			let n = l(t), r = u.BASE.multiply(t).toAffine(), i = c(r.x);
+			if (i === Q) return;
+			let a = c(n * c(w + i * y));
+			if (a === Q) return;
+			let o = (r.x === i ? 0 : 2) | Number(r.y & $), d = a;
+			return s && m(a) && (d = h(a), o ^= 1), new _(i, d, o);
+		}
+		return {
+			seed: x,
+			k2sig: T
+		};
+	}
+	let P = {
+		lowS: t.lowS,
+		prehash: !1
+	}, ne = {
+		lowS: t.lowS,
+		prehash: !1
+	};
+	function L(e, n, r = P) {
+		let { seed: i, k2sig: a } = N(e, n, r), o = t;
+		return ee(o.hash.outputLen, o.nByteLength, o.hmac)(i, a);
+	}
+	u.BASE._setWindowSize(8);
+	function re(e, n, r, i = ne) {
+		let a = e;
+		n = I("msgHash", n), r = I("publicKey", r);
+		let { lowS: o, prehash: s, format: d } = i;
+		if (et(i), "strict" in i) throw Error("options.strict was renamed to lowS");
+		if (d !== void 0 && d !== "compact" && d !== "der") throw Error("format must be compact or der");
+		let f = typeof a == "string" || te(a), p = !f && !d && typeof a == "object" && !!a && typeof a.r == "bigint" && typeof a.s == "bigint";
+		if (!f && !p) throw Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+		let m, h;
+		try {
+			if (p && (m = new _(a.r, a.s)), f) {
+				try {
+					d !== "compact" && (m = _.fromDER(a));
+				} catch (e) {
+					if (!(e instanceof Z.Err)) throw e;
+				}
+				!m && d !== "der" && (m = _.fromCompact(a));
+			}
+			h = u.fromHex(r);
+		} catch {
+			return !1;
+		}
+		if (!m || o && m.hasHighS()) return !1;
+		s && (n = t.hash(n));
+		let { r: g, s: v } = m, y = E(n), b = l(v), x = c(y * b), S = c(g * b), C = u.BASE.multiplyAndAddUnsafe(h, x, S)?.toAffine();
+		return C ? c(C.x) === g : !1;
+	}
+	return {
+		CURVE: t,
+		getPublicKey: y,
+		getSharedSecret: x,
+		sign: L,
+		verify: re,
+		ProjectivePoint: u,
+		Signature: _,
+		utils: v
+	};
+}
+//#endregion
+//#region ../../node_modules/@noble/curves/esm/_shortw_utils.js
+function ct(e) {
+	return {
+		hash: e,
+		hmac: (t, ...n) => xe(e, t, i(...n)),
+		randomBytes: k
+	};
+}
+function lt(e, t) {
+	let n = (t) => st({
+		...e,
+		...ct(t)
+	});
+	return {
+		...n(t),
+		create: n
+	};
+}
+//#endregion
+//#region ../../node_modules/@noble/curves/esm/secp256k1.js
+var ut = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), dt = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), ft = BigInt(0), pt = BigInt(1), mt = BigInt(2), ht = (e, t) => (e + t / mt) / t;
+function gt(e) {
+	let t = ut, n = BigInt(3), r = BigInt(6), i = BigInt(11), a = BigInt(22), o = BigInt(23), s = BigInt(44), c = BigInt(88), l = e * e * e % t, u = l * l * e % t, d = Y(Y(Y(u, n, t) * u % t, n, t) * u % t, mt, t) * l % t, f = Y(d, i, t) * d % t, p = Y(f, a, t) * f % t, m = Y(p, s, t) * p % t, h = Y(Y(Y(Y(Y(Y(m, c, t) * m % t, s, t) * p % t, n, t) * u % t, o, t) * f % t, r, t) * l % t, mt, t);
+	if (!_t.eql(_t.sqr(h), e)) throw Error("Cannot find square root");
+	return h;
+}
+var _t = X(ut, void 0, void 0, { sqrt: gt }), vt = lt({
+	a: ft,
+	b: BigInt(7),
+	Fp: _t,
+	n: dt,
+	Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
+	Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
+	h: BigInt(1),
+	lowS: !0,
+	endo: {
+		beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+		splitScalar: (e) => {
+			let t = dt, n = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), r = -pt * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), i = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), a = n, o = BigInt("0x100000000000000000000000000000000"), s = ht(a * e, t), c = ht(-r * e, t), l = J(e - s * n - c * i, t), u = J(-s * r - c * a, t), d = l > o, f = u > o;
+			if (d && (l = t - l), f && (u = t - u), l > o || u > o) throw Error("splitScalar: Endomorphism failed, k=" + e);
+			return {
+				k1neg: d,
+				k1: l,
+				k2neg: f,
+				k2: u
+			};
+		}
+	}
+}, _e);
+//#endregion
+export { ye as a, _e as i, lt as n, ve as o, X as r, vt as t };