backpack-viewer 0.7.0 → 0.7.2

package/dist/extensions/share/index-B-LFGJqd.js

@@ -0,0 +1,4827 @@
+var es = Object.defineProperty;
+var ts = (t, e, n) => e in t ? es(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var g = (t, e, n) => ts(t, typeof e != "symbol" ? e + "" : e, n);
+function ns(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in t && t.BYTES_PER_ELEMENT === 1;
+}
+function de(t, e = "") {
+  if (typeof t != "number") {
+    const n = e && `"${e}" `;
+    throw new TypeError(`${n}expected number, got ${typeof t}`);
+  }
+  if (!Number.isSafeInteger(t) || t < 0) {
+    const n = e && `"${e}" `;
+    throw new RangeError(`${n}expected integer >= 0, got ${t}`);
+  }
+}
+function nt(t, e, n = "") {
+  const r = ns(t), o = t == null ? void 0 : t.length;
+  if (!r || e !== void 0) {
+    const i = n && `"${n}" `, c = "", f = r ? `length=${o}` : `type=${typeof t}`, u = i + "expected Uint8Array" + c + ", got " + f;
+    throw r ? new RangeError(u) : new TypeError(u);
+  }
+  return t;
+}
+function Zt(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new TypeError("Hash must wrapped by utils.createHasher");
+  if (de(t.outputLen), de(t.blockLen), t.outputLen < 1)
+    throw new Error('"outputLen" must be >= 1');
+  if (t.blockLen < 1)
+    throw new Error('"blockLen" must be >= 1');
+}
+function Nt(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function Fr(t, e) {
+  nt(t, void 0, "digestInto() output");
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new RangeError('"digestInto() output" expected to be of length >=' + n);
+}
+function sn(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function De(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function Tt(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function he(t, e) {
+  return t << 32 - e | t >>> e;
+}
+function j(t, e) {
+  return t << e | t >>> 32 - e >>> 0;
+}
+const rs = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function os(t) {
+  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
+}
+function ss(t) {
+  for (let e = 0; e < t.length; e++)
+    t[e] = os(t[e]);
+  return t;
+}
+const sr = rs ? (t) => t : ss;
+function is(t) {
+  if (typeof t != "string")
+    throw new TypeError("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function ir(t, e = "") {
+  return typeof t == "string" ? is(t) : nt(t, void 0, e);
+}
+function Pr(t, e) {
+  if (e !== void 0 && {}.toString.call(e) !== "[object Object]")
+    throw new TypeError("options must be object or undefined");
+  return Object.assign(t, e);
+}
+function cs(t, e = {}) {
+  const n = (o, s) => t(s).update(o).digest(), r = t(void 0);
+  return n.outputLen = r.outputLen, n.blockLen = r.blockLen, n.canXOF = r.canXOF, n.create = (o) => t(o), Object.assign(n, e), Object.freeze(n);
+}
+function me(t = 32) {
+  de(t, "bytesLength");
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof (e == null ? void 0 : e.getRandomValues) != "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  if (t > 65536)
+    throw new RangeError(`"bytesLength" expected <= 65536, got ${t}`);
+  return e.getRandomValues(new Uint8Array(t));
+}
+const fs = (t) => ({
+  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+  // Larger suffix values would need base-128 OID encoding and a different length byte.
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, t])
+});
+let cr = class {
+  constructor(e, n) {
+    g(this, "oHash");
+    g(this, "iHash");
+    g(this, "blockLen");
+    g(this, "outputLen");
+    g(this, "canXOF", !1);
+    g(this, "finished", !1);
+    g(this, "destroyed", !1);
+    if (Zt(e), nt(n, void 0, "key"), this.iHash = e.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 r = this.blockLen, o = new Uint8Array(r);
+    o.set(n.length > r ? e.create().update(n).digest() : n);
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 54;
+    this.iHash.update(o), this.oHash = e.create();
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 106;
+    this.oHash.update(o), De(o);
+  }
+  update(e) {
+    return Nt(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    Nt(this), Fr(e, this), this.finished = !0;
+    const n = e.subarray(0, this.outputLen);
+    this.iHash.digestInto(n), this.oHash.update(n), this.oHash.digestInto(n), this.destroy();
+  }
+  digest() {
+    const e = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(e), e;
+  }
+  _cloneInto(e) {
+    e || (e = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: n, iHash: r, finished: o, destroyed: s, blockLen: i, outputLen: c } = this;
+    return e = e, e.finished = o, e.destroyed = s, e.blockLen = i, e.outputLen = c, e.oHash = n._cloneInto(e.oHash), e.iHash = r._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+};
+const Et = /* @__PURE__ */ (() => {
+  const t = ((e, n, r) => new cr(e, n).update(r).digest());
+  return t.create = (e, n) => new cr(e, n), t;
+})();
+function mt(t, e, n) {
+  return Zt(t), n === void 0 && (n = new Uint8Array(t.outputLen)), Et(t, n, e);
+}
+const cn = /* @__PURE__ */ Uint8Array.of(0), fr = /* @__PURE__ */ Uint8Array.of();
+function Dr(t, e, n, r = 32) {
+  Zt(t), de(r, "length"), nt(e, void 0, "prk");
+  const o = t.outputLen;
+  if (e.length < o)
+    throw new Error('"prk" must be at least HashLen octets');
+  if (r > 255 * o)
+    throw new Error("Length must be <= 255*HashLen");
+  const s = Math.ceil(r / o);
+  n === void 0 ? n = fr : nt(n, void 0, "info");
+  const i = new Uint8Array(s * o), c = Et.create(t, e), f = c._cloneInto(), u = new Uint8Array(c.outputLen);
+  for (let d = 0; d < s; d++)
+    cn[0] = d + 1, f.update(d === 0 ? fr : u).update(n).update(cn).digestInto(u), i.set(u, o * d), c._cloneInto(f);
+  return c.destroy(), f.destroy(), De(u, cn), i.slice(0, r);
+}
+const rt = (t, e, n, r, o) => Dr(t, mt(t, e, n), r, o);
+function as(t, e, n) {
+  return t & e ^ ~t & n;
+}
+function us(t, e, n) {
+  return t & e ^ t & n ^ e & n;
+}
+let ds = class {
+  constructor(e, n, r, o) {
+    g(this, "blockLen");
+    g(this, "outputLen");
+    g(this, "canXOF", !1);
+    g(this, "padOffset");
+    g(this, "isLE");
+    // For partial updates less than block size
+    g(this, "buffer");
+    g(this, "view");
+    g(this, "finished", !1);
+    g(this, "length", 0);
+    g(this, "pos", 0);
+    g(this, "destroyed", !1);
+    this.blockLen = e, this.outputLen = n, this.padOffset = r, this.isLE = o, this.buffer = new Uint8Array(e), this.view = Tt(this.buffer);
+  }
+  update(e) {
+    Nt(this), nt(e);
+    const { view: n, buffer: r, blockLen: o } = this, s = e.length;
+    for (let i = 0; i < s; ) {
+      const c = Math.min(o - this.pos, s - i);
+      if (c === o) {
+        const f = Tt(e);
+        for (; o <= s - i; i += o)
+          this.process(f, i);
+        continue;
+      }
+      r.set(e.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === o && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    Nt(this), Fr(e, this), this.finished = !0;
+    const { buffer: n, view: r, blockLen: o, isLE: s } = this;
+    let { pos: i } = this;
+    n[i++] = 128, De(this.buffer.subarray(i)), this.padOffset > o - i && (this.process(r, 0), i = 0);
+    for (let a = i; a < o; a++)
+      n[a] = 0;
+    r.setBigUint64(o - 8, BigInt(this.length * 8), s), this.process(r, 0);
+    const c = Tt(e), f = this.outputLen;
+    if (f % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const u = f / 4, d = this.get();
+    if (u > d.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let a = 0; a < u; a++)
+      c.setUint32(4 * a, d[a], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: n, buffer: r, length: o, finished: s, destroyed: i, pos: c } = this;
+    return e.destroyed = i, e.finished = s, e.length = o, e.pos = c, o % n && e.buffer.set(r), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+const Ae = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), ls = /* @__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
+]), Be = /* @__PURE__ */ new Uint32Array(64);
+let hs = class extends ds {
+  constructor(e) {
+    super(64, e, 8, !1);
+  }
+  get() {
+    const { A: e, B: n, C: r, D: o, E: s, F: i, G: c, H: f } = this;
+    return [e, n, r, o, s, i, c, f];
+  }
+  // prettier-ignore
+  set(e, n, r, o, s, i, c, f) {
+    this.A = e | 0, this.B = n | 0, this.C = r | 0, this.D = o | 0, this.E = s | 0, this.F = i | 0, this.G = c | 0, this.H = f | 0;
+  }
+  process(e, n) {
+    for (let a = 0; a < 16; a++, n += 4)
+      Be[a] = e.getUint32(n, !1);
+    for (let a = 16; a < 64; a++) {
+      const y = Be[a - 15], l = Be[a - 2], b = he(y, 7) ^ he(y, 18) ^ y >>> 3, E = he(l, 17) ^ he(l, 19) ^ l >>> 10;
+      Be[a] = E + Be[a - 7] + b + Be[a - 16] | 0;
+    }
+    let { A: r, B: o, C: s, D: i, E: c, F: f, G: u, H: d } = this;
+    for (let a = 0; a < 64; a++) {
+      const y = he(c, 6) ^ he(c, 11) ^ he(c, 25), l = d + y + as(c, f, u) + ls[a] + Be[a] | 0, E = (he(r, 2) ^ he(r, 13) ^ he(r, 22)) + us(r, o, s) | 0;
+      d = u, u = f, f = c, c = i + l | 0, i = s, s = o, o = r, r = l + E | 0;
+    }
+    r = r + this.A | 0, o = o + this.B | 0, s = s + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, f = f + this.F | 0, u = u + this.G | 0, d = d + this.H | 0, this.set(r, o, s, i, c, f, u, d);
+  }
+  roundClean() {
+    De(Be);
+  }
+  destroy() {
+    this.destroyed = !0, this.set(0, 0, 0, 0, 0, 0, 0, 0), De(this.buffer);
+  }
+}, ys = class extends hs {
+  constructor() {
+    super(32);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    g(this, "A", Ae[0] | 0);
+    g(this, "B", Ae[1] | 0);
+    g(this, "C", Ae[2] | 0);
+    g(this, "D", Ae[3] | 0);
+    g(this, "E", Ae[4] | 0);
+    g(this, "F", Ae[5] | 0);
+    g(this, "G", Ae[6] | 0);
+    g(this, "H", Ae[7] | 0);
+  }
+};
+const ee = /* @__PURE__ */ cs(
+  () => new ys(),
+  /* @__PURE__ */ fs(1)
+);
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function Rn(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function ps(t) {
+  if (!Rn(t))
+    throw new Error("Uint8Array expected");
+}
+function jr(t, e) {
+  return Array.isArray(e) ? e.length === 0 ? !0 : t ? e.every((n) => typeof n == "string") : e.every((n) => Number.isSafeInteger(n)) : !1;
+}
+function gs(t) {
+  if (typeof t != "function")
+    throw new Error("function expected");
+  return !0;
+}
+function je(t, e) {
+  if (typeof e != "string")
+    throw new Error(`${t}: string expected`);
+  return !0;
+}
+function Tn(t) {
+  if (!Number.isSafeInteger(t))
+    throw new Error(`invalid integer: ${t}`);
+}
+function wn(t) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+}
+function Mt(t, e) {
+  if (!jr(!0, e))
+    throw new Error(`${t}: array of strings expected`);
+}
+function qr(t, e) {
+  if (!jr(!1, e))
+    throw new Error(`${t}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function Cn(...t) {
+  const e = (s) => s, n = (s, i) => (c) => s(i(c)), r = t.map((s) => s.encode).reduceRight(n, e), o = t.map((s) => s.decode).reduce(n, e);
+  return { encode: r, decode: o };
+}
+// @__NO_SIDE_EFFECTS__
+function On(t) {
+  const e = typeof t == "string" ? t.split("") : t, n = e.length;
+  Mt("alphabet", e);
+  const r = new Map(e.map((o, s) => [o, s]));
+  return {
+    encode: (o) => (wn(o), o.map((s) => {
+      if (!Number.isSafeInteger(s) || s < 0 || s >= n)
+        throw new Error(`alphabet.encode: digit index outside alphabet "${s}". Allowed: ${t}`);
+      return e[s];
+    })),
+    decode: (o) => (wn(o), o.map((s) => {
+      je("alphabet.decode", s);
+      const i = r.get(s);
+      if (i === void 0)
+        throw new Error(`Unknown letter: "${s}". Allowed: ${t}`);
+      return i;
+    }))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function $n(t = "") {
+  return je("join", t), {
+    encode: (e) => (Mt("join.decode", e), e.join(t)),
+    decode: (e) => (je("join.decode", e), e.split(t))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function bs(t, e = "=") {
+  return Tn(t), je("padding", e), {
+    encode(n) {
+      for (Mt("padding.encode", n); n.length * t % 8; )
+        n.push(e);
+      return n;
+    },
+    decode(n) {
+      Mt("padding.decode", n);
+      let r = n.length;
+      if (r * t % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; r > 0 && n[r - 1] === e; r--)
+        if ((r - 1) * t % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      return n.slice(0, r);
+    }
+  };
+}
+const zr = (t, e) => e === 0 ? t : zr(e, t % e), Ft = /* @__NO_SIDE_EFFECTS__ */ (t, e) => t + (e - zr(t, e)), Ct = /* @__PURE__ */ (() => {
+  let t = [];
+  for (let e = 0; e < 40; e++)
+    t.push(2 ** e);
+  return t;
+})();
+function xn(t, e, n, r) {
+  if (wn(t), e <= 0 || e > 32)
+    throw new Error(`convertRadix2: wrong from=${e}`);
+  if (n <= 0 || n > 32)
+    throw new Error(`convertRadix2: wrong to=${n}`);
+  if (/* @__PURE__ */ Ft(e, n) > 32)
+    throw new Error(`convertRadix2: carry overflow from=${e} to=${n} carryBits=${/* @__PURE__ */ Ft(e, n)}`);
+  let o = 0, s = 0;
+  const i = Ct[e], c = Ct[n] - 1, f = [];
+  for (const u of t) {
+    if (Tn(u), u >= i)
+      throw new Error(`convertRadix2: invalid data word=${u} from=${e}`);
+    if (o = o << e | u, s + e > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${s} from=${e}`);
+    for (s += e; s >= n; s -= n)
+      f.push((o >> s - n & c) >>> 0);
+    const d = Ct[s];
+    if (d === void 0)
+      throw new Error("invalid carry");
+    o &= d - 1;
+  }
+  if (o = o << n - s & c, !r && s >= e)
+    throw new Error("Excess padding");
+  if (!r && o > 0)
+    throw new Error(`Non-zero padding: ${o}`);
+  return r && s > 0 && f.push(o >>> 0), f;
+}
+// @__NO_SIDE_EFFECTS__
+function Nn(t, e = !1) {
+  if (Tn(t), t <= 0 || t > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ Ft(8, t) > 32 || /* @__PURE__ */ Ft(t, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (n) => {
+      if (!Rn(n))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return xn(Array.from(n), 8, t, !e);
+    },
+    decode: (n) => (qr("radix2.decode", n), Uint8Array.from(xn(n, t, 8, e)))
+  };
+}
+function ar(t) {
+  return gs(t), function(...e) {
+    try {
+      return t.apply(null, e);
+    } catch {
+    }
+  };
+}
+const ws = typeof Uint8Array.from([]).toBase64 == "function" && typeof Uint8Array.fromBase64 == "function", xs = (t, e) => {
+  je("base64", t);
+  const n = /^[A-Za-z0-9=+/]+$/, r = "base64";
+  if (t.length > 0 && !n.test(t))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(t, { alphabet: r, lastChunkHandling: "strict" });
+}, Vr = ws ? {
+  encode(t) {
+    return ps(t), t.toBase64();
+  },
+  decode(t) {
+    return xs(t);
+  }
+} : /* @__PURE__ */ Cn(/* @__PURE__ */ Nn(6), /* @__PURE__ */ On("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ bs(6), /* @__PURE__ */ $n("")), se = /* @__PURE__ */ Cn(/* @__PURE__ */ Nn(6), /* @__PURE__ */ On("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ $n("")), En = /* @__PURE__ */ Cn(/* @__PURE__ */ On("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ $n("")), ur = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function ft(t) {
+  const e = t >> 25;
+  let n = (t & 33554431) << 5;
+  for (let r = 0; r < ur.length; r++)
+    (e >> r & 1) === 1 && (n ^= ur[r]);
+  return n;
+}
+function dr(t, e, n = 1) {
+  const r = t.length;
+  let o = 1;
+  for (let s = 0; s < r; s++) {
+    const i = t.charCodeAt(s);
+    if (i < 33 || i > 126)
+      throw new Error(`Invalid prefix (${t})`);
+    o = ft(o) ^ i >> 5;
+  }
+  o = ft(o);
+  for (let s = 0; s < r; s++)
+    o = ft(o) ^ t.charCodeAt(s) & 31;
+  for (let s of e)
+    o = ft(o) ^ s;
+  for (let s = 0; s < 6; s++)
+    o = ft(o);
+  return o ^= n, En.encode(xn([o % Ct[30]], 30, 5, !1));
+}
+// @__NO_SIDE_EFFECTS__
+function Es(t) {
+  const e = t === "bech32" ? 1 : 734539939, n = /* @__PURE__ */ Nn(5), r = n.decode, o = n.encode, s = ar(r);
+  function i(a, y, l = 90) {
+    je("bech32.encode prefix", a), Rn(y) && (y = Array.from(y)), qr("bech32.encode", y);
+    const b = a.length;
+    if (b === 0)
+      throw new TypeError(`Invalid prefix length ${b}`);
+    const E = b + 7 + y.length;
+    if (l !== !1 && E > l)
+      throw new TypeError(`Length ${E} exceeds limit ${l}`);
+    const x = a.toLowerCase(), w = dr(x, y, e);
+    return `${x}1${En.encode(y)}${w}`;
+  }
+  function c(a, y = 90) {
+    je("bech32.decode input", a);
+    const l = a.length;
+    if (l < 8 || y !== !1 && l > y)
+      throw new TypeError(`invalid string length: ${l} (${a}). Expected (8..${y})`);
+    const b = a.toLowerCase();
+    if (a !== b && a !== a.toUpperCase())
+      throw new Error("String must be lowercase or uppercase");
+    const E = b.lastIndexOf("1");
+    if (E === 0 || E === -1)
+      throw new Error('Letter "1" must be present between prefix and data only');
+    const x = b.slice(0, E), w = b.slice(E + 1);
+    if (w.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const H = En.decode(w).slice(0, -6), k = dr(x, H, e);
+    if (!w.endsWith(k))
+      throw new Error(`Invalid checksum in ${a}: expected "${k}"`);
+    return { prefix: x, words: H };
+  }
+  const f = ar(c);
+  function u(a) {
+    const { prefix: y, words: l } = c(a, !1);
+    return { prefix: y, words: l, bytes: r(l) };
+  }
+  function d(a, y) {
+    return i(a, o(y));
+  }
+  return {
+    encode: i,
+    decode: c,
+    encodeFromBytes: d,
+    decodeToBytes: u,
+    decodeUnsafe: f,
+    fromWords: r,
+    fromWordsUnsafe: s,
+    toWords: o
+  };
+}
+const re = /* @__PURE__ */ Es("bech32");
+function ms(t, e, n, r) {
+  Zt(t);
+  const o = Pr({ dkLen: 32, asyncTick: 10 }, r), { c: s, dkLen: i, asyncTick: c } = o;
+  if (de(s, "c"), de(i, "dkLen"), de(c, "asyncTick"), s < 1)
+    throw new Error("iterations (c) must be >= 1");
+  if (i < 1)
+    throw new Error('"dkLen" must be >= 1');
+  if (i > (2 ** 32 - 1) * t.outputLen)
+    throw new Error("derived key too long");
+  const f = ir(e, "password"), u = ir(n, "salt"), d = new Uint8Array(i), a = Et.create(t, f), y = a._cloneInto().update(u);
+  return { c: s, dkLen: i, asyncTick: c, DK: d, PRF: a, PRFSalt: y };
+}
+function As(t, e, n, r, o) {
+  return t.destroy(), e.destroy(), r && r.destroy(), De(o), n;
+}
+function Gr(t, e, n, r) {
+  const { c: o, dkLen: s, DK: i, PRF: c, PRFSalt: f } = ms(t, e, n, r);
+  let u;
+  const d = new Uint8Array(4), a = Tt(d), y = new Uint8Array(c.outputLen);
+  for (let l = 1, b = 0; b < s; l++, b += c.outputLen) {
+    const E = i.subarray(b, b + c.outputLen);
+    a.setInt32(0, l, !1), (u = f._cloneInto(u)).update(d).digestInto(y), E.set(y.subarray(0, E.length));
+    for (let x = 1; x < o; x++) {
+      c._cloneInto(u).update(y).digestInto(y);
+      for (let w = 0; w < E.length; w++)
+        E[w] ^= y[w];
+    }
+  }
+  return As(c, f, i, u, y);
+}
+function lr(t, e, n, r, o, s) {
+  let i = t[e++] ^ n[r++], c = t[e++] ^ n[r++], f = t[e++] ^ n[r++], u = t[e++] ^ n[r++], d = t[e++] ^ n[r++], a = t[e++] ^ n[r++], y = t[e++] ^ n[r++], l = t[e++] ^ n[r++], b = t[e++] ^ n[r++], E = t[e++] ^ n[r++], x = t[e++] ^ n[r++], w = t[e++] ^ n[r++], H = t[e++] ^ n[r++], k = t[e++] ^ n[r++], O = t[e++] ^ n[r++], $ = t[e++] ^ n[r++], R = i, N = c, T = f, S = u, M = d, C = a, K = y, v = l, h = b, p = E, A = x, L = w, U = H, m = k, I = O, B = $;
+  for (let _ = 0; _ < 8; _ += 2)
+    M ^= j(R + U | 0, 7), h ^= j(M + R | 0, 9), U ^= j(h + M | 0, 13), R ^= j(U + h | 0, 18), p ^= j(C + N | 0, 7), m ^= j(p + C | 0, 9), N ^= j(m + p | 0, 13), C ^= j(N + m | 0, 18), I ^= j(A + K | 0, 7), T ^= j(I + A | 0, 9), K ^= j(T + I | 0, 13), A ^= j(K + T | 0, 18), S ^= j(B + L | 0, 7), v ^= j(S + B | 0, 9), L ^= j(v + S | 0, 13), B ^= j(L + v | 0, 18), N ^= j(R + S | 0, 7), T ^= j(N + R | 0, 9), S ^= j(T + N | 0, 13), R ^= j(S + T | 0, 18), K ^= j(C + M | 0, 7), v ^= j(K + C | 0, 9), M ^= j(v + K | 0, 13), C ^= j(M + v | 0, 18), L ^= j(A + p | 0, 7), h ^= j(L + A | 0, 9), p ^= j(h + L | 0, 13), A ^= j(p + h | 0, 18), U ^= j(B + I | 0, 7), m ^= j(U + B | 0, 9), I ^= j(m + U | 0, 13), B ^= j(I + m | 0, 18);
+  o[s++] = i + R | 0, o[s++] = c + N | 0, o[s++] = f + T | 0, o[s++] = u + S | 0, o[s++] = d + M | 0, o[s++] = a + C | 0, o[s++] = y + K | 0, o[s++] = l + v | 0, o[s++] = b + h | 0, o[s++] = E + p | 0, o[s++] = x + A | 0, o[s++] = w + L | 0, o[s++] = H + U | 0, o[s++] = k + m | 0, o[s++] = O + I | 0, o[s++] = $ + B | 0;
+}
+function fn(t, e, n, r, o) {
+  let s = r + 0, i = r + 16 * o;
+  for (let c = 0; c < 16; c++)
+    n[i + c] = t[e + (2 * o - 1) * 16 + c];
+  for (let c = 0; c < o; c++, s += 16, e += 16)
+    lr(n, i, t, e, n, s), c > 0 && (i += 16), lr(n, s, t, e += 16, n, i);
+}
+function Bs(t, e, n) {
+  const r = Pr({
+    dkLen: 32,
+    asyncTick: 10,
+    maxmem: 1073742848
+  }, n), { N: o, r: s, p: i, dkLen: c, asyncTick: f, maxmem: u, onProgress: d } = r;
+  if (de(o, "N"), de(s, "r"), de(i, "p"), de(c, "dkLen"), de(f, "asyncTick"), de(u, "maxmem"), d !== void 0 && typeof d != "function")
+    throw new Error("progressCb must be a function");
+  const a = 128 * s, y = a / 4, l = Math.pow(2, 32);
+  if (o <= 1 || (o & o - 1) !== 0 || o > l)
+    throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32');
+  if (i < 1 || i > (l - 1) * 32 / a)
+    throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)');
+  if (c < 1 || c > (l - 1) * 32)
+    throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32');
+  const b = a * (o + i + 1);
+  if (b > u)
+    throw new Error('"maxmem" limit was hit: memUsed(128*r*(N+p+1))=' + b + ", maxmem=" + u);
+  const E = Gr(ee, t, e, { c: 1, dkLen: a * i }), x = sn(E), w = sn(new Uint8Array(a * o)), H = sn(new Uint8Array(a));
+  let k = () => {
+  };
+  if (d) {
+    const O = 2 * o * i, $ = Math.max(Math.floor(O / 1e4), 1);
+    let R = 0;
+    k = () => {
+      R++, d && (!(R % $) || R === O) && d(R / O);
+    };
+  }
+  return { N: o, r: s, p: i, dkLen: c, blockSize32: y, V: w, B32: x, B: E, tmp: H, blockMixCb: k, asyncTick: f };
+}
+function Ls(t, e, n, r, o) {
+  const s = Gr(ee, t, n, { c: 1, dkLen: e });
+  return De(n, r, o), s;
+}
+function Yr(t, e, n) {
+  const { N: r, r: o, p: s, dkLen: i, blockSize32: c, V: f, B32: u, B: d, tmp: a, blockMixCb: y } = Bs(t, e, n);
+  sr(u);
+  for (let l = 0; l < s; l++) {
+    const b = c * l;
+    for (let E = 0; E < c; E++)
+      f[E] = u[b + E];
+    for (let E = 0, x = 0; E < r - 1; E++)
+      fn(f, x, f, x += c, o), y();
+    fn(f, (r - 1) * c, u, b, o), y();
+    for (let E = 0; E < r; E++) {
+      const x = (u[b + c - 16] & r - 1) >>> 0;
+      for (let w = 0; w < c; w++)
+        a[w] = u[b + w] ^ f[x * c + w];
+      fn(a, 0, u, b, o), y();
+    }
+  }
+  return sr(u), Ls(t, i, d, f, a);
+}
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function Ss(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in t && t.BYTES_PER_ELEMENT === 1;
+}
+function mn(t) {
+  if (typeof t != "boolean")
+    throw new TypeError(`boolean expected, not ${t}`);
+}
+function yt(t) {
+  if (typeof t != "number")
+    throw new TypeError("number expected, got " + typeof t);
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new RangeError("positive integer expected, got " + t);
+}
+function ne(t, e, n = "") {
+  const r = Ss(t), o = t == null ? void 0 : t.length, s = e !== void 0;
+  if (!r || s && o !== e) {
+    const i = n && `"${n}" `, c = s ? ` of length ${e}` : "", f = r ? `length=${o}` : `type=${typeof t}`, u = i + "expected Uint8Array" + c + ", got " + f;
+    throw r ? new RangeError(u) : new TypeError(u);
+  }
+  return t;
+}
+function hr(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function Hs(t, e, n = !1) {
+  ne(t, void 0, "output");
+  const r = e.outputLen;
+  if (t.length < r)
+    throw new RangeError("digestInto() expects output buffer of length at least " + r);
+  if (n && !bt(t))
+    throw new Error("invalid output, must be aligned");
+}
+function xe(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function Ke(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function Us(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+const Je = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68, Is = (t) => t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255, ks = (t) => {
+  for (let e = 0; e < t.length; e++)
+    t[e] = Is(t[e]);
+  return t;
+}, Ne = Je ? (t) => t : ks;
+function _s(t, e) {
+  if (e == null || typeof e != "object")
+    throw new Error("options must be defined");
+  return Object.assign(t, e);
+}
+function Ks(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  let n = 0;
+  for (let r = 0; r < t.length; r++)
+    n |= t[r] ^ e[r];
+  return n === 0;
+}
+function vs(t, e, n) {
+  const r = e, o = (() => []), s = (c, f) => r(f, ...o(c)).update(c).digest(), i = r(new Uint8Array(t), ...o(new Uint8Array(0)));
+  return s.outputLen = i.outputLen, s.blockLen = i.blockLen, s.create = (c, ...f) => r(c, ...f), s;
+}
+const Rs = /* @__NO_SIDE_EFFECTS__ */ (t, e) => {
+  function n(r, ...o) {
+    if (ne(r, void 0, "key"), t.nonceLength !== void 0) {
+      const d = o[0];
+      ne(d, t.varSizeNonce ? void 0 : t.nonceLength, "nonce");
+    }
+    const s = t.tagLength;
+    s && o[1] !== void 0 && ne(o[1], void 0, "AAD");
+    const i = e(r, ...o), c = (d, a) => {
+      if (a !== void 0) {
+        if (d !== 2)
+          throw new Error("cipher output not supported");
+        ne(a, void 0, "output");
+      }
+    };
+    let f = !1;
+    return {
+      encrypt(d, a) {
+        if (f)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        return f = !0, ne(d), c(i.encrypt.length, a), i.encrypt(d, a);
+      },
+      decrypt(d, a) {
+        if (ne(d), s && d.length < s)
+          throw new Error('"ciphertext" expected length bigger than tagLength=' + s);
+        return c(i.decrypt.length, a), i.decrypt(d, a);
+      }
+    };
+  }
+  return Object.assign(n, t), n;
+};
+function An(t, e, n = !0) {
+  if (e === void 0)
+    return new Uint8Array(t);
+  if (ne(e, void 0, "output"), e.length !== t)
+    throw new Error('"output" expected Uint8Array of length ' + t + ", got: " + e.length);
+  if (n && !bt(e))
+    throw new Error("invalid output, must be aligned");
+  return e;
+}
+function Ts(t, e, n) {
+  yt(t), yt(e), mn(n);
+  const r = new Uint8Array(16), o = Us(r);
+  return o.setBigUint64(0, BigInt(e), n), o.setBigUint64(8, BigInt(t), n), r;
+}
+function bt(t) {
+  return t.byteOffset % 4 === 0;
+}
+function Pt(t) {
+  return Uint8Array.from(ne(t));
+}
+const Zr = (t) => Uint8Array.from(t.split(""), (e) => e.charCodeAt(0)), Cs = Ne(xe(Zr("expand 16-byte k"))), Os = Ne(xe(Zr("expand 32-byte k")));
+function q(t, e) {
+  return t << e | t >>> 32 - e;
+}
+const at = 64, $s = 16, Bn = 2 ** 32 - 1, yr = /* @__PURE__ */ Uint32Array.of();
+function Ns(t, e, n, r, o, s, i, c) {
+  const f = o.length, u = new Uint8Array(at), d = xe(u), a = Je && bt(o) && bt(s), y = a ? xe(o) : yr, l = a ? xe(s) : yr;
+  if (!Je) {
+    for (let b = 0; b < f; i++) {
+      if (t(e, n, r, d, i, c), Ne(d), i >= Bn)
+        throw new Error("arx: counter overflow");
+      const E = Math.min(at, f - b);
+      for (let x = 0, w; x < E; x++)
+        w = b + x, s[w] = o[w] ^ u[x];
+      b += E;
+    }
+    return;
+  }
+  for (let b = 0; b < f; i++) {
+    if (t(e, n, r, d, i, c), i >= Bn)
+      throw new Error("arx: counter overflow");
+    const E = Math.min(at, f - b);
+    if (a && E === at) {
+      const x = b / 4;
+      if (b % 4 !== 0)
+        throw new Error("arx: invalid block position");
+      for (let w = 0, H; w < $s; w++)
+        H = x + w, l[H] = y[H] ^ d[w];
+      b += at;
+      continue;
+    }
+    for (let x = 0, w; x < E; x++)
+      w = b + x, s[w] = o[w] ^ u[x];
+    b += E;
+  }
+}
+function Ms(t, e) {
+  const { allowShortKeys: n, extendNonceFn: r, counterLength: o, counterRight: s, rounds: i } = _s({ allowShortKeys: !1, counterLength: 8, counterRight: !1, rounds: 20 }, e);
+  if (typeof t != "function")
+    throw new Error("core must be a function");
+  return yt(o), yt(i), mn(s), mn(n), (c, f, u, d, a = 0) => {
+    ne(c, void 0, "key"), ne(f, void 0, "nonce"), ne(u, void 0, "data");
+    const y = u.length;
+    if (d = An(y, d, !1), yt(a), a < 0 || a >= Bn)
+      throw new Error("arx: counter overflow");
+    const l = [];
+    let b = c.length, E, x;
+    if (b === 32)
+      l.push(E = Pt(c)), x = Os;
+    else if (b === 16 && n)
+      E = new Uint8Array(32), E.set(c), E.set(c, 16), x = Cs, l.push(E);
+    else
+      throw ne(c, 32, "arx key"), new Error("invalid key size");
+    (!Je || !bt(f)) && l.push(f = Pt(f));
+    let w = xe(E);
+    if (r) {
+      if (f.length !== 24)
+        throw new Error("arx: extended nonce must be 24 bytes");
+      const O = f.subarray(0, 16);
+      if (Je)
+        r(x, w, xe(O), w);
+      else {
+        const $ = Ne(Uint32Array.from(x));
+        r($, w, xe(O), w), Ke($), Ne(w);
+      }
+      f = f.subarray(16);
+    } else Je || Ne(w);
+    const H = 16 - o;
+    if (H !== f.length)
+      throw new Error(`arx: nonce must be ${H} or 16 bytes`);
+    if (H !== 12) {
+      const O = new Uint8Array(12);
+      O.set(f, s ? 0 : 12 - f.length), f = O, l.push(f);
+    }
+    const k = Ne(xe(f));
+    try {
+      return Ns(t, x, w, k, u, d, a, i), d;
+    } finally {
+      Ke(...l);
+    }
+  };
+}
+function J(t, e) {
+  return t[e++] & 255 | (t[e++] & 255) << 8;
+}
+class Fs {
+  // Can be speed-up using BigUint64Array, at the cost of complexity
+  constructor(e) {
+    g(this, "blockLen", 16);
+    g(this, "outputLen", 16);
+    g(this, "buffer", new Uint8Array(16));
+    g(this, "r", new Uint16Array(10));
+    // Allocating 1 array with .subarray() here is slower than 3
+    g(this, "h", new Uint16Array(10));
+    g(this, "pad", new Uint16Array(8));
+    g(this, "pos", 0);
+    g(this, "finished", !1);
+    g(this, "destroyed", !1);
+    e = Pt(ne(e, 32, "key"));
+    const n = J(e, 0), r = J(e, 2), o = J(e, 4), s = J(e, 6), i = J(e, 8), c = J(e, 10), f = J(e, 12), u = J(e, 14);
+    this.r[0] = n & 8191, this.r[1] = (n >>> 13 | r << 3) & 8191, this.r[2] = (r >>> 10 | o << 6) & 7939, this.r[3] = (o >>> 7 | s << 9) & 8191, this.r[4] = (s >>> 4 | i << 12) & 255, this.r[5] = i >>> 1 & 8190, this.r[6] = (i >>> 14 | c << 2) & 8191, this.r[7] = (c >>> 11 | f << 5) & 8065, this.r[8] = (f >>> 8 | u << 8) & 8191, this.r[9] = u >>> 5 & 127;
+    for (let d = 0; d < 8; d++)
+      this.pad[d] = J(e, 16 + 2 * d);
+  }
+  process(e, n, r = !1) {
+    const o = r ? 0 : 2048, { h: s, r: i } = this, c = i[0], f = i[1], u = i[2], d = i[3], a = i[4], y = i[5], l = i[6], b = i[7], E = i[8], x = i[9], w = J(e, n + 0), H = J(e, n + 2), k = J(e, n + 4), O = J(e, n + 6), $ = J(e, n + 8), R = J(e, n + 10), N = J(e, n + 12), T = J(e, n + 14);
+    let S = s[0] + (w & 8191), M = s[1] + ((w >>> 13 | H << 3) & 8191), C = s[2] + ((H >>> 10 | k << 6) & 8191), K = s[3] + ((k >>> 7 | O << 9) & 8191), v = s[4] + ((O >>> 4 | $ << 12) & 8191), h = s[5] + ($ >>> 1 & 8191), p = s[6] + (($ >>> 14 | R << 2) & 8191), A = s[7] + ((R >>> 11 | N << 5) & 8191), L = s[8] + ((N >>> 8 | T << 8) & 8191), U = s[9] + (T >>> 5 | o), m = 0, I = m + S * c + M * (5 * x) + C * (5 * E) + K * (5 * b) + v * (5 * l);
+    m = I >>> 13, I &= 8191, I += h * (5 * y) + p * (5 * a) + A * (5 * d) + L * (5 * u) + U * (5 * f), m += I >>> 13, I &= 8191;
+    let B = m + S * f + M * c + C * (5 * x) + K * (5 * E) + v * (5 * b);
+    m = B >>> 13, B &= 8191, B += h * (5 * l) + p * (5 * y) + A * (5 * a) + L * (5 * d) + U * (5 * u), m += B >>> 13, B &= 8191;
+    let _ = m + S * u + M * f + C * c + K * (5 * x) + v * (5 * E);
+    m = _ >>> 13, _ &= 8191, _ += h * (5 * b) + p * (5 * l) + A * (5 * y) + L * (5 * a) + U * (5 * d), m += _ >>> 13, _ &= 8191;
+    let P = m + S * d + M * u + C * f + K * c + v * (5 * x);
+    m = P >>> 13, P &= 8191, P += h * (5 * E) + p * (5 * b) + A * (5 * l) + L * (5 * y) + U * (5 * a), m += P >>> 13, P &= 8191;
+    let z = m + S * a + M * d + C * u + K * f + v * c;
+    m = z >>> 13, z &= 8191, z += h * (5 * x) + p * (5 * E) + A * (5 * b) + L * (5 * l) + U * (5 * y), m += z >>> 13, z &= 8191;
+    let D = m + S * y + M * a + C * d + K * u + v * f;
+    m = D >>> 13, D &= 8191, D += h * c + p * (5 * x) + A * (5 * E) + L * (5 * b) + U * (5 * l), m += D >>> 13, D &= 8191;
+    let F = m + S * l + M * y + C * a + K * d + v * u;
+    m = F >>> 13, F &= 8191, F += h * f + p * c + A * (5 * x) + L * (5 * E) + U * (5 * b), m += F >>> 13, F &= 8191;
+    let V = m + S * b + M * l + C * y + K * a + v * d;
+    m = V >>> 13, V &= 8191, V += h * u + p * f + A * c + L * (5 * x) + U * (5 * E), m += V >>> 13, V &= 8191;
+    let G = m + S * E + M * b + C * l + K * y + v * a;
+    m = G >>> 13, G &= 8191, G += h * d + p * u + A * f + L * c + U * (5 * x), m += G >>> 13, G &= 8191;
+    let X = m + S * x + M * E + C * b + K * l + v * y;
+    m = X >>> 13, X &= 8191, X += h * a + p * d + A * u + L * f + U * c, m += X >>> 13, X &= 8191, m = (m << 2) + m | 0, m = m + I | 0, I = m & 8191, m = m >>> 13, B += m, s[0] = I, s[1] = B, s[2] = _, s[3] = P, s[4] = z, s[5] = D, s[6] = F, s[7] = V, s[8] = G, s[9] = X;
+  }
+  finalize() {
+    const { h: e, pad: n } = this, r = new Uint16Array(10);
+    let o = e[1] >>> 13;
+    e[1] &= 8191;
+    for (let c = 2; c < 10; c++)
+      e[c] += o, o = e[c] >>> 13, e[c] &= 8191;
+    e[0] += o * 5, o = e[0] >>> 13, e[0] &= 8191, e[1] += o, o = e[1] >>> 13, e[1] &= 8191, e[2] += o, r[0] = e[0] + 5, o = r[0] >>> 13, r[0] &= 8191;
+    for (let c = 1; c < 10; c++)
+      r[c] = e[c] + o, o = r[c] >>> 13, r[c] &= 8191;
+    r[9] -= 8192;
+    let s = (o ^ 1) - 1;
+    for (let c = 0; c < 10; c++)
+      r[c] &= s;
+    s = ~s;
+    for (let c = 0; c < 10; c++)
+      e[c] = e[c] & s | r[c];
+    e[0] = (e[0] | e[1] << 13) & 65535, e[1] = (e[1] >>> 3 | e[2] << 10) & 65535, e[2] = (e[2] >>> 6 | e[3] << 7) & 65535, e[3] = (e[3] >>> 9 | e[4] << 4) & 65535, e[4] = (e[4] >>> 12 | e[5] << 1 | e[6] << 14) & 65535, e[5] = (e[6] >>> 2 | e[7] << 11) & 65535, e[6] = (e[7] >>> 5 | e[8] << 8) & 65535, e[7] = (e[8] >>> 8 | e[9] << 5) & 65535;
+    let i = e[0] + n[0];
+    e[0] = i & 65535;
+    for (let c = 1; c < 8; c++)
+      i = (e[c] + n[c] | 0) + (i >>> 16) | 0, e[c] = i & 65535;
+    Ke(r);
+  }
+  update(e) {
+    hr(this), ne(e), e = Pt(e);
+    const { buffer: n, blockLen: r } = this, o = e.length;
+    for (let s = 0; s < o; ) {
+      const i = Math.min(r - this.pos, o - s);
+      if (i === r) {
+        for (; r <= o - s; s += r)
+          this.process(e, s);
+        continue;
+      }
+      n.set(e.subarray(s, s + i), this.pos), this.pos += i, s += i, this.pos === r && (this.process(n, 0, !1), this.pos = 0);
+    }
+    return this;
+  }
+  destroy() {
+    this.destroyed = !0, Ke(this.h, this.r, this.buffer, this.pad);
+  }
+  digestInto(e) {
+    hr(this), Hs(e, this), this.finished = !0;
+    const { buffer: n, h: r } = this;
+    let { pos: o } = this;
+    if (o) {
+      for (n[o++] = 1; o < 16; o++)
+        n[o] = 0;
+      this.process(n, 0, !0);
+    }
+    this.finalize();
+    let s = 0;
+    for (let i = 0; i < 8; i++)
+      e[s++] = r[i] >>> 0, e[s++] = r[i] >>> 8;
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+}
+const Ps = /* @__PURE__ */ vs(32, (t) => new Fs(t));
+function Ds(t, e, n, r, o, s = 20) {
+  let i = t[0], c = t[1], f = t[2], u = t[3], d = e[0], a = e[1], y = e[2], l = e[3], b = e[4], E = e[5], x = e[6], w = e[7], H = o, k = n[0], O = n[1], $ = n[2], R = i, N = c, T = f, S = u, M = d, C = a, K = y, v = l, h = b, p = E, A = x, L = w, U = H, m = k, I = O, B = $;
+  for (let P = 0; P < s; P += 2)
+    R = R + M | 0, U = q(U ^ R, 16), h = h + U | 0, M = q(M ^ h, 12), R = R + M | 0, U = q(U ^ R, 8), h = h + U | 0, M = q(M ^ h, 7), N = N + C | 0, m = q(m ^ N, 16), p = p + m | 0, C = q(C ^ p, 12), N = N + C | 0, m = q(m ^ N, 8), p = p + m | 0, C = q(C ^ p, 7), T = T + K | 0, I = q(I ^ T, 16), A = A + I | 0, K = q(K ^ A, 12), T = T + K | 0, I = q(I ^ T, 8), A = A + I | 0, K = q(K ^ A, 7), S = S + v | 0, B = q(B ^ S, 16), L = L + B | 0, v = q(v ^ L, 12), S = S + v | 0, B = q(B ^ S, 8), L = L + B | 0, v = q(v ^ L, 7), R = R + C | 0, B = q(B ^ R, 16), A = A + B | 0, C = q(C ^ A, 12), R = R + C | 0, B = q(B ^ R, 8), A = A + B | 0, C = q(C ^ A, 7), N = N + K | 0, U = q(U ^ N, 16), L = L + U | 0, K = q(K ^ L, 12), N = N + K | 0, U = q(U ^ N, 8), L = L + U | 0, K = q(K ^ L, 7), T = T + v | 0, m = q(m ^ T, 16), h = h + m | 0, v = q(v ^ h, 12), T = T + v | 0, m = q(m ^ T, 8), h = h + m | 0, v = q(v ^ h, 7), S = S + M | 0, I = q(I ^ S, 16), p = p + I | 0, M = q(M ^ p, 12), S = S + M | 0, I = q(I ^ S, 8), p = p + I | 0, M = q(M ^ p, 7);
+  let _ = 0;
+  r[_++] = i + R | 0, r[_++] = c + N | 0, r[_++] = f + T | 0, r[_++] = u + S | 0, r[_++] = d + M | 0, r[_++] = a + C | 0, r[_++] = y + K | 0, r[_++] = l + v | 0, r[_++] = b + h | 0, r[_++] = E + p | 0, r[_++] = x + A | 0, r[_++] = w + L | 0, r[_++] = H + U | 0, r[_++] = k + m | 0, r[_++] = O + I | 0, r[_++] = $ + B | 0;
+}
+const js = /* @__PURE__ */ Ms(Ds, {
+  counterRight: !1,
+  counterLength: 4,
+  allowShortKeys: !1
+}), qs = /* @__PURE__ */ new Uint8Array(16), pr = (t, e) => {
+  t.update(e);
+  const n = e.length % 16;
+  n && t.update(qs.subarray(n));
+}, zs = /* @__PURE__ */ new Uint8Array(32);
+function gr(t, e, n, r, o) {
+  o !== void 0 && ne(o, void 0, "AAD");
+  const s = t(e, n, zs), i = Ts(r.length, o ? o.length : 0, !0), c = Ps.create(s);
+  o && pr(c, o), pr(c, r), c.update(i);
+  const f = c.digest();
+  return Ke(s, i), f;
+}
+const Vs = (t) => (e, n, r) => ({
+  encrypt(s, i) {
+    const c = s.length;
+    i = An(c + 16, i, !1), i.set(s);
+    const f = i.subarray(0, -16);
+    t(e, n, f, f, 1);
+    const u = gr(t, e, n, f, r);
+    return i.set(u, c), Ke(u), i;
+  },
+  decrypt(s, i) {
+    i = An(s.length - 16, i, !1);
+    const c = s.subarray(0, -16), f = s.subarray(-16), u = gr(t, e, n, c, r);
+    if (!Ks(f, u))
+      throw Ke(u), new Error("invalid tag");
+    return i.set(s.subarray(0, -16)), t(e, n, i, i, 1), Ke(u), i;
+  }
+}), ge = /* @__PURE__ */ Rs(
+  { blockSize: 64, nonceLength: 12, tagLength: 16 },
+  /* @__PURE__ */ Vs(js)
+);
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function Mn(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function qe(t, e = "") {
+  if (!Number.isSafeInteger(t) || t < 0) {
+    const n = e && `"${e}" `;
+    throw new Error(`${n}expected integer >= 0, got ${t}`);
+  }
+}
+function Z(t, e, n = "") {
+  const r = Mn(t), o = t == null ? void 0 : t.length, s = e !== void 0;
+  if (!r || s && o !== e) {
+    const i = n && `"${n}" `, c = s ? ` of length ${e}` : "", f = r ? `length=${o}` : `type=${typeof t}`;
+    throw new Error(i + "expected Uint8Array" + c + ", got " + f);
+  }
+  return t;
+}
+function Xr(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  qe(t.outputLen), qe(t.blockLen);
+}
+function Dt(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function Gs(t, e) {
+  Z(t, void 0, "digestInto() output");
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error('"digestInto() output" expected to be of length >=' + n);
+}
+function ot(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function an(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function ye(t, e) {
+  return t << 32 - e | t >>> e;
+}
+const Wr = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Ys = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function Xt(t) {
+  if (Z(t), Wr)
+    return t.toHex();
+  let e = "";
+  for (let n = 0; n < t.length; n++)
+    e += Ys[t[n]];
+  return e;
+}
+const be = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function br(t) {
+  if (t >= be._0 && t <= be._9)
+    return t - be._0;
+  if (t >= be.A && t <= be.F)
+    return t - (be.A - 10);
+  if (t >= be.a && t <= be.f)
+    return t - (be.a - 10);
+}
+function jt(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (Wr)
+    return Uint8Array.fromHex(t);
+  const e = t.length, n = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const r = new Uint8Array(n);
+  for (let o = 0, s = 0; o < n; o++, s += 2) {
+    const i = br(t.charCodeAt(s)), c = br(t.charCodeAt(s + 1));
+    if (i === void 0 || c === void 0) {
+      const f = t[s] + t[s + 1];
+      throw new Error('hex string expected, got non-hex character "' + f + '" at index ' + s);
+    }
+    r[o] = i * 16 + c;
+  }
+  return r;
+}
+function ie(...t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r];
+    Z(o), e += o.length;
+  }
+  const n = new Uint8Array(e);
+  for (let r = 0, o = 0; r < t.length; r++) {
+    const s = t[r];
+    n.set(s, o), o += s.length;
+  }
+  return n;
+}
+function Qr(t, e = {}) {
+  const n = (o, s) => t(s).update(o).digest(), r = t(void 0);
+  return n.outputLen = r.outputLen, n.blockLen = r.blockLen, n.create = (o) => t(o), Object.assign(n, e), Object.freeze(n);
+}
+function Fn(t = 32) {
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof (e == null ? void 0 : e.getRandomValues) != "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return e.getRandomValues(new Uint8Array(t));
+}
+const Jr = (t) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, t])
+});
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Pn = /* @__PURE__ */ BigInt(0), Ln = /* @__PURE__ */ BigInt(1);
+function qt(t, e = "") {
+  if (typeof t != "boolean") {
+    const n = e && `"${e}" `;
+    throw new Error(n + "expected boolean, got type=" + typeof t);
+  }
+  return t;
+}
+function eo(t) {
+  if (typeof t == "bigint") {
+    if (!Ot(t))
+      throw new Error("positive bigint expected, got " + t);
+  } else
+    qe(t);
+  return t;
+}
+function Ht(t) {
+  const e = eo(t).toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function to(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? Pn : BigInt("0x" + t);
+}
+function At(t) {
+  return to(Xt(t));
+}
+function wt(t) {
+  return to(Xt(Sn(Z(t)).reverse()));
+}
+function Wt(t, e) {
+  qe(e), t = eo(t);
+  const n = jt(t.toString(16).padStart(e * 2, "0"));
+  if (n.length !== e)
+    throw new Error("number too large");
+  return n;
+}
+function Dn(t, e) {
+  return Wt(t, e).reverse();
+}
+function Sn(t) {
+  return Uint8Array.from(t);
+}
+function Me(t) {
+  return Uint8Array.from(t, (e, n) => {
+    const r = e.charCodeAt(0);
+    if (e.length !== 1 || r > 127)
+      throw new Error(`string contains non-ASCII character "${t[n]}" with code ${r} at position ${n}`);
+    return r;
+  });
+}
+const Ot = (t) => typeof t == "bigint" && Pn <= t;
+function Zs(t, e, n) {
+  return Ot(t) && Ot(e) && Ot(n) && e <= t && t < n;
+}
+function Hn(t, e, n, r) {
+  if (!Zs(e, n, r))
+    throw new Error("expected valid " + t + ": " + n + " <= n < " + r + ", got " + e);
+}
+function Xs(t) {
+  let e;
+  for (e = 0; t > Pn; t >>= Ln, e += 1)
+    ;
+  return e;
+}
+const jn = (t) => (Ln << BigInt(t)) - Ln;
+function Ws(t, e, n) {
+  if (qe(t, "hashLen"), qe(e, "qByteLen"), typeof n != "function")
+    throw new Error("hmacFn must be a function");
+  const r = (x) => new Uint8Array(x), o = Uint8Array.of(), s = Uint8Array.of(0), i = Uint8Array.of(1), c = 1e3;
+  let f = r(t), u = r(t), d = 0;
+  const a = () => {
+    f.fill(1), u.fill(0), d = 0;
+  }, y = (...x) => n(u, ie(f, ...x)), l = (x = o) => {
+    u = y(s, x), f = y(), x.length !== 0 && (u = y(i, x), f = y());
+  }, b = () => {
+    if (d++ >= c)
+      throw new Error("drbg: tried max amount of iterations");
+    let x = 0;
+    const w = [];
+    for (; x < e; ) {
+      f = y();
+      const H = f.slice();
+      w.push(H), x += f.length;
+    }
+    return ie(...w);
+  };
+  return (x, w) => {
+    a(), l(x);
+    let H;
+    for (; !(H = w(b())); )
+      l();
+    return a(), H;
+  };
+}
+function Qt(t, e = {}, n = {}) {
+  if (!t || typeof t != "object")
+    throw new Error("expected valid options object");
+  function r(s, i, c) {
+    const f = t[s];
+    if (c && f === void 0)
+      return;
+    const u = typeof f;
+    if (u !== i || f === null)
+      throw new Error(`param "${s}" is invalid: expected ${i}, got ${u}`);
+  }
+  const o = (s, i) => Object.entries(s).forEach(([c, f]) => r(c, f, i));
+  o(e, !1), o(n, !0);
+}
+function wr(t) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return (n, ...r) => {
+    const o = e.get(n);
+    if (o !== void 0)
+      return o;
+    const s = t(n, ...r);
+    return e.set(n, s), s;
+  };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const ae = /* @__PURE__ */ BigInt(0), fe = /* @__PURE__ */ BigInt(1), Fe = /* @__PURE__ */ BigInt(2), no = /* @__PURE__ */ BigInt(3), ro = /* @__PURE__ */ BigInt(4), oo = /* @__PURE__ */ BigInt(5), Qs = /* @__PURE__ */ BigInt(7), so = /* @__PURE__ */ BigInt(8), Js = /* @__PURE__ */ BigInt(9), io = /* @__PURE__ */ BigInt(16);
+function ue(t, e) {
+  const n = t % e;
+  return n >= ae ? n : e + n;
+}
+function le(t, e, n) {
+  let r = t;
+  for (; e-- > ae; )
+    r *= r, r %= n;
+  return r;
+}
+function xr(t, e) {
+  if (t === ae)
+    throw new Error("invert: expected non-zero number");
+  if (e <= ae)
+    throw new Error("invert: expected positive modulus, got " + e);
+  let n = ue(t, e), r = e, o = ae, s = fe;
+  for (; n !== ae; ) {
+    const c = r / n, f = r % n, u = o - s * c;
+    r = n, n = f, o = s, s = u;
+  }
+  if (r !== fe)
+    throw new Error("invert: does not exist");
+  return ue(o, e);
+}
+function qn(t, e, n) {
+  if (!t.eql(t.sqr(e), n))
+    throw new Error("Cannot find square root");
+}
+function co(t, e) {
+  const n = (t.ORDER + fe) / ro, r = t.pow(e, n);
+  return qn(t, r, e), r;
+}
+function ei(t, e) {
+  const n = (t.ORDER - oo) / so, r = t.mul(e, Fe), o = t.pow(r, n), s = t.mul(e, o), i = t.mul(t.mul(s, Fe), o), c = t.mul(s, t.sub(i, t.ONE));
+  return qn(t, c, e), c;
+}
+function ti(t) {
+  const e = zn(t), n = fo(t), r = n(e, e.neg(e.ONE)), o = n(e, r), s = n(e, e.neg(r)), i = (t + Qs) / io;
+  return (c, f) => {
+    let u = c.pow(f, i), d = c.mul(u, r);
+    const a = c.mul(u, o), y = c.mul(u, s), l = c.eql(c.sqr(d), f), b = c.eql(c.sqr(a), f);
+    u = c.cmov(u, d, l), d = c.cmov(y, a, b);
+    const E = c.eql(c.sqr(d), f), x = c.cmov(u, d, E);
+    return qn(c, x, f), x;
+  };
+}
+function fo(t) {
+  if (t < no)
+    throw new Error("sqrt is not defined for small field");
+  let e = t - fe, n = 0;
+  for (; e % Fe === ae; )
+    e /= Fe, n++;
+  let r = Fe;
+  const o = zn(t);
+  for (; Er(o, r) === 1; )
+    if (r++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (n === 1)
+    return co;
+  let s = o.pow(r, e);
+  const i = (e + fe) / Fe;
+  return function(f, u) {
+    if (f.is0(u))
+      return u;
+    if (Er(f, u) !== 1)
+      throw new Error("Cannot find square root");
+    let d = n, a = f.mul(f.ONE, s), y = f.pow(u, e), l = f.pow(u, i);
+    for (; !f.eql(y, f.ONE); ) {
+      if (f.is0(y))
+        return f.ZERO;
+      let b = 1, E = f.sqr(y);
+      for (; !f.eql(E, f.ONE); )
+        if (b++, E = f.sqr(E), b === d)
+          throw new Error("Cannot find square root");
+      const x = fe << BigInt(d - b - 1), w = f.pow(a, x);
+      d = b, a = f.sqr(w), y = f.mul(y, a), l = f.mul(l, w);
+    }
+    return l;
+  };
+}
+function ni(t) {
+  return t % ro === no ? co : t % so === oo ? ei : t % io === Js ? ti(t) : fo(t);
+}
+const ri = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function oi(t) {
+  const e = {
+    ORDER: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  }, n = ri.reduce((r, o) => (r[o] = "function", r), e);
+  return Qt(t, n), t;
+}
+function si(t, e, n) {
+  if (n < ae)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (n === ae)
+    return t.ONE;
+  if (n === fe)
+    return e;
+  let r = t.ONE, o = e;
+  for (; n > ae; )
+    n & fe && (r = t.mul(r, o)), o = t.sqr(o), n >>= fe;
+  return r;
+}
+function ao(t, e, n = !1) {
+  const r = new Array(e.length).fill(n ? t.ZERO : void 0), o = e.reduce((i, c, f) => t.is0(c) ? i : (r[f] = i, t.mul(i, c)), t.ONE), s = t.inv(o);
+  return e.reduceRight((i, c, f) => t.is0(c) ? i : (r[f] = t.mul(i, r[f]), t.mul(i, c)), s), r;
+}
+function Er(t, e) {
+  const n = (t.ORDER - fe) / Fe, r = t.pow(e, n), o = t.eql(r, t.ONE), s = t.eql(r, t.ZERO), i = t.eql(r, t.neg(t.ONE));
+  if (!o && !s && !i)
+    throw new Error("invalid Legendre symbol result");
+  return o ? 1 : s ? 0 : -1;
+}
+function ii(t, e) {
+  e !== void 0 && qe(e);
+  const n = e !== void 0 ? e : t.toString(2).length, r = Math.ceil(n / 8);
+  return { nBitLength: n, nByteLength: r };
+}
+class ci {
+  constructor(e, n = {}) {
+    g(this, "ORDER");
+    g(this, "BITS");
+    g(this, "BYTES");
+    g(this, "isLE");
+    g(this, "ZERO", ae);
+    g(this, "ONE", fe);
+    g(this, "_lengths");
+    g(this, "_sqrt");
+    // cached sqrt
+    g(this, "_mod");
+    var i;
+    if (e <= ae)
+      throw new Error("invalid field: expected ORDER > 0, got " + e);
+    let r;
+    this.isLE = !1, n != null && typeof n == "object" && (typeof n.BITS == "number" && (r = n.BITS), typeof n.sqrt == "function" && (this.sqrt = n.sqrt), typeof n.isLE == "boolean" && (this.isLE = n.isLE), n.allowedLengths && (this._lengths = (i = n.allowedLengths) == null ? void 0 : i.slice()), typeof n.modFromBytes == "boolean" && (this._mod = n.modFromBytes));
+    const { nBitLength: o, nByteLength: s } = ii(e, r);
+    if (s > 2048)
+      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+    this.ORDER = e, this.BITS = o, this.BYTES = s, this._sqrt = void 0, Object.preventExtensions(this);
+  }
+  create(e) {
+    return ue(e, this.ORDER);
+  }
+  isValid(e) {
+    if (typeof e != "bigint")
+      throw new Error("invalid field element: expected bigint, got " + typeof e);
+    return ae <= e && e < this.ORDER;
+  }
+  is0(e) {
+    return e === ae;
+  }
+  // is valid and invertible
+  isValidNot0(e) {
+    return !this.is0(e) && this.isValid(e);
+  }
+  isOdd(e) {
+    return (e & fe) === fe;
+  }
+  neg(e) {
+    return ue(-e, this.ORDER);
+  }
+  eql(e, n) {
+    return e === n;
+  }
+  sqr(e) {
+    return ue(e * e, this.ORDER);
+  }
+  add(e, n) {
+    return ue(e + n, this.ORDER);
+  }
+  sub(e, n) {
+    return ue(e - n, this.ORDER);
+  }
+  mul(e, n) {
+    return ue(e * n, this.ORDER);
+  }
+  pow(e, n) {
+    return si(this, e, n);
+  }
+  div(e, n) {
+    return ue(e * xr(n, this.ORDER), this.ORDER);
+  }
+  // Same as above, but doesn't normalize
+  sqrN(e) {
+    return e * e;
+  }
+  addN(e, n) {
+    return e + n;
+  }
+  subN(e, n) {
+    return e - n;
+  }
+  mulN(e, n) {
+    return e * n;
+  }
+  inv(e) {
+    return xr(e, this.ORDER);
+  }
+  sqrt(e) {
+    return this._sqrt || (this._sqrt = ni(this.ORDER)), this._sqrt(this, e);
+  }
+  toBytes(e) {
+    return this.isLE ? Dn(e, this.BYTES) : Wt(e, this.BYTES);
+  }
+  fromBytes(e, n = !1) {
+    Z(e);
+    const { _lengths: r, BYTES: o, isLE: s, ORDER: i, _mod: c } = this;
+    if (r) {
+      if (!r.includes(e.length) || e.length > o)
+        throw new Error("Field.fromBytes: expected " + r + " bytes, got " + e.length);
+      const u = new Uint8Array(o);
+      u.set(e, s ? 0 : u.length - e.length), e = u;
+    }
+    if (e.length !== o)
+      throw new Error("Field.fromBytes: expected " + o + " bytes, got " + e.length);
+    let f = s ? wt(e) : At(e);
+    if (c && (f = ue(f, i)), !n && !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(e) {
+    return ao(this, e);
+  }
+  // We can't move this out because Fp6, Fp12 implement it
+  // and it's unclear what to return in there.
+  cmov(e, n, r) {
+    return r ? n : e;
+  }
+}
+function zn(t, e = {}) {
+  return new ci(t, e);
+}
+function uo(t) {
+  if (typeof t != "bigint")
+    throw new Error("field order must be bigint");
+  const e = t.toString(2).length;
+  return Math.ceil(e / 8);
+}
+function lo(t) {
+  const e = uo(t);
+  return e + Math.ceil(e / 2);
+}
+function fi(t, e, n = !1) {
+  Z(t);
+  const r = t.length, o = uo(e), s = lo(e);
+  if (r < 16 || r < s || r > 1024)
+    throw new Error("expected " + s + "-1024 bytes of input, got " + r);
+  const i = n ? wt(t) : At(t), c = ue(i, e - fe) + fe;
+  return n ? Dn(c, o) : Wt(c, o);
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const st = /* @__PURE__ */ BigInt(0), Pe = /* @__PURE__ */ BigInt(1);
+function zt(t, e) {
+  const n = e.negate();
+  return t ? n : e;
+}
+function mr(t, e) {
+  const n = ao(t.Fp, e.map((r) => r.Z));
+  return e.map((r, o) => t.fromAffine(r.toAffine(n[o])));
+}
+function ho(t, e) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > e)
+    throw new Error("invalid window size, expected [1.." + e + "], got W=" + t);
+}
+function un(t, e) {
+  ho(t, e);
+  const n = Math.ceil(e / t) + 1, r = 2 ** (t - 1), o = 2 ** t, s = jn(t), i = BigInt(t);
+  return { windows: n, windowSize: r, mask: s, maxNumber: o, shiftBy: i };
+}
+function Ar(t, e, n) {
+  const { windowSize: r, mask: o, maxNumber: s, shiftBy: i } = n;
+  let c = Number(t & o), f = t >> i;
+  c > r && (c -= s, f += Pe);
+  const u = e * r, d = u + Math.abs(c) - 1, a = c === 0, y = c < 0, l = e % 2 !== 0;
+  return { nextN: f, offset: d, isZero: a, isNeg: y, isNegF: l, offsetF: u };
+}
+const dn = /* @__PURE__ */ new WeakMap(), yo = /* @__PURE__ */ new WeakMap();
+function ln(t) {
+  return yo.get(t) || 1;
+}
+function Br(t) {
+  if (t !== st)
+    throw new Error("invalid wNAF");
+}
+class ai {
+  // Parametrized with a given Point class (not individual point)
+  constructor(e, n) {
+    g(this, "BASE");
+    g(this, "ZERO");
+    g(this, "Fn");
+    g(this, "bits");
+    this.BASE = e.BASE, this.ZERO = e.ZERO, this.Fn = e.Fn, this.bits = n;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(e, n, r = this.ZERO) {
+    let o = e;
+    for (; n > st; )
+      n & Pe && (r = r.add(o)), o = o.double(), n >>= Pe;
+    return r;
+  }
+  /**
+   * 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(e, n) {
+    const { windows: r, windowSize: o } = un(n, this.bits), s = [];
+    let i = e, c = i;
+    for (let f = 0; f < r; f++) {
+      c = i, s.push(c);
+      for (let u = 1; u < o; u++)
+        c = c.add(i), s.push(c);
+      i = c.double();
+    }
+    return s;
+  }
+  /**
+   * 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(e, n, r) {
+    if (!this.Fn.isValid(r))
+      throw new Error("invalid scalar");
+    let o = this.ZERO, s = this.BASE;
+    const i = un(e, this.bits);
+    for (let c = 0; c < i.windows; c++) {
+      const { nextN: f, offset: u, isZero: d, isNeg: a, isNegF: y, offsetF: l } = Ar(r, c, i);
+      r = f, d ? s = s.add(zt(y, n[l])) : o = o.add(zt(a, n[u]));
+    }
+    return Br(r), { p: o, f: s };
+  }
+  /**
+   * 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(e, n, r, o = this.ZERO) {
+    const s = un(e, this.bits);
+    for (let i = 0; i < s.windows && r !== st; i++) {
+      const { nextN: c, offset: f, isZero: u, isNeg: d } = Ar(r, i, s);
+      if (r = c, !u) {
+        const a = n[f];
+        o = o.add(d ? a.negate() : a);
+      }
+    }
+    return Br(r), o;
+  }
+  getPrecomputes(e, n, r) {
+    let o = dn.get(n);
+    return o || (o = this.precomputeWindow(n, e), e !== 1 && (typeof r == "function" && (o = r(o)), dn.set(n, o))), o;
+  }
+  cached(e, n, r) {
+    const o = ln(e);
+    return this.wNAF(o, this.getPrecomputes(o, e, r), n);
+  }
+  unsafe(e, n, r, o) {
+    const s = ln(e);
+    return s === 1 ? this._unsafeLadder(e, n, o) : this.wNAFUnsafe(s, this.getPrecomputes(s, e, r), n, o);
+  }
+  // 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(e, n) {
+    ho(n, this.bits), yo.set(e, n), dn.delete(e);
+  }
+  hasCache(e) {
+    return ln(e) !== 1;
+  }
+}
+function ui(t, e, n, r) {
+  let o = e, s = t.ZERO, i = t.ZERO;
+  for (; n > st || r > st; )
+    n & Pe && (s = s.add(o)), r & Pe && (i = i.add(o)), o = o.double(), n >>= Pe, r >>= Pe;
+  return { p1: s, p2: i };
+}
+function Lr(t, e, n) {
+  if (e) {
+    if (e.ORDER !== t)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return oi(e), e;
+  } else
+    return zn(t, { isLE: n });
+}
+function di(t, e, n = {}, r) {
+  if (r === void 0 && (r = t === "edwards"), !e || typeof e != "object")
+    throw new Error(`expected valid ${t} CURVE object`);
+  for (const f of ["p", "n", "h"]) {
+    const u = e[f];
+    if (!(typeof u == "bigint" && u > st))
+      throw new Error(`CURVE.${f} must be positive bigint`);
+  }
+  const o = Lr(e.p, n.Fp, r), s = Lr(e.n, n.Fn, r), c = ["Gx", "Gy", "a", "b"];
+  for (const f of c)
+    if (!o.isValid(e[f]))
+      throw new Error(`CURVE.${f} must be valid field element of CURVE.Fp`);
+  return e = Object.freeze(Object.assign({}, e)), { CURVE: e, Fp: o, Fn: s };
+}
+function po(t, e) {
+  return function(r) {
+    const o = t(r);
+    return { secretKey: o, publicKey: e(o) };
+  };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const ut = BigInt(0), Xe = BigInt(1), Ut = BigInt(2);
+function li(t) {
+  return Qt(t, {
+    adjustScalarBytes: "function",
+    powPminus2: "function"
+  }), Object.freeze({ ...t });
+}
+function hi(t) {
+  const e = li(t), { P: n, type: r, adjustScalarBytes: o, powPminus2: s, randomBytes: i } = e, c = r === "x25519";
+  if (!c && r !== "x448")
+    throw new Error("invalid type");
+  const f = i || Fn, u = c ? 255 : 448, d = c ? 32 : 56, a = BigInt(c ? 9 : 5), y = BigInt(c ? 121665 : 39081), l = c ? Ut ** BigInt(254) : Ut ** BigInt(447), b = c ? BigInt(8) * Ut ** BigInt(251) - Xe : BigInt(4) * Ut ** BigInt(445) - Xe, E = l + b + Xe, x = (h) => ue(h, n), w = H(a);
+  function H(h) {
+    return Dn(x(h), d);
+  }
+  function k(h) {
+    const p = Sn(Z(h, d, "uCoordinate"));
+    return c && (p[31] &= 127), x(wt(p));
+  }
+  function O(h) {
+    return wt(o(Sn(Z(h, d, "scalar"))));
+  }
+  function $(h, p) {
+    const A = M(k(p), O(h));
+    if (A === ut)
+      throw new Error("invalid private or public key received");
+    return H(A);
+  }
+  function R(h) {
+    return $(h, w);
+  }
+  const N = R, T = $;
+  function S(h, p, A) {
+    const L = x(h * (p - A));
+    return p = x(p - L), A = x(A + L), { x_2: p, x_3: A };
+  }
+  function M(h, p) {
+    Hn("u", h, ut, n), Hn("scalar", p, l, E);
+    const A = p, L = h;
+    let U = Xe, m = ut, I = h, B = Xe, _ = ut;
+    for (let z = BigInt(u - 1); z >= ut; z--) {
+      const D = A >> z & Xe;
+      _ ^= D, { x_2: U, x_3: I } = S(_, U, I), { x_2: m, x_3: B } = S(_, m, B), _ = D;
+      const F = U + m, V = x(F * F), G = U - m, X = x(G * G), Y = V - X, Q = I + B, St = I - B, ct = x(St * F), nr = x(Q * G), rr = ct + nr, or = ct - nr;
+      I = x(rr * rr), B = x(L * x(or * or)), U = x(V * X), m = x(Y * (V + x(y * Y)));
+    }
+    ({ x_2: U, x_3: I } = S(_, U, I)), { x_2: m, x_3: B } = S(_, m, B);
+    const P = s(m);
+    return x(U * P);
+  }
+  const C = {
+    secretKey: d,
+    publicKey: d,
+    seed: d
+  }, K = (h = f(d)) => (Z(h, C.seed, "seed"), h), v = { randomSecretKey: K };
+  return Object.freeze({
+    keygen: po(K, N),
+    getSharedSecret: T,
+    getPublicKey: N,
+    scalarMult: $,
+    scalarMultBase: R,
+    utils: v,
+    GuBytes: w.slice(),
+    lengths: C
+  });
+}
+let go = class {
+  constructor(e, n) {
+    g(this, "oHash");
+    g(this, "iHash");
+    g(this, "blockLen");
+    g(this, "outputLen");
+    g(this, "finished", !1);
+    g(this, "destroyed", !1);
+    if (Xr(e), Z(n, void 0, "key"), this.iHash = e.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 r = this.blockLen, o = new Uint8Array(r);
+    o.set(n.length > r ? e.create().update(n).digest() : n);
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 54;
+    this.iHash.update(o), this.oHash = e.create();
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 106;
+    this.oHash.update(o), ot(o);
+  }
+  update(e) {
+    return Dt(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    Dt(this), Z(e, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
+  }
+  digest() {
+    const e = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(e), e;
+  }
+  _cloneInto(e) {
+    e || (e = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: n, iHash: r, finished: o, destroyed: s, blockLen: i, outputLen: c } = this;
+    return e = e, e.finished = o, e.destroyed = s, e.blockLen = i, e.outputLen = c, e.oHash = n._cloneInto(e.oHash), e.iHash = r._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+};
+const bo = (t, e, n) => new go(t, e).update(n).digest();
+bo.create = (t, e) => new go(t, e);
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Sr = (t, e) => (t + (t >= 0 ? e : -e) / wo) / e;
+function yi(t, e, n) {
+  const [[r, o], [s, i]] = e, c = Sr(i * t, n), f = Sr(-o * t, n);
+  let u = t - c * r - f * s, d = -c * o - f * i;
+  const a = u < Ee, y = d < Ee;
+  a && (u = -u), y && (d = -d);
+  const l = jn(Math.ceil(Xs(n) / 2)) + et;
+  if (u < Ee || u >= l || d < Ee || d >= l)
+    throw new Error("splitScalar (endomorphism): failed, k=" + t);
+  return { k1neg: a, k1: u, k2neg: y, k2: d };
+}
+function Un(t) {
+  if (!["compact", "recovered", "der"].includes(t))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return t;
+}
+function hn(t, e) {
+  const n = {};
+  for (let r of Object.keys(e))
+    n[r] = t[r] === void 0 ? e[r] : t[r];
+  return qt(n.lowS, "lowS"), qt(n.prehash, "prehash"), n.format !== void 0 && Un(n.format), n;
+}
+class pi extends Error {
+  constructor(e = "") {
+    super(e);
+  }
+}
+const _e = {
+  // asn.1 DER encoding utils
+  Err: pi,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (t, e) => {
+      const { Err: n } = _e;
+      if (t < 0 || t > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (e.length & 1)
+        throw new n("tlv.encode: unpadded data");
+      const r = e.length / 2, o = Ht(r);
+      if (o.length / 2 & 128)
+        throw new n("tlv.encode: long form length too big");
+      const s = r > 127 ? Ht(o.length / 2 | 128) : "";
+      return Ht(t) + s + o + e;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(t, e) {
+      const { Err: n } = _e;
+      let r = 0;
+      if (t < 0 || t > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (e.length < 2 || e[r++] !== t)
+        throw new n("tlv.decode: wrong tlv");
+      const o = e[r++], s = !!(o & 128);
+      let i = 0;
+      if (!s)
+        i = o;
+      else {
+        const f = o & 127;
+        if (!f)
+          throw new n("tlv.decode(long): indefinite length not supported");
+        if (f > 4)
+          throw new n("tlv.decode(long): byte length is too big");
+        const u = e.subarray(r, r + f);
+        if (u.length !== f)
+          throw new n("tlv.decode: length bytes not complete");
+        if (u[0] === 0)
+          throw new n("tlv.decode(long): zero leftmost byte");
+        for (const d of u)
+          i = i << 8 | d;
+        if (r += f, i < 128)
+          throw new n("tlv.decode(long): not minimal encoding");
+      }
+      const c = e.subarray(r, r + i);
+      if (c.length !== i)
+        throw new n("tlv.decode: wrong value length");
+      return { v: c, l: e.subarray(r + 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(t) {
+      const { Err: e } = _e;
+      if (t < Ee)
+        throw new e("integer: negative integers are not allowed");
+      let n = Ht(t);
+      if (Number.parseInt(n[0], 16) & 8 && (n = "00" + n), n.length & 1)
+        throw new e("unexpected DER parsing assertion: unpadded hex");
+      return n;
+    },
+    decode(t) {
+      const { Err: e } = _e;
+      if (t[0] & 128)
+        throw new e("invalid signature integer: negative");
+      if (t[0] === 0 && !(t[1] & 128))
+        throw new e("invalid signature integer: unnecessary leading zero");
+      return At(t);
+    }
+  },
+  toSig(t) {
+    const { Err: e, _int: n, _tlv: r } = _e, o = Z(t, void 0, "signature"), { v: s, l: i } = r.decode(48, o);
+    if (i.length)
+      throw new e("invalid signature: left bytes after parsing");
+    const { v: c, l: f } = r.decode(2, s), { v: u, l: d } = r.decode(2, f);
+    if (d.length)
+      throw new e("invalid signature: left bytes after parsing");
+    return { r: n.decode(c), s: n.decode(u) };
+  },
+  hexFromSig(t) {
+    const { _tlv: e, _int: n } = _e, r = e.encode(2, n.encode(t.r)), o = e.encode(2, n.encode(t.s)), s = r + o;
+    return e.encode(48, s);
+  }
+}, Ee = BigInt(0), et = BigInt(1), wo = BigInt(2), It = BigInt(3), gi = BigInt(4);
+function xo(t, e = {}) {
+  const n = di("weierstrass", t, e), { Fp: r, Fn: o } = n;
+  let s = n.CURVE;
+  const { h: i, n: c } = s;
+  Qt(e, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object"
+  });
+  const { endo: f } = e;
+  if (f && (!r.is0(s.a) || typeof f.beta != "bigint" || !Array.isArray(f.basises)))
+    throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+  const u = mo(r, o);
+  function d() {
+    if (!r.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function a(v, h, p) {
+    const { x: A, y: L } = h.toAffine(), U = r.toBytes(A);
+    if (qt(p, "isCompressed"), p) {
+      d();
+      const m = !r.isOdd(L);
+      return ie(Eo(m), U);
+    } else
+      return ie(Uint8Array.of(4), U, r.toBytes(L));
+  }
+  function y(v) {
+    Z(v, void 0, "Point");
+    const { publicKey: h, publicKeyUncompressed: p } = u, A = v.length, L = v[0], U = v.subarray(1);
+    if (A === h && (L === 2 || L === 3)) {
+      const m = r.fromBytes(U);
+      if (!r.isValid(m))
+        throw new Error("bad point: is not on curve, wrong x");
+      const I = E(m);
+      let B;
+      try {
+        B = r.sqrt(I);
+      } catch (z) {
+        const D = z instanceof Error ? ": " + z.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + D);
+      }
+      d();
+      const _ = r.isOdd(B);
+      return (L & 1) === 1 !== _ && (B = r.neg(B)), { x: m, y: B };
+    } else if (A === p && L === 4) {
+      const m = r.BYTES, I = r.fromBytes(U.subarray(0, m)), B = r.fromBytes(U.subarray(m, m * 2));
+      if (!x(I, B))
+        throw new Error("bad point: is not on curve");
+      return { x: I, y: B };
+    } else
+      throw new Error(`bad point: got length ${A}, expected compressed=${h} or uncompressed=${p}`);
+  }
+  const l = e.toBytes || a, b = e.fromBytes || y;
+  function E(v) {
+    const h = r.sqr(v), p = r.mul(h, v);
+    return r.add(r.add(p, r.mul(v, s.a)), s.b);
+  }
+  function x(v, h) {
+    const p = r.sqr(h), A = E(v);
+    return r.eql(p, A);
+  }
+  if (!x(s.Gx, s.Gy))
+    throw new Error("bad curve params: generator point");
+  const w = r.mul(r.pow(s.a, It), gi), H = r.mul(r.sqr(s.b), BigInt(27));
+  if (r.is0(r.add(w, H)))
+    throw new Error("bad curve params: a or b");
+  function k(v, h, p = !1) {
+    if (!r.isValid(h) || p && r.is0(h))
+      throw new Error(`bad point coordinate ${v}`);
+    return h;
+  }
+  function O(v) {
+    if (!(v instanceof S))
+      throw new Error("Weierstrass Point expected");
+  }
+  function $(v) {
+    if (!f || !f.basises)
+      throw new Error("no endo");
+    return yi(v, f.basises, o.ORDER);
+  }
+  const R = wr((v, h) => {
+    const { X: p, Y: A, Z: L } = v;
+    if (r.eql(L, r.ONE))
+      return { x: p, y: A };
+    const U = v.is0();
+    h == null && (h = U ? r.ONE : r.inv(L));
+    const m = r.mul(p, h), I = r.mul(A, h), B = r.mul(L, h);
+    if (U)
+      return { x: r.ZERO, y: r.ZERO };
+    if (!r.eql(B, r.ONE))
+      throw new Error("invZ was invalid");
+    return { x: m, y: I };
+  }), N = wr((v) => {
+    if (v.is0()) {
+      if (e.allowInfinityPoint && !r.is0(v.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x: h, y: p } = v.toAffine();
+    if (!r.isValid(h) || !r.isValid(p))
+      throw new Error("bad point: x or y not field elements");
+    if (!x(h, p))
+      throw new Error("bad point: equation left != right");
+    if (!v.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return !0;
+  });
+  function T(v, h, p, A, L) {
+    return p = new S(r.mul(p.X, v), p.Y, p.Z), h = zt(A, h), p = zt(L, p), h.add(p);
+  }
+  const K = class K {
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(h, p, A) {
+      g(this, "X");
+      g(this, "Y");
+      g(this, "Z");
+      this.X = k("x", h), this.Y = k("y", p, !0), this.Z = k("z", A), Object.freeze(this);
+    }
+    static CURVE() {
+      return s;
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(h) {
+      const { x: p, y: A } = h || {};
+      if (!h || !r.isValid(p) || !r.isValid(A))
+        throw new Error("invalid affine point");
+      if (h instanceof K)
+        throw new Error("projective point not allowed");
+      return r.is0(p) && r.is0(A) ? K.ZERO : new K(p, A, r.ONE);
+    }
+    static fromBytes(h) {
+      const p = K.fromAffine(b(Z(h, void 0, "point")));
+      return p.assertValidity(), p;
+    }
+    static fromHex(h) {
+      return K.fromBytes(jt(h));
+    }
+    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(h = 8, p = !0) {
+      return C.createCache(this, h), p || this.multiply(It), this;
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      N(this);
+    }
+    hasEvenY() {
+      const { y: h } = this.toAffine();
+      if (!r.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !r.isOdd(h);
+    }
+    /** Compare one point to another. */
+    equals(h) {
+      O(h);
+      const { X: p, Y: A, Z: L } = this, { X: U, Y: m, Z: I } = h, B = r.eql(r.mul(p, I), r.mul(U, L)), _ = r.eql(r.mul(A, I), r.mul(m, L));
+      return B && _;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new K(this.X, r.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: h, b: p } = s, A = r.mul(p, It), { X: L, Y: U, Z: m } = this;
+      let I = r.ZERO, B = r.ZERO, _ = r.ZERO, P = r.mul(L, L), z = r.mul(U, U), D = r.mul(m, m), F = r.mul(L, U);
+      return F = r.add(F, F), _ = r.mul(L, m), _ = r.add(_, _), I = r.mul(h, _), B = r.mul(A, D), B = r.add(I, B), I = r.sub(z, B), B = r.add(z, B), B = r.mul(I, B), I = r.mul(F, I), _ = r.mul(A, _), D = r.mul(h, D), F = r.sub(P, D), F = r.mul(h, F), F = r.add(F, _), _ = r.add(P, P), P = r.add(_, P), P = r.add(P, D), P = r.mul(P, F), B = r.add(B, P), D = r.mul(U, m), D = r.add(D, D), P = r.mul(D, F), I = r.sub(I, P), _ = r.mul(D, z), _ = r.add(_, _), _ = r.add(_, _), new K(I, B, _);
+    }
+    // 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(h) {
+      O(h);
+      const { X: p, Y: A, Z: L } = this, { X: U, Y: m, Z: I } = h;
+      let B = r.ZERO, _ = r.ZERO, P = r.ZERO;
+      const z = s.a, D = r.mul(s.b, It);
+      let F = r.mul(p, U), V = r.mul(A, m), G = r.mul(L, I), X = r.add(p, A), Y = r.add(U, m);
+      X = r.mul(X, Y), Y = r.add(F, V), X = r.sub(X, Y), Y = r.add(p, L);
+      let Q = r.add(U, I);
+      return Y = r.mul(Y, Q), Q = r.add(F, G), Y = r.sub(Y, Q), Q = r.add(A, L), B = r.add(m, I), Q = r.mul(Q, B), B = r.add(V, G), Q = r.sub(Q, B), P = r.mul(z, Y), B = r.mul(D, G), P = r.add(B, P), B = r.sub(V, P), P = r.add(V, P), _ = r.mul(B, P), V = r.add(F, F), V = r.add(V, F), G = r.mul(z, G), Y = r.mul(D, Y), V = r.add(V, G), G = r.sub(F, G), G = r.mul(z, G), Y = r.add(Y, G), F = r.mul(V, Y), _ = r.add(_, F), F = r.mul(Q, Y), B = r.mul(X, B), B = r.sub(B, F), F = r.mul(X, V), P = r.mul(Q, P), P = r.add(P, F), new K(B, _, P);
+    }
+    subtract(h) {
+      return this.add(h.negate());
+    }
+    is0() {
+      return this.equals(K.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(h) {
+      const { endo: p } = e;
+      if (!o.isValidNot0(h))
+        throw new Error("invalid scalar: out of range");
+      let A, L;
+      const U = (m) => C.cached(this, m, (I) => mr(K, I));
+      if (p) {
+        const { k1neg: m, k1: I, k2neg: B, k2: _ } = $(h), { p: P, f: z } = U(I), { p: D, f: F } = U(_);
+        L = z.add(F), A = T(p.beta, P, D, m, B);
+      } else {
+        const { p: m, f: I } = U(h);
+        A = m, L = I;
+      }
+      return mr(K, [A, L])[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(h) {
+      const { endo: p } = e, A = this;
+      if (!o.isValid(h))
+        throw new Error("invalid scalar: out of range");
+      if (h === Ee || A.is0())
+        return K.ZERO;
+      if (h === et)
+        return A;
+      if (C.hasCache(this))
+        return this.multiply(h);
+      if (p) {
+        const { k1neg: L, k1: U, k2neg: m, k2: I } = $(h), { p1: B, p2: _ } = ui(K, A, U, I);
+        return T(p.beta, B, _, L, m);
+      } else
+        return C.unsafe(A, h);
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(h) {
+      return R(this, h);
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree: h } = e;
+      return i === et ? !0 : h ? h(K, this) : C.unsafe(this, c).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor: h } = e;
+      return i === et ? this : h ? h(K, this) : this.multiplyUnsafe(i);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(i).is0();
+    }
+    toBytes(h = !0) {
+      return qt(h, "isCompressed"), this.assertValidity(), l(K, this, h);
+    }
+    toHex(h = !0) {
+      return Xt(this.toBytes(h));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  };
+  // base / generator point
+  g(K, "BASE", new K(s.Gx, s.Gy, r.ONE)), // zero / infinity / identity point
+  g(K, "ZERO", new K(r.ZERO, r.ONE, r.ZERO)), // 0, 1, 0
+  // math field
+  g(K, "Fp", r), // scalar field
+  g(K, "Fn", o);
+  let S = K;
+  const M = o.BITS, C = new ai(S, e.endo ? Math.ceil(M / 2) : M);
+  return S.BASE.precompute(8), S;
+}
+function Eo(t) {
+  return Uint8Array.of(t ? 2 : 3);
+}
+function mo(t, e) {
+  return {
+    secretKey: e.BYTES,
+    publicKey: 1 + t.BYTES,
+    publicKeyUncompressed: 1 + 2 * t.BYTES,
+    publicKeyHasPrefix: !0,
+    signature: 2 * e.BYTES
+  };
+}
+function bi(t, e = {}) {
+  const { Fn: n } = t, r = e.randomBytes || Fn, o = Object.assign(mo(t.Fp, n), { seed: lo(n.ORDER) });
+  function s(l) {
+    try {
+      const b = n.fromBytes(l);
+      return n.isValidNot0(b);
+    } catch {
+      return !1;
+    }
+  }
+  function i(l, b) {
+    const { publicKey: E, publicKeyUncompressed: x } = o;
+    try {
+      const w = l.length;
+      return b === !0 && w !== E || b === !1 && w !== x ? !1 : !!t.fromBytes(l);
+    } catch {
+      return !1;
+    }
+  }
+  function c(l = r(o.seed)) {
+    return fi(Z(l, o.seed, "seed"), n.ORDER);
+  }
+  function f(l, b = !0) {
+    return t.BASE.multiply(n.fromBytes(l)).toBytes(b);
+  }
+  function u(l) {
+    const { secretKey: b, publicKey: E, publicKeyUncompressed: x } = o;
+    if (!Mn(l) || "_lengths" in n && n._lengths || b === E)
+      return;
+    const w = Z(l, void 0, "key").length;
+    return w === E || w === x;
+  }
+  function d(l, b, E = !0) {
+    if (u(l) === !0)
+      throw new Error("first arg must be private key");
+    if (u(b) === !1)
+      throw new Error("second arg must be public key");
+    const x = n.fromBytes(l);
+    return t.fromBytes(b).multiply(x).toBytes(E);
+  }
+  const a = {
+    isValidSecretKey: s,
+    isValidPublicKey: i,
+    randomSecretKey: c
+  }, y = po(c, f);
+  return Object.freeze({ getPublicKey: f, getSharedSecret: d, keygen: y, Point: t, utils: a, lengths: o });
+}
+function Ao(t, e, n = {}) {
+  Xr(e), Qt(n, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  }), n = Object.assign({}, n);
+  const r = n.randomBytes || Fn, o = n.hmac || ((h, p) => bo(e, h, p)), { Fp: s, Fn: i } = t, { ORDER: c, BITS: f } = i, { keygen: u, getPublicKey: d, getSharedSecret: a, utils: y, lengths: l } = bi(t, n), b = {
+    prehash: !0,
+    lowS: typeof n.lowS == "boolean" ? n.lowS : !0,
+    format: "compact",
+    extraEntropy: !1
+  }, E = c * wo < s.ORDER;
+  function x(h) {
+    const p = c >> et;
+    return h > p;
+  }
+  function w(h, p) {
+    if (!i.isValidNot0(p))
+      throw new Error(`invalid signature ${h}: out of range 1..Point.Fn.ORDER`);
+    return p;
+  }
+  function H() {
+    if (E)
+      throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
+  }
+  function k(h, p) {
+    Un(p);
+    const A = l.signature, L = p === "compact" ? A : p === "recovered" ? A + 1 : void 0;
+    return Z(h, L);
+  }
+  class O {
+    constructor(p, A, L) {
+      g(this, "r");
+      g(this, "s");
+      g(this, "recovery");
+      if (this.r = w("r", p), this.s = w("s", A), L != null) {
+        if (H(), ![0, 1, 2, 3].includes(L))
+          throw new Error("invalid recovery id");
+        this.recovery = L;
+      }
+      Object.freeze(this);
+    }
+    static fromBytes(p, A = b.format) {
+      k(p, A);
+      let L;
+      if (A === "der") {
+        const { r: B, s: _ } = _e.toSig(Z(p));
+        return new O(B, _);
+      }
+      A === "recovered" && (L = p[0], A = "compact", p = p.subarray(1));
+      const U = l.signature / 2, m = p.subarray(0, U), I = p.subarray(U, U * 2);
+      return new O(i.fromBytes(m), i.fromBytes(I), L);
+    }
+    static fromHex(p, A) {
+      return this.fromBytes(jt(p), A);
+    }
+    assertRecovery() {
+      const { recovery: p } = this;
+      if (p == null)
+        throw new Error("invalid recovery id: must be present");
+      return p;
+    }
+    addRecoveryBit(p) {
+      return new O(this.r, this.s, p);
+    }
+    recoverPublicKey(p) {
+      const { r: A, s: L } = this, U = this.assertRecovery(), m = U === 2 || U === 3 ? A + c : A;
+      if (!s.isValid(m))
+        throw new Error("invalid recovery id: sig.r+curve.n != R.x");
+      const I = s.toBytes(m), B = t.fromBytes(ie(Eo((U & 1) === 0), I)), _ = i.inv(m), P = R(Z(p, void 0, "msgHash")), z = i.create(-P * _), D = i.create(L * _), F = t.BASE.multiplyUnsafe(z).add(B.multiplyUnsafe(D));
+      if (F.is0())
+        throw new Error("invalid recovery: point at infinify");
+      return F.assertValidity(), F;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return x(this.s);
+    }
+    toBytes(p = b.format) {
+      if (Un(p), p === "der")
+        return jt(_e.hexFromSig(this));
+      const { r: A, s: L } = this, U = i.toBytes(A), m = i.toBytes(L);
+      return p === "recovered" ? (H(), ie(Uint8Array.of(this.assertRecovery()), U, m)) : ie(U, m);
+    }
+    toHex(p) {
+      return Xt(this.toBytes(p));
+    }
+  }
+  const $ = n.bits2int || function(p) {
+    if (p.length > 8192)
+      throw new Error("input is too large");
+    const A = At(p), L = p.length * 8 - f;
+    return L > 0 ? A >> BigInt(L) : A;
+  }, R = n.bits2int_modN || function(p) {
+    return i.create($(p));
+  }, N = jn(f);
+  function T(h) {
+    return Hn("num < 2^" + f, h, Ee, N), i.toBytes(h);
+  }
+  function S(h, p) {
+    return Z(h, void 0, "message"), p ? Z(e(h), void 0, "prehashed message") : h;
+  }
+  function M(h, p, A) {
+    const { lowS: L, prehash: U, extraEntropy: m } = hn(A, b);
+    h = S(h, U);
+    const I = R(h), B = i.fromBytes(p);
+    if (!i.isValidNot0(B))
+      throw new Error("invalid private key");
+    const _ = [T(B), T(I)];
+    if (m != null && m !== !1) {
+      const F = m === !0 ? r(l.secretKey) : m;
+      _.push(Z(F, void 0, "extraEntropy"));
+    }
+    const P = ie(..._), z = I;
+    function D(F) {
+      const V = $(F);
+      if (!i.isValidNot0(V))
+        return;
+      const G = i.inv(V), X = t.BASE.multiply(V).toAffine(), Y = i.create(X.x);
+      if (Y === Ee)
+        return;
+      const Q = i.create(G * i.create(z + Y * B));
+      if (Q === Ee)
+        return;
+      let St = (X.x === Y ? 0 : 2) | Number(X.y & et), ct = Q;
+      return L && x(Q) && (ct = i.neg(Q), St ^= 1), new O(Y, ct, E ? void 0 : St);
+    }
+    return { seed: P, k2sig: D };
+  }
+  function C(h, p, A = {}) {
+    const { seed: L, k2sig: U } = M(h, p, A);
+    return Ws(e.outputLen, i.BYTES, o)(L, U).toBytes(A.format);
+  }
+  function K(h, p, A, L = {}) {
+    const { lowS: U, prehash: m, format: I } = hn(L, b);
+    if (A = Z(A, void 0, "publicKey"), p = S(p, m), !Mn(h)) {
+      const B = h instanceof O ? ", use sig.toBytes()" : "";
+      throw new Error("verify expects Uint8Array signature" + B);
+    }
+    k(h, I);
+    try {
+      const B = O.fromBytes(h, I), _ = t.fromBytes(A);
+      if (U && B.hasHighS())
+        return !1;
+      const { r: P, s: z } = B, D = R(p), F = i.inv(z), V = i.create(D * F), G = i.create(P * F), X = t.BASE.multiplyUnsafe(V).add(_.multiplyUnsafe(G));
+      return X.is0() ? !1 : i.create(X.x) === P;
+    } catch {
+      return !1;
+    }
+  }
+  function v(h, p, A = {}) {
+    const { prehash: L } = hn(A, b);
+    return p = S(p, L), O.fromBytes(h, "recovered").recoverPublicKey(p).toBytes();
+  }
+  return Object.freeze({
+    keygen: u,
+    getPublicKey: d,
+    getSharedSecret: a,
+    utils: y,
+    lengths: l,
+    Point: t,
+    sign: C,
+    verify: K,
+    recoverPublicKey: v,
+    Signature: O,
+    hash: e
+  });
+}
+function wi(t, e, n) {
+  return t & e ^ ~t & n;
+}
+function xi(t, e, n) {
+  return t & e ^ t & n ^ e & n;
+}
+let Bo = class {
+  constructor(e, n, r, o) {
+    g(this, "blockLen");
+    g(this, "outputLen");
+    g(this, "padOffset");
+    g(this, "isLE");
+    // For partial updates less than block size
+    g(this, "buffer");
+    g(this, "view");
+    g(this, "finished", !1);
+    g(this, "length", 0);
+    g(this, "pos", 0);
+    g(this, "destroyed", !1);
+    this.blockLen = e, this.outputLen = n, this.padOffset = r, this.isLE = o, this.buffer = new Uint8Array(e), this.view = an(this.buffer);
+  }
+  update(e) {
+    Dt(this), Z(e);
+    const { view: n, buffer: r, blockLen: o } = this, s = e.length;
+    for (let i = 0; i < s; ) {
+      const c = Math.min(o - this.pos, s - i);
+      if (c === o) {
+        const f = an(e);
+        for (; o <= s - i; i += o)
+          this.process(f, i);
+        continue;
+      }
+      r.set(e.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === o && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    Dt(this), Gs(e, this), this.finished = !0;
+    const { buffer: n, view: r, blockLen: o, isLE: s } = this;
+    let { pos: i } = this;
+    n[i++] = 128, ot(this.buffer.subarray(i)), this.padOffset > o - i && (this.process(r, 0), i = 0);
+    for (let a = i; a < o; a++)
+      n[a] = 0;
+    r.setBigUint64(o - 8, BigInt(this.length * 8), s), this.process(r, 0);
+    const c = an(e), f = this.outputLen;
+    if (f % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const u = f / 4, d = this.get();
+    if (u > d.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let a = 0; a < u; a++)
+      c.setUint32(4 * a, d[a], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: n, buffer: r, length: o, finished: s, destroyed: i, pos: c } = this;
+    return e.destroyed = i, e.finished = s, e.length = o, e.pos = c, o % n && e.buffer.set(r), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+const Le = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), te = /* @__PURE__ */ Uint32Array.from([
+  3418070365,
+  3238371032,
+  1654270250,
+  914150663,
+  2438529370,
+  812702999,
+  355462360,
+  4144912697,
+  1731405415,
+  4290775857,
+  2394180231,
+  1750603025,
+  3675008525,
+  1694076839,
+  1203062813,
+  3204075428
+]), kt = /* @__PURE__ */ BigInt(2 ** 32 - 1), Hr = /* @__PURE__ */ BigInt(32);
+function Ei(t, e = !1) {
+  return e ? { h: Number(t & kt), l: Number(t >> Hr & kt) } : { h: Number(t >> Hr & kt) | 0, l: Number(t & kt) | 0 };
+}
+function mi(t, e = !1) {
+  const n = t.length;
+  let r = new Uint32Array(n), o = new Uint32Array(n);
+  for (let s = 0; s < n; s++) {
+    const { h: i, l: c } = Ei(t[s], e);
+    [r[s], o[s]] = [i, c];
+  }
+  return [r, o];
+}
+const Ur = (t, e, n) => t >>> n, Ir = (t, e, n) => t << 32 - n | e >>> n, We = (t, e, n) => t >>> n | e << 32 - n, Qe = (t, e, n) => t << 32 - n | e >>> n, _t = (t, e, n) => t << 64 - n | e >>> n - 32, Kt = (t, e, n) => t >>> n - 32 | e << 64 - n;
+function we(t, e, n, r) {
+  const o = (e >>> 0) + (r >>> 0);
+  return { h: t + n + (o / 2 ** 32 | 0) | 0, l: o | 0 };
+}
+const Ai = (t, e, n) => (t >>> 0) + (e >>> 0) + (n >>> 0), Bi = (t, e, n, r) => e + n + r + (t / 2 ** 32 | 0) | 0, Li = (t, e, n, r) => (t >>> 0) + (e >>> 0) + (n >>> 0) + (r >>> 0), Si = (t, e, n, r, o) => e + n + r + o + (t / 2 ** 32 | 0) | 0, Hi = (t, e, n, r, o) => (t >>> 0) + (e >>> 0) + (n >>> 0) + (r >>> 0) + (o >>> 0), Ui = (t, e, n, r, o, s) => e + n + r + o + s + (t / 2 ** 32 | 0) | 0, Ii = /* @__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
+]), Se = /* @__PURE__ */ new Uint32Array(64);
+let ki = class extends Bo {
+  constructor(e) {
+    super(64, e, 8, !1);
+  }
+  get() {
+    const { A: e, B: n, C: r, D: o, E: s, F: i, G: c, H: f } = this;
+    return [e, n, r, o, s, i, c, f];
+  }
+  // prettier-ignore
+  set(e, n, r, o, s, i, c, f) {
+    this.A = e | 0, this.B = n | 0, this.C = r | 0, this.D = o | 0, this.E = s | 0, this.F = i | 0, this.G = c | 0, this.H = f | 0;
+  }
+  process(e, n) {
+    for (let a = 0; a < 16; a++, n += 4)
+      Se[a] = e.getUint32(n, !1);
+    for (let a = 16; a < 64; a++) {
+      const y = Se[a - 15], l = Se[a - 2], b = ye(y, 7) ^ ye(y, 18) ^ y >>> 3, E = ye(l, 17) ^ ye(l, 19) ^ l >>> 10;
+      Se[a] = E + Se[a - 7] + b + Se[a - 16] | 0;
+    }
+    let { A: r, B: o, C: s, D: i, E: c, F: f, G: u, H: d } = this;
+    for (let a = 0; a < 64; a++) {
+      const y = ye(c, 6) ^ ye(c, 11) ^ ye(c, 25), l = d + y + wi(c, f, u) + Ii[a] + Se[a] | 0, E = (ye(r, 2) ^ ye(r, 13) ^ ye(r, 22)) + xi(r, o, s) | 0;
+      d = u, u = f, f = c, c = i + l | 0, i = s, s = o, o = r, r = l + E | 0;
+    }
+    r = r + this.A | 0, o = o + this.B | 0, s = s + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, f = f + this.F | 0, u = u + this.G | 0, d = d + this.H | 0, this.set(r, o, s, i, c, f, u, d);
+  }
+  roundClean() {
+    ot(Se);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), ot(this.buffer);
+  }
+}, _i = class extends ki {
+  constructor() {
+    super(32);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    g(this, "A", Le[0] | 0);
+    g(this, "B", Le[1] | 0);
+    g(this, "C", Le[2] | 0);
+    g(this, "D", Le[3] | 0);
+    g(this, "E", Le[4] | 0);
+    g(this, "F", Le[5] | 0);
+    g(this, "G", Le[6] | 0);
+    g(this, "H", Le[7] | 0);
+  }
+};
+const Lo = mi([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((t) => BigInt(t))), Ki = Lo[0], vi = Lo[1], He = /* @__PURE__ */ new Uint32Array(80), Ue = /* @__PURE__ */ new Uint32Array(80);
+class Ri extends Bo {
+  constructor(e) {
+    super(128, e, 16, !1);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah: e, Al: n, Bh: r, Bl: o, Ch: s, Cl: i, Dh: c, Dl: f, Eh: u, El: d, Fh: a, Fl: y, Gh: l, Gl: b, Hh: E, Hl: x } = this;
+    return [e, n, r, o, s, i, c, f, u, d, a, y, l, b, E, x];
+  }
+  // prettier-ignore
+  set(e, n, r, o, s, i, c, f, u, d, a, y, l, b, E, x) {
+    this.Ah = e | 0, this.Al = n | 0, this.Bh = r | 0, this.Bl = o | 0, this.Ch = s | 0, this.Cl = i | 0, this.Dh = c | 0, this.Dl = f | 0, this.Eh = u | 0, this.El = d | 0, this.Fh = a | 0, this.Fl = y | 0, this.Gh = l | 0, this.Gl = b | 0, this.Hh = E | 0, this.Hl = x | 0;
+  }
+  process(e, n) {
+    for (let k = 0; k < 16; k++, n += 4)
+      He[k] = e.getUint32(n), Ue[k] = e.getUint32(n += 4);
+    for (let k = 16; k < 80; k++) {
+      const O = He[k - 15] | 0, $ = Ue[k - 15] | 0, R = We(O, $, 1) ^ We(O, $, 8) ^ Ur(O, $, 7), N = Qe(O, $, 1) ^ Qe(O, $, 8) ^ Ir(O, $, 7), T = He[k - 2] | 0, S = Ue[k - 2] | 0, M = We(T, S, 19) ^ _t(T, S, 61) ^ Ur(T, S, 6), C = Qe(T, S, 19) ^ Kt(T, S, 61) ^ Ir(T, S, 6), K = Li(N, C, Ue[k - 7], Ue[k - 16]), v = Si(K, R, M, He[k - 7], He[k - 16]);
+      He[k] = v | 0, Ue[k] = K | 0;
+    }
+    let { Ah: r, Al: o, Bh: s, Bl: i, Ch: c, Cl: f, Dh: u, Dl: d, Eh: a, El: y, Fh: l, Fl: b, Gh: E, Gl: x, Hh: w, Hl: H } = this;
+    for (let k = 0; k < 80; k++) {
+      const O = We(a, y, 14) ^ We(a, y, 18) ^ _t(a, y, 41), $ = Qe(a, y, 14) ^ Qe(a, y, 18) ^ Kt(a, y, 41), R = a & l ^ ~a & E, N = y & b ^ ~y & x, T = Hi(H, $, N, vi[k], Ue[k]), S = Ui(T, w, O, R, Ki[k], He[k]), M = T | 0, C = We(r, o, 28) ^ _t(r, o, 34) ^ _t(r, o, 39), K = Qe(r, o, 28) ^ Kt(r, o, 34) ^ Kt(r, o, 39), v = r & s ^ r & c ^ s & c, h = o & i ^ o & f ^ i & f;
+      w = E | 0, H = x | 0, E = l | 0, x = b | 0, l = a | 0, b = y | 0, { h: a, l: y } = we(u | 0, d | 0, S | 0, M | 0), u = c | 0, d = f | 0, c = s | 0, f = i | 0, s = r | 0, i = o | 0;
+      const p = Ai(M, K, h);
+      r = Bi(p, S, C, v), o = p | 0;
+    }
+    ({ h: r, l: o } = we(this.Ah | 0, this.Al | 0, r | 0, o | 0)), { h: s, l: i } = we(this.Bh | 0, this.Bl | 0, s | 0, i | 0), { h: c, l: f } = we(this.Ch | 0, this.Cl | 0, c | 0, f | 0), { h: u, l: d } = we(this.Dh | 0, this.Dl | 0, u | 0, d | 0), { h: a, l: y } = we(this.Eh | 0, this.El | 0, a | 0, y | 0), { h: l, l: b } = we(this.Fh | 0, this.Fl | 0, l | 0, b | 0), { h: E, l: x } = we(this.Gh | 0, this.Gl | 0, E | 0, x | 0), { h: w, l: H } = we(this.Hh | 0, this.Hl | 0, w | 0, H | 0), this.set(r, o, s, i, c, f, u, d, a, y, l, b, E, x, w, H);
+  }
+  roundClean() {
+    ot(He, Ue);
+  }
+  destroy() {
+    ot(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+class Ti extends Ri {
+  constructor() {
+    super(48);
+    g(this, "Ah", te[0] | 0);
+    g(this, "Al", te[1] | 0);
+    g(this, "Bh", te[2] | 0);
+    g(this, "Bl", te[3] | 0);
+    g(this, "Ch", te[4] | 0);
+    g(this, "Cl", te[5] | 0);
+    g(this, "Dh", te[6] | 0);
+    g(this, "Dl", te[7] | 0);
+    g(this, "Eh", te[8] | 0);
+    g(this, "El", te[9] | 0);
+    g(this, "Fh", te[10] | 0);
+    g(this, "Fl", te[11] | 0);
+    g(this, "Gh", te[12] | 0);
+    g(this, "Gl", te[13] | 0);
+    g(this, "Hh", te[14] | 0);
+    g(this, "Hl", te[15] | 0);
+  }
+}
+const Ci = /* @__PURE__ */ Qr(
+  () => new _i(),
+  /* @__PURE__ */ Jr(1)
+), Oi = /* @__PURE__ */ Qr(
+  () => new Ti(),
+  /* @__PURE__ */ Jr(2)
+);
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const $i = BigInt(1), kr = BigInt(2), Ni = /* @__PURE__ */ BigInt(3), Mi = BigInt(5);
+BigInt(8);
+const So = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
+function Fi(t) {
+  const e = BigInt(10), n = BigInt(20), r = BigInt(40), o = BigInt(80), s = So, c = t * t % s * t % s, f = le(c, kr, s) * c % s, u = le(f, $i, s) * t % s, d = le(u, Mi, s) * u % s, a = le(d, e, s) * d % s, y = le(a, n, s) * a % s, l = le(y, r, s) * y % s, b = le(l, o, s) * l % s, E = le(b, o, s) * l % s, x = le(E, e, s) * d % s;
+  return { pow_p_5_8: le(x, kr, s) * t % s, b2: c };
+}
+function Pi(t) {
+  return t[0] &= 248, t[31] &= 127, t[31] |= 64, t;
+}
+const Vt = /* @__PURE__ */ (() => {
+  const t = So;
+  return hi({
+    P: t,
+    type: "x25519",
+    powPminus2: (e) => {
+      const { pow_p_5_8: n, b2: r } = Fi(e);
+      return ue(le(n, Ni, t) * r, t);
+    },
+    adjustScalarBytes: Pi
+  });
+})();
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Di = {
+  p: BigInt("0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff"),
+  n: BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551"),
+  h: BigInt(1),
+  a: BigInt("0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc"),
+  b: BigInt("0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b"),
+  Gx: BigInt("0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296"),
+  Gy: BigInt("0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5")
+}, ji = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff"),
+  n: BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973"),
+  h: BigInt(1),
+  a: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffc"),
+  b: BigInt("0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef"),
+  Gx: BigInt("0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7"),
+  Gy: BigInt("0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f")
+}, qi = /* @__PURE__ */ xo(Di), Oe = /* @__PURE__ */ Ao(qi, Ci), zi = /* @__PURE__ */ xo(ji), Vi = /* @__PURE__ */ Ao(zi, Oi);
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function Gi(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function ze(t, e = "") {
+  if (!Number.isSafeInteger(t) || t < 0) {
+    const n = e && `"${e}" `;
+    throw new Error(`${n}expected integer >= 0, got ${t}`);
+  }
+}
+function W(t, e, n = "") {
+  const r = Gi(t), o = t == null ? void 0 : t.length, s = e !== void 0;
+  if (!r || s && o !== e) {
+    const i = n && `"${n}" `, c = s ? ` of length ${e}` : "", f = r ? `length=${o}` : `type=${typeof t}`;
+    throw new Error(i + "expected Uint8Array" + c + ", got " + f);
+  }
+  return t;
+}
+function Ve(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  ze(t.outputLen), ze(t.blockLen);
+}
+function it(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function Ho(t, e) {
+  W(t, void 0, "digestInto() output");
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error('"digestInto() output" expected to be of length >=' + n);
+}
+function Uo(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function Ge(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function yn(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function pe(t, e) {
+  return t << 32 - e | t >>> e;
+}
+const Yi = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function Zi(t) {
+  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
+}
+function Xi(t) {
+  for (let e = 0; e < t.length; e++)
+    t[e] = Zi(t[e]);
+  return t;
+}
+const _r = Yi ? (t) => t : Xi;
+function Vn(t, e = {}) {
+  const n = (o, s) => t(s).update(o).digest(), r = t(void 0);
+  return n.outputLen = r.outputLen, n.blockLen = r.blockLen, n.create = (o) => t(o), Object.assign(n, e), Object.freeze(n);
+}
+function Wi(t = 32) {
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof (e == null ? void 0 : e.getRandomValues) != "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return e.getRandomValues(new Uint8Array(t));
+}
+const Bt = (t) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, t])
+});
+class Io {
+  constructor(e, n) {
+    g(this, "oHash");
+    g(this, "iHash");
+    g(this, "blockLen");
+    g(this, "outputLen");
+    g(this, "finished", !1);
+    g(this, "destroyed", !1);
+    if (Ve(e), W(n, void 0, "key"), this.iHash = e.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 r = this.blockLen, o = new Uint8Array(r);
+    o.set(n.length > r ? e.create().update(n).digest() : n);
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 54;
+    this.iHash.update(o), this.oHash = e.create();
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 106;
+    this.oHash.update(o), Ge(o);
+  }
+  update(e) {
+    return it(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    it(this), W(e, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
+  }
+  digest() {
+    const e = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(e), e;
+  }
+  _cloneInto(e) {
+    e || (e = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: n, iHash: r, finished: o, destroyed: s, blockLen: i, outputLen: c } = this;
+    return e = e, e.finished = o, e.destroyed = s, e.blockLen = i, e.outputLen = c, e.oHash = n._cloneInto(e.oHash), e.iHash = r._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const Gn = (t, e, n) => new Io(t, e).update(n).digest();
+Gn.create = (t, e) => new Io(t, e);
+function Qi(t, e, n) {
+  return Ve(t), n === void 0 && (n = new Uint8Array(t.outputLen)), Gn(t, n, e);
+}
+const pn = /* @__PURE__ */ Uint8Array.of(0), Kr = /* @__PURE__ */ Uint8Array.of();
+function Ji(t, e, n, r = 32) {
+  Ve(t), ze(r, "length");
+  const o = t.outputLen;
+  if (r > 255 * o)
+    throw new Error("Length must be <= 255*HashLen");
+  const s = Math.ceil(r / o);
+  n === void 0 ? n = Kr : W(n, void 0, "info");
+  const i = new Uint8Array(s * o), c = Gn.create(t, e), f = c._cloneInto(), u = new Uint8Array(c.outputLen);
+  for (let d = 0; d < s; d++)
+    pn[0] = d + 1, f.update(d === 0 ? Kr : u).update(n).update(pn).digestInto(u), i.set(u, o * d), c._cloneInto(f);
+  return c.destroy(), f.destroy(), Ge(u, pn), i.slice(0, r);
+}
+function ec(t, e, n) {
+  return t & e ^ ~t & n;
+}
+function tc(t, e, n) {
+  return t & e ^ t & n ^ e & n;
+}
+class nc {
+  constructor(e, n, r, o) {
+    g(this, "blockLen");
+    g(this, "outputLen");
+    g(this, "padOffset");
+    g(this, "isLE");
+    // For partial updates less than block size
+    g(this, "buffer");
+    g(this, "view");
+    g(this, "finished", !1);
+    g(this, "length", 0);
+    g(this, "pos", 0);
+    g(this, "destroyed", !1);
+    this.blockLen = e, this.outputLen = n, this.padOffset = r, this.isLE = o, this.buffer = new Uint8Array(e), this.view = yn(this.buffer);
+  }
+  update(e) {
+    it(this), W(e);
+    const { view: n, buffer: r, blockLen: o } = this, s = e.length;
+    for (let i = 0; i < s; ) {
+      const c = Math.min(o - this.pos, s - i);
+      if (c === o) {
+        const f = yn(e);
+        for (; o <= s - i; i += o)
+          this.process(f, i);
+        continue;
+      }
+      r.set(e.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === o && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    it(this), Ho(e, this), this.finished = !0;
+    const { buffer: n, view: r, blockLen: o, isLE: s } = this;
+    let { pos: i } = this;
+    n[i++] = 128, Ge(this.buffer.subarray(i)), this.padOffset > o - i && (this.process(r, 0), i = 0);
+    for (let a = i; a < o; a++)
+      n[a] = 0;
+    r.setBigUint64(o - 8, BigInt(this.length * 8), s), this.process(r, 0);
+    const c = yn(e), f = this.outputLen;
+    if (f % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const u = f / 4, d = this.get();
+    if (u > d.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let a = 0; a < u; a++)
+      c.setUint32(4 * a, d[a], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: n, buffer: r, length: o, finished: s, destroyed: i, pos: c } = this;
+    return e.destroyed = i, e.finished = s, e.length = o, e.pos = c, o % n && e.buffer.set(r), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const Ie = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), vt = /* @__PURE__ */ BigInt(2 ** 32 - 1), vr = /* @__PURE__ */ BigInt(32);
+function rc(t, e = !1) {
+  return e ? { h: Number(t & vt), l: Number(t >> vr & vt) } : { h: Number(t >> vr & vt) | 0, l: Number(t & vt) | 0 };
+}
+function oc(t, e = !1) {
+  const n = t.length;
+  let r = new Uint32Array(n), o = new Uint32Array(n);
+  for (let s = 0; s < n; s++) {
+    const { h: i, l: c } = rc(t[s], e);
+    [r[s], o[s]] = [i, c];
+  }
+  return [r, o];
+}
+const sc = (t, e, n) => t << n | e >>> 32 - n, ic = (t, e, n) => e << n | t >>> 32 - n, cc = (t, e, n) => e << n - 32 | t >>> 64 - n, fc = (t, e, n) => t << n - 32 | e >>> 64 - n, ac = /* @__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
+]), ke = /* @__PURE__ */ new Uint32Array(64);
+class uc extends nc {
+  constructor(e) {
+    super(64, e, 8, !1);
+  }
+  get() {
+    const { A: e, B: n, C: r, D: o, E: s, F: i, G: c, H: f } = this;
+    return [e, n, r, o, s, i, c, f];
+  }
+  // prettier-ignore
+  set(e, n, r, o, s, i, c, f) {
+    this.A = e | 0, this.B = n | 0, this.C = r | 0, this.D = o | 0, this.E = s | 0, this.F = i | 0, this.G = c | 0, this.H = f | 0;
+  }
+  process(e, n) {
+    for (let a = 0; a < 16; a++, n += 4)
+      ke[a] = e.getUint32(n, !1);
+    for (let a = 16; a < 64; a++) {
+      const y = ke[a - 15], l = ke[a - 2], b = pe(y, 7) ^ pe(y, 18) ^ y >>> 3, E = pe(l, 17) ^ pe(l, 19) ^ l >>> 10;
+      ke[a] = E + ke[a - 7] + b + ke[a - 16] | 0;
+    }
+    let { A: r, B: o, C: s, D: i, E: c, F: f, G: u, H: d } = this;
+    for (let a = 0; a < 64; a++) {
+      const y = pe(c, 6) ^ pe(c, 11) ^ pe(c, 25), l = d + y + ec(c, f, u) + ac[a] + ke[a] | 0, E = (pe(r, 2) ^ pe(r, 13) ^ pe(r, 22)) + tc(r, o, s) | 0;
+      d = u, u = f, f = c, c = i + l | 0, i = s, s = o, o = r, r = l + E | 0;
+    }
+    r = r + this.A | 0, o = o + this.B | 0, s = s + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, f = f + this.F | 0, u = u + this.G | 0, d = d + this.H | 0, this.set(r, o, s, i, c, f, u, d);
+  }
+  roundClean() {
+    Ge(ke);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), Ge(this.buffer);
+  }
+}
+class dc extends uc {
+  constructor() {
+    super(32);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    g(this, "A", Ie[0] | 0);
+    g(this, "B", Ie[1] | 0);
+    g(this, "C", Ie[2] | 0);
+    g(this, "D", Ie[3] | 0);
+    g(this, "E", Ie[4] | 0);
+    g(this, "F", Ie[5] | 0);
+    g(this, "G", Ie[6] | 0);
+    g(this, "H", Ie[7] | 0);
+  }
+}
+const lc = /* @__PURE__ */ Vn(
+  () => new dc(),
+  /* @__PURE__ */ Bt(1)
+), hc = BigInt(0), dt = BigInt(1), yc = BigInt(2), pc = BigInt(7), gc = BigInt(256), bc = BigInt(113), ko = [], _o = [], Ko = [];
+for (let t = 0, e = dt, n = 1, r = 0; t < 24; t++) {
+  [n, r] = [r, (2 * n + 3 * r) % 5], ko.push(2 * (5 * r + n)), _o.push((t + 1) * (t + 2) / 2 % 64);
+  let o = hc;
+  for (let s = 0; s < 7; s++)
+    e = (e << dt ^ (e >> pc) * bc) % gc, e & yc && (o ^= dt << (dt << BigInt(s)) - dt);
+  Ko.push(o);
+}
+const vo = oc(Ko, !0), wc = vo[0], xc = vo[1], Rr = (t, e, n) => n > 32 ? cc(t, e, n) : sc(t, e, n), Tr = (t, e, n) => n > 32 ? fc(t, e, n) : ic(t, e, n);
+function Ec(t, e = 24) {
+  const n = new Uint32Array(10);
+  for (let r = 24 - e; r < 24; r++) {
+    for (let i = 0; i < 10; i++)
+      n[i] = t[i] ^ t[i + 10] ^ t[i + 20] ^ t[i + 30] ^ t[i + 40];
+    for (let i = 0; i < 10; i += 2) {
+      const c = (i + 8) % 10, f = (i + 2) % 10, u = n[f], d = n[f + 1], a = Rr(u, d, 1) ^ n[c], y = Tr(u, d, 1) ^ n[c + 1];
+      for (let l = 0; l < 50; l += 10)
+        t[i + l] ^= a, t[i + l + 1] ^= y;
+    }
+    let o = t[2], s = t[3];
+    for (let i = 0; i < 24; i++) {
+      const c = _o[i], f = Rr(o, s, c), u = Tr(o, s, c), d = ko[i];
+      o = t[d], s = t[d + 1], t[d] = f, t[d + 1] = u;
+    }
+    for (let i = 0; i < 50; i += 10) {
+      for (let c = 0; c < 10; c++)
+        n[c] = t[i + c];
+      for (let c = 0; c < 10; c++)
+        t[i + c] ^= ~n[(c + 2) % 10] & n[(c + 4) % 10];
+    }
+    t[0] ^= wc[r], t[1] ^= xc[r];
+  }
+  Ge(n);
+}
+class Jt {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(e, n, r, o = !1, s = 24) {
+    g(this, "state");
+    g(this, "pos", 0);
+    g(this, "posOut", 0);
+    g(this, "finished", !1);
+    g(this, "state32");
+    g(this, "destroyed", !1);
+    g(this, "blockLen");
+    g(this, "suffix");
+    g(this, "outputLen");
+    g(this, "enableXOF", !1);
+    g(this, "rounds");
+    if (this.blockLen = e, this.suffix = n, this.outputLen = r, this.enableXOF = o, this.rounds = s, ze(r, "outputLen"), !(0 < e && e < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = Uo(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    _r(this.state32), Ec(this.state32, this.rounds), _r(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(e) {
+    it(this), W(e);
+    const { blockLen: n, state: r } = this, o = e.length;
+    for (let s = 0; s < o; ) {
+      const i = Math.min(n - this.pos, o - s);
+      for (let c = 0; c < i; c++)
+        r[this.pos++] ^= e[s++];
+      this.pos === n && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: e, suffix: n, pos: r, blockLen: o } = this;
+    e[r] ^= n, (n & 128) !== 0 && r === o - 1 && this.keccak(), e[o - 1] ^= 128, this.keccak();
+  }
+  writeInto(e) {
+    it(this, !1), W(e), this.finish();
+    const n = this.state, { blockLen: r } = this;
+    for (let o = 0, s = e.length; o < s; ) {
+      this.posOut >= r && this.keccak();
+      const i = Math.min(r - this.posOut, s - o);
+      e.set(n.subarray(this.posOut, this.posOut + i), o), this.posOut += i, o += i;
+    }
+    return e;
+  }
+  xofInto(e) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(e);
+  }
+  xof(e) {
+    return ze(e), this.xofInto(new Uint8Array(e));
+  }
+  digestInto(e) {
+    if (Ho(e, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(e), this.destroy(), e;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, Ge(this.state);
+  }
+  _cloneInto(e) {
+    const { blockLen: n, suffix: r, outputLen: o, rounds: s, enableXOF: i } = this;
+    return e || (e = new Jt(n, r, o, i, s)), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = s, e.suffix = r, e.outputLen = o, e.enableXOF = i, e.destroyed = this.destroyed, e;
+  }
+}
+const Ro = (t, e, n, r = {}) => Vn(() => new Jt(e, t, n), r), Lt = /* @__PURE__ */ Ro(
+  6,
+  136,
+  32,
+  /* @__PURE__ */ Bt(8)
+), mc = /* @__PURE__ */ Ro(
+  6,
+  72,
+  64,
+  /* @__PURE__ */ Bt(10)
+), To = (t, e, n, r = {}) => Vn((o = {}) => new Jt(e, t, o.dkLen === void 0 ? n : o.dkLen, !0), r), Ac = /* @__PURE__ */ To(31, 168, 16, /* @__PURE__ */ Bt(11)), Ye = /* @__PURE__ */ To(31, 136, 32, /* @__PURE__ */ Bt(12));
+function Yn(t) {
+  if (!Number.isSafeInteger(t) || t < 0 || t > 4294967295)
+    throw new Error("wrong u32 integer:" + t);
+  return t;
+}
+function Co(t) {
+  return Yn(t), (t & t - 1) === 0 && t !== 0;
+}
+function Oo(t, e) {
+  Yn(t);
+  let n = 0;
+  for (let r = 0; r < e; r++, t >>>= 1)
+    n = n << 1 | t & 1;
+  return n;
+}
+function $o(t) {
+  return Yn(t), 31 - Math.clz32(t);
+}
+function Cr(t) {
+  const e = t.length;
+  if (e < 2 || !Co(e))
+    throw new Error("n must be a power of 2 and greater than 1. Got " + e);
+  const n = $o(e);
+  for (let r = 0; r < e; r++) {
+    const o = Oo(r, n);
+    if (r < o) {
+      const s = t[r];
+      t[r] = t[o], t[o] = s;
+    }
+  }
+  return t;
+}
+const Or = (t, e) => {
+  const { N: n, roots: r, dit: o, invertButterflies: s = !1, skipStages: i = 0, brp: c = !0 } = e, f = $o(n);
+  if (!Co(n))
+    throw new Error("FFT: Polynomial size should be power of two");
+  const u = o !== s;
+  return (d) => {
+    if (d.length !== n)
+      throw new Error("FFT: wrong Polynomial length");
+    o && c && Cr(d);
+    for (let a = 0, y = 1; a < f - i; a++) {
+      const l = o ? a + 1 + i : f - a, b = 1 << l, E = b >> 1, x = n >> l;
+      for (let w = 0; w < n; w += b)
+        for (let H = 0, k = y++; H < E; H++) {
+          const O = s ? o ? n - k : k : H * x, $ = w + H, R = w + H + E, N = r[O], T = d[R], S = d[$];
+          if (u) {
+            const M = t.mul(T, N);
+            d[$] = t.add(S, M), d[R] = t.sub(S, M);
+          } else s ? (d[$] = t.add(T, S), d[R] = t.mul(t.sub(T, S), N)) : (d[$] = t.add(S, T), d[R] = t.mul(t.sub(S, T), N));
+        }
+    }
+    return !o && c && Cr(d), d;
+  };
+};
+/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */
+const Re = Wi;
+function gn(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  let n = 0;
+  for (let r = 0; r < t.length; r++)
+    n |= t[r] ^ e[r];
+  return n === 0;
+}
+function Bc(t) {
+  return Uint8Array.from(t);
+}
+function pt(t, ...e) {
+  const n = (o) => typeof o == "number" ? o : o.bytesLen, r = e.reduce((o, s) => o + n(s), 0);
+  return {
+    bytesLen: r,
+    encode: (o) => {
+      const s = new Uint8Array(r);
+      for (let i = 0, c = 0; i < e.length; i++) {
+        const f = e[i], u = n(f), d = typeof f == "number" ? o[i] : f.encode(o[i]);
+        W(d, u, t), s.set(d, c), typeof f != "number" && d.fill(0), c += u;
+      }
+      return s;
+    },
+    decode: (o) => {
+      W(o, r, t);
+      const s = [];
+      for (const i of e) {
+        const c = n(i), f = o.subarray(0, c);
+        s.push(typeof i == "number" ? f : i.decode(f)), o = o.subarray(c);
+      }
+      return s;
+    }
+  };
+}
+function bn(t, e) {
+  const n = e * t.bytesLen;
+  return {
+    bytesLen: n,
+    encode: (r) => {
+      if (r.length !== e)
+        throw new Error(`vecCoder.encode: wrong length=${r.length}. Expected: ${e}`);
+      const o = new Uint8Array(n);
+      for (let s = 0, i = 0; s < r.length; s++) {
+        const c = t.encode(r[s]);
+        o.set(c, i), c.fill(0), i += c.length;
+      }
+      return o;
+    },
+    decode: (r) => {
+      W(r, n);
+      const o = [];
+      for (let s = 0; s < r.length; s += t.bytesLen)
+        o.push(t.decode(r.subarray(s, s + t.bytesLen)));
+      return o;
+    }
+  };
+}
+function oe(...t) {
+  for (const e of t)
+    if (Array.isArray(e))
+      for (const n of e)
+        n.fill(0);
+    else
+      e.fill(0);
+}
+function $r(t) {
+  return (1 << t) - 1;
+}
+/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */
+const Lc = (t) => {
+  const { newPoly: e, N: n, Q: r, F: o, ROOT_OF_UNITY: s, brvBits: i } = t, c = (w, H = r) => {
+    const k = w % H | 0;
+    return (k >= 0 ? k | 0 : H + k | 0) | 0;
+  }, f = (w, H = r) => {
+    const k = c(w, H) | 0;
+    return (k > H >> 1 ? k - H | 0 : k) | 0;
+  };
+  function u() {
+    const w = e(n);
+    for (let H = 0; H < n; H++) {
+      const k = Oo(H, i), O = BigInt(s) ** BigInt(k) % BigInt(r);
+      w[H] = Number(O) | 0;
+    }
+    return w;
+  }
+  const d = u(), a = {
+    add: (w, H) => c((w | 0) + (H | 0)) | 0,
+    sub: (w, H) => c((w | 0) - (H | 0)) | 0,
+    mul: (w, H) => c((w | 0) * (H | 0)) | 0,
+    inv: (w) => {
+      throw new Error("not implemented");
+    }
+  }, y = {
+    N: n,
+    roots: d,
+    invertButterflies: !0,
+    skipStages: 1,
+    brp: !1
+  }, l = Or(a, { dit: !1, ...y }), b = Or(a, { dit: !0, ...y });
+  return { mod: c, smod: f, nttZetas: d, NTT: {
+    encode: (w) => l(w),
+    decode: (w) => {
+      b(w);
+      for (let H = 0; H < w.length; H++)
+        w[H] = c(o * w[H]);
+      return w;
+    }
+  }, bitsCoder: (w, H) => {
+    const k = $r(w), O = w * (n / 8);
+    return {
+      bytesLen: O,
+      encode: ($) => {
+        const R = new Uint8Array(O);
+        for (let N = 0, T = 0, S = 0, M = 0; N < $.length; N++)
+          for (T |= (H.encode($[N]) & k) << S, S += w; S >= 8; S -= 8, T >>= 8)
+            R[M++] = T & $r(S);
+        return R;
+      },
+      decode: ($) => {
+        const R = e(n);
+        for (let N = 0, T = 0, S = 0, M = 0; N < $.length; N++)
+          for (T |= $[N] << S, S += 8; S >= w; S -= w, T >>= w)
+            R[M++] = H.decode(T & k);
+        return R;
+      }
+    };
+  } };
+}, Sc = (t) => (e, n) => {
+  n || (n = t.blockLen);
+  const r = new Uint8Array(e.length + 2);
+  r.set(e);
+  const o = e.length, s = new Uint8Array(n);
+  let i = t.create({}), c = 0, f = 0;
+  return {
+    stats: () => ({ calls: c, xofs: f }),
+    get: (u, d) => (r[o + 0] = u, r[o + 1] = d, i.destroy(), i = t.create({}).update(r), c++, () => (f++, i.xofInto(s))),
+    clean: () => {
+      i.destroy(), oe(s, r);
+    }
+  };
+}, Hc = /* @__PURE__ */ Sc(Ac);
+/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */
+const ce = 256, ve = 3329, Uc = 3303, Ic = 17, { mod: xt, nttZetas: kc, NTT: Te, bitsCoder: _c } = Lc({
+  N: ce,
+  Q: ve,
+  F: Uc,
+  ROOT_OF_UNITY: Ic,
+  newPoly: (t) => new Uint16Array(t),
+  brvBits: 7
+}), No = {
+  768: { N: ce, Q: ve, K: 3, ETA1: 2, ETA2: 2, du: 10, dv: 4, RBGstrength: 192 },
+  1024: { N: ce, Q: ve, K: 4, ETA1: 2, ETA2: 2, du: 11, dv: 5, RBGstrength: 256 }
+}, Kc = (t) => {
+  if (t >= 12)
+    return { encode: (n) => n, decode: (n) => n };
+  const e = 2 ** (t - 1);
+  return {
+    // const compress = (i: number) => round((2 ** d / Q) * i) % 2 ** d;
+    encode: (n) => ((n << t) + ve / 2) / ve,
+    // const decompress = (i: number) => round((Q / 2 ** d) * i);
+    decode: (n) => n * ve + e >>> t
+  };
+}, lt = (t) => _c(t, Kc(t));
+function Ce(t, e) {
+  for (let n = 0; n < ce; n++)
+    t[n] = xt(t[n] + e[n]);
+}
+function vc(t, e) {
+  for (let n = 0; n < ce; n++)
+    t[n] = xt(t[n] - e[n]);
+}
+function Rc(t, e, n, r, o) {
+  const s = xt(e * r * o + t * n), i = xt(t * r + e * n);
+  return { c0: s, c1: i };
+}
+function Rt(t, e) {
+  for (let n = 0; n < ce / 2; n++) {
+    let r = kc[64 + (n >> 1)];
+    n & 1 && (r = -r);
+    const { c0: o, c1: s } = Rc(t[2 * n + 0], t[2 * n + 1], e[2 * n + 0], e[2 * n + 1], r);
+    t[2 * n + 0] = o, t[2 * n + 1] = s;
+  }
+  return t;
+}
+function Nr(t) {
+  const e = new Uint16Array(ce);
+  for (let n = 0; n < ce; ) {
+    const r = t();
+    if (r.length % 3)
+      throw new Error("SampleNTT: unaligned block");
+    for (let o = 0; n < ce && o + 3 <= r.length; o += 3) {
+      const s = (r[o + 0] >> 0 | r[o + 1] << 8) & 4095, i = (r[o + 1] >> 4 | r[o + 2] << 4) & 4095;
+      s < ve && (e[n++] = s), n < ce && i < ve && (e[n++] = i);
+    }
+  }
+  return e;
+}
+function ht(t, e, n, r) {
+  const o = t(r * ce / 4, e, n), s = new Uint16Array(ce), i = Uo(o);
+  let c = 0;
+  for (let f = 0, u = 0, d = 0, a = 0; f < i.length; f++) {
+    let y = i[f];
+    for (let l = 0; l < 32; l++)
+      d += y & 1, y >>= 1, c += 1, c === r ? (a = d, d = 0) : c === 2 * r && (s[u++] = xt(a - d), d = 0, c = 0);
+  }
+  if (c)
+    throw new Error(`sampleCBD: leftover bits: ${c}`);
+  return s;
+}
+const Tc = (t) => {
+  const { K: e, PRF: n, XOF: r, HASH512: o, ETA1: s, ETA2: i, du: c, dv: f } = t, u = lt(1), d = lt(f), a = lt(c), y = pt("publicKey", bn(lt(12), e), 32), l = bn(lt(12), e), b = pt("ciphertext", bn(a, e), d), E = pt("seed", 32, 32);
+  return {
+    secretCoder: l,
+    lengths: {
+      secretKey: l.bytesLen,
+      publicKey: y.bytesLen,
+      cipherText: b.bytesLen
+    },
+    keygen: (x) => {
+      W(x, 32, "seed");
+      const w = new Uint8Array(33);
+      w.set(x), w[32] = e;
+      const H = o(w), [k, O] = E.decode(H), $ = [], R = [];
+      for (let S = 0; S < e; S++)
+        $.push(Te.encode(ht(n, O, S, s)));
+      const N = r(k);
+      for (let S = 0; S < e; S++) {
+        const M = Te.encode(ht(n, O, e + S, s));
+        for (let C = 0; C < e; C++) {
+          const K = Nr(N.get(C, S));
+          Ce(M, Rt(K, $[C]));
+        }
+        R.push(M);
+      }
+      N.clean();
+      const T = {
+        publicKey: y.encode([R, k]),
+        secretKey: l.encode($)
+      };
+      return oe(k, O, $, R, w, H), T;
+    },
+    encrypt: (x, w, H) => {
+      const [k, O] = y.decode(x), $ = [];
+      for (let C = 0; C < e; C++)
+        $.push(Te.encode(ht(n, H, C, s)));
+      const R = r(O), N = new Uint16Array(ce), T = [];
+      for (let C = 0; C < e; C++) {
+        const K = ht(n, H, e + C, i), v = new Uint16Array(ce);
+        for (let h = 0; h < e; h++) {
+          const p = Nr(R.get(C, h));
+          Ce(v, Rt(p, $[h]));
+        }
+        Ce(K, Te.decode(v)), T.push(K), Ce(N, Rt(k[C], $[C])), oe(v);
+      }
+      R.clean();
+      const S = ht(n, H, 2 * e, i);
+      Ce(S, Te.decode(N));
+      const M = u.decode(w);
+      return Ce(M, S), oe(k, $, N, S), b.encode([T, M]);
+    },
+    decrypt: (x, w) => {
+      const [H, k] = b.decode(x), O = l.decode(w), $ = new Uint16Array(ce);
+      for (let R = 0; R < e; R++)
+        Ce($, Rt(O[R], Te.encode(H[R])));
+      return vc(k, Te.decode($)), oe($, O, H), u.encode(k);
+    }
+  };
+};
+function Mo(t) {
+  const e = Tc(t), { HASH256: n, HASH512: r, KDF: o } = t, { secretCoder: s, lengths: i } = e, c = pt("secretKey", i.secretKey, i.publicKey, 32, 32), f = 32, u = 64;
+  return {
+    info: { type: "ml-kem" },
+    lengths: {
+      ...i,
+      seed: 64,
+      msg: f,
+      msgRand: f,
+      secretKey: c.bytesLen
+    },
+    keygen: (d = Re(u)) => {
+      W(d, u, "seed");
+      const { publicKey: a, secretKey: y } = e.keygen(d.subarray(0, 32)), l = n(a), b = c.encode([y, a, l, d.subarray(32)]);
+      return oe(y, l), { publicKey: a, secretKey: b };
+    },
+    getPublicKey: (d) => {
+      const [a, y, l, b] = c.decode(d);
+      return Uint8Array.from(y);
+    },
+    encapsulate: (d, a = Re(f)) => {
+      W(d, i.publicKey, "publicKey"), W(a, f, "message");
+      const y = d.subarray(0, 384 * t.K), l = s.encode(s.decode(Bc(y)));
+      if (!gn(l, y))
+        throw oe(l), new Error("ML-KEM.encapsulate: wrong publicKey modulus");
+      oe(l);
+      const b = r.create().update(a).update(n(d)).digest(), E = e.encrypt(d, a, b.subarray(32, 64));
+      return oe(b.subarray(32)), { cipherText: E, sharedSecret: b.subarray(0, 32) };
+    },
+    decapsulate: (d, a) => {
+      W(a, c.bytesLen, "secretKey"), W(d, i.cipherText, "cipherText");
+      const y = c.bytesLen - 96, l = y + 32, b = n(a.subarray(y / 2, l));
+      if (!gn(b, a.subarray(l, l + 32)))
+        throw new Error("invalid secretKey: hash check failed");
+      const [E, x, w, H] = c.decode(a), k = e.decrypt(d, E), O = r.create().update(k).update(w).digest(), $ = O.subarray(0, 32), R = e.encrypt(x, k, O.subarray(32, 64)), N = gn(d, R), T = o.create({ dkLen: 32 }).update(H).update(d).digest();
+      return oe(k, R, N ? T : $), N ? $ : T;
+    }
+  };
+}
+function Cc(t, e, n) {
+  return Ye.create({ dkLen: t }).update(e).update(new Uint8Array([n])).digest();
+}
+const Fo = {
+  HASH256: Lt,
+  HASH512: mc,
+  KDF: Ye,
+  XOF: Hc,
+  PRF: Cc
+}, en = /* @__PURE__ */ Mo({
+  ...Fo,
+  ...No[768]
+}), Oc = /* @__PURE__ */ Mo({
+  ...Fo,
+  ...No[1024]
+});
+/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */
+function $c(t, e = !1) {
+  const n = t.lengths;
+  let r = t.keygen;
+  if (e) {
+    const s = t.Point.Fn;
+    if (!s)
+      throw new Error("No Point.Fn");
+    r = (i = Re(n.seed)) => {
+      W(i, n.seed, "seed");
+      const c = s.isLE ? wt(i) : At(i), f = s.toBytes(s.create(c));
+      return { secretKey: f, publicKey: t.getPublicKey(f) };
+    };
+  }
+  return {
+    lengths: { secretKey: n.secretKey, publicKey: n.publicKey, seed: n.seed },
+    keygen: r,
+    getPublicKey: (o) => t.getPublicKey(o)
+  };
+}
+function Zn(t, e = !1) {
+  const n = $c(t, e);
+  if (!t.getSharedSecret)
+    throw new Error("wrong curve");
+  return {
+    lengths: { ...n.lengths, msg: n.lengths.seed, cipherText: n.lengths.publicKey },
+    keygen: n.keygen,
+    getPublicKey: n.getPublicKey,
+    encapsulate(r, o = Re(t.lengths.seed)) {
+      const s = this.keygen(o).secretKey, i = this.decapsulate(r, s), c = t.getPublicKey(s);
+      return oe(s), { sharedSecret: i, cipherText: c };
+    },
+    decapsulate(r, o) {
+      const s = t.getSharedSecret(o, r);
+      return t.lengths.publicKeyHasPrefix ? s.subarray(1) : s;
+    }
+  };
+}
+function gt(t, e) {
+  return pt(e, ...t.map((n) => {
+    if (typeof n.lengths[e] != "number")
+      throw new Error("wrong length: " + e);
+    return n.lengths[e];
+  }));
+}
+function Xn(t) {
+  return (e, n) => t(e, { dkLen: n });
+}
+function Nc(t, e, ...n) {
+  const r = gt(n, "seed"), o = gt(n, "publicKey");
+  ze(t);
+  function s(i) {
+    W(i, t);
+    const c = r.decode(e(i, r.bytesLen)), f = n.map((a, y) => a.keygen(c[y])), u = f.map((a) => a.secretKey), d = f.map((a) => a.publicKey);
+    return { secretKey: u, publicKey: d };
+  }
+  return {
+    info: { lengths: { seed: t, publicKey: o.bytesLen, secretKey: t } },
+    getPublicKey(i) {
+      return this.keygen(i).publicKey;
+    },
+    keygen(i = Re(t)) {
+      const { publicKey: c, secretKey: f } = s(i), u = o.encode(c);
+      return oe(c), oe(f), { secretKey: i, publicKey: u };
+    },
+    expandDecapsulationKey: s,
+    realSeedLen: t
+  };
+}
+function tn(t, e, n, r, ...o) {
+  const s = Nc(t, n, ...o), i = gt(o, "cipherText"), c = gt(o, "publicKey"), f = gt(o, "msg");
+  return ze(e), {
+    lengths: {
+      ...s.info.lengths,
+      msg: e,
+      msgRand: f.bytesLen,
+      cipherText: i.bytesLen
+    },
+    getPublicKey: s.getPublicKey,
+    keygen: s.keygen,
+    encapsulate(u, d = Re(f.bytesLen)) {
+      const a = c.decode(u), y = f.decode(d), l = o.map((w, H) => w.encapsulate(a[H], y[H])), b = l.map((w) => w.sharedSecret), E = l.map((w) => w.cipherText), x = {
+        sharedSecret: r(a, E, b),
+        cipherText: i.encode(E)
+      };
+      return oe(b, E), x;
+    },
+    decapsulate(u, d) {
+      const a = i.decode(u), { publicKey: y, secretKey: l } = s.expandDecapsulationKey(d), b = o.map((E, x) => E.decapsulate(a[x], l[x]));
+      return r(y, a, b);
+    }
+  };
+}
+function Po(t, e, n, r, o) {
+  return Ve(r), Ve(o), tn(32, 32, Xn(r), (s, i, c) => o(ie(c[0], c[1], i[1], s[1], Me(t))), e, n);
+}
+Po("QSF-KEM(ML-KEM-768,P-256)-XOF(SHAKE256)-KDF(SHA3-256)", en, Zn(Oe, !0), Ye, Lt);
+Po("QSF-KEM(ML-KEM-1024,P-384)-XOF(SHAKE256)-KDF(SHA3-256)", Oc, Zn(Vi, !0), Ye, Lt);
+function Mc(t, e, n, r, o) {
+  return Ve(r), Ve(o), tn(32, 32, Xn(r), (s, i, c) => {
+    const f = ie(c[0], c[1], i[0], s[0], i[1], s[1], Me(t)), u = 32, d = ie(Me("hybrid_prk"), f), a = Qi(o, d), y = ie(Wt(u, 2), Me("shared_secret"), Me("")), l = Ji(o, a, y, u);
+    return oe(a, y, d, f), l;
+  }, e, n);
+}
+const Do = Zn(Vt);
+Mc("KitchenSink-KEM(ML-KEM-768,X25519)-XOF(SHAKE256)-KDF(HKDF-SHA-256)", en, Do, Ye, lc);
+const Fc = tn(
+  32,
+  32,
+  Xn(Ye),
+  // Awesome label, so much escaping hell in a single line.
+  (t, e, n) => Lt(ie(n[0], n[1], e[1], t[1], Me("\\.//^\\"))),
+  en,
+  Do
+);
+function Pc(t, e, n, r) {
+  const o = t.Point.Fn;
+  if (!o)
+    throw new Error("no Point.Fn");
+  function s(i) {
+    let c;
+    for (let d = 0, a = e; ; d = a, a += e) {
+      if (a > i.length)
+        throw new Error("rejection sampling failed");
+      if (c = o.fromBytes(i.subarray(d, a), !0), o.isValidNot0(c))
+        break;
+    }
+    const f = o.toBytes(o.create(c)), u = t.getPublicKey(f, !1);
+    return { secretKey: f, publicKey: u };
+  }
+  return {
+    lengths: {
+      secretKey: e,
+      publicKey: n,
+      seed: r,
+      msg: r,
+      cipherText: n
+    },
+    keygen(i = Re(r)) {
+      return W(i, r, "seed"), s(i);
+    },
+    getPublicKey(i) {
+      return t.getPublicKey(i, !1);
+    },
+    encapsulate(i, c = Re(r)) {
+      W(c, r, "rand");
+      const { secretKey: f } = s(c), u = this.decapsulate(i, f), d = t.getPublicKey(f, !1);
+      return oe(f), { sharedSecret: u, cipherText: d };
+    },
+    decapsulate(i, c) {
+      return t.getSharedSecret(c, i).subarray(1);
+    }
+  };
+}
+function Dc(t, e, n, r) {
+  const { secretKey: o, publicKeyUncompressed: s } = n.lengths;
+  if (!o || !s)
+    throw new Error("wrong curve");
+  const i = Pc(n, o, s, r), c = 64, f = c + r;
+  return tn(32, 32, (u) => {
+    W(u, 32);
+    const d = Ye(u, { dkLen: f }), a = d.subarray(0, c), y = d.subarray(c, f);
+    return ie(a, y);
+  }, (u, d, a) => Lt(ie(a[0], a[1], d[1], u[1], Me(t))), e, i);
+}
+const jc = Dc("MLKEM768-P256", en, Oe, 128), Wn = Fc, qc = jc, jo = !1;
+async function qo(t, e) {
+  try {
+    return await t();
+  } catch (n) {
+    if (n instanceof ReferenceError || n instanceof DOMException && n.name === "NotSupportedError")
+      return await e();
+    throw n;
+  }
+}
+async function Qn(t, e) {
+  return await qo(async () => {
+    const n = In(t) ? t : await Vc(t), r = await crypto.subtle.importKey("raw", e, { name: "X25519" }, jo, []);
+    return new Uint8Array(await crypto.subtle.deriveBits({ name: "X25519", public: r }, n, 256));
+  }, () => {
+    if (In(t))
+      throw new Error("CryptoKey provided but X25519 WebCrypto is not supported");
+    return Vt.scalarMult(t, e);
+  });
+}
+async function Gt(t) {
+  return await qo(async () => Qn(t, Vt.GuBytes), () => {
+    if (In(t))
+      throw new Error("CryptoKey provided but X25519 WebCrypto is not supported");
+    return Vt.scalarMultBase(t);
+  });
+}
+const zc = /* @__PURE__ */ new Uint8Array([
+  48,
+  46,
+  2,
+  1,
+  0,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  110,
+  4,
+  34,
+  4,
+  32
+]);
+async function Vc(t) {
+  if (t.length !== 32)
+    throw new Error("X25519 private key must be 32 bytes");
+  const e = new Uint8Array([...zc, ...t]);
+  return crypto.subtle.importKey("pkcs8", e, { name: "X25519" }, jo, ["deriveBits"]);
+}
+function In(t) {
+  return typeof CryptoKey < "u" && t instanceof CryptoKey;
+}
+class Gc {
+  constructor(e) {
+    g(this, "s");
+    g(this, "transcript", []);
+    g(this, "buf", new Uint8Array(0));
+    this.s = e.getReader();
+  }
+  async readLine() {
+    const e = [];
+    for (; ; ) {
+      const n = this.buf.indexOf(10);
+      if (n >= 0)
+        return e.push(this.buf.subarray(0, n)), this.transcript.push(this.buf.subarray(0, n + 1)), this.buf = this.buf.subarray(n + 1), Yc(tt(e));
+      this.buf.length > 0 && (e.push(this.buf), this.transcript.push(this.buf));
+      const r = await this.s.read();
+      if (r.done)
+        return this.buf = tt(e), null;
+      this.buf = r.value;
+    }
+  }
+  close() {
+    return this.s.releaseLock(), { rest: this.buf, transcript: tt(this.transcript) };
+  }
+}
+function Yc(t) {
+  return t.forEach((e) => {
+    if (e < 32 || e > 126)
+      throw Error("invalid non-ASCII byte in header");
+  }), new TextDecoder().decode(t);
+}
+function tt(t) {
+  const e = t.reduce(((o, s) => o + s.length), 0), n = new Uint8Array(e);
+  let r = 0;
+  for (const o of t)
+    n.set(o, r), r += o.length;
+  return n;
+}
+function Yt(t, ...e) {
+  return t.pipeThrough(new TransformStream({
+    start(n) {
+      for (const r of e)
+        n.enqueue(r);
+    }
+  }));
+}
+function kn(t) {
+  return new ReadableStream({
+    start(e) {
+      e.enqueue(t), e.close();
+    }
+  });
+}
+async function zo(t) {
+  if (!(t instanceof ReadableStream))
+    throw new Error("readAll expects a ReadableStream<Uint8Array>");
+  return new Uint8Array(await new Response(t).arrayBuffer());
+}
+async function Zc(t) {
+  if (!(t instanceof ReadableStream))
+    throw new Error("readAllString expects a ReadableStream<Uint8Array>");
+  return await new Response(t).text();
+}
+async function Xc(t, e) {
+  const n = t.getReader(), r = [];
+  let o = 0;
+  for (; o < e; ) {
+    const { done: f, value: u } = await n.read();
+    if (f)
+      throw Error("stream ended before reading " + e.toString() + " bytes");
+    r.push(u), o += u.length;
+  }
+  n.releaseLock();
+  const s = tt(r), i = s.subarray(0, e), c = Yt(t, s.subarray(e));
+  return { data: i, rest: c };
+}
+class Ze {
+  constructor(e, n) {
+    /**
+     * All space-separated arguments on the first line of the stanza.
+     * Each argument is a string that does not contain spaces.
+     * The first argument is often a recipient type, which should look like
+     * `example.com/...` to avoid collisions.
+     */
+    g(this, "args");
+    /**
+     * The raw body of the stanza. This is automatically base64-encoded and
+     * split into lines of 48 characters each.
+     */
+    g(this, "body");
+    this.args = e, this.body = n;
+  }
+}
+async function Wc(t) {
+  const e = await t.readLine();
+  if (e === null)
+    throw Error("invalid stanza");
+  const n = e.split(" ");
+  if (n.length < 2 || n.shift() !== "->")
+    return { next: e };
+  for (const s of n)
+    if (s.length === 0)
+      throw Error("invalid stanza");
+  const r = [];
+  for (; ; ) {
+    const s = await t.readLine();
+    if (s === null)
+      throw Error("invalid stanza");
+    const i = se.decode(s);
+    if (i.length > 48)
+      throw Error("invalid stanza");
+    if (r.push(i), i.length < 48)
+      break;
+  }
+  const o = tt(r);
+  return { s: new Ze(n, o) };
+}
+async function Qc(t) {
+  const e = new Gc(t), n = await e.readLine();
+  if (n !== "age-encryption.org/v1")
+    throw Error("invalid version " + (n ?? "line"));
+  const r = [];
+  for (; ; ) {
+    const { s: o, next: s } = await Wc(e);
+    if (o !== void 0) {
+      r.push(o);
+      continue;
+    }
+    if (!s.startsWith("--- "))
+      throw Error("invalid header");
+    const i = se.decode(s.slice(4)), { rest: c, transcript: f } = e.close(), u = f.slice(0, f.length - 1 - s.length + 3);
+    return { stanzas: r, headerNoMAC: u, MAC: i, headerSize: f.length, rest: Yt(t, c) };
+  }
+}
+function Vo(t) {
+  const e = [];
+  e.push(`age-encryption.org/v1
+`);
+  for (const n of t) {
+    e.push("-> " + n.args.join(" ") + `
+`);
+    for (let r = 0; r < n.body.length; r += 48) {
+      let o = r + 48;
+      o > n.body.length && (o = n.body.length), e.push(se.encode(n.body.subarray(r, o)) + `
+`);
+    }
+    n.body.length % 48 === 0 && e.push(`
+`);
+  }
+  return e.push("---"), new TextEncoder().encode(e.join(""));
+}
+function Jc(t, e) {
+  return tt([
+    Vo(t),
+    new TextEncoder().encode(" " + se.encode(e) + `
+`)
+  ]);
+}
+function Df() {
+  return ef();
+}
+function ef() {
+  const t = me(32), e = re.encodeFromBytes("AGE-SECRET-KEY-", t).toUpperCase();
+  return Promise.resolve(e);
+}
+function jf() {
+  const t = me(32), e = re.encodeFromBytes("AGE-SECRET-KEY-PQ-", t).toUpperCase();
+  return Promise.resolve(e);
+}
+async function qf(t) {
+  let e;
+  if (Yo(t))
+    e = t;
+  else if (t.startsWith("AGE-SECRET-KEY-PQ-1")) {
+    const r = re.decodeToBytes(t);
+    if (r.prefix.toUpperCase() !== "AGE-SECRET-KEY-PQ-" || r.bytes.length !== 32)
+      throw Error("invalid identity");
+    const o = Wn.getPublicKey(r.bytes);
+    return re.encode("age1pq", re.toWords(o), !1);
+  } else {
+    const r = re.decodeToBytes(t);
+    if (!t.startsWith("AGE-SECRET-KEY-1") || r.prefix.toUpperCase() !== "AGE-SECRET-KEY-" || r.bytes.length !== 32)
+      throw Error("invalid identity");
+    e = r.bytes;
+  }
+  const n = await Gt(e);
+  return re.encodeFromBytes("age", n);
+}
+class tf {
+  constructor(e) {
+    g(this, "recipient");
+    const n = re.decodeToBytes(e);
+    if (!e.startsWith("age1pq1") || n.prefix.toLowerCase() !== "age1pq" || n.bytes.length !== 1216)
+      throw Error("invalid recipient");
+    this.recipient = n.bytes;
+  }
+  wrapFileKey(e) {
+    const { cipherText: n, sharedSecret: r } = Wn.encapsulate(this.recipient), o = new TextEncoder().encode("age-encryption.org/mlkem768x25519"), { key: s, nonce: i } = nn(Go, r, o), c = ge(s, i).encrypt(e);
+    return [new Ze(["mlkem768x25519", se.encode(n)], c)];
+  }
+}
+class nf {
+  constructor(e) {
+    g(this, "identity");
+    const n = re.decodeToBytes(e);
+    if (!e.startsWith("AGE-SECRET-KEY-PQ-1") || n.prefix.toUpperCase() !== "AGE-SECRET-KEY-PQ-" || n.bytes.length !== 32)
+      throw Error("invalid identity");
+    this.identity = n.bytes;
+  }
+  unwrapFileKey(e) {
+    for (const n of e) {
+      if (n.args.length < 1 || n.args[0] !== "mlkem768x25519")
+        continue;
+      if (n.args.length !== 2)
+        throw Error("invalid mlkem768x25519 stanza");
+      const r = se.decode(n.args[1]);
+      if (r.length !== 1120 || n.body.length !== 32)
+        throw Error("invalid mlkem768x25519 stanza");
+      const o = Wn.decapsulate(r, this.identity), s = new TextEncoder().encode("age-encryption.org/mlkem768x25519"), { key: i, nonce: c } = nn(Go, o, s);
+      try {
+        return ge(i, c).decrypt(n.body);
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+}
+const Go = 25722, rf = 80, _n = 16;
+function nn(t, e, n) {
+  const r = of(t), o = $t(r, void 0, "psk_id_hash", new Uint8Array(0)), s = $t(r, void 0, "info_hash", n), i = new Uint8Array(1 + o.length + s.length);
+  i[0] = 0, i.set(o, 1), i.set(s, 1 + o.length);
+  const c = $t(r, e, "secret", new Uint8Array(0)), f = Kn(r, c, "key", i, 32), u = Kn(r, c, "base_nonce", i, 12);
+  return { key: f, nonce: u };
+}
+function of(t) {
+  const e = new Uint8Array(10);
+  return e.set(new TextEncoder().encode("HPKE"), 0), e[4] = t >> 8 & 255, e[5] = t & 255, e[6] = 0, e[7] = 1, e[8] = 0, e[9] = 3, e;
+}
+function $t(t, e, n, r) {
+  const o = new Uint8Array(7 + t.length + n.length + r.length);
+  let s = 0;
+  return o.set(new TextEncoder().encode("HPKE-v1"), s), s += 7, o.set(t, s), s += t.length, o.set(new TextEncoder().encode(n), s), s += n.length, o.set(r, s), mt(ee, o, e);
+}
+function Kn(t, e, n, r, o) {
+  const s = new Uint8Array(9 + t.length + n.length + r.length);
+  let i = 0;
+  return s[i] = o >> 8 & 255, s[i + 1] = o & 255, i += 2, s.set(new TextEncoder().encode("HPKE-v1"), i), i += 7, s.set(t, i), i += t.length, s.set(new TextEncoder().encode(n), i), i += n.length, s.set(r, i), Dr(ee, e, s, o);
+}
+function sf(t) {
+  t.length !== Oe.lengths.publicKeyUncompressed && (t = Oe.Point.fromBytes(t).toBytes(!1));
+  const e = Oe.utils.randomSecretKey(), n = Oe.getPublicKey(e, !1), r = Oe.getSharedSecret(e, t, !0).subarray(1), o = new Uint8Array(n.length + t.length);
+  o.set(n, 0), o.set(t, n.length);
+  const s = new Uint8Array(5);
+  s.set(new TextEncoder().encode("KEM"), 0), s[3] = _n >> 8, s[4] = _n & 255;
+  const i = $t(s, void 0, "eae_prk", r), c = Kn(s, i, "shared_secret", o, 32);
+  return { encapsulatedKey: n, sharedSecret: c };
+}
+class cf {
+  constructor(e) {
+    g(this, "recipient");
+    const n = re.decodeToBytes(e);
+    if (!e.startsWith("age1tag1") || n.prefix.toLowerCase() !== "age1tag" || n.bytes.length !== 33)
+      throw Error("invalid recipient");
+    this.recipient = n.bytes;
+  }
+  wrapFileKey(e) {
+    const { encapsulatedKey: n, sharedSecret: r } = sf(this.recipient), o = new TextEncoder().encode("age-encryption.org/p256tag"), s = (() => {
+      const u = ee(this.recipient).subarray(0, 4), d = new Uint8Array(n.length + u.length);
+      return d.set(n, 0), d.set(u, n.length), mt(ee, d, o).subarray(0, 4);
+    })(), { key: i, nonce: c } = nn(_n, r, o), f = ge(i, c).encrypt(e);
+    return [new Ze(["p256tag", se.encode(s), se.encode(n)], f)];
+  }
+}
+class ff {
+  constructor(e) {
+    g(this, "recipient");
+    const n = re.decodeToBytes(e);
+    if (!e.startsWith("age1tagpq1") || n.prefix.toLowerCase() !== "age1tagpq" || n.bytes.length !== 1249)
+      throw Error("invalid recipient");
+    this.recipient = n.bytes;
+  }
+  wrapFileKey(e) {
+    const { cipherText: n, sharedSecret: r } = qc.encapsulate(this.recipient), o = new TextEncoder().encode("age-encryption.org/mlkem768p256tag"), s = (() => {
+      const u = ee(this.recipient.subarray(1184)).subarray(0, 4), d = new Uint8Array(n.length + u.length);
+      return d.set(n, 0), d.set(u, n.length), mt(ee, d, o).subarray(0, 4);
+    })(), { key: i, nonce: c } = nn(rf, r, o), f = ge(i, c).encrypt(e);
+    return [new Ze(["mlkem768p256tag", se.encode(s), se.encode(n)], f)];
+  }
+}
+class af {
+  constructor(e) {
+    g(this, "recipient");
+    const n = re.decodeToBytes(e);
+    if (!e.startsWith("age1") || n.prefix.toLowerCase() !== "age" || n.bytes.length !== 32)
+      throw Error("invalid recipient");
+    this.recipient = n.bytes;
+  }
+  async wrapFileKey(e) {
+    const n = me(32), r = await Gt(n), o = await Qn(n, this.recipient), s = new Uint8Array(r.length + this.recipient.length);
+    s.set(r), s.set(this.recipient, r.length);
+    const i = new TextEncoder().encode("age-encryption.org/v1/X25519"), c = rt(ee, o, s, i, 32);
+    return [new Ze(["X25519", se.encode(r)], Jn(e, c))];
+  }
+}
+class Mr {
+  constructor(e) {
+    g(this, "identity");
+    g(this, "recipient");
+    if (Yo(e)) {
+      this.identity = e, this.recipient = Gt(e);
+      return;
+    }
+    const n = re.decodeToBytes(e);
+    if (!e.startsWith("AGE-SECRET-KEY-1") || n.prefix.toUpperCase() !== "AGE-SECRET-KEY-" || n.bytes.length !== 32)
+      throw Error("invalid identity");
+    this.identity = n.bytes, this.recipient = Gt(n.bytes);
+  }
+  async unwrapFileKey(e) {
+    for (const n of e) {
+      if (n.args.length < 1 || n.args[0] !== "X25519")
+        continue;
+      if (n.args.length !== 2)
+        throw Error("invalid X25519 stanza");
+      const r = se.decode(n.args[1]);
+      if (r.length !== 32)
+        throw Error("invalid X25519 stanza");
+      const o = await Qn(this.identity, r), s = await this.recipient, i = new Uint8Array(r.length + s.length);
+      i.set(r), i.set(s, r.length);
+      const c = new TextEncoder().encode("age-encryption.org/v1/X25519"), f = rt(ee, o, i, c, 32), u = er(n.body, f);
+      if (u !== null)
+        return u;
+    }
+    return null;
+  }
+}
+class uf {
+  constructor(e, n) {
+    g(this, "passphrase");
+    g(this, "logN");
+    this.passphrase = e, this.logN = n;
+  }
+  wrapFileKey(e) {
+    const n = me(16), r = "age-encryption.org/v1/scrypt", o = new Uint8Array(r.length + 16);
+    o.set(new TextEncoder().encode(r)), o.set(n, r.length);
+    const s = Yr(this.passphrase, o, { N: 2 ** this.logN, r: 8, p: 1, dkLen: 32 });
+    return [new Ze(["scrypt", se.encode(n), this.logN.toString()], Jn(e, s))];
+  }
+}
+class df {
+  constructor(e) {
+    g(this, "passphrase");
+    this.passphrase = e;
+  }
+  unwrapFileKey(e) {
+    for (const n of e) {
+      if (n.args.length < 1 || n.args[0] !== "scrypt")
+        continue;
+      if (e.length !== 1)
+        throw Error("scrypt recipient is not the only one in the header");
+      if (n.args.length !== 3 || !/^[1-9][0-9]*$/.test(n.args[2]))
+        throw Error("invalid scrypt stanza");
+      const r = se.decode(n.args[1]);
+      if (r.length !== 16)
+        throw Error("invalid scrypt stanza");
+      const o = Number(n.args[2]);
+      if (o > 20)
+        throw Error("scrypt work factor is too high");
+      const s = "age-encryption.org/v1/scrypt", i = new Uint8Array(s.length + 16);
+      i.set(new TextEncoder().encode(s)), i.set(r, s.length);
+      const c = Yr(this.passphrase, i, { N: 2 ** o, r: 8, p: 1, dkLen: 32 }), f = er(n.body, c);
+      if (f !== null)
+        return f;
+    }
+    return null;
+  }
+}
+function Jn(t, e) {
+  const n = new Uint8Array(12);
+  return ge(e, n).encrypt(t);
+}
+function er(t, e) {
+  if (t.length !== 32)
+    throw Error("invalid stanza");
+  const n = new Uint8Array(12);
+  try {
+    return ge(e, n).decrypt(t);
+  } catch {
+    return null;
+  }
+}
+function Yo(t) {
+  return typeof CryptoKey < "u" && t instanceof CryptoKey;
+}
+const $e = 16, tr = 64 * 1024, vn = tr + $e;
+function lf(t) {
+  const e = new Uint8Array(12), n = () => {
+    for (let i = e.length - 2; i >= 0 && (e[i]++, e[i] === 0); i--)
+      ;
+  };
+  let r = !0;
+  const o = new Uint8Array(vn);
+  let s = 0;
+  return new TransformStream({
+    transform(i, c) {
+      for (; i.length > 0; ) {
+        if (s === o.length) {
+          const u = ge(t, e).decrypt(o);
+          c.enqueue(u), n(), s = 0, r = !1;
+        }
+        const f = Math.min(o.length - s, i.length);
+        o.set(i.subarray(0, f), s), s += f, i = i.subarray(f);
+      }
+    },
+    flush(i) {
+      e[11] = 1;
+      const c = ge(t, e).decrypt(o.subarray(0, s));
+      if (!r && c.length === 0)
+        throw new Error("final chunk is empty");
+      i.enqueue(c);
+    }
+  });
+}
+function hf(t) {
+  if (t < $e)
+    throw Error("ciphertext is too small");
+  if (t === $e)
+    return 0;
+  const e = Math.floor(t / vn), n = t % vn;
+  if (0 < n && n <= $e)
+    throw Error("ciphertext size is invalid");
+  let r = t;
+  return r -= e * $e, r -= n > 0 ? $e : 0, r;
+}
+function yf(t) {
+  const e = new Uint8Array(12), n = () => {
+    for (let s = e.length - 2; s >= 0 && (e[s]++, e[s] === 0); s--)
+      ;
+  }, r = new Uint8Array(tr);
+  let o = 0;
+  return new TransformStream({
+    transform(s, i) {
+      for (; s.length > 0; ) {
+        if (o === r.length) {
+          const f = ge(t, e).encrypt(r);
+          i.enqueue(f), n(), o = 0;
+        }
+        const c = Math.min(r.length - o, s.length);
+        r.set(s.subarray(0, c), o), o += c, s = s.subarray(c);
+      }
+    },
+    flush(s) {
+      e[11] = 1;
+      const i = ge(t, e).encrypt(r.subarray(0, o));
+      s.enqueue(i);
+    }
+  });
+}
+function pf(t) {
+  const e = Math.max(1, Math.ceil(t / tr));
+  return t + $e * e;
+}
+function gf(t) {
+  const e = [];
+  e.push(`-----BEGIN AGE ENCRYPTED FILE-----
+`);
+  for (let n = 0; n < t.length; n += 48) {
+    let r = n + 48;
+    r > t.length && (r = t.length), e.push(Vr.encode(t.subarray(n, r)) + `
+`);
+  }
+  return e.push(`-----END AGE ENCRYPTED FILE-----
+`), e.join("");
+}
+function bf(t) {
+  const e = t.trim().replaceAll(`\r
+`, `
+`).split(`
+`);
+  if (e.shift() !== "-----BEGIN AGE ENCRYPTED FILE-----")
+    throw Error("invalid header");
+  if (e.pop() !== "-----END AGE ENCRYPTED FILE-----")
+    throw Error("invalid footer");
+  function n(r, o) {
+    return r === e.length - 1 ? o.length > 0 && o.length <= 64 && o.length % 4 === 0 : o.length === 64;
+  }
+  if (!e.every((r, o) => n(o, r)))
+    throw Error("invalid line length");
+  if (!e.every((r) => /^[A-Za-z0-9+/=]+$/.test(r)))
+    throw Error("invalid base64");
+  return Vr.decode(e.join(""));
+}
+const zf = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  decode: bf,
+  encode: gf
+}, Symbol.toStringTag, { value: "Module" }));
+function rn(t) {
+  if (t.length === 0)
+    throw Error("cbor: unexpected EOF");
+  const e = t[0] >> 5, n = t[0] & 31;
+  if (n <= 23)
+    return [e, n, t.subarray(1)];
+  if (n === 24) {
+    if (t.length < 2)
+      throw Error("cbor: unexpected EOF");
+    return [e, t[1], t.subarray(2)];
+  }
+  if (n === 25) {
+    if (t.length < 3)
+      throw Error("cbor: unexpected EOF");
+    return [e, t[1] << 8 | t[2], t.subarray(3)];
+  }
+  throw Error("cbor: unsupported argument encoding");
+}
+function wf(t) {
+  const [e, n, r] = rn(t);
+  if (e !== 0)
+    throw Error("cbor: expected unsigned integer");
+  return [n, r];
+}
+function xf(t) {
+  const [e, n, r] = rn(t);
+  if (e !== 2)
+    throw Error("cbor: expected byte string");
+  if (n > r.length)
+    throw Error("cbor: unexpected EOF");
+  return [r.subarray(0, n), r.subarray(n)];
+}
+function Zo(t) {
+  const [e, n, r] = rn(t);
+  if (e !== 3)
+    throw Error("cbor: expected text string");
+  if (n > r.length)
+    throw Error("cbor: unexpected EOF");
+  return [new TextDecoder("utf-8", { fatal: !0, ignoreBOM: !0 }).decode(r.subarray(0, n)), r.subarray(n)];
+}
+function Ef(t) {
+  const [e, n, r] = rn(t);
+  if (e !== 4)
+    throw Error("cbor: expected array");
+  let o = r;
+  const s = [];
+  for (let i = 0; i < n; i++) {
+    let c;
+    [c, o] = Zo(o), s.push(c);
+  }
+  return [s, o];
+}
+function mf(t) {
+  return new Uint8Array([t]);
+}
+function Af(t) {
+  if (t.length <= 23)
+    return new Uint8Array([64 | t.length, ...t]);
+  if (t.length <= 255)
+    return new Uint8Array([88, t.length, ...t]);
+  if (t.length <= 65535)
+    return new Uint8Array([89, t.length >> 8, t.length & 255, ...t]);
+  throw Error("cbor: byte string too long");
+}
+function Xo(t) {
+  const e = new TextEncoder().encode(t);
+  if (e.length <= 23)
+    return new Uint8Array([96 | e.length, ...e]);
+  if (e.length <= 255)
+    return new Uint8Array([120, e.length, ...e]);
+  if (e.length <= 65535)
+    return new Uint8Array([121, e.length >> 8, e.length & 255, ...e]);
+  throw Error("cbor: text string too long");
+}
+function Bf(t) {
+  const e = t.flatMap((n) => [...Xo(n)]);
+  if (t.length <= 23)
+    return new Uint8Array([128 | t.length, ...e]);
+  if (t.length <= 255)
+    return new Uint8Array([152, t.length, ...e]);
+  if (t.length <= 65535)
+    return new Uint8Array([153, t.length >> 8, t.length & 255, ...e]);
+  throw Error("cbor: array too long");
+}
+const Lf = [
+  { type: "public-key", alg: -8 },
+  // Ed25519
+  { type: "public-key", alg: -7 },
+  // ECDSA with P-256 and SHA-256
+  { type: "public-key", alg: -257 }
+  // RSA PKCS#1 v1.5 with SHA-256
+];
+async function Sf(t) {
+  var r;
+  const e = await navigator.credentials.create({
+    publicKey: {
+      rp: { name: "", id: t.rpId },
+      user: {
+        name: t.keyName,
+        id: me(8),
+        // avoid overwriting existing keys
+        displayName: ""
+      },
+      pubKeyCredParams: Lf,
+      authenticatorSelection: {
+        requireResidentKey: t.type !== "security-key",
+        residentKey: t.type !== "security-key" ? "required" : "discouraged",
+        userVerification: "required"
+        // prf requires UV
+      },
+      hints: t.type === "security-key" ? ["security-key"] : [],
+      extensions: { prf: {} },
+      challenge: new Uint8Array([0]).buffer
+      // unused without attestation
+    }
+  });
+  if (!((r = e.getClientExtensionResults().prf) != null && r.enabled))
+    throw Error("PRF extension not available (need macOS 15+, Chrome 132+)");
+  const n = t.rpId ?? new URL(window.origin).hostname;
+  return Hf(e, n);
+}
+const Wo = "AGE-PLUGIN-FIDO2PRF-";
+function Hf(t, e) {
+  const n = t.response, r = mf(1), o = Af(new Uint8Array(t.rawId)), s = Xo(e), i = Bf(n.getTransports()), c = new Uint8Array([...r, ...o, ...s, ...i]);
+  return re.encode(Wo, re.toWords(c), !1).toUpperCase();
+}
+function Uf(t) {
+  const e = re.decodeToBytes(t);
+  if (!t.startsWith(Wo + "1"))
+    throw Error("invalid identity");
+  const [n, r] = wf(e.bytes);
+  if (n !== 1)
+    throw Error("unsupported identity version");
+  const [o, s] = xf(r), [i, c] = Zo(s), [f] = Ef(c);
+  return [o, i, f];
+}
+const on = "age-encryption.org/fido2prf";
+class Qo {
+  constructor(e) {
+    g(this, "credId");
+    g(this, "transports");
+    g(this, "rpId");
+    if (e != null && e.identity) {
+      const [n, r, o] = Uf(e.identity);
+      this.credId = n, this.transports = o, this.rpId = r;
+    } else
+      this.rpId = e == null ? void 0 : e.rpId;
+  }
+  async getCredential(e) {
+    var o;
+    const r = (o = (await navigator.credentials.get({
+      publicKey: {
+        allowCredentials: this.credId ? [{
+          id: this.credId,
+          transports: this.transports,
+          type: "public-key"
+        }] : [],
+        challenge: me(16),
+        extensions: { prf: { eval: _f(e) } },
+        userVerification: "required",
+        // prf requires UV
+        rpId: this.rpId
+      }
+    })).getClientExtensionResults().prf) == null ? void 0 : o.results;
+    if (r === void 0)
+      throw Error("PRF extension not available (need macOS 15+, Chrome 132+)");
+    return r;
+  }
+}
+class If extends Qo {
+  /**
+   * Implements {@link Recipient.wrapFileKey}.
+   */
+  async wrapFileKey(e) {
+    const n = me(16), r = await this.getCredential(n), o = Jo(r);
+    return [new Ze([on, se.encode(n)], Jn(e, o))];
+  }
+}
+class kf extends Qo {
+  /**
+   * Implements {@link Identity.unwrapFileKey}.
+   */
+  async unwrapFileKey(e) {
+    for (const n of e) {
+      if (n.args.length < 1 || n.args[0] !== on)
+        continue;
+      if (n.args.length !== 2)
+        throw Error("invalid prf stanza");
+      const r = se.decode(n.args[1]);
+      if (r.length !== 16)
+        throw Error("invalid prf stanza");
+      const o = await this.getCredential(r), s = Jo(o), i = er(n.body, s);
+      if (i !== null)
+        return i;
+    }
+    return null;
+  }
+}
+function _f(t) {
+  const e = new TextEncoder().encode(on), n = new Uint8Array(e.length + t.length + 1);
+  n.set(e, 0), n[e.length] = 1, n.set(t, e.length + 1);
+  const r = new Uint8Array(e.length + t.length + 1);
+  return r.set(e, 0), r[e.length] = 2, r.set(t, e.length + 1), { first: n, second: r };
+}
+function Jo(t) {
+  if (t.second === void 0)
+    throw Error("Missing second PRF result");
+  const e = new Uint8Array(t.first.byteLength + t.second.byteLength);
+  return e.set(new Uint8Array(t.first), 0), e.set(new Uint8Array(t.second), t.first.byteLength), mt(ee, e, new TextEncoder().encode(on));
+}
+const Vf = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WebAuthnIdentity: kf,
+  WebAuthnRecipient: If,
+  createCredential: Sf
+}, Symbol.toStringTag, { value: "Module" }));
+class Gf {
+  constructor() {
+    g(this, "passphrase", null);
+    g(this, "scryptWorkFactor", 18);
+    g(this, "recipients", []);
+  }
+  /**
+   * Set the passphrase to encrypt the file(s) with. This method can only be
+   * called once, and can't be called if {@link Encrypter.addRecipient} has
+   * been called.
+   *
+   * The passphrase is passed through the scrypt key derivation function, but
+   * it needs to have enough entropy to resist offline brute-force attacks.
+   * You should use at least 8-10 random alphanumeric characters, or 4-5
+   * random words from a list of at least 2000 words.
+   *
+   * @param s - The passphrase to encrypt the file with.
+   */
+  setPassphrase(e) {
+    if (this.passphrase !== null)
+      throw new Error("can encrypt to at most one passphrase");
+    if (this.recipients.length !== 0)
+      throw new Error("can't encrypt to both recipients and passphrases");
+    this.passphrase = e;
+  }
+  /**
+   * Set the scrypt work factor to use when encrypting the file(s) with a
+   * passphrase. The default is 18. Using a lower value will require stronger
+   * passphrases to resist offline brute-force attacks.
+   *
+   * @param logN - The base-2 logarithm of the scrypt work factor.
+   */
+  setScryptWorkFactor(e) {
+    this.scryptWorkFactor = e;
+  }
+  /**
+   * Add a recipient to encrypt the file(s) for. This method can be called
+   * multiple times to encrypt the file(s) for multiple recipients.
+   *
+   * This version supports native X25519 recipients (`age1...`), hybrid
+   * post-quantum recipients (`age1pq1...`), tag recipients (`age1tag1...`),
+   * and hybrid tag recipients (`age1tagpq1...`).
+   *
+   * @param s - The recipient to encrypt the file for. Either a string
+   * beginning with `age1...` or an object implementing the {@link Recipient}
+   * interface.
+   */
+  addRecipient(e) {
+    if (this.passphrase !== null)
+      throw new Error("can't encrypt to both recipients and passphrases");
+    if (typeof e == "string")
+      if (e.startsWith("age1pq1"))
+        this.recipients.push(new tf(e));
+      else if (e.startsWith("age1tag1"))
+        this.recipients.push(new cf(e));
+      else if (e.startsWith("age1tagpq1"))
+        this.recipients.push(new ff(e));
+      else if (e.startsWith("age1"))
+        this.recipients.push(new af(e));
+      else
+        throw new Error("unrecognized recipient type");
+    else
+      this.recipients.push(e);
+  }
+  async encrypt(e) {
+    const n = me(16), r = [];
+    let o = this.recipients;
+    this.passphrase !== null && (o = [new uf(this.passphrase, this.scryptWorkFactor)]);
+    for (const l of o)
+      r.push(...await l.wrapFileKey(n));
+    const s = new TextEncoder().encode("header"), i = rt(ee, n, void 0, s, 32), c = Et(ee, i, Vo(r)), f = Jc(r, c), u = me(16), d = new TextEncoder().encode("payload"), a = rt(ee, n, u, d, 32), y = yf(a);
+    return e instanceof ReadableStream ? Object.assign(Yt(e.pipeThrough(y), f, u), {
+      size: (l) => pf(l) + f.length + u.length
+    }) : (typeof e == "string" && (e = new TextEncoder().encode(e)), await zo(Yt(kn(e).pipeThrough(y), f, u)));
+  }
+}
+class Yf {
+  constructor() {
+    g(this, "identities", []);
+  }
+  /**
+   * Add a passphrase to decrypt password-encrypted file(s) with. This method
+   * can be called multiple times to try multiple passphrases.
+   *
+   * @param s - The passphrase to decrypt the file with.
+   */
+  addPassphrase(e) {
+    this.identities.push(new df(e));
+  }
+  /**
+   * Add an identity to decrypt file(s) with. This method can be called
+   * multiple times to try multiple identities.
+   *
+   * @param s - The identity to decrypt the file with. Either a string
+   * beginning with `AGE-SECRET-KEY-PQ-1...` or `AGE-SECRET-KEY-1...`, an
+   * X25519 private
+   * {@link https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey | CryptoKey}
+   * object, or an object implementing the {@link Identity} interface.
+   *
+   * A CryptoKey object must have
+   * {@link https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey/type | type}
+   * `private`,
+   * {@link https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey/algorithm | algorithm}
+   * `{name: 'X25519'}`, and
+   * {@link https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey/usages | usages}
+   * `["deriveBits"]`. For example:
+   * ```js
+   * const keyPair = await crypto.subtle.generateKey({ name: "X25519" }, false, ["deriveBits"])
+   * decrypter.addIdentity(key.privateKey)
+   * ```
+   */
+  addIdentity(e) {
+    if (vf(e))
+      this.identities.push(new Mr(e));
+    else if (typeof e == "string")
+      if (e.startsWith("AGE-SECRET-KEY-1"))
+        this.identities.push(new Mr(e));
+      else if (e.startsWith("AGE-SECRET-KEY-PQ-1"))
+        this.identities.push(new nf(e));
+      else
+        throw new Error("unrecognized identity type");
+    else
+      this.identities.push(e);
+  }
+  async decrypt(e, n) {
+    const r = e instanceof ReadableStream ? e : kn(e), { fileKey: o, headerSize: s, rest: i } = await this.decryptHeaderInternal(r), { data: c, rest: f } = await Xc(i, 16), u = new TextEncoder().encode("payload"), d = rt(ee, o, c, u, 32), a = lf(d), y = f.pipeThrough(a), l = Object.assign(y, {
+      size: (b) => hf(b - s - c.length)
+    });
+    return e instanceof ReadableStream ? l : n === "text" ? await Zc(y) : await zo(y);
+  }
+  /**
+   * Decrypt the file key from a detached header. This is a low-level
+   * function that can be used to implement delegated decryption logic.
+   * Most users won't need this.
+   *
+   * It is the caller's responsibility to keep track of what file the
+   * returned file key decrypts, and to ensure the file key is not used
+   * for any other purpose.
+   *
+   * @param header - The file's textual header, including the MAC.
+   *
+   * @returns The file key used to encrypt the file.
+   */
+  async decryptHeader(e) {
+    return (await this.decryptHeaderInternal(kn(e))).fileKey;
+  }
+  async decryptHeaderInternal(e) {
+    const n = await Qc(e), r = await this.unwrapFileKey(n.stanzas);
+    if (r === null)
+      throw Error("no identity matched any of the file's recipients");
+    const o = new TextEncoder().encode("header"), s = rt(ee, r, void 0, o, 32), i = Et(ee, s, n.headerNoMAC);
+    if (!Kf(n.MAC, i))
+      throw Error("invalid header HMAC");
+    return { fileKey: r, headerSize: n.headerSize, rest: n.rest };
+  }
+  async unwrapFileKey(e) {
+    for (const n of this.identities) {
+      const r = await n.unwrapFileKey(e);
+      if (r !== null)
+        return r;
+    }
+    return null;
+  }
+}
+function Kf(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  let n = 0;
+  for (let r = 0; r < t.length; r++)
+    n |= t[r] ^ e[r];
+  return n === 0;
+}
+function vf(t) {
+  return typeof CryptoKey < "u" && t instanceof CryptoKey;
+}
+export {
+  Yf as Decrypter,
+  Gf as Encrypter,
+  Ze as Stanza,
+  zf as armor,
+  jf as generateHybridIdentity,
+  Df as generateIdentity,
+  ef as generateX25519Identity,
+  qf as identityToRecipient,
+  Vf as webauthn
+};