digiid-ts 2.0.3 → 3.0.0

package/dist/digiid-ts.es.js

@@ -1,2080 +1,1792 @@
-var Ve = Object.defineProperty;
-var Me = (e, t, r) => t in e ? Ve(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var m = (e, t, r) => Me(e, typeof t != "symbol" ? t + "" : t, r);
-import { randomBytes as Ye } from "crypto";
-class C extends Error {
-  constructor(t) {
-    super(t), this.name = "DigiIDError";
-  }
-}
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function Tt(e) {
-  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
-}
-function at(e, t = "") {
-  if (!Number.isSafeInteger(e) || e < 0) {
-    const r = t && `"${t}" `;
-    throw new Error(`${r}expected integer >= 0, got ${e}`);
-  }
-}
-function N(e, t, r = "") {
-  const n = Tt(e), s = e == null ? void 0 : e.length, o = t !== void 0;
-  if (!n || o && s !== t) {
-    const i = r && `"${r}" `, c = o ? ` of length ${t}` : "", f = n ? `length=${s}` : `type=${typeof e}`;
-    throw new Error(i + "expected Uint8Array" + c + ", got " + f);
-  }
-  return e;
-}
-function ue(e) {
-  if (typeof e != "function" || typeof e.create != "function")
-    throw new Error("Hash must wrapped by utils.createHasher");
-  at(e.outputLen), at(e.blockLen);
-}
-function Bt(e, t = !0) {
-  if (e.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (t && e.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function je(e, t) {
-  N(e, void 0, "digestInto() output");
-  const r = t.outputLen;
-  if (e.length < r)
-    throw new Error('"digestInto() output" expected to be of length >=' + r);
-}
-function vt(...e) {
-  for (let t = 0; t < e.length; t++)
-    e[t].fill(0);
-}
-function Ot(e) {
-  return new DataView(e.buffer, e.byteOffset, e.byteLength);
-}
-function P(e, t) {
-  return e << 32 - t | e >>> t;
-}
-const ae = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Ke = /* @__PURE__ */ Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
-function Lt(e) {
-  if (N(e), ae)
-    return e.toHex();
-  let t = "";
-  for (let r = 0; r < e.length; r++)
-    t += Ke[e[r]];
-  return t;
-}
-const J = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
-function Wt(e) {
-  if (e >= J._0 && e <= J._9)
-    return e - J._0;
-  if (e >= J.A && e <= J.F)
-    return e - (J.A - 10);
-  if (e >= J.a && e <= J.f)
-    return e - (J.a - 10);
-}
-function Rt(e) {
-  if (typeof e != "string")
-    throw new Error("hex string expected, got " + typeof e);
-  if (ae)
-    return Uint8Array.fromHex(e);
-  const t = e.length, r = t / 2;
-  if (t % 2)
-    throw new Error("hex string expected, got unpadded hex of length " + t);
-  const n = new Uint8Array(r);
-  for (let s = 0, o = 0; s < r; s++, o += 2) {
-    const i = Wt(e.charCodeAt(o)), c = Wt(e.charCodeAt(o + 1));
-    if (i === void 0 || c === void 0) {
-      const f = e[o] + e[o + 1];
-      throw new Error('hex string expected, got non-hex character "' + f + '" at index ' + o);
-    }
-    n[s] = i * 16 + c;
-  }
-  return n;
-}
-function it(...e) {
-  let t = 0;
-  for (let n = 0; n < e.length; n++) {
-    const s = e[n];
-    N(s), t += s.length;
-  }
-  const r = new Uint8Array(t);
-  for (let n = 0, s = 0; n < e.length; n++) {
-    const o = e[n];
-    r.set(o, s), s += o.length;
-  }
-  return r;
-}
-function Ge(e, t = {}) {
-  const r = (s, o) => e(o).update(s).digest(), n = e(void 0);
-  return r.outputLen = n.outputLen, r.blockLen = n.blockLen, r.create = (s) => e(s), Object.assign(r, t), Object.freeze(r);
-}
-function le(e = 32) {
-  const t = typeof globalThis == "object" ? globalThis.crypto : null;
-  if (typeof (t == null ? void 0 : t.getRandomValues) != "function")
-    throw new Error("crypto.getRandomValues must be defined");
-  return t.getRandomValues(new Uint8Array(e));
-}
-const Xe = (e) => ({
-  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, e])
-});
-function ze(e, t, r) {
-  return e & t ^ ~e & r;
-}
-function Fe(e, t, r) {
-  return e & t ^ e & r ^ t & r;
-}
-let We = class {
-  constructor(t, r, n, s) {
-    m(this, "blockLen");
-    m(this, "outputLen");
-    m(this, "padOffset");
-    m(this, "isLE");
-    // For partial updates less than block size
-    m(this, "buffer");
-    m(this, "view");
-    m(this, "finished", !1);
-    m(this, "length", 0);
-    m(this, "pos", 0);
-    m(this, "destroyed", !1);
-    this.blockLen = t, this.outputLen = r, this.padOffset = n, this.isLE = s, this.buffer = new Uint8Array(t), this.view = Ot(this.buffer);
-  }
-  update(t) {
-    Bt(this), N(t);
-    const { view: r, buffer: n, blockLen: s } = this, o = t.length;
-    for (let i = 0; i < o; ) {
-      const c = Math.min(s - this.pos, o - i);
-      if (c === s) {
-        const f = Ot(t);
-        for (; s <= o - i; i += s)
-          this.process(f, i);
-        continue;
-      }
-      n.set(t.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === s && (this.process(r, 0), this.pos = 0);
-    }
-    return this.length += t.length, this.roundClean(), this;
-  }
-  digestInto(t) {
-    Bt(this), je(t, this), this.finished = !0;
-    const { buffer: r, view: n, blockLen: s, isLE: o } = this;
-    let { pos: i } = this;
-    r[i++] = 128, vt(this.buffer.subarray(i)), this.padOffset > s - i && (this.process(n, 0), i = 0);
-    for (let d = i; d < s; d++)
-      r[d] = 0;
-    n.setBigUint64(s - 8, BigInt(this.length * 8), o), this.process(n, 0);
-    const c = Ot(t), f = this.outputLen;
-    if (f % 4)
-      throw new Error("_sha2: outputLen must be aligned to 32bit");
-    const u = f / 4, h = this.get();
-    if (u > h.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let d = 0; d < u; d++)
-      c.setUint32(4 * d, h[d], o);
-  }
-  digest() {
-    const { buffer: t, outputLen: r } = this;
-    this.digestInto(t);
-    const n = t.slice(0, r);
-    return this.destroy(), n;
-  }
-  _cloneInto(t) {
-    t || (t = new this.constructor()), t.set(...this.get());
-    const { blockLen: r, buffer: n, length: s, finished: o, destroyed: i, pos: c } = this;
-    return t.destroyed = i, t.finished = o, t.length = s, t.pos = c, s % r && t.buffer.set(n), t;
-  }
-  clone() {
-    return this._cloneInto();
-  }
+import { randomBytes as e } from "crypto";
+//#region src/types.ts
+var t = class extends Error {
+	constructor(e) {
+		super(e), this.name = "DigiIDError";
+	}
+};
+//#endregion
+//#region node_modules/@noble/hashes/utils.js
+function n(e) {
+	return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in e && e.BYTES_PER_ELEMENT === 1;
+}
+function r(e, t = "") {
+	if (typeof e != "number") {
+		let n = t && `"${t}" `;
+		throw TypeError(`${n}expected number, got ${typeof e}`);
+	}
+	if (!Number.isSafeInteger(e) || e < 0) {
+		let n = t && `"${t}" `;
+		throw RangeError(`${n}expected integer >= 0, got ${e}`);
+	}
+}
+function i(e, t, r = "") {
+	let i = n(e), a = e?.length, o = t !== void 0;
+	if (!i || o && a !== t) {
+		let n = r && `"${r}" `, s = o ? ` of length ${t}` : "", c = i ? `length=${a}` : `type=${typeof e}`, l = n + "expected Uint8Array" + s + ", got " + c;
+		throw i ? RangeError(l) : TypeError(l);
+	}
+	return e;
+}
+function a(e) {
+	if (typeof e != "function" || typeof e.create != "function") throw TypeError("Hash must wrapped by utils.createHasher");
+	if (r(e.outputLen), r(e.blockLen), e.outputLen < 1) throw Error("\"outputLen\" must be >= 1");
+	if (e.blockLen < 1) throw Error("\"blockLen\" must be >= 1");
+}
+function o(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 s(e, t) {
+	i(e, void 0, "digestInto() output");
+	let n = t.outputLen;
+	if (e.length < n) throw RangeError("\"digestInto() output\" expected to be of length >=" + n);
+}
+function c(...e) {
+	for (let t = 0; t < e.length; t++) e[t].fill(0);
+}
+function l(e) {
+	return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function u(e, t) {
+	return e << 32 - t | e >>> t;
+}
+function d(e, t) {
+	return e << t | e >>> 32 - t >>> 0;
+}
+var f = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", p = /* @__PURE__ */ Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+function m(e) {
+	if (i(e), f) return e.toHex();
+	let t = "";
+	for (let n = 0; n < e.length; n++) t += p[e[n]];
+	return t;
+}
+var h = {
+	_0: 48,
+	_9: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
 };
-const et = /* @__PURE__ */ Uint32Array.from([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]), Pe = /* @__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
-]), nt = /* @__PURE__ */ new Uint32Array(64);
-class Qe extends We {
-  constructor(t) {
-    super(64, t, 8, !1);
-  }
-  get() {
-    const { A: t, B: r, C: n, D: s, E: o, F: i, G: c, H: f } = this;
-    return [t, r, n, s, o, i, c, f];
-  }
-  // prettier-ignore
-  set(t, r, n, s, o, i, c, f) {
-    this.A = t | 0, this.B = r | 0, this.C = n | 0, this.D = s | 0, this.E = o | 0, this.F = i | 0, this.G = c | 0, this.H = f | 0;
-  }
-  process(t, r) {
-    for (let d = 0; d < 16; d++, r += 4)
-      nt[d] = t.getUint32(r, !1);
-    for (let d = 16; d < 64; d++) {
-      const x = nt[d - 15], g = nt[d - 2], y = P(x, 7) ^ P(x, 18) ^ x >>> 3, U = P(g, 17) ^ P(g, 19) ^ g >>> 10;
-      nt[d] = U + nt[d - 7] + y + nt[d - 16] | 0;
-    }
-    let { A: n, B: s, C: o, D: i, E: c, F: f, G: u, H: h } = this;
-    for (let d = 0; d < 64; d++) {
-      const x = P(c, 6) ^ P(c, 11) ^ P(c, 25), g = h + x + ze(c, f, u) + Pe[d] + nt[d] | 0, U = (P(n, 2) ^ P(n, 13) ^ P(n, 22)) + Fe(n, s, o) | 0;
-      h = u, u = f, f = c, c = i + g | 0, i = o, o = s, s = n, n = g + U | 0;
-    }
-    n = n + this.A | 0, s = s + this.B | 0, o = o + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, f = f + this.F | 0, u = u + this.G | 0, h = h + this.H | 0, this.set(n, s, o, i, c, f, u, h);
-  }
-  roundClean() {
-    vt(nt);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0), vt(this.buffer);
-  }
-}
-class Je extends Qe {
-  constructor() {
-    super(32);
-    // We cannot use array here since array allows indexing by variable
-    // which means optimizer/compiler cannot use registers.
-    m(this, "A", et[0] | 0);
-    m(this, "B", et[1] | 0);
-    m(this, "C", et[2] | 0);
-    m(this, "D", et[3] | 0);
-    m(this, "E", et[4] | 0);
-    m(this, "F", et[5] | 0);
-    m(this, "G", et[6] | 0);
-    m(this, "H", et[7] | 0);
-  }
-}
-const tn = /* @__PURE__ */ Ge(
-  () => new Je(),
-  /* @__PURE__ */ Xe(1)
-);
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-const Vt = /* @__PURE__ */ BigInt(0), $t = /* @__PURE__ */ BigInt(1);
-function At(e, t = "") {
-  if (typeof e != "boolean") {
-    const r = t && `"${t}" `;
-    throw new Error(r + "expected boolean, got type=" + typeof e);
-  }
-  return e;
+function g(e) {
+	if (e >= h._0 && e <= h._9) return e - h._0;
+	if (e >= h.A && e <= h.F) return e - (h.A - 10);
+	if (e >= h.a && e <= h.f) return e - (h.a - 10);
+}
+function _(e) {
+	if (typeof e != "string") throw TypeError("hex string expected, got " + typeof e);
+	if (f) try {
+		return Uint8Array.fromHex(e);
+	} catch (e) {
+		throw e instanceof SyntaxError ? RangeError(e.message) : e;
+	}
+	let t = e.length, n = t / 2;
+	if (t % 2) throw RangeError("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 = g(e.charCodeAt(i)), a = g(e.charCodeAt(i + 1));
+		if (n === void 0 || a === void 0) {
+			let t = e[i] + e[i + 1];
+			throw RangeError("hex string expected, got non-hex character \"" + t + "\" at index " + i);
+		}
+		r[t] = n * 16 + a;
+	}
+	return r;
+}
+function v(...e) {
+	let t = 0;
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		i(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 y(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.canXOF = r.canXOF, n.create = (t) => e(t), Object.assign(n, t), Object.freeze(n);
+}
+function b(e = 32) {
+	r(e, "bytesLength");
+	let t = typeof globalThis == "object" ? globalThis.crypto : null;
+	if (typeof t?.getRandomValues != "function") throw Error("crypto.getRandomValues must be defined");
+	if (e > 65536) throw RangeError(`"bytesLength" expected <= 65536, got ${e}`);
+	return t.getRandomValues(new Uint8Array(e));
+}
+var x = (e) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	e
+]) });
+//#endregion
+//#region node_modules/@noble/hashes/_md.js
+function S(e, t, n) {
+	return e & t ^ ~e & n;
+}
+function C(e, t, n) {
+	return e & t ^ e & n ^ t & n;
+}
+var w = class {
+	blockLen;
+	outputLen;
+	canXOF = !1;
+	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 = l(this.buffer);
+	}
+	update(e) {
+		o(this), i(e);
+		let { view: t, buffer: n, blockLen: r } = this, a = e.length;
+		for (let i = 0; i < a;) {
+			let o = Math.min(r - this.pos, a - i);
+			if (o === r) {
+				let t = l(e);
+				for (; r <= a - i; i += r) this.process(t, i);
+				continue;
+			}
+			n.set(e.subarray(i, i + o), this.pos), this.pos += o, i += o, this.pos === r && (this.process(t, 0), this.pos = 0);
+		}
+		return this.length += e.length, this.roundClean(), this;
+	}
+	digestInto(e) {
+		o(this), s(e, this), this.finished = !0;
+		let { buffer: t, view: n, blockLen: r, isLE: i } = this, { pos: a } = this;
+		t[a++] = 128, c(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 u = l(e), d = this.outputLen;
+		if (d % 4) throw Error("_sha2: outputLen must be aligned to 32bit");
+		let f = d / 4, p = this.get();
+		if (f > p.length) throw Error("_sha2: outputLen bigger than state");
+		for (let e = 0; e < f; e++) u.setUint32(4 * e, p[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();
+	}
+}, T = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]), E = /* @__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
+]), D = /* @__PURE__ */ new Uint32Array(64), ee = class extends w {
+	constructor(e) {
+		super(64, e, 8, !1);
+	}
+	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(e, t) {
+		for (let n = 0; n < 16; n++, t += 4) D[n] = e.getUint32(t, !1);
+		for (let e = 16; e < 64; e++) {
+			let t = D[e - 15], n = D[e - 2], r = u(t, 7) ^ u(t, 18) ^ t >>> 3;
+			D[e] = (u(n, 17) ^ u(n, 19) ^ n >>> 10) + D[e - 7] + r + D[e - 16] | 0;
+		}
+		let { A: n, B: r, C: i, D: a, E: o, F: s, G: c, H: l } = this;
+		for (let e = 0; e < 64; e++) {
+			let t = u(o, 6) ^ u(o, 11) ^ u(o, 25), d = l + t + S(o, s, c) + E[e] + D[e] | 0, f = (u(n, 2) ^ u(n, 13) ^ u(n, 22)) + C(n, r, i) | 0;
+			l = c, c = s, s = o, o = a + d | 0, a = i, i = r, r = n, n = d + f | 0;
+		}
+		n = n + this.A | 0, r = r + this.B | 0, i = i + this.C | 0, a = a + this.D | 0, o = o + this.E | 0, s = s + this.F | 0, c = c + this.G | 0, l = l + this.H | 0, this.set(n, r, i, a, o, s, c, l);
+	}
+	roundClean() {
+		c(D);
+	}
+	destroy() {
+		this.destroyed = !0, this.set(0, 0, 0, 0, 0, 0, 0, 0), c(this.buffer);
+	}
+}, te = class extends ee {
+	A = T[0] | 0;
+	B = T[1] | 0;
+	C = T[2] | 0;
+	D = T[3] | 0;
+	E = T[4] | 0;
+	F = T[5] | 0;
+	G = T[6] | 0;
+	H = T[7] | 0;
+	constructor() {
+		super(32);
+	}
+}, O = /* @__PURE__ */ y(() => new te(), /* @__PURE__ */ x(1)), k = (e, t, n) => i(e, t, n), A = r, ne = m, j = (...e) => v(...e), M = (e) => _(e), re = n, ie = (e) => b(e), N = /* @__PURE__ */ BigInt(0), P = /* @__PURE__ */ BigInt(1);
+function F(e, t = "") {
+	if (typeof e != "boolean") {
+		let n = t && `"${t}" `;
+		throw TypeError(n + "expected boolean, got type=" + typeof e);
+	}
+	return e;
+}
+function ae(e) {
+	if (typeof e == "bigint") {
+		if (!R(e)) throw RangeError("positive bigint expected, got " + e);
+	} else A(e);
+	return e;
+}
+function oe(e, t = "") {
+	if (typeof e != "number") {
+		let n = t && `"${t}" `;
+		throw TypeError(n + "expected number, got type=" + typeof e);
+	}
+	if (!Number.isSafeInteger(e)) {
+		let n = t && `"${t}" `;
+		throw RangeError(n + "expected safe integer, got " + e);
+	}
+}
+function I(e) {
+	let t = ae(e).toString(16);
+	return t.length & 1 ? "0" + t : t;
+}
+function se(e) {
+	if (typeof e != "string") throw TypeError("hex string expected, got " + typeof e);
+	return e === "" ? N : BigInt("0x" + e);
+}
+function L(e) {
+	return se(m(e));
+}
+function ce(e) {
+	return se(m(de(i(e)).reverse()));
+}
+function le(e, t) {
+	if (r(t), t === 0) throw RangeError("zero length");
+	e = ae(e);
+	let n = e.toString(16);
+	if (n.length > t * 2) throw RangeError("number too large");
+	return _(n.padStart(t * 2, "0"));
+}
+function ue(e, t) {
+	return le(e, t).reverse();
 }
 function de(e) {
-  if (typeof e == "bigint") {
-    if (!Et(e))
-      throw new Error("positive bigint expected, got " + e);
-  } else
-    at(e);
-  return e;
-}
-function pt(e) {
-  const t = de(e).toString(16);
-  return t.length & 1 ? "0" + t : t;
-}
-function he(e) {
-  if (typeof e != "string")
-    throw new Error("hex string expected, got " + typeof e);
-  return e === "" ? Vt : BigInt("0x" + e);
-}
-function Ut(e) {
-  return he(Lt(e));
-}
-function ge(e) {
-  return he(Lt(en(N(e)).reverse()));
-}
-function Mt(e, t) {
-  at(t), e = de(e);
-  const r = Rt(e.toString(16).padStart(t * 2, "0"));
-  if (r.length !== t)
-    throw new Error("number too large");
-  return r;
+	return Uint8Array.from(k(e));
+}
+var R = (e) => typeof e == "bigint" && N <= e;
+function fe(e, t, n) {
+	return R(e) && R(t) && R(n) && t <= e && e < n;
+}
+function pe(e, t, n, r) {
+	if (!fe(t, n, r)) throw RangeError("expected valid " + e + ": " + n + " <= n < " + r + ", got " + t);
+}
+function me(e) {
+	if (e < N) throw Error("expected non-negative bigint, got " + e);
+	let t;
+	for (t = 0; e > N; e >>= P, t += 1);
+	return t;
+}
+var he = (e) => (P << BigInt(e)) - P;
+function ge(e, t, n) {
+	if (r(e, "hashLen"), r(t, "qByteLen"), typeof n != "function") throw TypeError("hmacFn must be a function");
+	let i = (e) => new Uint8Array(e), a = Uint8Array.of(), o = Uint8Array.of(0), s = Uint8Array.of(1), c = i(e), l = i(e), u = 0, d = () => {
+		c.fill(1), l.fill(0), u = 0;
+	}, f = (...e) => n(l, j(c, ...e)), p = (e = a) => {
+		l = f(o, e), c = f(), e.length !== 0 && (l = f(s, e), c = f());
+	}, m = () => {
+		if (u++ >= 1e3) throw Error("drbg: tried max amount of iterations");
+		let e = 0, n = [];
+		for (; e < t;) {
+			c = f();
+			let t = c.slice();
+			n.push(t), e += c.length;
+		}
+		return j(...n);
+	};
+	return (e, t) => {
+		d(), p(e);
+		let n;
+		for (; (n = t(m())) === void 0;) p();
+		return d(), n;
+	};
+}
+function z(e, t = {}, n = {}) {
+	if (Object.prototype.toString.call(e) !== "[object Object]") throw TypeError("expected valid options object");
+	function r(t, n, r) {
+		if (!r && n !== "function" && !Object.hasOwn(e, t)) throw TypeError(`param "${t}" is invalid: expected own property`);
+		let i = e[t];
+		if (r && i === void 0) return;
+		let a = typeof i;
+		if (a !== n || i === null) throw TypeError(`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);
+}
+//#endregion
+//#region node_modules/@noble/curves/abstract/modular.js
+var B = /* @__PURE__ */ BigInt(0), V = /* @__PURE__ */ BigInt(1), H = /* @__PURE__ */ BigInt(2), _e = /* @__PURE__ */ BigInt(3), ve = /* @__PURE__ */ BigInt(4), ye = /* @__PURE__ */ BigInt(5), be = /* @__PURE__ */ BigInt(7), xe = /* @__PURE__ */ BigInt(8), Se = /* @__PURE__ */ BigInt(9), Ce = /* @__PURE__ */ BigInt(16);
+function U(e, t) {
+	if (t <= B) throw Error("mod: expected positive modulus, got " + t);
+	let n = e % t;
+	return n >= B ? n : t + n;
+}
+function W(e, t, n) {
+	if (t < B) throw Error("pow2: expected non-negative exponent, got " + t);
+	let r = e;
+	for (; t-- > B;) r *= r, r %= n;
+	return r;
 }
 function we(e, t) {
-  return Mt(e, t).reverse();
-}
-function en(e) {
-  return Uint8Array.from(e);
-}
-const Et = (e) => typeof e == "bigint" && Vt <= e;
-function nn(e, t, r) {
-  return Et(e) && Et(t) && Et(r) && t <= e && e < r;
-}
-function rn(e, t, r, n) {
-  if (!nn(t, r, n))
-    throw new Error("expected valid " + e + ": " + r + " <= n < " + n + ", got " + t);
-}
-function sn(e) {
-  let t;
-  for (t = 0; e > Vt; e >>= $t, t += 1)
-    ;
-  return t;
-}
-const Yt = (e) => ($t << BigInt(e)) - $t;
-function on(e, t, r) {
-  if (at(e, "hashLen"), at(t, "qByteLen"), typeof r != "function")
-    throw new Error("hmacFn must be a function");
-  const n = (I) => new Uint8Array(I), s = Uint8Array.of(), o = Uint8Array.of(0), i = Uint8Array.of(1), c = 1e3;
-  let f = n(e), u = n(e), h = 0;
-  const d = () => {
-    f.fill(1), u.fill(0), h = 0;
-  }, x = (...I) => r(u, it(f, ...I)), g = (I = s) => {
-    u = x(o, I), f = x(), I.length !== 0 && (u = x(i, I), f = x());
-  }, y = () => {
-    if (h++ >= c)
-      throw new Error("drbg: tried max amount of iterations");
-    let I = 0;
-    const O = [];
-    for (; I < t; ) {
-      f = x();
-      const j = f.slice();
-      O.push(j), I += f.length;
-    }
-    return it(...O);
-  };
-  return (I, O) => {
-    d(), g(I);
-    let j;
-    for (; !(j = O(y())); )
-      g();
-    return d(), j;
-  };
-}
-function jt(e, t = {}, r = {}) {
-  if (!e || typeof e != "object")
-    throw new Error("expected valid options object");
-  function n(o, i, c) {
-    const f = e[o];
-    if (c && f === void 0)
-      return;
-    const u = typeof f;
-    if (u !== i || f === null)
-      throw new Error(`param "${o}" is invalid: expected ${i}, got ${u}`);
-  }
-  const s = (o, i) => Object.entries(o).forEach(([c, f]) => n(c, f, i));
-  s(t, !1), s(r, !0);
-}
-function Pt(e) {
-  const t = /* @__PURE__ */ new WeakMap();
-  return (r, ...n) => {
-    const s = t.get(r);
-    if (s !== void 0)
-      return s;
-    const o = e(r, ...n);
-    return t.set(r, o), o;
-  };
-}
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-const Y = /* @__PURE__ */ BigInt(0), M = /* @__PURE__ */ BigInt(1), ft = /* @__PURE__ */ BigInt(2), be = /* @__PURE__ */ BigInt(3), pe = /* @__PURE__ */ BigInt(4), ye = /* @__PURE__ */ BigInt(5), cn = /* @__PURE__ */ BigInt(7), xe = /* @__PURE__ */ BigInt(8), fn = /* @__PURE__ */ BigInt(9), me = /* @__PURE__ */ BigInt(16);
-function F(e, t) {
-  const r = e % t;
-  return r >= Y ? r : t + r;
-}
-function X(e, t, r) {
-  let n = e;
-  for (; t-- > Y; )
-    n *= n, n %= r;
-  return n;
-}
-function Qt(e, t) {
-  if (e === Y)
-    throw new Error("invert: expected non-zero number");
-  if (t <= Y)
-    throw new Error("invert: expected positive modulus, got " + t);
-  let r = F(e, t), n = t, s = Y, o = M;
-  for (; r !== Y; ) {
-    const c = n / r, f = n % r, u = s - o * c;
-    n = r, r = f, s = o, o = u;
-  }
-  if (n !== M)
-    throw new Error("invert: does not exist");
-  return F(s, t);
-}
-function Kt(e, t, r) {
-  if (!e.eql(e.sqr(t), r))
-    throw new Error("Cannot find square root");
+	if (e === B) throw Error("invert: expected non-zero number");
+	if (t <= B) throw Error("invert: expected positive modulus, got " + t);
+	let n = U(e, t), r = t, i = B, a = V, o = V, s = B;
+	for (; n !== B;) {
+		let e = r / n, t = r - n * e, c = i - o * e, l = a - s * e;
+		r = n, n = t, i = o, a = s, o = c, s = l;
+	}
+	if (r !== V) throw Error("invert: does not exist");
+	return U(i, t);
+}
+function Te(e, t, n) {
+	let r = e;
+	if (!r.eql(r.sqr(t), n)) throw Error("Cannot find square root");
 }
 function Ee(e, t) {
-  const r = (e.ORDER + M) / pe, n = e.pow(t, r);
-  return Kt(e, n, t), n;
-}
-function un(e, t) {
-  const r = (e.ORDER - ye) / xe, n = e.mul(t, ft), s = e.pow(n, r), o = e.mul(t, s), i = e.mul(e.mul(o, ft), s), c = e.mul(o, e.sub(i, e.ONE));
-  return Kt(e, c, t), c;
-}
-function an(e) {
-  const t = St(e), r = Be(e), n = r(t, t.neg(t.ONE)), s = r(t, n), o = r(t, t.neg(n)), i = (e + cn) / me;
-  return (c, f) => {
-    let u = c.pow(f, i), h = c.mul(u, n);
-    const d = c.mul(u, s), x = c.mul(u, o), g = c.eql(c.sqr(h), f), y = c.eql(c.sqr(d), f);
-    u = c.cmov(u, h, g), h = c.cmov(x, d, y);
-    const U = c.eql(c.sqr(h), f), I = c.cmov(u, h, U);
-    return Kt(c, I, f), I;
-  };
+	let n = e, r = (n.ORDER + V) / ve, i = n.pow(t, r);
+	return Te(n, i, t), i;
 }
-function Be(e) {
-  if (e < be)
-    throw new Error("sqrt is not defined for small field");
-  let t = e - M, r = 0;
-  for (; t % ft === Y; )
-    t /= ft, r++;
-  let n = ft;
-  const s = St(e);
-  for (; Jt(s, n) === 1; )
-    if (n++ > 1e3)
-      throw new Error("Cannot find square root: probably non-prime P");
-  if (r === 1)
-    return Ee;
-  let o = s.pow(n, t);
-  const i = (t + M) / ft;
-  return function(f, u) {
-    if (f.is0(u))
-      return u;
-    if (Jt(f, u) !== 1)
-      throw new Error("Cannot find square root");
-    let h = r, d = f.mul(f.ONE, o), x = f.pow(u, t), g = f.pow(u, i);
-    for (; !f.eql(x, f.ONE); ) {
-      if (f.is0(x))
-        return f.ZERO;
-      let y = 1, U = f.sqr(x);
-      for (; !f.eql(U, f.ONE); )
-        if (y++, U = f.sqr(U), y === h)
-          throw new Error("Cannot find square root");
-      const I = M << BigInt(h - y - 1), O = f.pow(d, I);
-      h = y, d = f.sqr(O), x = f.mul(x, d), g = f.mul(g, O);
-    }
-    return g;
-  };
-}
-function ln(e) {
-  return e % pe === be ? Ee : e % xe === ye ? un : e % me === fn ? an(e) : Be(e);
-}
-const dn = [
-  "create",
-  "isValid",
-  "is0",
-  "neg",
-  "inv",
-  "sqrt",
-  "sqr",
-  "eql",
-  "add",
-  "sub",
-  "mul",
-  "pow",
-  "div",
-  "addN",
-  "subN",
-  "mulN",
-  "sqrN"
-];
-function hn(e) {
-  const t = {
-    ORDER: "bigint",
-    BYTES: "number",
-    BITS: "number"
-  }, r = dn.reduce((n, s) => (n[s] = "function", n), t);
-  return jt(e, r), e;
-}
-function gn(e, t, r) {
-  if (r < Y)
-    throw new Error("invalid exponent, negatives unsupported");
-  if (r === Y)
-    return e.ONE;
-  if (r === M)
-    return t;
-  let n = e.ONE, s = t;
-  for (; r > Y; )
-    r & M && (n = e.mul(n, s)), s = e.sqr(s), r >>= M;
-  return n;
-}
-function ve(e, t, r = !1) {
-  const n = new Array(t.length).fill(r ? e.ZERO : void 0), s = t.reduce((i, c, f) => e.is0(c) ? i : (n[f] = i, e.mul(i, c)), e.ONE), o = e.inv(s);
-  return t.reduceRight((i, c, f) => e.is0(c) ? i : (n[f] = e.mul(i, n[f]), e.mul(i, c)), o), n;
-}
-function Jt(e, t) {
-  const r = (e.ORDER - M) / ft, n = e.pow(t, r), s = e.eql(n, e.ONE), o = e.eql(n, e.ZERO), i = e.eql(n, e.neg(e.ONE));
-  if (!s && !o && !i)
-    throw new Error("invalid Legendre symbol result");
-  return s ? 1 : o ? 0 : -1;
-}
-function wn(e, t) {
-  t !== void 0 && at(t);
-  const r = t !== void 0 ? t : e.toString(2).length, n = Math.ceil(r / 8);
-  return { nBitLength: r, nByteLength: n };
-}
-class bn {
-  constructor(t, r = {}) {
-    m(this, "ORDER");
-    m(this, "BITS");
-    m(this, "BYTES");
-    m(this, "isLE");
-    m(this, "ZERO", Y);
-    m(this, "ONE", M);
-    m(this, "_lengths");
-    m(this, "_sqrt");
-    // cached sqrt
-    m(this, "_mod");
-    var i;
-    if (t <= Y)
-      throw new Error("invalid field: expected ORDER > 0, got " + t);
-    let n;
-    this.isLE = !1, r != null && typeof r == "object" && (typeof r.BITS == "number" && (n = r.BITS), typeof r.sqrt == "function" && (this.sqrt = r.sqrt), typeof r.isLE == "boolean" && (this.isLE = r.isLE), r.allowedLengths && (this._lengths = (i = r.allowedLengths) == null ? void 0 : i.slice()), typeof r.modFromBytes == "boolean" && (this._mod = r.modFromBytes));
-    const { nBitLength: s, nByteLength: o } = wn(t, n);
-    if (o > 2048)
-      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
-    this.ORDER = t, this.BITS = s, this.BYTES = o, this._sqrt = void 0, Object.preventExtensions(this);
-  }
-  create(t) {
-    return F(t, this.ORDER);
-  }
-  isValid(t) {
-    if (typeof t != "bigint")
-      throw new Error("invalid field element: expected bigint, got " + typeof t);
-    return Y <= t && t < this.ORDER;
-  }
-  is0(t) {
-    return t === Y;
-  }
-  // is valid and invertible
-  isValidNot0(t) {
-    return !this.is0(t) && this.isValid(t);
-  }
-  isOdd(t) {
-    return (t & M) === M;
-  }
-  neg(t) {
-    return F(-t, this.ORDER);
-  }
-  eql(t, r) {
-    return t === r;
-  }
-  sqr(t) {
-    return F(t * t, this.ORDER);
-  }
-  add(t, r) {
-    return F(t + r, this.ORDER);
-  }
-  sub(t, r) {
-    return F(t - r, this.ORDER);
-  }
-  mul(t, r) {
-    return F(t * r, this.ORDER);
-  }
-  pow(t, r) {
-    return gn(this, t, r);
-  }
-  div(t, r) {
-    return F(t * Qt(r, this.ORDER), this.ORDER);
-  }
-  // Same as above, but doesn't normalize
-  sqrN(t) {
-    return t * t;
-  }
-  addN(t, r) {
-    return t + r;
-  }
-  subN(t, r) {
-    return t - r;
-  }
-  mulN(t, r) {
-    return t * r;
-  }
-  inv(t) {
-    return Qt(t, this.ORDER);
-  }
-  sqrt(t) {
-    return this._sqrt || (this._sqrt = ln(this.ORDER)), this._sqrt(this, t);
-  }
-  toBytes(t) {
-    return this.isLE ? we(t, this.BYTES) : Mt(t, this.BYTES);
-  }
-  fromBytes(t, r = !1) {
-    N(t);
-    const { _lengths: n, BYTES: s, isLE: o, ORDER: i, _mod: c } = this;
-    if (n) {
-      if (!n.includes(t.length) || t.length > s)
-        throw new Error("Field.fromBytes: expected " + n + " bytes, got " + t.length);
-      const u = new Uint8Array(s);
-      u.set(t, o ? 0 : u.length - t.length), t = u;
-    }
-    if (t.length !== s)
-      throw new Error("Field.fromBytes: expected " + s + " bytes, got " + t.length);
-    let f = o ? ge(t) : Ut(t);
-    if (c && (f = F(f, i)), !r && !this.isValid(f))
-      throw new Error("invalid field element: outside of range 0..ORDER");
-    return f;
-  }
-  // TODO: we don't need it here, move out to separate fn
-  invertBatch(t) {
-    return ve(this, t);
-  }
-  // We can't move this out because Fp6, Fp12 implement it
-  // and it's unclear what to return in there.
-  cmov(t, r, n) {
-    return n ? r : t;
-  }
-}
-function St(e, t = {}) {
-  return new bn(e, t);
-}
-function Re(e) {
-  if (typeof e != "bigint")
-    throw new Error("field order must be bigint");
-  const t = e.toString(2).length;
-  return Math.ceil(t / 8);
+function De(e, t) {
+	let n = e, r = (n.ORDER - ye) / xe, i = n.mul(t, H), a = n.pow(i, r), o = n.mul(t, a), s = n.mul(n.mul(o, H), a), c = n.mul(o, n.sub(s, n.ONE));
+	return Te(n, c, t), c;
+}
+function Oe(e) {
+	let t = G(e), n = ke(e), r = n(t, t.neg(t.ONE)), i = n(t, r), a = n(t, t.neg(r)), o = (e + be) / Ce;
+	return ((e, t) => {
+		let n = e, s = n.pow(t, o), c = n.mul(s, r), l = n.mul(s, i), u = n.mul(s, a), d = n.eql(n.sqr(c), t), f = n.eql(n.sqr(l), t);
+		s = n.cmov(s, c, d), c = n.cmov(u, l, f);
+		let p = n.eql(n.sqr(c), t), m = n.cmov(s, c, p);
+		return Te(n, m, t), m;
+	});
+}
+function ke(e) {
+	if (e < _e) throw Error("sqrt is not defined for small field");
+	let t = e - V, n = 0;
+	for (; t % H === B;) t /= H, n++;
+	let r = H, i = G(e);
+	for (; Fe(i, r) === 1;) if (r++ > 1e3) throw Error("Cannot find square root: probably non-prime P");
+	if (n === 1) return Ee;
+	let a = i.pow(r, t), o = (t + V) / H;
+	return function(e, r) {
+		let i = e;
+		if (i.is0(r)) return r;
+		if (Fe(i, r) !== 1) throw Error("Cannot find square root");
+		let s = n, c = i.mul(i.ONE, a), l = i.pow(r, t), u = i.pow(r, o);
+		for (; !i.eql(l, i.ONE);) {
+			if (i.is0(l)) return i.ZERO;
+			let e = 1, t = i.sqr(l);
+			for (; !i.eql(t, i.ONE);) if (e++, t = i.sqr(t), e === s) throw Error("Cannot find square root");
+			let n = V << BigInt(s - e - 1), r = i.pow(c, n);
+			s = e, c = i.sqr(r), l = i.mul(l, c), u = i.mul(u, r);
+		}
+		return u;
+	};
 }
 function Ae(e) {
-  const t = Re(e);
-  return t + Math.ceil(t / 2);
-}
-function pn(e, t, r = !1) {
-  N(e);
-  const n = e.length, s = Re(t), o = Ae(t);
-  if (n < 16 || n < o || n > 1024)
-    throw new Error("expected " + o + "-1024 bytes of input, got " + n);
-  const i = r ? ge(e) : Ut(e), c = F(i, t - M) + M;
-  return r ? we(c, s) : Mt(c, s);
-}
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-const dt = /* @__PURE__ */ BigInt(0), ut = /* @__PURE__ */ BigInt(1);
-function It(e, t) {
-  const r = t.negate();
-  return e ? r : t;
-}
-function te(e, t) {
-  const r = ve(e.Fp, t.map((n) => n.Z));
-  return t.map((n, s) => e.fromAffine(n.toAffine(r[s])));
+	return e % ve === _e ? Ee : e % xe === ye ? De : e % Ce === Se ? Oe(e) : ke(e);
+}
+var je = [
+	"create",
+	"isValid",
+	"is0",
+	"neg",
+	"inv",
+	"sqrt",
+	"sqr",
+	"eql",
+	"add",
+	"sub",
+	"mul",
+	"pow",
+	"div",
+	"addN",
+	"subN",
+	"mulN",
+	"sqrN"
+];
+function Me(e) {
+	if (z(e, je.reduce((e, t) => (e[t] = "function", e), {
+		ORDER: "bigint",
+		BYTES: "number",
+		BITS: "number"
+	})), oe(e.BYTES, "BYTES"), oe(e.BITS, "BITS"), e.BYTES < 1 || e.BITS < 1) throw Error("invalid field: expected BYTES/BITS > 0");
+	if (e.ORDER <= V) throw Error("invalid field: expected ORDER > 1, got " + e.ORDER);
+	return e;
+}
+function Ne(e, t, n) {
+	let r = e;
+	if (n < B) throw Error("invalid exponent, negatives unsupported");
+	if (n === B) return r.ONE;
+	if (n === V) return t;
+	let i = r.ONE, a = t;
+	for (; n > B;) n & V && (i = r.mul(i, a)), a = r.sqr(a), n >>= V;
+	return i;
+}
+function Pe(e, t, n = !1) {
+	let r = e, i = Array(t.length).fill(n ? r.ZERO : void 0), a = t.reduce((e, t, n) => r.is0(t) ? e : (i[n] = e, r.mul(e, t)), r.ONE), o = r.inv(a);
+	return t.reduceRight((e, t, n) => r.is0(t) ? e : (i[n] = r.mul(e, i[n]), r.mul(e, t)), o), i;
+}
+function Fe(e, t) {
+	let n = e, r = (n.ORDER - V) / H, i = n.pow(t, r), a = n.eql(i, n.ONE), o = n.eql(i, n.ZERO), s = n.eql(i, n.neg(n.ONE));
+	if (!a && !o && !s) throw Error("invalid Legendre symbol result");
+	return a ? 1 : o ? 0 : -1;
 }
 function Ie(e, t) {
-  if (!Number.isSafeInteger(e) || e <= 0 || e > t)
-    throw new Error("invalid window size, expected [1.." + t + "], got W=" + e);
-}
-function Ht(e, t) {
-  Ie(e, t);
-  const r = Math.ceil(t / e) + 1, n = 2 ** (e - 1), s = 2 ** e, o = Yt(e), i = BigInt(e);
-  return { windows: r, windowSize: n, mask: o, maxNumber: s, shiftBy: i };
-}
-function ee(e, t, r) {
-  const { windowSize: n, mask: s, maxNumber: o, shiftBy: i } = r;
-  let c = Number(e & s), f = e >> i;
-  c > n && (c -= o, f += ut);
-  const u = t * n, h = u + Math.abs(c) - 1, d = c === 0, x = c < 0, g = t % 2 !== 0;
-  return { nextN: f, offset: h, isZero: d, isNeg: x, isNegF: g, offsetF: u };
-}
-const qt = /* @__PURE__ */ new WeakMap(), Le = /* @__PURE__ */ new WeakMap();
-function Nt(e) {
-  return Le.get(e) || 1;
-}
-function ne(e) {
-  if (e !== dt)
-    throw new Error("invalid wNAF");
-}
-class yn {
-  // Parametrized with a given Point class (not individual point)
-  constructor(t, r) {
-    m(this, "BASE");
-    m(this, "ZERO");
-    m(this, "Fn");
-    m(this, "bits");
-    this.BASE = t.BASE, this.ZERO = t.ZERO, this.Fn = t.Fn, this.bits = r;
-  }
-  // non-const time multiplication ladder
-  _unsafeLadder(t, r, n = this.ZERO) {
-    let s = t;
-    for (; r > dt; )
-      r & ut && (n = n.add(s)), s = s.double(), r >>= ut;
-    return n;
-  }
-  /**
-   * Creates a wNAF precomputation window. Used for caching.
-   * Default window size is set by `utils.precompute()` and is equal to 8.
-   * Number of precomputed points depends on the curve size:
-   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
-   * - 𝑊 is the window size
-   * - 𝑛 is the bitlength of the curve order.
-   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
-   * @param point Point instance
-   * @param W window size
-   * @returns precomputed point tables flattened to a single array
-   */
-  precomputeWindow(t, r) {
-    const { windows: n, windowSize: s } = Ht(r, this.bits), o = [];
-    let i = t, c = i;
-    for (let f = 0; f < n; f++) {
-      c = i, o.push(c);
-      for (let u = 1; u < s; u++)
-        c = c.add(i), o.push(c);
-      i = c.double();
-    }
-    return o;
-  }
-  /**
-   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
-   * More compact implementation:
-   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
-   * @returns real and fake (for const-time) points
-   */
-  wNAF(t, r, n) {
-    if (!this.Fn.isValid(n))
-      throw new Error("invalid scalar");
-    let s = this.ZERO, o = this.BASE;
-    const i = Ht(t, this.bits);
-    for (let c = 0; c < i.windows; c++) {
-      const { nextN: f, offset: u, isZero: h, isNeg: d, isNegF: x, offsetF: g } = ee(n, c, i);
-      n = f, h ? o = o.add(It(x, r[g])) : s = s.add(It(d, r[u]));
-    }
-    return ne(n), { p: s, f: o };
-  }
-  /**
-   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
-   * @param acc accumulator point to add result of multiplication
-   * @returns point
-   */
-  wNAFUnsafe(t, r, n, s = this.ZERO) {
-    const o = Ht(t, this.bits);
-    for (let i = 0; i < o.windows && n !== dt; i++) {
-      const { nextN: c, offset: f, isZero: u, isNeg: h } = ee(n, i, o);
-      if (n = c, !u) {
-        const d = r[f];
-        s = s.add(h ? d.negate() : d);
-      }
-    }
-    return ne(n), s;
-  }
-  getPrecomputes(t, r, n) {
-    let s = qt.get(r);
-    return s || (s = this.precomputeWindow(r, t), t !== 1 && (typeof n == "function" && (s = n(s)), qt.set(r, s))), s;
-  }
-  cached(t, r, n) {
-    const s = Nt(t);
-    return this.wNAF(s, this.getPrecomputes(s, t, n), r);
-  }
-  unsafe(t, r, n, s) {
-    const o = Nt(t);
-    return o === 1 ? this._unsafeLadder(t, r, s) : this.wNAFUnsafe(o, this.getPrecomputes(o, t, n), r, s);
-  }
-  // We calculate precomputes for elliptic curve point multiplication
-  // using windowed method. This specifies window size and
-  // stores precomputed values. Usually only base point would be precomputed.
-  createCache(t, r) {
-    Ie(r, this.bits), Le.set(t, r), qt.delete(t);
-  }
-  hasCache(t) {
-    return Nt(t) !== 1;
-  }
-}
-function xn(e, t, r, n) {
-  let s = t, o = e.ZERO, i = e.ZERO;
-  for (; r > dt || n > dt; )
-    r & ut && (o = o.add(s)), n & ut && (i = i.add(s)), s = s.double(), r >>= ut, n >>= ut;
-  return { p1: o, p2: i };
-}
-function re(e, t, r) {
-  if (t) {
-    if (t.ORDER !== e)
-      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
-    return hn(t), t;
-  } else
-    return St(e, { isLE: r });
-}
-function mn(e, t, r = {}, n) {
-  if (n === void 0 && (n = e === "edwards"), !t || typeof t != "object")
-    throw new Error(`expected valid ${e} CURVE object`);
-  for (const f of ["p", "n", "h"]) {
-    const u = t[f];
-    if (!(typeof u == "bigint" && u > dt))
-      throw new Error(`CURVE.${f} must be positive bigint`);
-  }
-  const s = re(t.p, r.Fp, n), o = re(t.n, r.Fn, n), c = ["Gx", "Gy", "a", "b"];
-  for (const f of c)
-    if (!s.isValid(t[f]))
-      throw new Error(`CURVE.${f} must be valid field element of CURVE.Fp`);
-  return t = Object.freeze(Object.assign({}, t)), { CURVE: t, Fp: s, Fn: o };
-}
-function En(e, t) {
-  return function(n) {
-    const s = e(n);
-    return { secretKey: s, publicKey: t(s) };
-  };
-}
-class Ue {
-  constructor(t, r) {
-    m(this, "oHash");
-    m(this, "iHash");
-    m(this, "blockLen");
-    m(this, "outputLen");
-    m(this, "finished", !1);
-    m(this, "destroyed", !1);
-    if (ue(t), N(r, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function")
-      throw new Error("Expected instance of class which extends utils.Hash");
-    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
-    const n = this.blockLen, s = new Uint8Array(n);
-    s.set(r.length > n ? t.create().update(r).digest() : r);
-    for (let o = 0; o < s.length; o++)
-      s[o] ^= 54;
-    this.iHash.update(s), this.oHash = t.create();
-    for (let o = 0; o < s.length; o++)
-      s[o] ^= 106;
-    this.oHash.update(s), vt(s);
-  }
-  update(t) {
-    return Bt(this), this.iHash.update(t), this;
-  }
-  digestInto(t) {
-    Bt(this), N(t, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
-  }
-  digest() {
-    const t = new Uint8Array(this.oHash.outputLen);
-    return this.digestInto(t), t;
-  }
-  _cloneInto(t) {
-    t || (t = Object.create(Object.getPrototypeOf(this), {}));
-    const { oHash: r, iHash: n, finished: s, destroyed: o, blockLen: i, outputLen: c } = this;
-    return t = t, t.finished = s, t.destroyed = o, t.blockLen = i, t.outputLen = c, t.oHash = r._cloneInto(t.oHash), t.iHash = n._cloneInto(t.iHash), t;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  destroy() {
-    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
-  }
-}
-const Se = (e, t, r) => new Ue(e, t).update(r).digest();
-Se.create = (e, t) => new Ue(e, t);
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-const se = (e, t) => (e + (e >= 0 ? t : -t) / _e) / t;
-function Bn(e, t, r) {
-  const [[n, s], [o, i]] = t, c = se(i * e, r), f = se(-s * e, r);
-  let u = e - c * n - f * o, h = -c * s - f * i;
-  const d = u < tt, x = h < tt;
-  d && (u = -u), x && (h = -h);
-  const g = Yt(Math.ceil(sn(r) / 2)) + lt;
-  if (u < tt || u >= g || h < tt || h >= g)
-    throw new Error("splitScalar (endomorphism): failed, k=" + e);
-  return { k1neg: d, k1: u, k2neg: x, k2: h };
-}
-function Zt(e) {
-  if (!["compact", "recovered", "der"].includes(e))
-    throw new Error('Signature format must be "compact", "recovered", or "der"');
-  return e;
-}
-function kt(e, t) {
-  const r = {};
-  for (let n of Object.keys(t))
-    r[n] = e[n] === void 0 ? t[n] : e[n];
-  return At(r.lowS, "lowS"), At(r.prehash, "prehash"), r.format !== void 0 && Zt(r.format), r;
-}
-class vn extends Error {
-  constructor(t = "") {
-    super(t);
-  }
-}
-const ot = {
-  // asn.1 DER encoding utils
-  Err: vn,
-  // Basic building block is TLV (Tag-Length-Value)
-  _tlv: {
-    encode: (e, t) => {
-      const { Err: r } = ot;
-      if (e < 0 || e > 256)
-        throw new r("tlv.encode: wrong tag");
-      if (t.length & 1)
-        throw new r("tlv.encode: unpadded data");
-      const n = t.length / 2, s = pt(n);
-      if (s.length / 2 & 128)
-        throw new r("tlv.encode: long form length too big");
-      const o = n > 127 ? pt(s.length / 2 | 128) : "";
-      return pt(e) + o + s + t;
-    },
-    // v - value, l - left bytes (unparsed)
-    decode(e, t) {
-      const { Err: r } = ot;
-      let n = 0;
-      if (e < 0 || e > 256)
-        throw new r("tlv.encode: wrong tag");
-      if (t.length < 2 || t[n++] !== e)
-        throw new r("tlv.decode: wrong tlv");
-      const s = t[n++], o = !!(s & 128);
-      let i = 0;
-      if (!o)
-        i = s;
-      else {
-        const f = s & 127;
-        if (!f)
-          throw new r("tlv.decode(long): indefinite length not supported");
-        if (f > 4)
-          throw new r("tlv.decode(long): byte length is too big");
-        const u = t.subarray(n, n + f);
-        if (u.length !== f)
-          throw new r("tlv.decode: length bytes not complete");
-        if (u[0] === 0)
-          throw new r("tlv.decode(long): zero leftmost byte");
-        for (const h of u)
-          i = i << 8 | h;
-        if (n += f, i < 128)
-          throw new r("tlv.decode(long): not minimal encoding");
-      }
-      const c = t.subarray(n, n + i);
-      if (c.length !== i)
-        throw new r("tlv.decode: wrong value length");
-      return { v: c, l: t.subarray(n + i) };
-    }
-  },
-  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
-  // since we always use positive integers here. It must always be empty:
-  // - add zero byte if exists
-  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
-  _int: {
-    encode(e) {
-      const { Err: t } = ot;
-      if (e < tt)
-        throw new t("integer: negative integers are not allowed");
-      let r = pt(e);
-      if (Number.parseInt(r[0], 16) & 8 && (r = "00" + r), r.length & 1)
-        throw new t("unexpected DER parsing assertion: unpadded hex");
-      return r;
-    },
-    decode(e) {
-      const { Err: t } = ot;
-      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 Ut(e);
-    }
-  },
-  toSig(e) {
-    const { Err: t, _int: r, _tlv: n } = ot, s = N(e, void 0, "signature"), { v: o, l: i } = n.decode(48, s);
-    if (i.length)
-      throw new t("invalid signature: left bytes after parsing");
-    const { v: c, l: f } = n.decode(2, o), { v: u, l: h } = n.decode(2, f);
-    if (h.length)
-      throw new t("invalid signature: left bytes after parsing");
-    return { r: r.decode(c), s: r.decode(u) };
-  },
-  hexFromSig(e) {
-    const { _tlv: t, _int: r } = ot, n = t.encode(2, r.encode(e.r)), s = t.encode(2, r.encode(e.s)), o = n + s;
-    return t.encode(48, o);
-  }
-}, tt = BigInt(0), lt = BigInt(1), _e = BigInt(2), yt = BigInt(3), Rn = BigInt(4);
-function An(e, t = {}) {
-  const r = mn("weierstrass", e, t), { Fp: n, Fn: s } = r;
-  let o = r.CURVE;
-  const { h: i, n: c } = o;
-  jt(t, {}, {
-    allowInfinityPoint: "boolean",
-    clearCofactor: "function",
-    isTorsionFree: "function",
-    fromBytes: "function",
-    toBytes: "function",
-    endo: "object"
-  });
-  const { endo: f } = t;
-  if (f && (!n.is0(o.a) || typeof f.beta != "bigint" || !Array.isArray(f.basises)))
-    throw new Error('invalid endo: expected "beta": bigint and "basises": array');
-  const u = He(n, s);
-  function h() {
-    if (!n.isOdd)
-      throw new Error("compression is not supported: Field does not have .isOdd()");
-  }
-  function d(S, l, a) {
-    const { x: w, y: p } = l.toAffine(), B = n.toBytes(w);
-    if (At(a, "isCompressed"), a) {
-      h();
-      const E = !n.isOdd(p);
-      return it(Oe(E), B);
-    } else
-      return it(Uint8Array.of(4), B, n.toBytes(p));
-  }
-  function x(S) {
-    N(S, void 0, "Point");
-    const { publicKey: l, publicKeyUncompressed: a } = u, w = S.length, p = S[0], B = S.subarray(1);
-    if (w === l && (p === 2 || p === 3)) {
-      const E = n.fromBytes(B);
-      if (!n.isValid(E))
-        throw new Error("bad point: is not on curve, wrong x");
-      const v = U(E);
-      let b;
-      try {
-        b = n.sqrt(v);
-      } catch (k) {
-        const H = k instanceof Error ? ": " + k.message : "";
-        throw new Error("bad point: is not on curve, sqrt error" + H);
-      }
-      h();
-      const R = n.isOdd(b);
-      return (p & 1) === 1 !== R && (b = n.neg(b)), { x: E, y: b };
-    } else if (w === a && p === 4) {
-      const E = n.BYTES, v = n.fromBytes(B.subarray(0, E)), b = n.fromBytes(B.subarray(E, E * 2));
-      if (!I(v, b))
-        throw new Error("bad point: is not on curve");
-      return { x: v, y: b };
-    } else
-      throw new Error(`bad point: got length ${w}, expected compressed=${l} or uncompressed=${a}`);
-  }
-  const g = t.toBytes || d, y = t.fromBytes || x;
-  function U(S) {
-    const l = n.sqr(S), a = n.mul(l, S);
-    return n.add(n.add(a, n.mul(S, o.a)), o.b);
-  }
-  function I(S, l) {
-    const a = n.sqr(l), w = U(S);
-    return n.eql(a, w);
-  }
-  if (!I(o.Gx, o.Gy))
-    throw new Error("bad curve params: generator point");
-  const O = n.mul(n.pow(o.a, yt), Rn), j = n.mul(n.sqr(o.b), BigInt(27));
-  if (n.is0(n.add(O, j)))
-    throw new Error("bad curve params: a or b");
-  function W(S, l, a = !1) {
-    if (!n.isValid(l) || a && n.is0(l))
-      throw new Error(`bad point coordinate ${S}`);
-    return l;
-  }
-  function Z(S) {
-    if (!(S instanceof z))
-      throw new Error("Weierstrass Point expected");
-  }
-  function D(S) {
-    if (!f || !f.basises)
-      throw new Error("no endo");
-    return Bn(S, f.basises, s.ORDER);
-  }
-  const G = Pt((S, l) => {
-    const { X: a, Y: w, Z: p } = S;
-    if (n.eql(p, n.ONE))
-      return { x: a, y: w };
-    const B = S.is0();
-    l == null && (l = B ? n.ONE : n.inv(p));
-    const E = n.mul(a, l), v = n.mul(w, l), b = n.mul(p, l);
-    if (B)
-      return { x: n.ZERO, y: n.ZERO };
-    if (!n.eql(b, n.ONE))
-      throw new Error("invZ was invalid");
-    return { x: E, y: v };
-  }), _t = Pt((S) => {
-    if (S.is0()) {
-      if (t.allowInfinityPoint && !n.is0(S.Y))
-        return;
-      throw new Error("bad point: ZERO");
-    }
-    const { x: l, y: a } = S.toAffine();
-    if (!n.isValid(l) || !n.isValid(a))
-      throw new Error("bad point: x or y not field elements");
-    if (!I(l, a))
-      throw new Error("bad point: equation left != right");
-    if (!S.isTorsionFree())
-      throw new Error("bad point: not in prime-order subgroup");
-    return !0;
-  });
-  function ht(S, l, a, w, p) {
-    return a = new z(n.mul(a.X, S), a.Y, a.Z), l = It(w, l), a = It(p, a), l.add(a);
-  }
-  const _ = class _ {
-    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
-    constructor(l, a, w) {
-      m(this, "X");
-      m(this, "Y");
-      m(this, "Z");
-      this.X = W("x", l), this.Y = W("y", a, !0), this.Z = W("z", w), Object.freeze(this);
-    }
-    static CURVE() {
-      return o;
-    }
-    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
-    static fromAffine(l) {
-      const { x: a, y: w } = l || {};
-      if (!l || !n.isValid(a) || !n.isValid(w))
-        throw new Error("invalid affine point");
-      if (l instanceof _)
-        throw new Error("projective point not allowed");
-      return n.is0(a) && n.is0(w) ? _.ZERO : new _(a, w, n.ONE);
-    }
-    static fromBytes(l) {
-      const a = _.fromAffine(y(N(l, void 0, "point")));
-      return a.assertValidity(), a;
-    }
-    static fromHex(l) {
-      return _.fromBytes(Rt(l));
-    }
-    get x() {
-      return this.toAffine().x;
-    }
-    get y() {
-      return this.toAffine().y;
-    }
-    /**
-     *
-     * @param windowSize
-     * @param isLazy true will defer table computation until the first multiplication
-     * @returns
-     */
-    precompute(l = 8, a = !0) {
-      return ct.createCache(this, l), a || this.multiply(yt), this;
-    }
-    // TODO: return `this`
-    /** A point on curve is valid if it conforms to equation. */
-    assertValidity() {
-      _t(this);
-    }
-    hasEvenY() {
-      const { y: l } = this.toAffine();
-      if (!n.isOdd)
-        throw new Error("Field doesn't support isOdd");
-      return !n.isOdd(l);
-    }
-    /** Compare one point to another. */
-    equals(l) {
-      Z(l);
-      const { X: a, Y: w, Z: p } = this, { X: B, Y: E, Z: v } = l, b = n.eql(n.mul(a, v), n.mul(B, p)), R = n.eql(n.mul(w, v), n.mul(E, p));
-      return b && R;
-    }
-    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
-    negate() {
-      return new _(this.X, n.neg(this.Y), this.Z);
-    }
-    // Renes-Costello-Batina exception-free doubling formula.
-    // There is 30% faster Jacobian formula, but it is not complete.
-    // https://eprint.iacr.org/2015/1060, algorithm 3
-    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
-    double() {
-      const { a: l, b: a } = o, w = n.mul(a, yt), { X: p, Y: B, Z: E } = this;
-      let v = n.ZERO, b = n.ZERO, R = n.ZERO, L = n.mul(p, p), k = n.mul(B, B), H = n.mul(E, E), A = n.mul(p, B);
-      return A = n.add(A, A), R = n.mul(p, E), R = n.add(R, R), v = n.mul(l, R), b = n.mul(w, H), b = n.add(v, b), v = n.sub(k, b), b = n.add(k, b), b = n.mul(v, b), v = n.mul(A, v), R = n.mul(w, R), H = n.mul(l, H), A = n.sub(L, H), A = n.mul(l, A), A = n.add(A, R), R = n.add(L, L), L = n.add(R, L), L = n.add(L, H), L = n.mul(L, A), b = n.add(b, L), H = n.mul(B, E), H = n.add(H, H), L = n.mul(H, A), v = n.sub(v, L), R = n.mul(H, k), R = n.add(R, R), R = n.add(R, R), new _(v, b, R);
-    }
-    // Renes-Costello-Batina exception-free addition formula.
-    // There is 30% faster Jacobian formula, but it is not complete.
-    // https://eprint.iacr.org/2015/1060, algorithm 1
-    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
-    add(l) {
-      Z(l);
-      const { X: a, Y: w, Z: p } = this, { X: B, Y: E, Z: v } = l;
-      let b = n.ZERO, R = n.ZERO, L = n.ZERO;
-      const k = o.a, H = n.mul(o.b, yt);
-      let A = n.mul(a, B), $ = n.mul(w, E), T = n.mul(p, v), K = n.add(a, w), q = n.add(B, E);
-      K = n.mul(K, q), q = n.add(A, $), K = n.sub(K, q), q = n.add(a, p);
-      let V = n.add(B, v);
-      return q = n.mul(q, V), V = n.add(A, T), q = n.sub(q, V), V = n.add(w, p), b = n.add(E, v), V = n.mul(V, b), b = n.add($, T), V = n.sub(V, b), L = n.mul(k, q), b = n.mul(H, T), L = n.add(b, L), b = n.sub($, L), L = n.add($, L), R = n.mul(b, L), $ = n.add(A, A), $ = n.add($, A), T = n.mul(k, T), q = n.mul(H, q), $ = n.add($, T), T = n.sub(A, T), T = n.mul(k, T), q = n.add(q, T), A = n.mul($, q), R = n.add(R, A), A = n.mul(V, q), b = n.mul(K, b), b = n.sub(b, A), A = n.mul(K, $), L = n.mul(V, L), L = n.add(L, A), new _(b, R, L);
-    }
-    subtract(l) {
-      return this.add(l.negate());
-    }
-    is0() {
-      return this.equals(_.ZERO);
-    }
-    /**
-     * Constant time multiplication.
-     * Uses wNAF method. Windowed method may be 10% faster,
-     * but takes 2x longer to generate and consumes 2x memory.
-     * Uses precomputes when available.
-     * Uses endomorphism for Koblitz curves.
-     * @param scalar by which the point would be multiplied
-     * @returns New point
-     */
-    multiply(l) {
-      const { endo: a } = t;
-      if (!s.isValidNot0(l))
-        throw new Error("invalid scalar: out of range");
-      let w, p;
-      const B = (E) => ct.cached(this, E, (v) => te(_, v));
-      if (a) {
-        const { k1neg: E, k1: v, k2neg: b, k2: R } = D(l), { p: L, f: k } = B(v), { p: H, f: A } = B(R);
-        p = k.add(A), w = ht(a.beta, L, H, E, b);
-      } else {
-        const { p: E, f: v } = B(l);
-        w = E, p = v;
-      }
-      return te(_, [w, p])[0];
-    }
-    /**
-     * Non-constant-time multiplication. Uses double-and-add algorithm.
-     * It's faster, but should only be used when you don't care about
-     * an exposed secret key e.g. sig verification, which works over *public* keys.
-     */
-    multiplyUnsafe(l) {
-      const { endo: a } = t, w = this;
-      if (!s.isValid(l))
-        throw new Error("invalid scalar: out of range");
-      if (l === tt || w.is0())
-        return _.ZERO;
-      if (l === lt)
-        return w;
-      if (ct.hasCache(this))
-        return this.multiply(l);
-      if (a) {
-        const { k1neg: p, k1: B, k2neg: E, k2: v } = D(l), { p1: b, p2: R } = xn(_, w, B, v);
-        return ht(a.beta, b, R, p, E);
-      } else
-        return ct.unsafe(w, l);
-    }
-    /**
-     * Converts Projective point to affine (x, y) coordinates.
-     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
-     */
-    toAffine(l) {
-      return G(this, l);
-    }
-    /**
-     * Checks whether Point is free of torsion elements (is in prime subgroup).
-     * Always torsion-free for cofactor=1 curves.
-     */
-    isTorsionFree() {
-      const { isTorsionFree: l } = t;
-      return i === lt ? !0 : l ? l(_, this) : ct.unsafe(this, c).is0();
-    }
-    clearCofactor() {
-      const { clearCofactor: l } = t;
-      return i === lt ? this : l ? l(_, this) : this.multiplyUnsafe(i);
-    }
-    isSmallOrder() {
-      return this.multiplyUnsafe(i).is0();
-    }
-    toBytes(l = !0) {
-      return At(l, "isCompressed"), this.assertValidity(), g(_, this, l);
-    }
-    toHex(l = !0) {
-      return Lt(this.toBytes(l));
-    }
-    toString() {
-      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
-    }
-  };
-  // base / generator point
-  m(_, "BASE", new _(o.Gx, o.Gy, n.ONE)), // zero / infinity / identity point
-  m(_, "ZERO", new _(n.ZERO, n.ONE, n.ZERO)), // 0, 1, 0
-  // math field
-  m(_, "Fp", n), // scalar field
-  m(_, "Fn", s);
-  let z = _;
-  const bt = s.BITS, ct = new yn(z, t.endo ? Math.ceil(bt / 2) : bt);
-  return z.BASE.precompute(8), z;
+	if (t !== void 0 && A(t), e <= B) throw Error("invalid n length: expected positive n, got " + e);
+	if (t !== void 0 && t < 1) throw Error("invalid n length: expected positive bit length, got " + t);
+	let n = me(e);
+	if (t !== void 0 && t < n) throw Error(`invalid n length: expected bit length (${n}) >= n.length (${t})`);
+	let r = t === void 0 ? n : t;
+	return {
+		nBitLength: r,
+		nByteLength: Math.ceil(r / 8)
+	};
+}
+var Le = /* @__PURE__ */ new WeakMap(), Re = class {
+	ORDER;
+	BITS;
+	BYTES;
+	isLE;
+	ZERO = B;
+	ONE = V;
+	_lengths;
+	_mod;
+	constructor(e, t = {}) {
+		if (e <= V) throw Error("invalid field: expected ORDER > 1, got " + e);
+		let n;
+		this.isLE = !1, typeof t == "object" && t && (typeof t.BITS == "number" && (n = t.BITS), typeof t.sqrt == "function" && Object.defineProperty(this, "sqrt", {
+			value: t.sqrt,
+			enumerable: !0
+		}), typeof t.isLE == "boolean" && (this.isLE = t.isLE), t.allowedLengths && (this._lengths = Object.freeze(t.allowedLengths.slice())), typeof t.modFromBytes == "boolean" && (this._mod = t.modFromBytes));
+		let { nBitLength: r, nByteLength: i } = Ie(e, n);
+		if (i > 2048) throw Error("invalid field: expected ORDER of <= 2048 bytes");
+		this.ORDER = e, this.BITS = r, this.BYTES = i, Object.freeze(this);
+	}
+	create(e) {
+		return U(e, this.ORDER);
+	}
+	isValid(e) {
+		if (typeof e != "bigint") throw TypeError("invalid field element: expected bigint, got " + typeof e);
+		return B <= e && e < this.ORDER;
+	}
+	is0(e) {
+		return e === B;
+	}
+	isValidNot0(e) {
+		return !this.is0(e) && this.isValid(e);
+	}
+	isOdd(e) {
+		return (e & V) === V;
+	}
+	neg(e) {
+		return U(-e, this.ORDER);
+	}
+	eql(e, t) {
+		return e === t;
+	}
+	sqr(e) {
+		return U(e * e, this.ORDER);
+	}
+	add(e, t) {
+		return U(e + t, this.ORDER);
+	}
+	sub(e, t) {
+		return U(e - t, this.ORDER);
+	}
+	mul(e, t) {
+		return U(e * t, this.ORDER);
+	}
+	pow(e, t) {
+		return Ne(this, e, t);
+	}
+	div(e, t) {
+		return U(e * we(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 we(e, this.ORDER);
+	}
+	sqrt(e) {
+		let t = Le.get(this);
+		return t || Le.set(this, t = Ae(this.ORDER)), t(this, e);
+	}
+	toBytes(e) {
+		return this.isLE ? ue(e, this.BYTES) : le(e, this.BYTES);
+	}
+	fromBytes(e, t = !1) {
+		k(e);
+		let { _lengths: n, BYTES: r, isLE: i, ORDER: a, _mod: o } = this;
+		if (n) {
+			if (e.length < 1 || !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 ? ce(e) : L(e);
+		if (o && (s = U(s, a)), !t && !this.isValid(s)) throw Error("invalid field element: outside of range 0..ORDER");
+		return s;
+	}
+	invertBatch(e) {
+		return Pe(this, e);
+	}
+	cmov(e, t, n) {
+		return F(n, "condition"), n ? t : e;
+	}
+};
+Object.freeze(Re.prototype);
+function G(e, t = {}) {
+	return new Re(e, t);
 }
-function Oe(e) {
-  return Uint8Array.of(e ? 2 : 3);
+function ze(e) {
+	if (typeof e != "bigint") throw Error("field order must be bigint");
+	if (e <= V) throw Error("field order must be greater than 1");
+	let t = me(e - V);
+	return Math.ceil(t / 8);
+}
+function Be(e) {
+	let t = ze(e);
+	return t + Math.ceil(t / 2);
+}
+function Ve(e, t, n = !1) {
+	k(e);
+	let r = e.length, i = ze(t), a = Math.max(Be(t), 16);
+	if (r < a || r > 1024) throw Error("expected " + a + "-1024 bytes of input, got " + r);
+	let o = U(n ? ce(e) : L(e), t - V) + V;
+	return n ? ue(o, i) : le(o, i);
+}
+//#endregion
+//#region node_modules/@noble/curves/abstract/curve.js
+var K = /* @__PURE__ */ BigInt(0), q = /* @__PURE__ */ BigInt(1);
+function J(e, t) {
+	let n = t.negate();
+	return e ? n : t;
 }
 function He(e, t) {
-  return {
-    secretKey: t.BYTES,
-    publicKey: 1 + e.BYTES,
-    publicKeyUncompressed: 1 + 2 * e.BYTES,
-    publicKeyHasPrefix: !0,
-    signature: 2 * t.BYTES
-  };
-}
-function In(e, t = {}) {
-  const { Fn: r } = e, n = t.randomBytes || le, s = Object.assign(He(e.Fp, r), { seed: Ae(r.ORDER) });
-  function o(g) {
-    try {
-      const y = r.fromBytes(g);
-      return r.isValidNot0(y);
-    } catch {
-      return !1;
-    }
-  }
-  function i(g, y) {
-    const { publicKey: U, publicKeyUncompressed: I } = s;
-    try {
-      const O = g.length;
-      return y === !0 && O !== U || y === !1 && O !== I ? !1 : !!e.fromBytes(g);
-    } catch {
-      return !1;
-    }
-  }
-  function c(g = n(s.seed)) {
-    return pn(N(g, s.seed, "seed"), r.ORDER);
-  }
-  function f(g, y = !0) {
-    return e.BASE.multiply(r.fromBytes(g)).toBytes(y);
-  }
-  function u(g) {
-    const { secretKey: y, publicKey: U, publicKeyUncompressed: I } = s;
-    if (!Tt(g) || "_lengths" in r && r._lengths || y === U)
-      return;
-    const O = N(g, void 0, "key").length;
-    return O === U || O === I;
-  }
-  function h(g, y, U = !0) {
-    if (u(g) === !0)
-      throw new Error("first arg must be private key");
-    if (u(y) === !1)
-      throw new Error("second arg must be public key");
-    const I = r.fromBytes(g);
-    return e.fromBytes(y).multiply(I).toBytes(U);
-  }
-  const d = {
-    isValidSecretKey: o,
-    isValidPublicKey: i,
-    randomSecretKey: c
-  }, x = En(c, f);
-  return Object.freeze({ getPublicKey: f, getSharedSecret: h, keygen: x, Point: e, utils: d, lengths: s });
-}
-function Ln(e, t, r = {}) {
-  ue(t), jt(r, {}, {
-    hmac: "function",
-    lowS: "boolean",
-    randomBytes: "function",
-    bits2int: "function",
-    bits2int_modN: "function"
-  }), r = Object.assign({}, r);
-  const n = r.randomBytes || le, s = r.hmac || ((l, a) => Se(t, l, a)), { Fp: o, Fn: i } = e, { ORDER: c, BITS: f } = i, { keygen: u, getPublicKey: h, getSharedSecret: d, utils: x, lengths: g } = In(e, r), y = {
-    prehash: !0,
-    lowS: typeof r.lowS == "boolean" ? r.lowS : !0,
-    format: "compact",
-    extraEntropy: !1
-  }, U = c * _e < o.ORDER;
-  function I(l) {
-    const a = c >> lt;
-    return l > a;
-  }
-  function O(l, a) {
-    if (!i.isValidNot0(a))
-      throw new Error(`invalid signature ${l}: out of range 1..Point.Fn.ORDER`);
-    return a;
-  }
-  function j() {
-    if (U)
-      throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
-  }
-  function W(l, a) {
-    Zt(a);
-    const w = g.signature, p = a === "compact" ? w : a === "recovered" ? w + 1 : void 0;
-    return N(l, p);
-  }
-  class Z {
-    constructor(a, w, p) {
-      m(this, "r");
-      m(this, "s");
-      m(this, "recovery");
-      if (this.r = O("r", a), this.s = O("s", w), p != null) {
-        if (j(), ![0, 1, 2, 3].includes(p))
-          throw new Error("invalid recovery id");
-        this.recovery = p;
-      }
-      Object.freeze(this);
-    }
-    static fromBytes(a, w = y.format) {
-      W(a, w);
-      let p;
-      if (w === "der") {
-        const { r: b, s: R } = ot.toSig(N(a));
-        return new Z(b, R);
-      }
-      w === "recovered" && (p = a[0], w = "compact", a = a.subarray(1));
-      const B = g.signature / 2, E = a.subarray(0, B), v = a.subarray(B, B * 2);
-      return new Z(i.fromBytes(E), i.fromBytes(v), p);
-    }
-    static fromHex(a, w) {
-      return this.fromBytes(Rt(a), w);
-    }
-    assertRecovery() {
-      const { recovery: a } = this;
-      if (a == null)
-        throw new Error("invalid recovery id: must be present");
-      return a;
-    }
-    addRecoveryBit(a) {
-      return new Z(this.r, this.s, a);
-    }
-    recoverPublicKey(a) {
-      const { r: w, s: p } = this, B = this.assertRecovery(), E = B === 2 || B === 3 ? w + c : w;
-      if (!o.isValid(E))
-        throw new Error("invalid recovery id: sig.r+curve.n != R.x");
-      const v = o.toBytes(E), b = e.fromBytes(it(Oe((B & 1) === 0), v)), R = i.inv(E), L = G(N(a, void 0, "msgHash")), k = i.create(-L * R), H = i.create(p * R), A = e.BASE.multiplyUnsafe(k).add(b.multiplyUnsafe(H));
-      if (A.is0())
-        throw new Error("invalid recovery: point at infinify");
-      return A.assertValidity(), A;
-    }
-    // Signatures should be low-s, to prevent malleability.
-    hasHighS() {
-      return I(this.s);
-    }
-    toBytes(a = y.format) {
-      if (Zt(a), a === "der")
-        return Rt(ot.hexFromSig(this));
-      const { r: w, s: p } = this, B = i.toBytes(w), E = i.toBytes(p);
-      return a === "recovered" ? (j(), it(Uint8Array.of(this.assertRecovery()), B, E)) : it(B, E);
-    }
-    toHex(a) {
-      return Lt(this.toBytes(a));
-    }
-  }
-  const D = r.bits2int || function(a) {
-    if (a.length > 8192)
-      throw new Error("input is too large");
-    const w = Ut(a), p = a.length * 8 - f;
-    return p > 0 ? w >> BigInt(p) : w;
-  }, G = r.bits2int_modN || function(a) {
-    return i.create(D(a));
-  }, _t = Yt(f);
-  function ht(l) {
-    return rn("num < 2^" + f, l, tt, _t), i.toBytes(l);
-  }
-  function z(l, a) {
-    return N(l, void 0, "message"), a ? N(t(l), void 0, "prehashed message") : l;
-  }
-  function bt(l, a, w) {
-    const { lowS: p, prehash: B, extraEntropy: E } = kt(w, y);
-    l = z(l, B);
-    const v = G(l), b = i.fromBytes(a);
-    if (!i.isValidNot0(b))
-      throw new Error("invalid private key");
-    const R = [ht(b), ht(v)];
-    if (E != null && E !== !1) {
-      const A = E === !0 ? n(g.secretKey) : E;
-      R.push(N(A, void 0, "extraEntropy"));
-    }
-    const L = it(...R), k = v;
-    function H(A) {
-      const $ = D(A);
-      if (!i.isValidNot0($))
-        return;
-      const T = i.inv($), K = e.BASE.multiply($).toAffine(), q = i.create(K.x);
-      if (q === tt)
-        return;
-      const V = i.create(T * i.create(k + q * b));
-      if (V === tt)
-        return;
-      let zt = (K.x === q ? 0 : 2) | Number(K.y & lt), Ft = V;
-      return p && I(V) && (Ft = i.neg(V), zt ^= 1), new Z(q, Ft, U ? void 0 : zt);
-    }
-    return { seed: L, k2sig: H };
-  }
-  function ct(l, a, w = {}) {
-    const { seed: p, k2sig: B } = bt(l, a, w);
-    return on(t.outputLen, i.BYTES, s)(p, B).toBytes(w.format);
-  }
-  function _(l, a, w, p = {}) {
-    const { lowS: B, prehash: E, format: v } = kt(p, y);
-    if (w = N(w, void 0, "publicKey"), a = z(a, E), !Tt(l)) {
-      const b = l instanceof Z ? ", use sig.toBytes()" : "";
-      throw new Error("verify expects Uint8Array signature" + b);
-    }
-    W(l, v);
-    try {
-      const b = Z.fromBytes(l, v), R = e.fromBytes(w);
-      if (B && b.hasHighS())
-        return !1;
-      const { r: L, s: k } = b, H = G(a), A = i.inv(k), $ = i.create(H * A), T = i.create(L * A), K = e.BASE.multiplyUnsafe($).add(R.multiplyUnsafe(T));
-      return K.is0() ? !1 : i.create(K.x) === L;
-    } catch {
-      return !1;
-    }
-  }
-  function S(l, a, w = {}) {
-    const { prehash: p } = kt(w, y);
-    return a = z(a, p), Z.fromBytes(l, "recovered").recoverPublicKey(a).toBytes();
-  }
-  return Object.freeze({
-    keygen: u,
-    getPublicKey: h,
-    getSharedSecret: d,
-    utils: x,
-    lengths: g,
-    Point: e,
-    sign: ct,
-    verify: _,
-    recoverPublicKey: S,
-    Signature: Z,
-    hash: t
-  });
-}
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-const Gt = {
-  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
-  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
-  h: BigInt(1),
-  a: BigInt(0),
-  b: BigInt(7),
-  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
-  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
-}, Un = {
-  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
-  basises: [
-    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
-    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
-  ]
-}, oe = /* @__PURE__ */ BigInt(2);
-function Sn(e) {
-  const t = Gt.p, r = BigInt(3), n = BigInt(6), s = BigInt(11), o = BigInt(22), i = BigInt(23), c = BigInt(44), f = BigInt(88), u = e * e * e % t, h = u * u * e % t, d = X(h, r, t) * h % t, x = X(d, r, t) * h % t, g = X(x, oe, t) * u % t, y = X(g, s, t) * g % t, U = X(y, o, t) * y % t, I = X(U, c, t) * U % t, O = X(I, f, t) * I % t, j = X(O, c, t) * U % t, W = X(j, r, t) * h % t, Z = X(W, i, t) * y % t, D = X(Z, n, t) * u % t, G = X(D, oe, t);
-  if (!Ct.eql(Ct.sqr(G), e))
-    throw new Error("Cannot find square root");
-  return G;
-}
-const Ct = St(Gt.p, { sqrt: Sn }), _n = /* @__PURE__ */ An(Gt, {
-  Fp: Ct,
-  endo: Un
-}), On = /* @__PURE__ */ Ln(_n, tn);
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function Hn(e) {
-  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
-}
-function Xt(e, ...t) {
-  if (!Hn(e))
-    throw new Error("Uint8Array expected");
-  if (t.length > 0 && !t.includes(e.length))
-    throw new Error("Uint8Array expected of length " + t + ", got length=" + e.length);
-}
-function ie(e, t = !0) {
-  if (e.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (t && e.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function qn(e, t) {
-  Xt(e);
-  const r = t.outputLen;
-  if (e.length < r)
-    throw new Error("digestInto() expects output buffer of length at least " + r);
-}
-function gt(...e) {
-  for (let t = 0; t < e.length; t++)
-    e[t].fill(0);
-}
-function Dt(e) {
-  return new DataView(e.buffer, e.byteOffset, e.byteLength);
-}
-function Q(e, t) {
-  return e << 32 - t | e >>> t;
-}
-function xt(e, t) {
-  return e << t | e >>> 32 - t >>> 0;
-}
-function Nn(e) {
-  if (typeof e != "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(e));
-}
-function qe(e) {
-  return typeof e == "string" && (e = Nn(e)), Xt(e), e;
-}
-class kn {
-}
-function Ne(e) {
-  const t = (n) => e().update(qe(n)).digest(), r = e();
-  return t.outputLen = r.outputLen, t.blockLen = r.blockLen, t.create = () => e(), t;
-}
-function Dn(e, t, r, n) {
-  if (typeof e.setBigUint64 == "function")
-    return e.setBigUint64(t, r, n);
-  const s = BigInt(32), o = BigInt(4294967295), i = Number(r >> s & o), c = Number(r & o), f = n ? 4 : 0, u = n ? 0 : 4;
-  e.setUint32(t + f, i, n), e.setUint32(t + u, c, n);
-}
-function $n(e, t, r) {
-  return e & t ^ ~e & r;
-}
-function Zn(e, t, r) {
-  return e & t ^ e & r ^ t & r;
-}
-class ke extends kn {
-  constructor(t, r, n, s) {
-    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = r, this.padOffset = n, this.isLE = s, this.buffer = new Uint8Array(t), this.view = Dt(this.buffer);
-  }
-  update(t) {
-    ie(this), t = qe(t), Xt(t);
-    const { view: r, buffer: n, blockLen: s } = this, o = t.length;
-    for (let i = 0; i < o; ) {
-      const c = Math.min(s - this.pos, o - i);
-      if (c === s) {
-        const f = Dt(t);
-        for (; s <= o - i; i += s)
-          this.process(f, i);
-        continue;
-      }
-      n.set(t.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === s && (this.process(r, 0), this.pos = 0);
-    }
-    return this.length += t.length, this.roundClean(), this;
-  }
-  digestInto(t) {
-    ie(this), qn(t, this), this.finished = !0;
-    const { buffer: r, view: n, blockLen: s, isLE: o } = this;
-    let { pos: i } = this;
-    r[i++] = 128, gt(this.buffer.subarray(i)), this.padOffset > s - i && (this.process(n, 0), i = 0);
-    for (let d = i; d < s; d++)
-      r[d] = 0;
-    Dn(n, s - 8, BigInt(this.length * 8), o), this.process(n, 0);
-    const c = Dt(t), f = this.outputLen;
-    if (f % 4)
-      throw new Error("_sha2: outputLen should be aligned to 32bit");
-    const u = f / 4, h = this.get();
-    if (u > h.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let d = 0; d < u; d++)
-      c.setUint32(4 * d, h[d], o);
-  }
-  digest() {
-    const { buffer: t, outputLen: r } = this;
-    this.digestInto(t);
-    const n = t.slice(0, r);
-    return this.destroy(), n;
-  }
-  _cloneInto(t) {
-    t || (t = new this.constructor()), t.set(...this.get());
-    const { blockLen: r, buffer: n, length: s, finished: o, destroyed: i, pos: c } = this;
-    return t.destroyed = i, t.finished = o, t.length = s, t.pos = c, s % r && t.buffer.set(n), t;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-}
-const rt = /* @__PURE__ */ Uint32Array.from([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]), Cn = /* @__PURE__ */ Uint8Array.from([
-  7,
-  4,
-  13,
-  1,
-  10,
-  6,
-  15,
-  3,
-  12,
-  0,
-  9,
-  5,
-  2,
-  14,
-  11,
-  8
-]), De = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), Tn = De.map((e) => (9 * e + 5) % 16), $e = /* @__PURE__ */ (() => {
-  const r = [[De], [Tn]];
-  for (let n = 0; n < 4; n++)
-    for (let s of r)
-      s.push(s[n].map((o) => Cn[o]));
-  return r;
-})(), Ze = $e[0], Ce = $e[1], Te = /* @__PURE__ */ [
-  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
-  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
-  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
-  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
-  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
-].map((e) => Uint8Array.from(e)), Vn = /* @__PURE__ */ Ze.map((e, t) => e.map((r) => Te[t][r])), Mn = /* @__PURE__ */ Ce.map((e, t) => e.map((r) => Te[t][r])), Yn = /* @__PURE__ */ Uint32Array.from([
-  0,
-  1518500249,
-  1859775393,
-  2400959708,
-  2840853838
-]), jn = /* @__PURE__ */ Uint32Array.from([
-  1352829926,
-  1548603684,
-  1836072691,
-  2053994217,
-  0
-]);
-function ce(e, t, r, n) {
-  return e === 0 ? t ^ r ^ n : e === 1 ? t & r | ~t & n : e === 2 ? (t | ~r) ^ n : e === 3 ? t & n | r & ~n : t ^ (r | ~n);
-}
-const mt = /* @__PURE__ */ new Uint32Array(16);
-class Kn extends ke {
-  constructor() {
-    super(64, 20, 8, !0), this.h0 = 1732584193, this.h1 = -271733879, this.h2 = -1732584194, this.h3 = 271733878, this.h4 = -1009589776;
-  }
-  get() {
-    const { h0: t, h1: r, h2: n, h3: s, h4: o } = this;
-    return [t, r, n, s, o];
-  }
-  set(t, r, n, s, o) {
-    this.h0 = t | 0, this.h1 = r | 0, this.h2 = n | 0, this.h3 = s | 0, this.h4 = o | 0;
-  }
-  process(t, r) {
-    for (let g = 0; g < 16; g++, r += 4)
-      mt[g] = t.getUint32(r, !0);
-    let n = this.h0 | 0, s = n, o = this.h1 | 0, i = o, c = this.h2 | 0, f = c, u = this.h3 | 0, h = u, d = this.h4 | 0, x = d;
-    for (let g = 0; g < 5; g++) {
-      const y = 4 - g, U = Yn[g], I = jn[g], O = Ze[g], j = Ce[g], W = Vn[g], Z = Mn[g];
-      for (let D = 0; D < 16; D++) {
-        const G = xt(n + ce(g, o, c, u) + mt[O[D]] + U, W[D]) + d | 0;
-        n = d, d = u, u = xt(c, 10) | 0, c = o, o = G;
-      }
-      for (let D = 0; D < 16; D++) {
-        const G = xt(s + ce(y, i, f, h) + mt[j[D]] + I, Z[D]) + x | 0;
-        s = x, x = h, h = xt(f, 10) | 0, f = i, i = G;
-      }
-    }
-    this.set(this.h1 + c + h | 0, this.h2 + u + x | 0, this.h3 + d + s | 0, this.h4 + n + i | 0, this.h0 + o + f | 0);
-  }
-  roundClean() {
-    gt(mt);
-  }
-  destroy() {
-    this.destroyed = !0, gt(this.buffer), this.set(0, 0, 0, 0, 0);
-  }
-}
-const Gn = /* @__PURE__ */ Ne(() => new Kn()), Xn = Gn, zn = /* @__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
-]), st = /* @__PURE__ */ new Uint32Array(64);
-class Fn extends ke {
-  constructor(t = 32) {
-    super(64, t, 8, !1), this.A = rt[0] | 0, this.B = rt[1] | 0, this.C = rt[2] | 0, this.D = rt[3] | 0, this.E = rt[4] | 0, this.F = rt[5] | 0, this.G = rt[6] | 0, this.H = rt[7] | 0;
-  }
-  get() {
-    const { A: t, B: r, C: n, D: s, E: o, F: i, G: c, H: f } = this;
-    return [t, r, n, s, o, i, c, f];
-  }
-  // prettier-ignore
-  set(t, r, n, s, o, i, c, f) {
-    this.A = t | 0, this.B = r | 0, this.C = n | 0, this.D = s | 0, this.E = o | 0, this.F = i | 0, this.G = c | 0, this.H = f | 0;
-  }
-  process(t, r) {
-    for (let d = 0; d < 16; d++, r += 4)
-      st[d] = t.getUint32(r, !1);
-    for (let d = 16; d < 64; d++) {
-      const x = st[d - 15], g = st[d - 2], y = Q(x, 7) ^ Q(x, 18) ^ x >>> 3, U = Q(g, 17) ^ Q(g, 19) ^ g >>> 10;
-      st[d] = U + st[d - 7] + y + st[d - 16] | 0;
-    }
-    let { A: n, B: s, C: o, D: i, E: c, F: f, G: u, H: h } = this;
-    for (let d = 0; d < 64; d++) {
-      const x = Q(c, 6) ^ Q(c, 11) ^ Q(c, 25), g = h + x + $n(c, f, u) + zn[d] + st[d] | 0, U = (Q(n, 2) ^ Q(n, 13) ^ Q(n, 22)) + Zn(n, s, o) | 0;
-      h = u, u = f, f = c, c = i + g | 0, i = o, o = s, s = n, n = g + U | 0;
-    }
-    n = n + this.A | 0, s = s + this.B | 0, o = o + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, f = f + this.F | 0, u = u + this.G | 0, h = h + this.H | 0, this.set(n, s, o, i, c, f, u, h);
-  }
-  roundClean() {
-    gt(st);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0), gt(this.buffer);
-  }
-}
-const Wn = /* @__PURE__ */ Ne(() => new Fn()), wt = Wn, Pn = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function Qn(e) {
-  const t = [0];
-  for (let r = 0; r < e.length; r++) {
-    const n = e[r];
-    if (!n) continue;
-    const s = Pn.indexOf(n);
-    if (s === -1) throw new Error("Invalid base58 character");
-    for (let i = 0; i < t.length; i++)
-      t[i] *= 58;
-    t[0] += s;
-    let o = 0;
-    for (let i = 0; i < t.length; i++) {
-      const c = t[i];
-      t[i] = c + o, o = t[i] >> 8, t[i] &= 255;
-    }
-    for (; o > 0; )
-      t.push(o & 255), o >>= 8;
-  }
-  for (let r = 0; r < e.length && e[r] === "1"; r++)
-    t.push(0);
-  return new Uint8Array(t.reverse());
-}
-function Jn(e) {
-  const t = "qpzry9x8gf2tvdw0s3jn54khce6mua7l", n = e.toLowerCase().split("1");
-  if (n.length !== 2) return null;
-  const s = n[0], o = n[1];
-  if (!s || !o || s !== "dgb") return null;
-  const i = [];
-  for (const h of o) {
-    const d = t.indexOf(h);
-    if (d === -1) return null;
-    i.push(d);
-  }
-  const c = i.slice(0, -6);
-  if (c.length < 1) return null;
-  const f = c[0];
-  if (f === void 0) return null;
-  const u = tr(c.slice(1), 5, 8);
-  return u ? { version: f, program: new Uint8Array(u) } : null;
-}
-function tr(e, t, r, n) {
-  let s = 0, o = 0;
-  const i = [], c = (1 << r) - 1;
-  for (const f of e) {
-    if (f < 0 || f >> t !== 0) return null;
-    for (s = s << t | f, o += t; o >= r; )
-      o -= r, i.push(s >> o & c);
-  }
-  return o >= t || s << r - o & c ? null : i;
-}
-function er(e, t) {
-  const r = new TextEncoder().encode(t), n = new TextEncoder().encode(e), s = [];
-  let o = n.length;
-  if (o < 253)
-    s.push(o);
-  else if (o <= 65535)
-    s.push(253, o & 255, o >> 8 & 255);
-  else if (o <= 4294967295)
-    s.push(
-      254,
-      o & 255,
-      o >> 8 & 255,
-      o >> 16 & 255,
-      o >> 24 & 255
-    );
-  else
-    throw new Error("Message too long");
-  const i = new Uint8Array(s), c = r.length + i.length + n.length, f = new Uint8Array(c);
-  let u = 0;
-  return f.set(r, u), u += r.length, f.set(i, u), u += i.length, f.set(n, u), wt(wt(f));
-}
-function nr(e, t) {
-  if (t.length !== 65)
-    throw new Error("Invalid signature length");
-  if (t[0] === void 0) throw new Error("Invalid signature");
-  const n = t.slice(1, 33), s = t.slice(33, 65), o = [];
-  for (let i = 0; i < 4; i++)
-    try {
-      const f = new On.Signature(
-        BigInt("0x" + Array.from(n).map((d) => d.toString(16).padStart(2, "0")).join("")),
-        BigInt("0x" + Array.from(s).map((d) => d.toString(16).padStart(2, "0")).join(""))
-      ).addRecoveryBit(i).recoverPublicKey(e), u = f.toBytes(!0), h = f.toBytes(!1);
-      o.push(u), o.push(h);
-    } catch {
-      continue;
-    }
-  if (o.length === 0)
-    throw new Error("Failed to recover any public keys");
-  return o;
-}
-function fe(e) {
-  return Xn(wt(e));
-}
-function rr(e, t) {
-  if (e.startsWith("D") || e.startsWith("S"))
-    try {
-      const r = Qn(e);
-      if (r.length < 25) return !1;
-      const n = r.slice(0, -4), s = r.slice(-4), i = wt(wt(n)).slice(0, 4);
-      if (!s.every((u, h) => u === i[h]))
-        return !1;
-      const c = n.slice(1), f = fe(t);
-      return c.every((u, h) => u === f[h]);
-    } catch {
-      return !1;
-    }
-  if (e.toLowerCase().startsWith("dgb1"))
-    try {
-      const r = Jn(e);
-      if (!r) return !1;
-      const { version: n, program: s } = r;
-      if (n === 0) {
-        let o = t;
-        if (t.length === 65) {
-          const c = t[64] % 2 === 0;
-          o = new Uint8Array(33), o[0] = c ? 2 : 3, o.set(t.slice(1, 33), 1);
-        }
-        const i = fe(o);
-        return s.every((c, f) => c === i[f]);
-      }
-      return !1;
-    } catch {
-      return !1;
-    }
-  return !1;
-}
-async function sr(e, t, r) {
-  const n = `DigiByte Signed Message:
-`;
-  try {
-    const s = Uint8Array.from(atob(r), (c) => c.charCodeAt(0));
-    if (s.length !== 65)
-      throw new Error("Invalid signature length");
-    const o = er(e, n), i = nr(o, s);
-    for (const c of i)
-      if (rr(t, c))
-        return !0;
-    return !1;
-  } catch (s) {
-    const o = s instanceof Error ? s.message : String(s);
-    throw new C(`Signature verification failed: ${o}`);
-  }
-}
-function or(e = 16) {
-  return Ye(e).toString("hex");
-}
-function ur(e) {
-  if (!e.callbackUrl)
-    throw new C("Callback URL is required.");
-  let t;
-  try {
-    t = new URL(e.callbackUrl);
-  } catch (i) {
-    throw new C(`Invalid callback URL: ${i.message}`);
-  }
-  const r = t.host + t.pathname, n = e.nonce || or(), s = e.unsecure ? "1" : "0";
-  if (e.unsecure && t.protocol !== "http:")
-    throw new C("Unsecure flag is true, but callback URL does not use http protocol.");
-  if (!e.unsecure && t.protocol !== "https:")
-    throw new C("Callback URL must use https protocol unless unsecure flag is set to true.");
-  return `digiid://${r}?x=${n}&u=${s}`;
-}
-async function ar(e, t) {
-  const { address: r, uri: n, signature: s } = e, { expectedCallbackUrl: o, expectedNonce: i } = t;
-  if (!r || !n || !s)
-    throw new C("Missing required callback data: address, uri, or signature.");
-  let c;
-  try {
-    const y = n.replace(/^digiid:/, "http:");
-    c = new URL(y);
-  } catch (y) {
-    throw new C(`Invalid URI received in callback: ${y.message}`);
-  }
-  const f = c.searchParams.get("x"), u = c.searchParams.get("u"), h = c.host + c.pathname;
-  if (f === null || u === null)
-    throw new C("URI missing nonce (x) or unsecure (u) parameter.");
-  let d;
-  try {
-    d = typeof o == "string" ? new URL(o) : o;
-  } catch (y) {
-    throw new C(`Invalid expectedCallbackUrl provided: ${y.message}`);
-  }
-  const x = d.host + d.pathname;
-  if (h !== x)
-    throw new C(`Callback URL mismatch: URI contained "${h}", expected "${x}"`);
-  const g = d.protocol;
-  if (u === "1" && g !== "http:")
-    throw new C("URI indicates unsecure (u=1), but expectedCallbackUrl is not http.");
-  if (u === "0" && g !== "https:")
-    throw new C("URI indicates secure (u=0), but expectedCallbackUrl is not https.");
-  if (i && f !== i)
-    throw new C(`Nonce mismatch: URI contained "${f}", expected "${i}". Possible replay attack.`);
-  try {
-    if (!await sr(n, r, s))
-      throw new C("Invalid signature.");
-  } catch (y) {
-    throw y instanceof C ? y : new C(`Unexpected error during signature verification: ${y.message}`);
-  }
-  return {
-    isValid: !0,
-    address: r,
-    nonce: f
-    // Return the nonce from the URI
-  };
-}
-export {
-  C as DigiIDError,
-  sr as _internalVerifySignature,
-  ur as generateDigiIDUri,
-  ar as verifyDigiIDCallback
+	let n = Pe(e.Fp, t.map((e) => e.Z));
+	return t.map((t, r) => e.fromAffine(t.toAffine(n[r])));
+}
+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: he(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 += q);
+	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
+	};
+}
+var Ke = /* @__PURE__ */ new WeakMap(), qe = /* @__PURE__ */ new WeakMap();
+function Je(e) {
+	return qe.get(e) || 1;
+}
+function Ye(e) {
+	if (e !== K) throw Error("invalid wNAF");
+}
+var Xe = 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 > K;) t & q && (n = n.add(r)), r = r.double(), t >>= q;
+		return n;
+	}
+	precomputeWindow(e, t) {
+		let { windows: n, windowSize: r } = We(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 = We(e, this.bits);
+		for (let e = 0; e < a.windows; e++) {
+			let { nextN: o, offset: s, isZero: c, isNeg: l, isNegF: u, offsetF: d } = Ge(n, e, a);
+			n = o, c ? i = i.add(J(u, t[d])) : r = r.add(J(l, t[s]));
+		}
+		return Ye(n), {
+			p: r,
+			f: i
+		};
+	}
+	wNAFUnsafe(e, t, n, r = this.ZERO) {
+		let i = We(e, this.bits);
+		for (let e = 0; e < i.windows && n !== K; e++) {
+			let { nextN: a, offset: o, isZero: s, isNeg: c } = Ge(n, e, i);
+			if (n = a, !s) {
+				let e = t[o];
+				r = r.add(c ? e.negate() : e);
+			}
+		}
+		return Ye(n), r;
+	}
+	getPrecomputes(e, t, n) {
+		let r = Ke.get(t);
+		return r || (r = this.precomputeWindow(t, e), e !== 1 && (typeof n == "function" && (r = n(r)), Ke.set(t, r))), r;
+	}
+	cached(e, t, n) {
+		let r = Je(e);
+		return this.wNAF(r, this.getPrecomputes(r, e, n), t);
+	}
+	unsafe(e, t, n, r) {
+		let i = Je(e);
+		return i === 1 ? this._unsafeLadder(e, t, r) : this.wNAFUnsafe(i, this.getPrecomputes(i, e, n), t, r);
+	}
+	createCache(e, t) {
+		Ue(t, this.bits), qe.set(e, t), Ke.delete(e);
+	}
+	hasCache(e) {
+		return Je(e) !== 1;
+	}
 };
-//# sourceMappingURL=digiid-ts.es.js.map
+function Ze(e, t, n, r) {
+	let i = t, a = e.ZERO, o = e.ZERO;
+	for (; n > K || r > K;) n & q && (a = a.add(i)), r & q && (o = o.add(i)), i = i.double(), n >>= q, r >>= q;
+	return {
+		p1: a,
+		p2: o
+	};
+}
+function Qe(e, t, n) {
+	if (t) {
+		if (t.ORDER !== e) throw Error("Field.ORDER must match order: Fp == p, Fn == n");
+		return Me(t), t;
+	} else return G(e, { isLE: n });
+}
+function $e(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 > K)) throw Error(`CURVE.${e} must be positive bigint`);
+	}
+	let i = Qe(t.p, n.Fp, r), a = Qe(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 et(e, t) {
+	return function(n) {
+		let r = e(n);
+		return {
+			secretKey: r,
+			publicKey: t(r)
+		};
+	};
+}
+//#endregion
+//#region node_modules/@noble/hashes/hmac.js
+var tt = class {
+	oHash;
+	iHash;
+	blockLen;
+	outputLen;
+	canXOF = !1;
+	finished = !1;
+	destroyed = !1;
+	constructor(e, t) {
+		if (a(e), i(t, void 0, "key"), 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 n = this.blockLen, r = new Uint8Array(n);
+		r.set(t.length > n ? e.create().update(t).digest() : t);
+		for (let e = 0; e < r.length; e++) r[e] ^= 54;
+		this.iHash.update(r), this.oHash = e.create();
+		for (let e = 0; e < r.length; e++) r[e] ^= 106;
+		this.oHash.update(r), c(r);
+	}
+	update(e) {
+		return o(this), this.iHash.update(e), this;
+	}
+	digestInto(e) {
+		o(this), s(e, this), this.finished = !0;
+		let t = e.subarray(0, this.outputLen);
+		this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), 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();
+	}
+}, nt = /* @__PURE__ */ (() => {
+	let e = ((e, t, n) => new tt(e, t).update(n).digest());
+	return e.create = (e, t) => new tt(e, t), e;
+})(), rt = (e, t) => (e + (e >= 0 ? t : -t) / st) / t;
+function it(e, t, n) {
+	pe("scalar", e, X, n);
+	let [[r, i], [a, o]] = t, s = rt(o * e, n), c = rt(-i * e, n), l = e - s * r - c * a, u = -s * i - c * o, d = l < X, f = u < X;
+	d && (l = -l), f && (u = -u);
+	let p = he(Math.ceil(me(n) / 2)) + Z;
+	if (l < X || l >= p || u < X || u >= p) throw Error("splitScalar (endomorphism): failed for k");
+	return {
+		k1neg: d,
+		k1: l,
+		k2neg: f,
+		k2: u
+	};
+}
+function at(e) {
+	if (![
+		"compact",
+		"recovered",
+		"der"
+	].includes(e)) throw Error("Signature format must be \"compact\", \"recovered\", or \"der\"");
+	return e;
+}
+function ot(e, t) {
+	z(e);
+	let n = {};
+	for (let r of Object.keys(t)) n[r] = e[r] === void 0 ? t[r] : e[r];
+	return F(n.lowS, "lowS"), F(n.prehash, "prehash"), n.format !== void 0 && at(n.format), n;
+}
+var Y = {
+	Err: class extends Error {
+		constructor(e = "") {
+			super(e);
+		}
+	},
+	_tlv: {
+		encode: (e, t) => {
+			let { Err: n } = Y;
+			if (oe(e, "tag"), e < 0 || e > 255) throw new n("tlv.encode: wrong tag");
+			if (typeof t != "string") throw TypeError("\"data\" expected string, got type=" + typeof t);
+			if (t.length & 1) throw new n("tlv.encode: unpadded data");
+			let r = t.length / 2, i = I(r);
+			if (i.length / 2 & 128) throw new n("tlv.encode: long form length too big");
+			let a = r > 127 ? I(i.length / 2 | 128) : "";
+			return I(e) + a + i + t;
+		},
+		decode(e, t) {
+			let { Err: n } = Y;
+			t = k(t, void 0, "DER data");
+			let r = 0;
+			if (e < 0 || e > 255) 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 } = Y;
+			if (ae(e), e < X) throw new t("integer: negative integers are not allowed");
+			let n = I(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 } = Y;
+			if (e.length < 1) throw new t("invalid signature integer: empty");
+			if (e[0] & 128) throw new t("invalid signature integer: negative");
+			if (e.length > 1 && e[0] === 0 && !(e[1] & 128)) throw new t("invalid signature integer: unnecessary leading zero");
+			return L(e);
+		}
+	},
+	toSig(e) {
+		let { Err: t, _int: n, _tlv: r } = Y, i = k(e, void 0, "signature"), { 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 } = Y, r = t.encode(2, n.encode(e.r)) + t.encode(2, n.encode(e.s));
+		return t.encode(48, r);
+	}
+};
+Object.freeze(Y._tlv), Object.freeze(Y._int), Object.freeze(Y);
+var X = /* @__PURE__ */ BigInt(0), Z = /* @__PURE__ */ BigInt(1), st = /* @__PURE__ */ BigInt(2), Q = /* @__PURE__ */ BigInt(3), ct = /* @__PURE__ */ BigInt(4);
+function lt(e, t = {}) {
+	let n = $e("weierstrass", e, t), r = n.Fp, i = n.Fn, a = n.CURVE, { h: o, n: s } = a;
+	z(t, {}, {
+		allowInfinityPoint: "boolean",
+		clearCofactor: "function",
+		isTorsionFree: "function",
+		fromBytes: "function",
+		toBytes: "function",
+		endo: "object"
+	});
+	let { endo: c, allowInfinityPoint: l } = t;
+	if (c && (!r.is0(a.a) || typeof c.beta != "bigint" || !Array.isArray(c.basises))) throw Error("invalid endo: expected \"beta\": bigint and \"basises\": array");
+	let u = dt(r, i);
+	function d() {
+		if (!r.isOdd) throw Error("compression is not supported: Field does not have .isOdd()");
+	}
+	function f(e, t, n) {
+		if (l && t.is0()) return Uint8Array.of(0);
+		let { x: i, y: a } = t.toAffine(), o = r.toBytes(i);
+		return F(n, "isCompressed"), n ? (d(), j(ut(!r.isOdd(a)), o)) : j(Uint8Array.of(4), o, r.toBytes(a));
+	}
+	function p(e) {
+		k(e, void 0, "Point");
+		let { publicKey: t, publicKeyUncompressed: n } = u, i = e.length, a = e[0], o = e.subarray(1);
+		if (l && i === 1 && a === 0) return {
+			x: r.ZERO,
+			y: r.ZERO
+		};
+		if (i === t && (a === 2 || a === 3)) {
+			let e = r.fromBytes(o);
+			if (!r.isValid(e)) throw Error("bad point: is not on curve, wrong x");
+			let t = g(e), n;
+			try {
+				n = r.sqrt(t);
+			} catch (e) {
+				let t = e instanceof Error ? ": " + e.message : "";
+				throw Error("bad point: is not on curve, sqrt error" + t);
+			}
+			d();
+			let i = r.isOdd(n);
+			return (a & 1) == 1 !== i && (n = r.neg(n)), {
+				x: e,
+				y: n
+			};
+		} else if (i === n && a === 4) {
+			let e = r.BYTES, t = r.fromBytes(o.subarray(0, e)), n = r.fromBytes(o.subarray(e, e * 2));
+			if (!_(t, n)) throw Error("bad point: is not on curve");
+			return {
+				x: t,
+				y: n
+			};
+		} else throw Error(`bad point: got length ${i}, expected compressed=${t} or uncompressed=${n}`);
+	}
+	let m = t.toBytes === void 0 ? f : t.toBytes, h = t.fromBytes === void 0 ? p : t.fromBytes;
+	function g(e) {
+		let t = r.sqr(e), n = r.mul(t, e);
+		return r.add(r.add(n, r.mul(e, a.a)), a.b);
+	}
+	function _(e, t) {
+		let n = r.sqr(t), i = g(e);
+		return r.eql(n, i);
+	}
+	if (!_(a.Gx, a.Gy)) throw Error("bad curve params: generator point");
+	let v = r.mul(r.pow(a.a, Q), ct), y = r.mul(r.sqr(a.b), BigInt(27));
+	if (r.is0(r.add(v, y))) throw Error("bad curve params: a or b");
+	function b(e, t, n = !1) {
+		if (!r.isValid(t) || n && r.is0(t)) throw Error(`bad point coordinate ${e}`);
+		return t;
+	}
+	function x(e) {
+		if (!(e instanceof w)) throw Error("Weierstrass Point expected");
+	}
+	function S(e) {
+		if (!c || !c.basises) throw Error("no endo");
+		return it(e, c.basises, i.ORDER);
+	}
+	function C(e, t, n, i, a) {
+		return n = new w(r.mul(n.X, e), n.Y, n.Z), t = J(i, t), n = J(a, n), t.add(n);
+	}
+	class w {
+		static BASE = new w(a.Gx, a.Gy, r.ONE);
+		static ZERO = new w(r.ZERO, r.ONE, r.ZERO);
+		static Fp = r;
+		static Fn = i;
+		X;
+		Y;
+		Z;
+		constructor(e, t, n) {
+			this.X = b("x", e), this.Y = b("y", t, !0), this.Z = b("z", n), Object.freeze(this);
+		}
+		static CURVE() {
+			return a;
+		}
+		static fromAffine(e) {
+			let { x: t, y: n } = e || {};
+			if (!e || !r.isValid(t) || !r.isValid(n)) throw Error("invalid affine point");
+			if (e instanceof w) throw Error("projective point not allowed");
+			return r.is0(t) && r.is0(n) ? w.ZERO : new w(t, n, r.ONE);
+		}
+		static fromBytes(e) {
+			let t = w.fromAffine(h(k(e, void 0, "point")));
+			return t.assertValidity(), t;
+		}
+		static fromHex(e) {
+			return w.fromBytes(M(e));
+		}
+		get x() {
+			return this.toAffine().x;
+		}
+		get y() {
+			return this.toAffine().y;
+		}
+		precompute(e = 8, t = !0) {
+			return E.createCache(this, e), t || this.multiply(Q), this;
+		}
+		assertValidity() {
+			let e = this;
+			if (e.is0()) {
+				if (t.allowInfinityPoint && r.is0(e.X) && r.eql(e.Y, r.ONE) && r.is0(e.Z)) return;
+				throw Error("bad point: ZERO");
+			}
+			let { x: n, y: i } = e.toAffine();
+			if (!r.isValid(n) || !r.isValid(i)) throw Error("bad point: x or y not field elements");
+			if (!_(n, i)) throw Error("bad point: equation left != right");
+			if (!e.isTorsionFree()) throw Error("bad point: not in prime-order subgroup");
+		}
+		hasEvenY() {
+			let { y: e } = this.toAffine();
+			if (!r.isOdd) throw Error("Field doesn't support isOdd");
+			return !r.isOdd(e);
+		}
+		equals(e) {
+			x(e);
+			let { X: t, Y: n, Z: i } = this, { X: a, Y: o, Z: s } = e, c = r.eql(r.mul(t, s), r.mul(a, i)), l = r.eql(r.mul(n, s), r.mul(o, i));
+			return c && l;
+		}
+		negate() {
+			return new w(this.X, r.neg(this.Y), this.Z);
+		}
+		double() {
+			let { a: e, b: t } = a, n = r.mul(t, Q), { X: i, Y: o, Z: s } = this, c = r.ZERO, l = r.ZERO, u = r.ZERO, d = r.mul(i, i), f = r.mul(o, o), p = r.mul(s, s), m = r.mul(i, o);
+			return m = r.add(m, m), u = r.mul(i, s), u = r.add(u, u), c = r.mul(e, u), l = r.mul(n, p), l = r.add(c, l), c = r.sub(f, l), l = r.add(f, l), l = r.mul(c, l), c = r.mul(m, c), u = r.mul(n, u), p = r.mul(e, p), m = r.sub(d, p), m = r.mul(e, m), m = r.add(m, u), u = r.add(d, d), d = r.add(u, d), d = r.add(d, p), d = r.mul(d, m), l = r.add(l, d), p = r.mul(o, s), p = r.add(p, p), d = r.mul(p, m), c = r.sub(c, d), u = r.mul(p, f), u = r.add(u, u), u = r.add(u, u), new w(c, l, u);
+		}
+		add(e) {
+			x(e);
+			let { X: t, Y: n, Z: i } = this, { X: o, Y: s, Z: c } = e, l = r.ZERO, u = r.ZERO, d = r.ZERO, f = a.a, p = r.mul(a.b, Q), m = r.mul(t, o), h = r.mul(n, s), g = r.mul(i, c), _ = r.add(t, n), v = r.add(o, s);
+			_ = r.mul(_, v), v = r.add(m, h), _ = r.sub(_, v), v = r.add(t, i);
+			let y = r.add(o, c);
+			return v = r.mul(v, y), y = r.add(m, g), v = r.sub(v, y), y = r.add(n, i), l = r.add(s, c), y = r.mul(y, l), l = r.add(h, g), y = r.sub(y, l), d = r.mul(f, v), l = r.mul(p, g), d = r.add(l, d), l = r.sub(h, d), d = r.add(h, d), u = r.mul(l, d), h = r.add(m, m), h = r.add(h, m), g = r.mul(f, g), v = r.mul(p, v), h = r.add(h, g), g = r.sub(m, g), g = r.mul(f, g), v = r.add(v, g), m = r.mul(h, v), u = r.add(u, m), m = r.mul(y, v), l = r.mul(_, l), l = r.sub(l, m), m = r.mul(_, h), d = r.mul(y, d), d = r.add(d, m), new w(l, u, d);
+		}
+		subtract(e) {
+			return x(e), this.add(e.negate());
+		}
+		is0() {
+			return this.equals(w.ZERO);
+		}
+		multiply(e) {
+			let { endo: n } = t;
+			if (!i.isValidNot0(e)) throw RangeError("invalid scalar: out of range");
+			let r, a, o = (e) => E.cached(this, e, (e) => He(w, e));
+			if (n) {
+				let { k1neg: t, k1: i, k2neg: s, k2: c } = S(e), { p: l, f: u } = o(i), { p: d, f } = o(c);
+				a = u.add(f), r = C(n.beta, l, d, t, s);
+			} else {
+				let { p: t, f: n } = o(e);
+				r = t, a = n;
+			}
+			return He(w, [r, a])[0];
+		}
+		multiplyUnsafe(e) {
+			let { endo: n } = t, r = this, a = e;
+			if (!i.isValid(a)) throw RangeError("invalid scalar: out of range");
+			if (a === X || r.is0()) return w.ZERO;
+			if (a === Z) return r;
+			if (E.hasCache(this)) return this.multiply(a);
+			if (n) {
+				let { k1neg: e, k1: t, k2neg: i, k2: o } = S(a), { p1: s, p2: c } = Ze(w, r, t, o);
+				return C(n.beta, s, c, e, i);
+			} else return E.unsafe(r, a);
+		}
+		toAffine(e) {
+			let t = this, n = e, { X: i, Y: a, Z: o } = t;
+			if (r.eql(o, r.ONE)) return {
+				x: i,
+				y: a
+			};
+			let s = t.is0();
+			n ??= s ? r.ONE : r.inv(o);
+			let c = r.mul(i, n), l = r.mul(a, n), u = r.mul(o, n);
+			if (s) return {
+				x: r.ZERO,
+				y: r.ZERO
+			};
+			if (!r.eql(u, r.ONE)) throw Error("invZ was invalid");
+			return {
+				x: c,
+				y: l
+			};
+		}
+		isTorsionFree() {
+			let { isTorsionFree: e } = t;
+			return o === Z ? !0 : e ? e(w, this) : E.unsafe(this, s).is0();
+		}
+		clearCofactor() {
+			let { clearCofactor: e } = t;
+			return o === Z ? this : e ? e(w, this) : this.multiplyUnsafe(o);
+		}
+		isSmallOrder() {
+			return o === Z ? this.is0() : this.clearCofactor().is0();
+		}
+		toBytes(e = !0) {
+			return F(e, "isCompressed"), this.assertValidity(), m(w, this, e);
+		}
+		toHex(e = !0) {
+			return ne(this.toBytes(e));
+		}
+		toString() {
+			return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+		}
+	}
+	let T = i.BITS, E = new Xe(w, t.endo ? Math.ceil(T / 2) : T);
+	return T >= 8 && w.BASE.precompute(8), Object.freeze(w.prototype), Object.freeze(w), w;
+}
+function ut(e) {
+	return Uint8Array.of(e ? 2 : 3);
+}
+function dt(e, t) {
+	return {
+		secretKey: t.BYTES,
+		publicKey: 1 + e.BYTES,
+		publicKeyUncompressed: 1 + 2 * e.BYTES,
+		publicKeyHasPrefix: !0,
+		signature: 2 * t.BYTES
+	};
+}
+function ft(e, t = {}) {
+	let { Fn: n } = e, r = t.randomBytes === void 0 ? ie : t.randomBytes, i = Object.assign(dt(e.Fp, n), { seed: Math.max(Be(n.ORDER), 16) });
+	function a(e) {
+		try {
+			let t = n.fromBytes(e);
+			return n.isValidNot0(t);
+		} catch {
+			return !1;
+		}
+	}
+	function o(t, n) {
+		let { publicKey: r, publicKeyUncompressed: a } = i;
+		try {
+			let i = t.length;
+			return n === !0 && i !== r || n === !1 && i !== a ? !1 : !!e.fromBytes(t);
+		} catch {
+			return !1;
+		}
+	}
+	function s(e) {
+		return e = e === void 0 ? r(i.seed) : e, Ve(k(e, i.seed, "seed"), n.ORDER);
+	}
+	function c(t, r = !0) {
+		return e.BASE.multiply(n.fromBytes(t)).toBytes(r);
+	}
+	function l(e) {
+		let { secretKey: t, publicKey: r, publicKeyUncompressed: a } = i, o = n._lengths;
+		if (!re(e)) return;
+		let s = k(e, void 0, "key").length, c = s === r || s === a, l = s === t || !!o?.includes(s);
+		if (!(c && l)) return c;
+	}
+	function u(t, r, i = !0) {
+		if (l(t) === !0) throw Error("first arg must be private key");
+		if (l(r) === !1) throw Error("second arg must be public key");
+		let a = n.fromBytes(t);
+		return e.fromBytes(r).multiply(a).toBytes(i);
+	}
+	let d = {
+		isValidSecretKey: a,
+		isValidPublicKey: o,
+		randomSecretKey: s
+	}, f = et(s, c);
+	return Object.freeze(d), Object.freeze(i), Object.freeze({
+		getPublicKey: c,
+		getSharedSecret: u,
+		keygen: f,
+		Point: e,
+		utils: d,
+		lengths: i
+	});
+}
+function pt(e, t, n = {}) {
+	let r = t;
+	a(r), z(n, {}, {
+		hmac: "function",
+		lowS: "boolean",
+		randomBytes: "function",
+		bits2int: "function",
+		bits2int_modN: "function"
+	}), n = Object.assign({}, n);
+	let i = n.randomBytes === void 0 ? ie : n.randomBytes, o = n.hmac === void 0 ? (e, t) => nt(r, e, t) : n.hmac, { Fp: s, Fn: c } = e, { ORDER: l, BITS: u } = c, { keygen: d, getPublicKey: f, getSharedSecret: p, utils: m, lengths: h } = ft(e, n), g = {
+		prehash: !0,
+		lowS: typeof n.lowS == "boolean" ? n.lowS : !0,
+		format: "compact",
+		extraEntropy: !1
+	}, _ = l * st + Z < s.ORDER;
+	function v(e) {
+		return e > l >> Z;
+	}
+	function y(e, t) {
+		if (!c.isValidNot0(t)) throw Error(`invalid signature ${e}: out of range 1..Point.Fn.ORDER`);
+		return t;
+	}
+	function b() {
+		if (_) throw Error("\"recovered\" sig type is not supported for cofactor >2 curves");
+	}
+	function x(e, t) {
+		at(t);
+		let n = h.signature;
+		return k(e, t === "compact" ? n : t === "recovered" ? n + 1 : void 0);
+	}
+	class S {
+		r;
+		s;
+		recovery;
+		constructor(e, t, n) {
+			if (this.r = y("r", e), this.s = y("s", t), n != null) {
+				if (b(), ![
+					0,
+					1,
+					2,
+					3
+				].includes(n)) throw Error("invalid recovery id");
+				this.recovery = n;
+			}
+			Object.freeze(this);
+		}
+		static fromBytes(e, t = g.format) {
+			x(e, t);
+			let n;
+			if (t === "der") {
+				let { r: t, s: n } = Y.toSig(k(e));
+				return new S(t, n);
+			}
+			t === "recovered" && (n = e[0], t = "compact", e = e.subarray(1));
+			let r = h.signature / 2, i = e.subarray(0, r), a = e.subarray(r, r * 2);
+			return new S(c.fromBytes(i), c.fromBytes(a), n);
+		}
+		static fromHex(e, t) {
+			return this.fromBytes(M(e), t);
+		}
+		assertRecovery() {
+			let { recovery: e } = this;
+			if (e == null) throw Error("invalid recovery id: must be present");
+			return e;
+		}
+		addRecoveryBit(e) {
+			return new S(this.r, this.s, e);
+		}
+		recoverPublicKey(t) {
+			let { r: n, s: r } = this, i = this.assertRecovery(), a = i === 2 || i === 3 ? n + l : n;
+			if (!s.isValid(a)) throw Error("invalid recovery id: sig.r+curve.n != R.x");
+			let o = s.toBytes(a), u = e.fromBytes(j(ut((i & 1) == 0), o)), d = c.inv(a), f = w(k(t, void 0, "msgHash")), p = c.create(-f * d), m = c.create(r * d), h = e.BASE.multiplyUnsafe(p).add(u.multiplyUnsafe(m));
+			if (h.is0()) throw Error("invalid recovery: point at infinify");
+			return h.assertValidity(), h;
+		}
+		hasHighS() {
+			return v(this.s);
+		}
+		toBytes(e = g.format) {
+			if (at(e), e === "der") return M(Y.hexFromSig(this));
+			let { r: t, s: n } = this, r = c.toBytes(t), i = c.toBytes(n);
+			return e === "recovered" ? (b(), j(Uint8Array.of(this.assertRecovery()), r, i)) : j(r, i);
+		}
+		toHex(e) {
+			return ne(this.toBytes(e));
+		}
+	}
+	Object.freeze(S.prototype), Object.freeze(S);
+	let C = n.bits2int === void 0 ? function(e) {
+		if (e.length > 8192) throw Error("input is too large");
+		let t = L(e), n = e.length * 8 - u;
+		return n > 0 ? t >> BigInt(n) : t;
+	} : n.bits2int, w = n.bits2int_modN === void 0 ? function(e) {
+		return c.create(C(e));
+	} : n.bits2int_modN, T = he(u);
+	function E(e) {
+		return pe("num < 2^" + u, e, X, T), c.toBytes(e);
+	}
+	function D(e, t) {
+		return k(e, void 0, "message"), t ? k(r(e), void 0, "prehashed message") : e;
+	}
+	function ee(t, n, r) {
+		let { lowS: a, prehash: o, extraEntropy: s } = ot(r, g);
+		t = D(t, o);
+		let l = w(t), u = c.fromBytes(n);
+		if (!c.isValidNot0(u)) throw Error("invalid private key");
+		let d = [E(u), E(l)];
+		if (s != null && s !== !1) {
+			let e = s === !0 ? i(h.secretKey) : s;
+			d.push(k(e, void 0, "extraEntropy"));
+		}
+		let f = j(...d), p = l;
+		function m(t) {
+			let n = C(t);
+			if (!c.isValidNot0(n)) return;
+			let r = c.inv(n), i = e.BASE.multiply(n).toAffine(), o = c.create(i.x);
+			if (o === X) return;
+			let s = c.create(r * c.create(p + o * u));
+			if (s === X) return;
+			let l = (i.x === o ? 0 : 2) | Number(i.y & Z), d = s;
+			return a && v(s) && (d = c.neg(s), l ^= 1), new S(o, d, _ ? void 0 : l);
+		}
+		return {
+			seed: f,
+			k2sig: m
+		};
+	}
+	function te(e, t, n = {}) {
+		let { seed: i, k2sig: a } = ee(e, t, n);
+		return ge(r.outputLen, c.BYTES, o)(i, a).toBytes(n.format);
+	}
+	function O(t, n, r, i = {}) {
+		let { lowS: a, prehash: o, format: s } = ot(i, g);
+		if (r = k(r, void 0, "publicKey"), n = D(n, o), !re(t)) {
+			let e = t instanceof S ? ", use sig.toBytes()" : "";
+			throw Error("verify expects Uint8Array signature" + e);
+		}
+		x(t, s);
+		try {
+			let i = S.fromBytes(t, s), o = e.fromBytes(r);
+			if (a && i.hasHighS()) return !1;
+			let { r: l, s: u } = i, d = w(n), f = c.inv(u), p = c.create(d * f), m = c.create(l * f), h = e.BASE.multiplyUnsafe(p).add(o.multiplyUnsafe(m));
+			return h.is0() ? !1 : c.create(h.x) === l;
+		} catch {
+			return !1;
+		}
+	}
+	function A(e, t, n = {}) {
+		let { prehash: r } = ot(n, g);
+		return t = D(t, r), S.fromBytes(e, "recovered").recoverPublicKey(t).toBytes();
+	}
+	return Object.freeze({
+		keygen: d,
+		getPublicKey: f,
+		getSharedSecret: p,
+		utils: m,
+		lengths: h,
+		Point: e,
+		sign: te,
+		verify: O,
+		recoverPublicKey: A,
+		Signature: S,
+		hash: r
+	});
+}
+//#endregion
+//#region node_modules/@noble/curves/secp256k1.js
+var mt = {
+	p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+	n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+	h: BigInt(1),
+	a: BigInt(0),
+	b: BigInt(7),
+	Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+	Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+}, ht = {
+	beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+	basises: [[BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")], [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]]
+}, gt = /* @__PURE__ */ BigInt(2);
+function _t(e) {
+	let t = mt.p, 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 = W(W(W(u, n, t) * u % t, n, t) * u % t, gt, t) * l % t, f = W(d, i, t) * d % t, p = W(f, a, t) * f % t, m = W(p, s, t) * p % t, h = W(W(W(W(W(W(m, c, t) * m % t, s, t) * p % t, n, t) * u % t, o, t) * f % t, r, t) * l % t, gt, t);
+	if (!vt.eql(vt.sqr(h), e)) throw Error("Cannot find square root");
+	return h;
+}
+var vt = G(mt.p, { sqrt: _t }), yt = /* @__PURE__ */ pt(/* @__PURE__ */ lt(mt, {
+	Fp: vt,
+	endo: ht
+}), O), bt = /* @__PURE__ */ Uint8Array.from([
+	7,
+	4,
+	13,
+	1,
+	10,
+	6,
+	15,
+	3,
+	12,
+	0,
+	9,
+	5,
+	2,
+	14,
+	11,
+	8
+]), xt = /* @__PURE__ */ Uint8Array.from(Array(16).fill(0).map((e, t) => t)), St = /* @__PURE__ */ xt.map((e) => (9 * e + 5) % 16), Ct = /* @__PURE__ */ (() => {
+	let e = [[xt], [St]];
+	for (let t = 0; t < 4; t++) for (let n of e) n.push(n[t].map((e) => bt[e]));
+	return e;
+})(), wt = Ct[0], Tt = Ct[1], Et = /* @__PURE__ */ [
+	[
+		11,
+		14,
+		15,
+		12,
+		5,
+		8,
+		7,
+		9,
+		11,
+		13,
+		14,
+		15,
+		6,
+		7,
+		9,
+		8
+	],
+	[
+		12,
+		13,
+		11,
+		15,
+		6,
+		9,
+		9,
+		7,
+		12,
+		15,
+		11,
+		13,
+		7,
+		8,
+		7,
+		7
+	],
+	[
+		13,
+		15,
+		14,
+		11,
+		7,
+		7,
+		6,
+		8,
+		13,
+		14,
+		13,
+		12,
+		5,
+		5,
+		6,
+		9
+	],
+	[
+		14,
+		11,
+		12,
+		14,
+		8,
+		6,
+		5,
+		5,
+		15,
+		12,
+		15,
+		14,
+		9,
+		9,
+		8,
+		6
+	],
+	[
+		15,
+		12,
+		13,
+		13,
+		9,
+		5,
+		8,
+		6,
+		14,
+		11,
+		12,
+		11,
+		8,
+		6,
+		5,
+		5
+	]
+].map((e) => Uint8Array.from(e)), Dt = /* @__PURE__ */ wt.map((e, t) => e.map((e) => Et[t][e])), Ot = /* @__PURE__ */ Tt.map((e, t) => e.map((e) => Et[t][e])), kt = /* @__PURE__ */ Uint32Array.from([
+	0,
+	1518500249,
+	1859775393,
+	2400959708,
+	2840853838
+]), At = /* @__PURE__ */ Uint32Array.from([
+	1352829926,
+	1548603684,
+	1836072691,
+	2053994217,
+	0
+]);
+function jt(e, t, n, r) {
+	return e === 0 ? t ^ n ^ r : e === 1 ? t & n | ~t & r : e === 2 ? (t | ~n) ^ r : e === 3 ? t & r | n & ~r : t ^ (n | ~r);
+}
+var $ = /* @__PURE__ */ new Uint32Array(16), Mt = class extends w {
+	h0 = 1732584193;
+	h1 = -271733879;
+	h2 = -1732584194;
+	h3 = 271733878;
+	h4 = -1009589776;
+	constructor() {
+		super(64, 20, 8, !0);
+	}
+	get() {
+		let { h0: e, h1: t, h2: n, h3: r, h4: i } = this;
+		return [
+			e,
+			t,
+			n,
+			r,
+			i
+		];
+	}
+	set(e, t, n, r, i) {
+		this.h0 = e | 0, this.h1 = t | 0, this.h2 = n | 0, this.h3 = r | 0, this.h4 = i | 0;
+	}
+	process(e, t) {
+		for (let n = 0; n < 16; n++, t += 4) $[n] = e.getUint32(t, !0);
+		let n = this.h0 | 0, r = n, i = this.h1 | 0, a = i, o = this.h2 | 0, s = o, c = this.h3 | 0, l = c, u = this.h4 | 0, f = u;
+		for (let e = 0; e < 5; e++) {
+			let t = 4 - e, p = kt[e], m = At[e], h = wt[e], g = Tt[e], _ = Dt[e], v = Ot[e];
+			for (let t = 0; t < 16; t++) {
+				let r = d(n + jt(e, i, o, c) + $[h[t]] + p, _[t]) + u | 0;
+				n = u, u = c, c = d(o, 10) | 0, o = i, i = r;
+			}
+			for (let e = 0; e < 16; e++) {
+				let n = d(r + jt(t, a, s, l) + $[g[e]] + m, v[e]) + f | 0;
+				r = f, f = l, l = d(s, 10) | 0, s = a, a = n;
+			}
+		}
+		this.set(this.h1 + o + l | 0, this.h2 + c + f | 0, this.h3 + u + r | 0, this.h4 + n + a | 0, this.h0 + i + s | 0);
+	}
+	roundClean() {
+		c($);
+	}
+	destroy() {
+		this.destroyed = !0, c(this.buffer), this.set(0, 0, 0, 0, 0);
+	}
+}, Nt = /* @__PURE__ */ y(() => new Mt()), Pt = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function Ft(e) {
+	let t = [0];
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		if (!r) continue;
+		let i = Pt.indexOf(r);
+		if (i === -1) throw Error("Invalid base58 character");
+		for (let e = 0; e < t.length; e++) t[e] *= 58;
+		t[0] += i;
+		let a = 0;
+		for (let e = 0; e < t.length; e++) t[e] = t[e] + a, a = t[e] >> 8, t[e] &= 255;
+		for (; a > 0;) t.push(a & 255), a >>= 8;
+	}
+	for (let n = 0; n < e.length && e[n] === "1"; n++) t.push(0);
+	return new Uint8Array(t.reverse());
+}
+function It(e) {
+	let t = e.toLowerCase().split("1");
+	if (t.length !== 2) return null;
+	let n = t[0], r = t[1];
+	if (!n || !r || n !== "dgb") return null;
+	let i = [];
+	for (let e of r) {
+		let t = "qpzry9x8gf2tvdw0s3jn54khce6mua7l".indexOf(e);
+		if (t === -1) return null;
+		i.push(t);
+	}
+	let a = i.slice(0, -6);
+	if (a.length < 1) return null;
+	let o = a[0];
+	if (o === void 0) return null;
+	let s = Lt(a.slice(1), 5, 8, !1);
+	return s ? {
+		version: o,
+		program: new Uint8Array(s)
+	} : null;
+}
+function Lt(e, t, n, r) {
+	let i = 0, a = 0, o = [], s = (1 << n) - 1;
+	for (let r of e) {
+		if (r < 0 || r >> t !== 0) return null;
+		for (i = i << t | r, a += t; a >= n;) a -= n, o.push(i >> a & s);
+	}
+	if (r) a > 0 && o.push(i << n - a & s);
+	else if (a >= t || i << n - a & s) return null;
+	return o;
+}
+function Rt(e, t) {
+	let n = new TextEncoder().encode(t), r = new TextEncoder().encode(e), i = [], a = r.length;
+	if (a < 253) i.push(a);
+	else if (a <= 65535) i.push(253, a & 255, a >> 8 & 255);
+	else if (a <= 4294967295) i.push(254, a & 255, a >> 8 & 255, a >> 16 & 255, a >> 24 & 255);
+	else throw Error("Message too long");
+	let o = new Uint8Array(i), s = n.length + o.length + r.length, c = new Uint8Array(s), l = 0;
+	return c.set(n, l), l += n.length, c.set(o, l), l += o.length, c.set(r, l), O(O(c));
+}
+function zt(e, t) {
+	if (t.length !== 65) throw Error("Invalid signature length");
+	if (t[0] === void 0) throw Error("Invalid signature");
+	let n = t.slice(1, 33), r = t.slice(33, 65), i = [];
+	for (let t = 0; t < 4; t++) try {
+		let a = new yt.Signature(BigInt("0x" + Array.from(n).map((e) => e.toString(16).padStart(2, "0")).join("")), BigInt("0x" + Array.from(r).map((e) => e.toString(16).padStart(2, "0")).join(""))).addRecoveryBit(t).recoverPublicKey(e), o = a.toBytes(!0), s = a.toBytes(!1);
+		i.push(o), i.push(s);
+	} catch {
+		continue;
+	}
+	if (i.length === 0) throw Error("Failed to recover any public keys");
+	return i;
+}
+function Bt(e) {
+	return Nt(O(e));
+}
+function Vt(e, t) {
+	if (e.startsWith("D") || e.startsWith("S")) try {
+		let n = Ft(e);
+		if (n.length < 25) return !1;
+		let r = n.slice(0, -4), i = n.slice(-4), a = O(O(r)).slice(0, 4);
+		if (!i.every((e, t) => e === a[t])) return !1;
+		let o = r.slice(1), s = Bt(t);
+		return o.every((e, t) => e === s[t]);
+	} catch {
+		return !1;
+	}
+	if (e.toLowerCase().startsWith("dgb1")) try {
+		let n = It(e);
+		if (!n) return !1;
+		let { version: r, program: i } = n;
+		if (r === 0) {
+			let e = t;
+			if (t.length === 65) {
+				let n = t[64] % 2 == 0;
+				e = new Uint8Array(33), e[0] = n ? 2 : 3, e.set(t.slice(1, 33), 1);
+			}
+			let n = Bt(e);
+			return i.every((e, t) => e === n[t]);
+		}
+		return !1;
+	} catch {
+		return !1;
+	}
+	return !1;
+}
+async function Ht(e, n, r) {
+	try {
+		let t = Uint8Array.from(globalThis.atob(r), (e) => e.charCodeAt(0));
+		if (t.length !== 65) throw Error("Invalid signature length");
+		let i = zt(Rt(e, "DigiByte Signed Message:\n"), t);
+		for (let e of i) if (Vt(n, e)) return !0;
+		return !1;
+	} catch (e) {
+		throw new t(`Signature verification failed: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+function Ut(t = 16) {
+	return e(t).toString("hex");
+}
+function Wt(e) {
+	if (!e.callbackUrl) throw new t("Callback URL is required.");
+	let n;
+	try {
+		n = new URL(e.callbackUrl);
+	} catch (e) {
+		throw new t(`Invalid callback URL: ${e.message}`);
+	}
+	let r = n.host + n.pathname, i = e.nonce || Ut(), a = e.unsecure ? "1" : "0";
+	if (e.unsecure && n.protocol !== "http:") throw new t("Unsecure flag is true, but callback URL does not use http protocol.");
+	if (!e.unsecure && n.protocol !== "https:") throw new t("Callback URL must use https protocol unless unsecure flag is set to true.");
+	return `digiid://${r}?x=${i}&u=${a}`;
+}
+async function Gt(e, n) {
+	let { address: r, uri: i, signature: a } = e, { expectedCallbackUrl: o, expectedNonce: s } = n;
+	if (!r || !i || !a) throw new t("Missing required callback data: address, uri, or signature.");
+	let c;
+	try {
+		let e = i.replace(/^digiid:/, "http:");
+		c = new URL(e);
+	} catch (e) {
+		throw new t(`Invalid URI received in callback: ${e.message}`);
+	}
+	let l = c.searchParams.get("x"), u = c.searchParams.get("u"), d = c.host + c.pathname;
+	if (l === null || u === null) throw new t("URI missing nonce (x) or unsecure (u) parameter.");
+	let f;
+	try {
+		f = typeof o == "string" ? new URL(o) : o;
+	} catch (e) {
+		throw new t(`Invalid expectedCallbackUrl provided: ${e.message}`);
+	}
+	let p = f.host + f.pathname;
+	if (d !== p) throw new t(`Callback URL mismatch: URI contained "${d}", expected "${p}"`);
+	let m = f.protocol;
+	if (u === "1" && m !== "http:") throw new t("URI indicates unsecure (u=1), but expectedCallbackUrl is not http.");
+	if (u === "0" && m !== "https:") throw new t("URI indicates secure (u=0), but expectedCallbackUrl is not https.");
+	if (s && l !== s) throw new t(`Nonce mismatch: URI contained "${l}", expected "${s}". Possible replay attack.`);
+	try {
+		if (!await Ht(i, r, a)) throw new t("Invalid signature.");
+	} catch (e) {
+		throw e instanceof t ? e : new t(`Unexpected error during signature verification: ${e.message}`);
+	}
+	return {
+		isValid: !0,
+		address: r,
+		nonce: l
+	};
+}
+//#endregion
+export { t as DigiIDError, Ht as _internalVerifySignature, Wt as generateDigiIDUri, Gt as verifyDigiIDCallback };
+
+//# sourceMappingURL=digiid-ts.es.js.map