/*! For license information please see safari-notifications.js.LICENSE.txt */
let customModule;
(() => {
  const t = {
      82: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.createCurve = e.getHash = void 0);
        const n = r(569),
          o = r(89),
          i = r(551);
        function s(t) {
          return {
            hash: t,
            hmac: (e, ...r) => (0, n.hmac)(t, e, (0, o.concatBytes)(...r)),
            randomBytes: o.randomBytes,
          };
        }
        (e.getHash = s),
          (e.createCurve = function (t, e) {
            const r = (e) => (0, i.weierstrass)({ ...t, ...s(e) });
            return Object.freeze({ ...r(e), create: r });
          });
      },
      525: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.validateBasic = e.wNAF = void 0);
        const n = r(632),
          o = r(219),
          i = BigInt(0),
          s = BigInt(1);
        (e.wNAF = function (t, e) {
          const r = (t, e) => {
              const r = e.negate();
              return t ? r : e;
            },
            n = (t) => ({
              windows: Math.ceil(e / t) + 1,
              windowSize: 2 ** (t - 1),
            });
          return {
            constTimeNegate: r,
            unsafeLadder(e, r) {
              let n = t.ZERO,
                o = e;
              for (; r > i; )
                r & s && (n = n.add(o)), (o = o.double()), (r >>= s);
              return n;
            },
            precomputeWindow(t, e) {
              const { windows: r, windowSize: o } = n(e),
                i = [];
              let s = t,
                a = s;
              for (let t = 0; t < r; t++) {
                (a = s), i.push(a);
                for (let t = 1; t < o; t++) (a = a.add(s)), i.push(a);
                s = a.double();
              }
              return i;
            },
            wNAF(e, o, i) {
              const { windows: a, windowSize: f } = n(e);
              let c = t.ZERO,
                u = t.BASE;
              const h = BigInt(2 ** e - 1),
                l = 2 ** e,
                d = BigInt(e);
              for (let t = 0; t < a; t++) {
                const e = t * f;
                let n = Number(i & h);
                (i >>= d), n > f && ((n -= l), (i += s));
                const a = e,
                  y = e + Math.abs(n) - 1,
                  p = t % 2 != 0,
                  g = n < 0;
                0 === n ? (u = u.add(r(p, o[a]))) : (c = c.add(r(g, o[y])));
              }
              return { p: c, f: u };
            },
            wNAFCached(t, e, r, n) {
              const o = t._WINDOW_SIZE || 1;
              let i = e.get(t);
              return (
                i ||
                  ((i = this.precomputeWindow(t, o)),
                  1 !== o && e.set(t, n(i))),
                this.wNAF(o, i, r)
              );
            },
          };
        }),
          (e.validateBasic = function (t) {
            return (
              (0, n.validateField)(t.Fp),
              (0, o.validateObject)(
                t,
                { n: "bigint", h: "bigint", Gx: "field", Gy: "field" },
                { nBitLength: "isSafeInteger", nByteLength: "isSafeInteger" },
              ),
              Object.freeze({
                ...(0, n.nLength)(t.n, t.nBitLength),
                ...t,
                p: t.Fp.ORDER,
              })
            );
          });
      },
      134: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.createHasher =
            e.isogenyMap =
            e.hash_to_field =
            e.expand_message_xof =
            e.expand_message_xmd =
              void 0);
        const n = r(632),
          o = r(219),
          i = o.bytesToNumberBE;
        function s(t, e) {
          if (t < 0 || t >= 1 << (8 * e))
            throw new Error(`bad I2OSP call: value=${t} length=${e}`);
          const r = Array.from({ length: e }).fill(0);
          for (let n = e - 1; n >= 0; n--) (r[n] = 255 & t), (t >>>= 8);
          return new Uint8Array(r);
        }
        function a(t, e) {
          const r = new Uint8Array(t.length);
          for (let n = 0; n < t.length; n++) r[n] = t[n] ^ e[n];
          return r;
        }
        function f(t) {
          if (!(t instanceof Uint8Array))
            throw new Error("Uint8Array expected");
        }
        function c(t) {
          if (!Number.isSafeInteger(t)) throw new Error("number expected");
        }
        function u(t, e, r, n) {
          f(t),
            f(e),
            c(r),
            e.length > 255 &&
              (e = n(
                (0, o.concatBytes)((0, o.utf8ToBytes)("H2C-OVERSIZE-DST-"), e),
              ));
          const { outputLen: i, blockLen: u } = n,
            h = Math.ceil(r / i);
          if (h > 255) throw new Error("Invalid xmd length");
          const l = (0, o.concatBytes)(e, s(e.length, 1)),
            d = s(0, u),
            y = s(r, 2),
            p = new Array(h),
            g = n((0, o.concatBytes)(d, t, y, s(0, 1), l));
          p[0] = n((0, o.concatBytes)(g, s(1, 1), l));
          for (let t = 1; t <= h; t++) {
            const e = [a(g, p[t - 1]), s(t + 1, 1), l];
            p[t] = n((0, o.concatBytes)(...e));
          }
          return (0, o.concatBytes)(...p).slice(0, r);
        }
        function h(t, e, r, n, i) {
          if ((f(t), f(e), c(r), e.length > 255)) {
            const t = Math.ceil((2 * n) / 8);
            e = i
              .create({ dkLen: t })
              .update((0, o.utf8ToBytes)("H2C-OVERSIZE-DST-"))
              .update(e)
              .digest();
          }
          if (r > 65535 || e.length > 255)
            throw new Error("expand_message_xof: invalid lenInBytes");
          return i
            .create({ dkLen: r })
            .update(t)
            .update(s(r, 2))
            .update(e)
            .update(s(e.length, 1))
            .digest();
        }
        function l(t, e, r) {
          (0, o.validateObject)(r, {
            DST: "stringOrUint8Array",
            p: "bigint",
            m: "isSafeInteger",
            k: "isSafeInteger",
            hash: "hash",
          });
          const { p: s, k: a, m: l, hash: d, expand: y, DST: p } = r;
          f(t), c(e);
          const g = (function (t) {
              if (t instanceof Uint8Array) return t;
              if ("string" == typeof t) return (0, o.utf8ToBytes)(t);
              throw new Error("DST must be Uint8Array or string");
            })(p),
            w = s.toString(2).length,
            b = Math.ceil((w + a) / 8),
            m = e * l * b;
          let E;
          if ("xmd" === y) E = u(t, g, m, d);
          else if ("xof" === y) E = h(t, g, m, a, d);
          else {
            if ("_internal_pass" !== y)
              throw new Error('expand must be "xmd" or "xof"');
            E = t;
          }
          const v = new Array(e);
          for (let t = 0; t < e; t++) {
            const e = new Array(l);
            for (let r = 0; r < l; r++) {
              const o = b * (r + t * l),
                a = E.subarray(o, o + b);
              e[r] = (0, n.mod)(i(a), s);
            }
            v[t] = e;
          }
          return v;
        }
        (e.expand_message_xmd = u),
          (e.expand_message_xof = h),
          (e.hash_to_field = l),
          (e.isogenyMap = function (t, e) {
            const r = e.map((t) => Array.from(t).reverse());
            return (e, n) => {
              const [o, i, s, a] = r.map((r) =>
                r.reduce((r, n) => t.add(t.mul(r, e), n)),
              );
              return (
                (e = t.div(o, i)), (n = t.mul(n, t.div(s, a))), { x: e, y: n }
              );
            };
          }),
          (e.createHasher = function (t, e, r) {
            if ("function" != typeof e)
              throw new Error("mapToCurve() must be defined");
            return {
              hashToCurve(n, o) {
                const i = l(n, 2, { ...r, DST: r.DST, ...o }),
                  s = t.fromAffine(e(i[0])),
                  a = t.fromAffine(e(i[1])),
                  f = s.add(a).clearCofactor();
                return f.assertValidity(), f;
              },
              encodeToCurve(n, o) {
                const i = l(n, 1, { ...r, DST: r.encodeDST, ...o }),
                  s = t.fromAffine(e(i[0])).clearCofactor();
                return s.assertValidity(), s;
              },
            };
          });
      },
      632: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.mapHashToField =
            e.getMinHashLength =
            e.getFieldBytesLength =
            e.hashToPrivateScalar =
            e.FpSqrtEven =
            e.FpSqrtOdd =
            e.Field =
            e.nLength =
            e.FpIsSquare =
            e.FpDiv =
            e.FpInvertBatch =
            e.FpPow =
            e.validateField =
            e.isNegativeLE =
            e.FpSqrt =
            e.tonelliShanks =
            e.invert =
            e.pow2 =
            e.pow =
            e.mod =
              void 0);
        const n = r(219),
          o = BigInt(0),
          i = BigInt(1),
          s = BigInt(2),
          a = BigInt(3),
          f = BigInt(4),
          c = BigInt(5),
          u = BigInt(8);
        function h(t, e) {
          const r = t % e;
          return r >= o ? r : e + r;
        }
        function l(t, e, r) {
          if (r <= o || e < o) throw new Error("Expected power/modulo > 0");
          if (r === i) return o;
          let n = i;
          for (; e > o; )
            e & i && (n = (n * t) % r), (t = (t * t) % r), (e >>= i);
          return n;
        }
        function d(t, e) {
          if (t === o || e <= o)
            throw new Error(
              `invert: expected positive integers, got n=${t} mod=${e}`,
            );
          let r = h(t, e),
            n = e,
            s = o,
            a = i,
            f = i,
            c = o;
          for (; r !== o; ) {
            const t = n / r,
              e = n % r,
              o = s - f * t,
              i = a - c * t;
            (n = r), (r = e), (s = f), (a = c), (f = o), (c = i);
          }
          if (n !== i) throw new Error("invert: does not exist");
          return h(s, e);
        }
        function y(t) {
          const e = (t - i) / s;
          let r, n, a;
          for (r = t - i, n = 0; r % s === o; r /= s, n++);
          for (a = s; a < t && l(a, e, t) !== t - i; a++);
          if (1 === n) {
            const e = (t + i) / f;
            return function (t, r) {
              const n = t.pow(r, e);
              if (!t.eql(t.sqr(n), r))
                throw new Error("Cannot find square root");
              return n;
            };
          }
          const c = (r + i) / s;
          return function (t, o) {
            if (t.pow(o, e) === t.neg(t.ONE))
              throw new Error("Cannot find square root");
            let s = n,
              f = t.pow(t.mul(t.ONE, a), r),
              u = t.pow(o, c),
              h = t.pow(o, r);
            for (; !t.eql(h, t.ONE); ) {
              if (t.eql(h, t.ZERO)) return t.ZERO;
              let e = 1;
              for (let r = t.sqr(h); e < s && !t.eql(r, t.ONE); e++)
                r = t.sqr(r);
              const r = t.pow(f, i << BigInt(s - e - 1));
              (f = t.sqr(r)), (u = t.mul(u, r)), (h = t.mul(h, f)), (s = e);
            }
            return u;
          };
        }
        function p(t) {
          if (t % f === a) {
            const e = (t + i) / f;
            return function (t, r) {
              const n = t.pow(r, e);
              if (!t.eql(t.sqr(n), r))
                throw new Error("Cannot find square root");
              return n;
            };
          }
          if (t % u === c) {
            const e = (t - c) / u;
            return function (t, r) {
              const n = t.mul(r, s),
                o = t.pow(n, e),
                i = t.mul(r, o),
                a = t.mul(t.mul(i, s), o),
                f = t.mul(i, t.sub(a, t.ONE));
              if (!t.eql(t.sqr(f), r))
                throw new Error("Cannot find square root");
              return f;
            };
          }
          return y(t);
        }
        BigInt(9),
          BigInt(16),
          (e.mod = h),
          (e.pow = l),
          (e.pow2 = function (t, e, r) {
            let n = t;
            for (; e-- > o; ) (n *= n), (n %= r);
            return n;
          }),
          (e.invert = d),
          (e.tonelliShanks = y),
          (e.FpSqrt = p),
          (e.isNegativeLE = (t, e) => (h(t, e) & i) === i);
        const g = [
          "create",
          "isValid",
          "is0",
          "neg",
          "inv",
          "sqrt",
          "sqr",
          "eql",
          "add",
          "sub",
          "mul",
          "pow",
          "div",
          "addN",
          "subN",
          "mulN",
          "sqrN",
        ];
        function w(t, e, r) {
          if (r < o) throw new Error("Expected power > 0");
          if (r === o) return t.ONE;
          if (r === i) return e;
          let n = t.ONE,
            s = e;
          for (; r > o; ) r & i && (n = t.mul(n, s)), (s = t.sqr(s)), (r >>= i);
          return n;
        }
        function b(t, e) {
          const r = new Array(e.length),
            n = e.reduce(
              (e, n, o) => (t.is0(n) ? e : ((r[o] = e), t.mul(e, n))),
              t.ONE,
            ),
            o = t.inv(n);
          return (
            e.reduceRight(
              (e, n, o) =>
                t.is0(n) ? e : ((r[o] = t.mul(e, r[o])), t.mul(e, n)),
              o,
            ),
            r
          );
        }
        function m(t, e) {
          const r = void 0 !== e ? e : t.toString(2).length;
          return { nBitLength: r, nByteLength: Math.ceil(r / 8) };
        }
        function E(t) {
          if ("bigint" != typeof t)
            throw new Error("field order must be bigint");
          const e = t.toString(2).length;
          return Math.ceil(e / 8);
        }
        function v(t) {
          const e = E(t);
          return e + Math.ceil(e / 2);
        }
        (e.validateField = function (t) {
          const e = g.reduce((t, e) => ((t[e] = "function"), t), {
            ORDER: "bigint",
            MASK: "bigint",
            BYTES: "isSafeInteger",
            BITS: "isSafeInteger",
          });
          return (0, n.validateObject)(t, e);
        }),
          (e.FpPow = w),
          (e.FpInvertBatch = b),
          (e.FpDiv = function (t, e, r) {
            return t.mul(e, "bigint" == typeof r ? d(r, t.ORDER) : t.inv(r));
          }),
          (e.FpIsSquare = function (t) {
            const e = (t.ORDER - i) / s;
            return (r) => {
              const n = t.pow(r, e);
              return t.eql(n, t.ZERO) || t.eql(n, t.ONE);
            };
          }),
          (e.nLength = m),
          (e.Field = function (t, e, r = !1, s = {}) {
            if (t <= o) throw new Error(`Expected Field ORDER > 0, got ${t}`);
            const { nBitLength: a, nByteLength: f } = m(t, e);
            if (f > 2048)
              throw new Error(
                "Field lengths over 2048 bytes are not supported",
              );
            const c = p(t),
              u = Object.freeze({
                ORDER: t,
                BITS: a,
                BYTES: f,
                MASK: (0, n.bitMask)(a),
                ZERO: o,
                ONE: i,
                create: (e) => h(e, t),
                isValid: (e) => {
                  if ("bigint" != typeof e)
                    throw new Error(
                      "Invalid field element: expected bigint, got " + typeof e,
                    );
                  return o <= e && e < t;
                },
                is0: (t) => t === o,
                isOdd: (t) => (t & i) === i,
                neg: (e) => h(-e, t),
                eql: (t, e) => t === e,
                sqr: (e) => h(e * e, t),
                add: (e, r) => h(e + r, t),
                sub: (e, r) => h(e - r, t),
                mul: (e, r) => h(e * r, t),
                pow: (t, e) => w(u, t, e),
                div: (e, r) => h(e * d(r, t), t),
                sqrN: (t) => t * t,
                addN: (t, e) => t + e,
                subN: (t, e) => t - e,
                mulN: (t, e) => t * e,
                inv: (e) => d(e, t),
                sqrt: s.sqrt || ((t) => c(u, t)),
                invertBatch: (t) => b(u, t),
                cmov: (t, e, r) => (r ? e : t),
                toBytes: (t) =>
                  r
                    ? (0, n.numberToBytesLE)(t, f)
                    : (0, n.numberToBytesBE)(t, f),
                fromBytes: (t) => {
                  if (t.length !== f)
                    throw new Error(
                      `Fp.fromBytes: expected ${f}, got ${t.length}`,
                    );
                  return r
                    ? (0, n.bytesToNumberLE)(t)
                    : (0, n.bytesToNumberBE)(t);
                },
              });
            return Object.freeze(u);
          }),
          (e.FpSqrtOdd = function (t, e) {
            if (!t.isOdd) throw new Error("Field doesn't have isOdd");
            const r = t.sqrt(e);
            return t.isOdd(r) ? r : t.neg(r);
          }),
          (e.FpSqrtEven = function (t, e) {
            if (!t.isOdd) throw new Error("Field doesn't have isOdd");
            const r = t.sqrt(e);
            return t.isOdd(r) ? t.neg(r) : r;
          }),
          (e.hashToPrivateScalar = function (t, e, r = !1) {
            const o = (t = (0, n.ensureBytes)("privateHash", t)).length,
              s = m(e).nByteLength + 8;
            if (s < 24 || o < s || o > 1024)
              throw new Error(
                `hashToPrivateScalar: expected ${s}-1024 bytes of input, got ${o}`,
              );
            return (
              h(
                r ? (0, n.bytesToNumberLE)(t) : (0, n.bytesToNumberBE)(t),
                e - i,
              ) + i
            );
          }),
          (e.getFieldBytesLength = E),
          (e.getMinHashLength = v),
          (e.mapHashToField = function (t, e, r = !1) {
            const o = t.length,
              s = E(e),
              a = v(e);
            if (o < 16 || o < a || o > 1024)
              throw new Error(`expected ${a}-1024 bytes of input, got ${o}`);
            const f =
              h(
                r ? (0, n.bytesToNumberBE)(t) : (0, n.bytesToNumberLE)(t),
                e - i,
              ) + i;
            return r
              ? (0, n.numberToBytesLE)(f, s)
              : (0, n.numberToBytesBE)(f, s);
          });
      },
      219: (t, e) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.validateObject =
            e.createHmacDrbg =
            e.bitMask =
            e.bitSet =
            e.bitGet =
            e.bitLen =
            e.utf8ToBytes =
            e.equalBytes =
            e.concatBytes =
            e.ensureBytes =
            e.numberToVarBytesBE =
            e.numberToBytesLE =
            e.numberToBytesBE =
            e.bytesToNumberLE =
            e.bytesToNumberBE =
            e.hexToBytes =
            e.hexToNumber =
            e.numberToHexUnpadded =
            e.bytesToHex =
              void 0);
        const r = BigInt(0),
          n = BigInt(1),
          o = BigInt(2),
          i = (t) => t instanceof Uint8Array,
          s = Array.from({ length: 256 }, (t, e) =>
            e.toString(16).padStart(2, "0"),
          );
        function a(t) {
          if (!i(t)) throw new Error("Uint8Array expected");
          let e = "";
          for (let r = 0; r < t.length; r++) e += s[t[r]];
          return e;
        }
        function f(t) {
          const e = t.toString(16);
          return 1 & e.length ? `0${e}` : e;
        }
        function c(t) {
          if ("string" != typeof t)
            throw new Error("hex string expected, got " + typeof t);
          return BigInt("" === t ? "0" : `0x${t}`);
        }
        function u(t) {
          if ("string" != typeof t)
            throw new Error("hex string expected, got " + typeof t);
          const e = t.length;
          if (e % 2)
            throw new Error(
              "padded hex string expected, got unpadded hex of length " + e,
            );
          const r = new Uint8Array(e / 2);
          for (let e = 0; e < r.length; e++) {
            const n = 2 * e,
              o = t.slice(n, n + 2),
              i = Number.parseInt(o, 16);
            if (Number.isNaN(i) || i < 0)
              throw new Error("Invalid byte sequence");
            r[e] = i;
          }
          return r;
        }
        function h(t, e) {
          return u(t.toString(16).padStart(2 * e, "0"));
        }
        function l(...t) {
          const e = new Uint8Array(t.reduce((t, e) => t + e.length, 0));
          let r = 0;
          return (
            t.forEach((t) => {
              if (!i(t)) throw new Error("Uint8Array expected");
              e.set(t, r), (r += t.length);
            }),
            e
          );
        }
        (e.bytesToHex = a),
          (e.numberToHexUnpadded = f),
          (e.hexToNumber = c),
          (e.hexToBytes = u),
          (e.bytesToNumberBE = function (t) {
            return c(a(t));
          }),
          (e.bytesToNumberLE = function (t) {
            if (!i(t)) throw new Error("Uint8Array expected");
            return c(a(Uint8Array.from(t).reverse()));
          }),
          (e.numberToBytesBE = h),
          (e.numberToBytesLE = function (t, e) {
            return h(t, e).reverse();
          }),
          (e.numberToVarBytesBE = function (t) {
            return u(f(t));
          }),
          (e.ensureBytes = function (t, e, r) {
            let n;
            if ("string" == typeof e)
              try {
                n = u(e);
              } catch (r) {
                throw new Error(
                  `${t} must be valid hex string, got "${e}". Cause: ${r}`,
                );
              }
            else {
              if (!i(e))
                throw new Error(`${t} must be hex string or Uint8Array`);
              n = Uint8Array.from(e);
            }
            const o = n.length;
            if ("number" == typeof r && o !== r)
              throw new Error(`${t} expected ${r} bytes, got ${o}`);
            return n;
          }),
          (e.concatBytes = l),
          (e.equalBytes = function (t, e) {
            if (t.length !== e.length) return !1;
            for (let r = 0; r < t.length; r++) if (t[r] !== e[r]) return !1;
            return !0;
          }),
          (e.utf8ToBytes = function (t) {
            if ("string" != typeof t)
              throw new Error("utf8ToBytes expected string, got " + typeof t);
            return new Uint8Array(new TextEncoder().encode(t));
          }),
          (e.bitLen = function (t) {
            let e;
            for (e = 0; t > r; t >>= n, e += 1);
            return e;
          }),
          (e.bitGet = function (t, e) {
            return (t >> BigInt(e)) & n;
          }),
          (e.bitSet = (t, e, o) => t | ((o ? n : r) << BigInt(e))),
          (e.bitMask = (t) => (o << BigInt(t - 1)) - n);
        const d = (t) => new Uint8Array(t),
          y = (t) => Uint8Array.from(t);
        e.createHmacDrbg = function (t, e, r) {
          if ("number" != typeof t || t < 2)
            throw new Error("hashLen must be a number");
          if ("number" != typeof e || e < 2)
            throw new Error("qByteLen must be a number");
          if ("function" != typeof r)
            throw new Error("hmacFn must be a function");
          let n = d(t),
            o = d(t),
            i = 0;
          const s = () => {
              n.fill(1), o.fill(0), (i = 0);
            },
            a = (...t) => r(o, n, ...t),
            f = (t = d()) => {
              (o = a(y([0]), t)),
                (n = a()),
                0 !== t.length && ((o = a(y([1]), t)), (n = a()));
            },
            c = () => {
              if (i++ >= 1e3) throw new Error("drbg: tried 1000 values");
              let t = 0;
              const r = [];
              for (; t < e; ) {
                n = a();
                const e = n.slice();
                r.push(e), (t += n.length);
              }
              return l(...r);
            };
          return (t, e) => {
            let r;
            for (s(), f(t); !(r = e(c())); ) f();
            return s(), r;
          };
        };
        const p = {
          bigint: (t) => "bigint" == typeof t,
          function: (t) => "function" == typeof t,
          boolean: (t) => "boolean" == typeof t,
          string: (t) => "string" == typeof t,
          stringOrUint8Array: (t) =>
            "string" == typeof t || t instanceof Uint8Array,
          isSafeInteger: (t) => Number.isSafeInteger(t),
          array: (t) => Array.isArray(t),
          field: (t, e) => e.Fp.isValid(t),
          hash: (t) =>
            "function" == typeof t && Number.isSafeInteger(t.outputLen),
        };
        e.validateObject = function (t, e, r = {}) {
          const n = (e, r, n) => {
            const o = p[r];
            if ("function" != typeof o)
              throw new Error(`Invalid validator "${r}", expected function`);
            const i = t[e];
            if (!((n && void 0 === i) || o(i, t)))
              throw new Error(
                `Invalid param ${String(e)}=${i} (${typeof i}), expected ${r}`,
              );
          };
          for (const [t, r] of Object.entries(e)) n(t, r, !1);
          for (const [t, e] of Object.entries(r)) n(t, e, !0);
          return t;
        };
      },
      551: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.mapToCurveSimpleSWU =
            e.SWUFpSqrtRatio =
            e.weierstrass =
            e.weierstrassPoints =
            e.DER =
              void 0);
        const n = r(632),
          o = r(219),
          i = r(219),
          s = r(525),
          { bytesToNumberBE: a, hexToBytes: f } = o;
        e.DER = {
          Err: class extends Error {
            constructor(t = "") {
              super(t);
            }
          },
          _parseInt(t) {
            const { Err: r } = e.DER;
            if (t.length < 2 || 2 !== t[0])
              throw new r("Invalid signature integer tag");
            const n = t[1],
              o = t.subarray(2, n + 2);
            if (!n || o.length !== n)
              throw new r("Invalid signature integer: wrong length");
            if (128 & o[0]) throw new r("Invalid signature integer: negative");
            if (0 === o[0] && !(128 & o[1]))
              throw new r(
                "Invalid signature integer: unnecessary leading zero",
              );
            return { d: a(o), l: t.subarray(n + 2) };
          },
          toSig(t) {
            const { Err: r } = e.DER,
              n = "string" == typeof t ? f(t) : t;
            if (!(n instanceof Uint8Array)) throw new Error("ui8a expected");
            const o = n.length;
            if (o < 2 || 48 != n[0]) throw new r("Invalid signature tag");
            if (n[1] !== o - 2)
              throw new r("Invalid signature: incorrect length");
            const { d: i, l: s } = e.DER._parseInt(n.subarray(2)),
              { d: a, l: c } = e.DER._parseInt(s);
            if (c.length)
              throw new r("Invalid signature: left bytes after parsing");
            return { r: i, s: a };
          },
          hexFromSig(t) {
            const e = (t) => (8 & Number.parseInt(t[0], 16) ? "00" + t : t),
              r = (t) => {
                const e = t.toString(16);
                return 1 & e.length ? `0${e}` : e;
              },
              n = e(r(t.s)),
              o = e(r(t.r)),
              i = n.length / 2,
              s = o.length / 2,
              a = r(i),
              f = r(s);
            return `30${r(s + i + 4)}02${f}${o}02${a}${n}`;
          },
        };
        const c = BigInt(0),
          u = BigInt(1),
          h = BigInt(2),
          l = BigInt(3),
          d = BigInt(4);
        function y(t) {
          const e = (function (t) {
              const e = (0, s.validateBasic)(t);
              o.validateObject(
                e,
                { a: "field", b: "field" },
                {
                  allowedPrivateKeyLengths: "array",
                  wrapPrivateKey: "boolean",
                  isTorsionFree: "function",
                  clearCofactor: "function",
                  allowInfinityPoint: "boolean",
                  fromBytes: "function",
                  toBytes: "function",
                },
              );
              const { endo: r, Fp: n, a: i } = e;
              if (r) {
                if (!n.eql(i, n.ZERO))
                  throw new Error(
                    "Endomorphism can only be defined for Koblitz curves that have a=0",
                  );
                if (
                  "object" != typeof r ||
                  "bigint" != typeof r.beta ||
                  "function" != typeof r.splitScalar
                )
                  throw new Error(
                    "Expected endomorphism with beta: bigint and splitScalar: function",
                  );
              }
              return Object.freeze({ ...e });
            })(t),
            { Fp: r } = e,
            a =
              e.toBytes ||
              ((t, e, n) => {
                const i = e.toAffine();
                return o.concatBytes(
                  Uint8Array.from([4]),
                  r.toBytes(i.x),
                  r.toBytes(i.y),
                );
              }),
            f =
              e.fromBytes ||
              ((t) => {
                const e = t.subarray(1);
                return {
                  x: r.fromBytes(e.subarray(0, r.BYTES)),
                  y: r.fromBytes(e.subarray(r.BYTES, 2 * r.BYTES)),
                };
              });
          function h(t) {
            const { a: n, b: o } = e,
              i = r.sqr(t),
              s = r.mul(i, t);
            return r.add(r.add(s, r.mul(t, n)), o);
          }
          if (!r.eql(r.sqr(e.Gy), h(e.Gx)))
            throw new Error("bad generator point: equation left != right");
          function d(t) {
            return "bigint" == typeof t && c < t && t < e.n;
          }
          function y(t) {
            if (!d(t))
              throw new Error("Expected valid bigint: 0 < bigint < curve.n");
          }
          function p(t) {
            const {
              allowedPrivateKeyLengths: r,
              nByteLength: s,
              wrapPrivateKey: a,
              n: f,
            } = e;
            if (r && "bigint" != typeof t) {
              if (
                (t instanceof Uint8Array && (t = o.bytesToHex(t)),
                "string" != typeof t || !r.includes(t.length))
              )
                throw new Error("Invalid key");
              t = t.padStart(2 * s, "0");
            }
            let c;
            try {
              c =
                "bigint" == typeof t
                  ? t
                  : o.bytesToNumberBE((0, i.ensureBytes)("private key", t, s));
            } catch (e) {
              throw new Error(
                `private key must be ${s} bytes, hex or bigint, not ${typeof t}`,
              );
            }
            return a && (c = n.mod(c, f)), y(c), c;
          }
          const g = new Map();
          function w(t) {
            if (!(t instanceof b)) throw new Error("ProjectivePoint expected");
          }
          class b {
            constructor(t, e, n) {
              if (
                ((this.px = t),
                (this.py = e),
                (this.pz = n),
                null == t || !r.isValid(t))
              )
                throw new Error("x required");
              if (null == e || !r.isValid(e)) throw new Error("y required");
              if (null == n || !r.isValid(n)) throw new Error("z required");
            }
            static fromAffine(t) {
              const { x: e, y: n } = t || {};
              if (!t || !r.isValid(e) || !r.isValid(n))
                throw new Error("invalid affine point");
              if (t instanceof b)
                throw new Error("projective point not allowed");
              const o = (t) => r.eql(t, r.ZERO);
              return o(e) && o(n) ? b.ZERO : new b(e, n, r.ONE);
            }
            get x() {
              return this.toAffine().x;
            }
            get y() {
              return this.toAffine().y;
            }
            static normalizeZ(t) {
              const e = r.invertBatch(t.map((t) => t.pz));
              return t.map((t, r) => t.toAffine(e[r])).map(b.fromAffine);
            }
            static fromHex(t) {
              const e = b.fromAffine(f((0, i.ensureBytes)("pointHex", t)));
              return e.assertValidity(), e;
            }
            static fromPrivateKey(t) {
              return b.BASE.multiply(p(t));
            }
            _setWindowSize(t) {
              (this._WINDOW_SIZE = t), g.delete(this);
            }
            assertValidity() {
              if (this.is0()) {
                if (e.allowInfinityPoint && !r.is0(this.py)) return;
                throw new Error("bad point: ZERO");
              }
              const { x: t, y: n } = this.toAffine();
              if (!r.isValid(t) || !r.isValid(n))
                throw new Error("bad point: x or y not FE");
              const o = r.sqr(n),
                i = h(t);
              if (!r.eql(o, i))
                throw new Error("bad point: equation left != right");
              if (!this.isTorsionFree())
                throw new Error("bad point: not in prime-order subgroup");
            }
            hasEvenY() {
              const { y: t } = this.toAffine();
              if (r.isOdd) return !r.isOdd(t);
              throw new Error("Field doesn't support isOdd");
            }
            equals(t) {
              w(t);
              const { px: e, py: n, pz: o } = this,
                { px: i, py: s, pz: a } = t,
                f = r.eql(r.mul(e, a), r.mul(i, o)),
                c = r.eql(r.mul(n, a), r.mul(s, o));
              return f && c;
            }
            negate() {
              return new b(this.px, r.neg(this.py), this.pz);
            }
            double() {
              const { a: t, b: n } = e,
                o = r.mul(n, l),
                { px: i, py: s, pz: a } = this;
              let f = r.ZERO,
                c = r.ZERO,
                u = r.ZERO,
                h = r.mul(i, i),
                d = r.mul(s, s),
                y = r.mul(a, a),
                p = r.mul(i, s);
              return (
                (p = r.add(p, p)),
                (u = r.mul(i, a)),
                (u = r.add(u, u)),
                (f = r.mul(t, u)),
                (c = r.mul(o, y)),
                (c = r.add(f, c)),
                (f = r.sub(d, c)),
                (c = r.add(d, c)),
                (c = r.mul(f, c)),
                (f = r.mul(p, f)),
                (u = r.mul(o, u)),
                (y = r.mul(t, y)),
                (p = r.sub(h, y)),
                (p = r.mul(t, p)),
                (p = r.add(p, u)),
                (u = r.add(h, h)),
                (h = r.add(u, h)),
                (h = r.add(h, y)),
                (h = r.mul(h, p)),
                (c = r.add(c, h)),
                (y = r.mul(s, a)),
                (y = r.add(y, y)),
                (h = r.mul(y, p)),
                (f = r.sub(f, h)),
                (u = r.mul(y, d)),
                (u = r.add(u, u)),
                (u = r.add(u, u)),
                new b(f, c, u)
              );
            }
            add(t) {
              w(t);
              const { px: n, py: o, pz: i } = this,
                { px: s, py: a, pz: f } = t;
              let c = r.ZERO,
                u = r.ZERO,
                h = r.ZERO;
              const d = e.a,
                y = r.mul(e.b, l);
              let p = r.mul(n, s),
                g = r.mul(o, a),
                m = r.mul(i, f),
                E = r.add(n, o),
                v = r.add(s, a);
              (E = r.mul(E, v)),
                (v = r.add(p, g)),
                (E = r.sub(E, v)),
                (v = r.add(n, i));
              let B = r.add(s, f);
              return (
                (v = r.mul(v, B)),
                (B = r.add(p, m)),
                (v = r.sub(v, B)),
                (B = r.add(o, i)),
                (c = r.add(a, f)),
                (B = r.mul(B, c)),
                (c = r.add(g, m)),
                (B = r.sub(B, c)),
                (h = r.mul(d, v)),
                (c = r.mul(y, m)),
                (h = r.add(c, h)),
                (c = r.sub(g, h)),
                (h = r.add(g, h)),
                (u = r.mul(c, h)),
                (g = r.add(p, p)),
                (g = r.add(g, p)),
                (m = r.mul(d, m)),
                (v = r.mul(y, v)),
                (g = r.add(g, m)),
                (m = r.sub(p, m)),
                (m = r.mul(d, m)),
                (v = r.add(v, m)),
                (p = r.mul(g, v)),
                (u = r.add(u, p)),
                (p = r.mul(B, v)),
                (c = r.mul(E, c)),
                (c = r.sub(c, p)),
                (p = r.mul(E, g)),
                (h = r.mul(B, h)),
                (h = r.add(h, p)),
                new b(c, u, h)
              );
            }
            subtract(t) {
              return this.add(t.negate());
            }
            is0() {
              return this.equals(b.ZERO);
            }
            wNAF(t) {
              return E.wNAFCached(this, g, t, (t) => {
                const e = r.invertBatch(t.map((t) => t.pz));
                return t.map((t, r) => t.toAffine(e[r])).map(b.fromAffine);
              });
            }
            multiplyUnsafe(t) {
              const n = b.ZERO;
              if (t === c) return n;
              if ((y(t), t === u)) return this;
              const { endo: o } = e;
              if (!o) return E.unsafeLadder(this, t);
              let { k1neg: i, k1: s, k2neg: a, k2: f } = o.splitScalar(t),
                h = n,
                l = n,
                d = this;
              for (; s > c || f > c; )
                s & u && (h = h.add(d)),
                  f & u && (l = l.add(d)),
                  (d = d.double()),
                  (s >>= u),
                  (f >>= u);
              return (
                i && (h = h.negate()),
                a && (l = l.negate()),
                (l = new b(r.mul(l.px, o.beta), l.py, l.pz)),
                h.add(l)
              );
            }
            multiply(t) {
              y(t);
              let n,
                o,
                i = t;
              const { endo: s } = e;
              if (s) {
                const { k1neg: t, k1: e, k2neg: a, k2: f } = s.splitScalar(i);
                let { p: c, f: u } = this.wNAF(e),
                  { p: h, f: l } = this.wNAF(f);
                (c = E.constTimeNegate(t, c)),
                  (h = E.constTimeNegate(a, h)),
                  (h = new b(r.mul(h.px, s.beta), h.py, h.pz)),
                  (n = c.add(h)),
                  (o = u.add(l));
              } else {
                const { p: t, f: e } = this.wNAF(i);
                (n = t), (o = e);
              }
              return b.normalizeZ([n, o])[0];
            }
            multiplyAndAddUnsafe(t, e, r) {
              const n = b.BASE,
                o = (t, e) =>
                  e !== c && e !== u && t.equals(n)
                    ? t.multiply(e)
                    : t.multiplyUnsafe(e),
                i = o(this, e).add(o(t, r));
              return i.is0() ? void 0 : i;
            }
            toAffine(t) {
              const { px: e, py: n, pz: o } = this,
                i = this.is0();
              null == t && (t = i ? r.ONE : r.inv(o));
              const s = r.mul(e, t),
                a = r.mul(n, t),
                f = r.mul(o, t);
              if (i) return { x: r.ZERO, y: r.ZERO };
              if (!r.eql(f, r.ONE)) throw new Error("invZ was invalid");
              return { x: s, y: a };
            }
            isTorsionFree() {
              const { h: t, isTorsionFree: r } = e;
              if (t === u) return !0;
              if (r) return r(b, this);
              throw new Error(
                "isTorsionFree() has not been declared for the elliptic curve",
              );
            }
            clearCofactor() {
              const { h: t, clearCofactor: r } = e;
              return t === u ? this : r ? r(b, this) : this.multiplyUnsafe(e.h);
            }
            toRawBytes(t = !0) {
              return this.assertValidity(), a(b, this, t);
            }
            toHex(t = !0) {
              return o.bytesToHex(this.toRawBytes(t));
            }
          }
          (b.BASE = new b(e.Gx, e.Gy, r.ONE)),
            (b.ZERO = new b(r.ZERO, r.ONE, r.ZERO));
          const m = e.nBitLength,
            E = (0, s.wNAF)(b, e.endo ? Math.ceil(m / 2) : m);
          return {
            CURVE: e,
            ProjectivePoint: b,
            normPrivateKeyToScalar: p,
            weierstrassEquation: h,
            isWithinCurveOrder: d,
          };
        }
        function p(t, e) {
          const r = t.ORDER;
          let n = c;
          for (let t = r - u; t % h === c; t /= h) n += u;
          const o = n,
            i = h << (o - u - u),
            s = i * h,
            a = (r - u) / s,
            f = (a - u) / h,
            y = s - u,
            p = i,
            g = t.pow(e, a),
            w = t.pow(e, (a + u) / h);
          let b = (e, r) => {
            let n = g,
              i = t.pow(r, y),
              s = t.sqr(i);
            s = t.mul(s, r);
            let a = t.mul(e, s);
            (a = t.pow(a, f)),
              (a = t.mul(a, i)),
              (i = t.mul(a, r)),
              (s = t.mul(a, e));
            let c = t.mul(s, i);
            a = t.pow(c, p);
            const l = t.eql(a, t.ONE);
            (i = t.mul(s, w)),
              (a = t.mul(c, n)),
              (s = t.cmov(i, s, l)),
              (c = t.cmov(a, c, l));
            for (let e = o; e > u; e--) {
              let r = e - h;
              r = h << (r - u);
              let o = t.pow(c, r);
              const a = t.eql(o, t.ONE);
              (i = t.mul(s, n)),
                (n = t.mul(n, n)),
                (o = t.mul(c, n)),
                (s = t.cmov(i, s, a)),
                (c = t.cmov(o, c, a));
            }
            return { isValid: l, value: s };
          };
          if (t.ORDER % d === l) {
            const r = (t.ORDER - l) / d,
              n = t.sqrt(t.neg(e));
            b = (e, o) => {
              let i = t.sqr(o);
              const s = t.mul(e, o);
              i = t.mul(i, s);
              let a = t.pow(i, r);
              a = t.mul(a, s);
              const f = t.mul(a, n),
                c = t.mul(t.sqr(a), o),
                u = t.eql(c, e);
              return { isValid: u, value: t.cmov(f, a, u) };
            };
          }
          return b;
        }
        (e.weierstrassPoints = y),
          (e.weierstrass = function (t) {
            const r = (function (t) {
                const e = (0, s.validateBasic)(t);
                return (
                  o.validateObject(
                    e,
                    { hash: "hash", hmac: "function", randomBytes: "function" },
                    {
                      bits2int: "function",
                      bits2int_modN: "function",
                      lowS: "boolean",
                    },
                  ),
                  Object.freeze({ lowS: !0, ...e })
                );
              })(t),
              { Fp: a, n: f } = r,
              h = a.BYTES + 1,
              l = 2 * a.BYTES + 1;
            function d(t) {
              return n.mod(t, f);
            }
            function p(t) {
              return n.invert(t, f);
            }
            const {
                ProjectivePoint: g,
                normPrivateKeyToScalar: w,
                weierstrassEquation: b,
                isWithinCurveOrder: m,
              } = y({
                ...r,
                toBytes(t, e, r) {
                  const n = e.toAffine(),
                    i = a.toBytes(n.x),
                    s = o.concatBytes;
                  return r
                    ? s(Uint8Array.from([e.hasEvenY() ? 2 : 3]), i)
                    : s(Uint8Array.from([4]), i, a.toBytes(n.y));
                },
                fromBytes(t) {
                  const e = t.length,
                    r = t[0],
                    n = t.subarray(1);
                  if (e !== h || (2 !== r && 3 !== r)) {
                    if (e === l && 4 === r)
                      return {
                        x: a.fromBytes(n.subarray(0, a.BYTES)),
                        y: a.fromBytes(n.subarray(a.BYTES, 2 * a.BYTES)),
                      };
                    throw new Error(
                      `Point of length ${e} was invalid. Expected ${h} compressed bytes or ${l} uncompressed bytes`,
                    );
                  }
                  {
                    const t = o.bytesToNumberBE(n);
                    if (!(c < (i = t) && i < a.ORDER))
                      throw new Error("Point is not on curve");
                    const e = b(t);
                    let s = a.sqrt(e);
                    return (
                      (1 == (1 & r)) != ((s & u) === u) && (s = a.neg(s)),
                      { x: t, y: s }
                    );
                  }
                  let i;
                },
              }),
              E = (t) => o.bytesToHex(o.numberToBytesBE(t, r.nByteLength));
            function v(t) {
              return t > f >> u;
            }
            const B = (t, e, r) => o.bytesToNumberBE(t.slice(e, r));
            class x {
              constructor(t, e, r) {
                (this.r = t),
                  (this.s = e),
                  (this.recovery = r),
                  this.assertValidity();
              }
              static fromCompact(t) {
                const e = r.nByteLength;
                return (
                  (t = (0, i.ensureBytes)("compactSignature", t, 2 * e)),
                  new x(B(t, 0, e), B(t, e, 2 * e))
                );
              }
              static fromDER(t) {
                const { r, s: n } = e.DER.toSig((0, i.ensureBytes)("DER", t));
                return new x(r, n);
              }
              assertValidity() {
                if (!m(this.r)) throw new Error("r must be 0 < r < CURVE.n");
                if (!m(this.s)) throw new Error("s must be 0 < s < CURVE.n");
              }
              addRecoveryBit(t) {
                return new x(this.r, this.s, t);
              }
              recoverPublicKey(t) {
                const { r: e, s: n, recovery: o } = this,
                  s = U((0, i.ensureBytes)("msgHash", t));
                if (null == o || ![0, 1, 2, 3].includes(o))
                  throw new Error("recovery id invalid");
                const f = 2 === o || 3 === o ? e + r.n : e;
                if (f >= a.ORDER) throw new Error("recovery id 2 or 3 invalid");
                const c = 0 == (1 & o) ? "02" : "03",
                  u = g.fromHex(c + E(f)),
                  h = p(f),
                  l = d(-s * h),
                  y = d(n * h),
                  w = g.BASE.multiplyAndAddUnsafe(u, l, y);
                if (!w) throw new Error("point at infinify");
                return w.assertValidity(), w;
              }
              hasHighS() {
                return v(this.s);
              }
              normalizeS() {
                return this.hasHighS()
                  ? new x(this.r, d(-this.s), this.recovery)
                  : this;
              }
              toDERRawBytes() {
                return o.hexToBytes(this.toDERHex());
              }
              toDERHex() {
                return e.DER.hexFromSig({ r: this.r, s: this.s });
              }
              toCompactRawBytes() {
                return o.hexToBytes(this.toCompactHex());
              }
              toCompactHex() {
                return E(this.r) + E(this.s);
              }
            }
            const A = {
              isValidPrivateKey(t) {
                try {
                  return w(t), !0;
                } catch (t) {
                  return !1;
                }
              },
              normPrivateKeyToScalar: w,
              randomPrivateKey: () => {
                const t = n.getMinHashLength(r.n);
                return n.mapHashToField(r.randomBytes(t), r.n);
              },
              precompute: (t = 8, e = g.BASE) => (
                e._setWindowSize(t), e.multiply(BigInt(3)), e
              ),
            };
            function S(t) {
              const e = t instanceof Uint8Array,
                r = "string" == typeof t,
                n = (e || r) && t.length;
              return e
                ? n === h || n === l
                : r
                ? n === 2 * h || n === 2 * l
                : t instanceof g;
            }
            const T =
                r.bits2int ||
                function (t) {
                  const e = o.bytesToNumberBE(t),
                    n = 8 * t.length - r.nBitLength;
                  return n > 0 ? e >> BigInt(n) : e;
                },
              U =
                r.bits2int_modN ||
                function (t) {
                  return d(T(t));
                },
              _ = o.bitMask(r.nBitLength);
            function O(t) {
              if ("bigint" != typeof t) throw new Error("bigint expected");
              if (!(c <= t && t < _))
                throw new Error(`bigint expected < 2^${r.nBitLength}`);
              return o.numberToBytesBE(t, r.nByteLength);
            }
            const I = { lowS: r.lowS, prehash: !1 },
              L = { lowS: r.lowS, prehash: !1 };
            return (
              g.BASE._setWindowSize(8),
              {
                CURVE: r,
                getPublicKey: function (t, e = !0) {
                  return g.fromPrivateKey(t).toRawBytes(e);
                },
                getSharedSecret: function (t, e, r = !0) {
                  if (S(t)) throw new Error("first arg must be private key");
                  if (!S(e)) throw new Error("second arg must be public key");
                  return g.fromHex(e).multiply(w(t)).toRawBytes(r);
                },
                sign: function (t, e, n = I) {
                  const { seed: s, k2sig: f } = (function (t, e, n = I) {
                      if (["recovered", "canonical"].some((t) => t in n))
                        throw new Error("sign() legacy options not supported");
                      const { hash: s, randomBytes: f } = r;
                      let { lowS: h, prehash: l, extraEntropy: y } = n;
                      null == h && (h = !0),
                        (t = (0, i.ensureBytes)("msgHash", t)),
                        l &&
                          (t = (0, i.ensureBytes)("prehashed msgHash", s(t)));
                      const b = U(t),
                        E = w(e),
                        B = [O(E), O(b)];
                      if (null != y) {
                        const t = !0 === y ? f(a.BYTES) : y;
                        B.push((0, i.ensureBytes)("extraEntropy", t));
                      }
                      const A = o.concatBytes(...B),
                        S = b;
                      return {
                        seed: A,
                        k2sig: function (t) {
                          const e = T(t);
                          if (!m(e)) return;
                          const r = p(e),
                            n = g.BASE.multiply(e).toAffine(),
                            o = d(n.x);
                          if (o === c) return;
                          const i = d(r * d(S + o * E));
                          if (i === c) return;
                          let s = (n.x === o ? 0 : 2) | Number(n.y & u),
                            a = i;
                          return (
                            h &&
                              v(i) &&
                              ((a = (function (t) {
                                return v(t) ? d(-t) : t;
                              })(i)),
                              (s ^= 1)),
                            new x(o, a, s)
                          );
                        },
                      };
                    })(t, e, n),
                    h = r;
                  return o.createHmacDrbg(
                    h.hash.outputLen,
                    h.nByteLength,
                    h.hmac,
                  )(s, f);
                },
                verify: function (t, n, o, s = L) {
                  const a = t;
                  if (
                    ((n = (0, i.ensureBytes)("msgHash", n)),
                    (o = (0, i.ensureBytes)("publicKey", o)),
                    "strict" in s)
                  )
                    throw new Error("options.strict was renamed to lowS");
                  const { lowS: f, prehash: c } = s;
                  let u, h;
                  try {
                    if ("string" == typeof a || a instanceof Uint8Array)
                      try {
                        u = x.fromDER(a);
                      } catch (t) {
                        if (!(t instanceof e.DER.Err)) throw t;
                        u = x.fromCompact(a);
                      }
                    else {
                      if (
                        "object" != typeof a ||
                        "bigint" != typeof a.r ||
                        "bigint" != typeof a.s
                      )
                        throw new Error("PARSE");
                      {
                        const { r: t, s: e } = a;
                        u = new x(t, e);
                      }
                    }
                    h = g.fromHex(o);
                  } catch (t) {
                    if ("PARSE" === t.message)
                      throw new Error(
                        "signature must be Signature instance, Uint8Array or hex string",
                      );
                    return !1;
                  }
                  if (f && u.hasHighS()) return !1;
                  c && (n = r.hash(n));
                  const { r: l, s: y } = u,
                    w = U(n),
                    b = p(y),
                    m = d(w * b),
                    E = d(l * b),
                    v = g.BASE.multiplyAndAddUnsafe(h, m, E)?.toAffine();
                  return !!v && d(v.x) === l;
                },
                ProjectivePoint: g,
                Signature: x,
                utils: A,
              }
            );
          }),
          (e.SWUFpSqrtRatio = p),
          (e.mapToCurveSimpleSWU = function (t, e) {
            if (
              (n.validateField(t),
              !t.isValid(e.A) || !t.isValid(e.B) || !t.isValid(e.Z))
            )
              throw new Error("mapToCurveSimpleSWU: invalid opts");
            const r = p(t, e.Z);
            if (!t.isOdd) throw new Error("Fp.isOdd is not implemented!");
            return (n) => {
              let o, i, s, a, f, c, u, h;
              (o = t.sqr(n)),
                (o = t.mul(o, e.Z)),
                (i = t.sqr(o)),
                (i = t.add(i, o)),
                (s = t.add(i, t.ONE)),
                (s = t.mul(s, e.B)),
                (a = t.cmov(e.Z, t.neg(i), !t.eql(i, t.ZERO))),
                (a = t.mul(a, e.A)),
                (i = t.sqr(s)),
                (c = t.sqr(a)),
                (f = t.mul(c, e.A)),
                (i = t.add(i, f)),
                (i = t.mul(i, s)),
                (c = t.mul(c, a)),
                (f = t.mul(c, e.B)),
                (i = t.add(i, f)),
                (u = t.mul(o, s));
              const { isValid: l, value: d } = r(i, c);
              (h = t.mul(o, n)),
                (h = t.mul(h, d)),
                (u = t.cmov(u, s, l)),
                (h = t.cmov(h, d, l));
              const y = t.isOdd(n) === t.isOdd(h);
              return (
                (h = t.cmov(t.neg(h), h, y)), (u = t.div(u, a)), { x: u, y: h }
              );
            };
          });
      },
      497: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.encodeToCurve = e.hashToCurve = e.schnorr = e.secp256k1 = void 0);
        const n = r(61),
          o = r(89),
          i = r(632),
          s = r(551),
          a = r(219),
          f = r(134),
          c = r(82),
          u = BigInt(
            "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
          ),
          h = BigInt(
            "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
          ),
          l = BigInt(1),
          d = BigInt(2),
          y = (t, e) => (t + e / d) / e;
        function p(t) {
          const e = u,
            r = BigInt(3),
            n = BigInt(6),
            o = BigInt(11),
            s = BigInt(22),
            a = BigInt(23),
            f = BigInt(44),
            c = BigInt(88),
            h = (t * t * t) % e,
            l = (h * h * t) % e,
            y = ((0, i.pow2)(l, r, e) * l) % e,
            p = ((0, i.pow2)(y, r, e) * l) % e,
            w = ((0, i.pow2)(p, d, e) * h) % e,
            b = ((0, i.pow2)(w, o, e) * w) % e,
            m = ((0, i.pow2)(b, s, e) * b) % e,
            E = ((0, i.pow2)(m, f, e) * m) % e,
            v = ((0, i.pow2)(E, c, e) * E) % e,
            B = ((0, i.pow2)(v, f, e) * m) % e,
            x = ((0, i.pow2)(B, r, e) * l) % e,
            A = ((0, i.pow2)(x, a, e) * b) % e,
            S = ((0, i.pow2)(A, n, e) * h) % e,
            T = (0, i.pow2)(S, d, e);
          if (!g.eql(g.sqr(T), t)) throw new Error("Cannot find square root");
          return T;
        }
        const g = (0, i.Field)(u, void 0, void 0, { sqrt: p });
        e.secp256k1 = (0, c.createCurve)(
          {
            a: BigInt(0),
            b: BigInt(7),
            Fp: g,
            n: h,
            Gx: BigInt(
              "55066263022277343669578718895168534326250603453777594175500187360389116729240",
            ),
            Gy: BigInt(
              "32670510020758816978083085130507043184471273380659243275938904335757337482424",
            ),
            h: BigInt(1),
            lowS: !0,
            endo: {
              beta: BigInt(
                "0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
              ),
              splitScalar: (t) => {
                const e = h,
                  r = BigInt("0x3086d221a7d46bcde86c90e49284eb15"),
                  n = -l * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"),
                  o = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"),
                  s = r,
                  a = BigInt("0x100000000000000000000000000000000"),
                  f = y(s * t, e),
                  c = y(-n * t, e);
                let u = (0, i.mod)(t - f * r - c * o, e),
                  d = (0, i.mod)(-f * n - c * s, e);
                const p = u > a,
                  g = d > a;
                if ((p && (u = e - u), g && (d = e - d), u > a || d > a))
                  throw new Error("splitScalar: Endomorphism failed, k=" + t);
                return { k1neg: p, k1: u, k2neg: g, k2: d };
              },
            },
          },
          n.sha256,
        );
        const w = BigInt(0),
          b = (t) => "bigint" == typeof t && w < t && t < u,
          m = (t) => "bigint" == typeof t && w < t && t < h,
          E = {};
        function v(t, ...e) {
          let r = E[t];
          if (void 0 === r) {
            const e = (0, n.sha256)(Uint8Array.from(t, (t) => t.charCodeAt(0)));
            (r = (0, a.concatBytes)(e, e)), (E[t] = r);
          }
          return (0, n.sha256)((0, a.concatBytes)(r, ...e));
        }
        const B = (t) => t.toRawBytes(!0).slice(1),
          x = (t) => (0, a.numberToBytesBE)(t, 32),
          A = (t) => (0, i.mod)(t, u),
          S = (t) => (0, i.mod)(t, h),
          T = e.secp256k1.ProjectivePoint,
          U = (t, e, r) => T.BASE.multiplyAndAddUnsafe(t, e, r);
        function _(t) {
          const r = e.secp256k1.utils.normPrivateKeyToScalar(t),
            n = T.fromPrivateKey(r);
          return { scalar: n.hasEvenY() ? r : S(-r), bytes: B(n) };
        }
        function O(t) {
          if (!b(t)) throw new Error("bad x: need 0 < x < p");
          const e = A(t * t);
          let r = p(A(e * t + BigInt(7)));
          r % d !== w && (r = A(-r));
          const n = new T(t, r, l);
          return n.assertValidity(), n;
        }
        function I(...t) {
          return S((0, a.bytesToNumberBE)(v("BIP0340/challenge", ...t)));
        }
        function L(t, e, r) {
          const n = (0, a.ensureBytes)("signature", t, 64),
            o = (0, a.ensureBytes)("message", e),
            i = (0, a.ensureBytes)("publicKey", r, 32);
          try {
            const t = O((0, a.bytesToNumberBE)(i)),
              e = (0, a.bytesToNumberBE)(n.subarray(0, 32));
            if (!b(e)) return !1;
            const r = (0, a.bytesToNumberBE)(n.subarray(32, 64));
            if (!m(r)) return !1;
            const s = I(x(e), B(t), o),
              f = U(t, r, S(-s));
            return !(!f || !f.hasEvenY() || f.toAffine().x !== e);
          } catch (t) {
            return !1;
          }
        }
        e.schnorr = {
          getPublicKey: function (t) {
            return _(t).bytes;
          },
          sign: function (t, e, r = (0, o.randomBytes)(32)) {
            const n = (0, a.ensureBytes)("message", t),
              { bytes: i, scalar: s } = _(e),
              f = (0, a.ensureBytes)("auxRand", r, 32),
              c = x(s ^ (0, a.bytesToNumberBE)(v("BIP0340/aux", f))),
              u = v("BIP0340/nonce", c, i, n),
              h = S((0, a.bytesToNumberBE)(u));
            if (h === w) throw new Error("sign failed: k is zero");
            const { bytes: l, scalar: d } = _(h),
              y = I(l, i, n),
              p = new Uint8Array(64);
            if ((p.set(l, 0), p.set(x(S(d + y * s)), 32), !L(p, n, i)))
              throw new Error("sign: Invalid signature produced");
            return p;
          },
          verify: L,
          utils: {
            randomPrivateKey: e.secp256k1.utils.randomPrivateKey,
            lift_x: O,
            pointToBytes: B,
            numberToBytesBE: a.numberToBytesBE,
            bytesToNumberBE: a.bytesToNumberBE,
            taggedHash: v,
            mod: i.mod,
          },
        };
        const N = (() =>
            (0, f.isogenyMap)(
              g,
              [
                [
                  "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
                  "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
                  "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
                  "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c",
                ],
                [
                  "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
                  "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
                  "0x0000000000000000000000000000000000000000000000000000000000000001",
                ],
                [
                  "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
                  "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
                  "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
                  "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84",
                ],
                [
                  "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
                  "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
                  "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
                  "0x0000000000000000000000000000000000000000000000000000000000000001",
                ],
              ].map((t) => t.map((t) => BigInt(t))),
            ))(),
          R = (() =>
            (0, s.mapToCurveSimpleSWU)(g, {
              A: BigInt(
                "0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533",
              ),
              B: BigInt("1771"),
              Z: g.create(BigInt("-11")),
            }))(),
          k = (() =>
            (0, f.createHasher)(
              e.secp256k1.ProjectivePoint,
              (t) => {
                const { x: e, y: r } = R(g.create(t[0]));
                return N(e, r);
              },
              {
                DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
                encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
                p: g.ORDER,
                m: 1,
                k: 128,
                expand: "xmd",
                hash: n.sha256,
              },
            ))();
        (e.hashToCurve = k.hashToCurve), (e.encodeToCurve = k.encodeToCurve);
      },
      320: (t, e) => {
        "use strict";
        function r(t) {
          if (!Number.isSafeInteger(t) || t < 0)
            throw new Error(`Wrong positive integer: ${t}`);
        }
        function n(t) {
          if ("boolean" != typeof t)
            throw new Error(`Expected boolean, not ${t}`);
        }
        function o(t, ...e) {
          if (!(t instanceof Uint8Array))
            throw new Error("Expected Uint8Array");
          if (e.length > 0 && !e.includes(t.length))
            throw new Error(
              `Expected Uint8Array of length ${e}, not of length=${t.length}`,
            );
        }
        function i(t) {
          if ("function" != typeof t || "function" != typeof t.create)
            throw new Error("Hash should be wrapped by utils.wrapConstructor");
          r(t.outputLen), r(t.blockLen);
        }
        function s(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 a(t, e) {
          o(t);
          const r = e.outputLen;
          if (t.length < r)
            throw new Error(
              `digestInto() expects output buffer of length at least ${r}`,
            );
        }
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.output = e.exists = e.hash = e.bytes = e.bool = e.number = void 0),
          (e.number = r),
          (e.bool = n),
          (e.bytes = o),
          (e.hash = i),
          (e.exists = s),
          (e.output = a);
        const f = {
          number: r,
          bool: n,
          bytes: o,
          hash: i,
          exists: s,
          output: a,
        };
        e.default = f;
      },
      505: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.SHA2 = void 0);
        const n = r(320),
          o = r(89);
        class i extends o.Hash {
          constructor(t, e, r, n) {
            super(),
              (this.blockLen = t),
              (this.outputLen = e),
              (this.padOffset = r),
              (this.isLE = n),
              (this.finished = !1),
              (this.length = 0),
              (this.pos = 0),
              (this.destroyed = !1),
              (this.buffer = new Uint8Array(t)),
              (this.view = (0, o.createView)(this.buffer));
          }
          update(t) {
            (0, n.exists)(this);
            const { view: e, buffer: r, blockLen: i } = this,
              s = (t = (0, o.toBytes)(t)).length;
            for (let n = 0; n < s; ) {
              const a = Math.min(i - this.pos, s - n);
              if (a !== i)
                r.set(t.subarray(n, n + a), this.pos),
                  (this.pos += a),
                  (n += a),
                  this.pos === i && (this.process(e, 0), (this.pos = 0));
              else {
                const e = (0, o.createView)(t);
                for (; i <= s - n; n += i) this.process(e, n);
              }
            }
            return (this.length += t.length), this.roundClean(), this;
          }
          digestInto(t) {
            (0, n.exists)(this), (0, n.output)(t, this), (this.finished = !0);
            const { buffer: e, view: r, blockLen: i, isLE: s } = this;
            let { pos: a } = this;
            (e[a++] = 128),
              this.buffer.subarray(a).fill(0),
              this.padOffset > i - a && (this.process(r, 0), (a = 0));
            for (let t = a; t < i; t++) e[t] = 0;
            !(function (t, e, r, n) {
              if ("function" == typeof t.setBigUint64)
                return t.setBigUint64(e, r, n);
              const o = BigInt(32),
                i = BigInt(4294967295),
                s = Number((r >> o) & i),
                a = Number(r & i),
                f = n ? 4 : 0,
                c = n ? 0 : 4;
              t.setUint32(e + f, s, n), t.setUint32(e + c, a, n);
            })(r, i - 8, BigInt(8 * this.length), s),
              this.process(r, 0);
            const f = (0, o.createView)(t),
              c = this.outputLen;
            if (c % 4)
              throw new Error("_sha2: outputLen should be aligned to 32bit");
            const u = c / 4,
              h = this.get();
            if (u > h.length)
              throw new Error("_sha2: outputLen bigger than state");
            for (let t = 0; t < u; t++) f.setUint32(4 * t, h[t], s);
          }
          digest() {
            const { buffer: t, outputLen: e } = this;
            this.digestInto(t);
            const r = t.slice(0, e);
            return this.destroy(), r;
          }
          _cloneInto(t) {
            t || (t = new this.constructor()), t.set(...this.get());
            const {
              blockLen: e,
              buffer: r,
              length: n,
              finished: o,
              destroyed: i,
              pos: s,
            } = this;
            return (
              (t.length = n),
              (t.pos = s),
              (t.finished = o),
              (t.destroyed = i),
              n % e && t.buffer.set(r),
              t
            );
          }
        }
        e.SHA2 = i;
      },
      945: (t, e) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.crypto = void 0),
          (e.crypto =
            "object" == typeof globalThis && "crypto" in globalThis
              ? globalThis.crypto
              : void 0);
      },
      569: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.hmac = e.HMAC = void 0);
        const n = r(320),
          o = r(89);
        class i extends o.Hash {
          constructor(t, e) {
            super(),
              (this.finished = !1),
              (this.destroyed = !1),
              (0, n.hash)(t);
            const r = (0, o.toBytes)(e);
            if (
              ((this.iHash = t.create()),
              "function" != typeof this.iHash.update)
            )
              throw new Error(
                "Expected instance of class which extends utils.Hash",
              );
            (this.blockLen = this.iHash.blockLen),
              (this.outputLen = this.iHash.outputLen);
            const i = this.blockLen,
              s = new Uint8Array(i);
            s.set(r.length > i ? t.create().update(r).digest() : r);
            for (let t = 0; t < s.length; t++) s[t] ^= 54;
            this.iHash.update(s), (this.oHash = t.create());
            for (let t = 0; t < s.length; t++) s[t] ^= 106;
            this.oHash.update(s), s.fill(0);
          }
          update(t) {
            return (0, n.exists)(this), this.iHash.update(t), this;
          }
          digestInto(t) {
            (0, n.exists)(this),
              (0, n.bytes)(t, this.outputLen),
              (this.finished = !0),
              this.iHash.digestInto(t),
              this.oHash.update(t),
              this.oHash.digestInto(t),
              this.destroy();
          }
          digest() {
            const t = new Uint8Array(this.oHash.outputLen);
            return this.digestInto(t), t;
          }
          _cloneInto(t) {
            t || (t = Object.create(Object.getPrototypeOf(this), {}));
            const {
              oHash: e,
              iHash: r,
              finished: n,
              destroyed: o,
              blockLen: i,
              outputLen: s,
            } = this;
            return (
              (t.finished = n),
              (t.destroyed = o),
              (t.blockLen = i),
              (t.outputLen = s),
              (t.oHash = e._cloneInto(t.oHash)),
              (t.iHash = r._cloneInto(t.iHash)),
              t
            );
          }
          destroy() {
            (this.destroyed = !0), this.oHash.destroy(), this.iHash.destroy();
          }
        }
        (e.HMAC = i),
          (e.hmac = (t, e, r) => new i(t, e).update(r).digest()),
          (e.hmac.create = (t, e) => new i(t, e));
      },
      61: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.sha224 = e.sha256 = void 0);
        const n = r(505),
          o = r(89),
          i = (t, e, r) => (t & e) ^ (t & r) ^ (e & r),
          s = new Uint32Array([
            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,
          ]),
          a = new Uint32Array([
            1779033703, 3144134277, 1013904242, 2773480762, 1359893119,
            2600822924, 528734635, 1541459225,
          ]),
          f = new Uint32Array(64);
        class c extends n.SHA2 {
          constructor() {
            super(64, 32, 8, !1),
              (this.A = 0 | a[0]),
              (this.B = 0 | a[1]),
              (this.C = 0 | a[2]),
              (this.D = 0 | a[3]),
              (this.E = 0 | a[4]),
              (this.F = 0 | a[5]),
              (this.G = 0 | a[6]),
              (this.H = 0 | a[7]);
          }
          get() {
            const { A: t, B: e, C: r, D: n, E: o, F: i, G: s, H: a } = this;
            return [t, e, r, n, o, i, s, a];
          }
          set(t, e, r, n, o, i, s, a) {
            (this.A = 0 | t),
              (this.B = 0 | e),
              (this.C = 0 | r),
              (this.D = 0 | n),
              (this.E = 0 | o),
              (this.F = 0 | i),
              (this.G = 0 | s),
              (this.H = 0 | a);
          }
          process(t, e) {
            for (let r = 0; r < 16; r++, e += 4) f[r] = t.getUint32(e, !1);
            for (let t = 16; t < 64; t++) {
              const e = f[t - 15],
                r = f[t - 2],
                n = (0, o.rotr)(e, 7) ^ (0, o.rotr)(e, 18) ^ (e >>> 3),
                i = (0, o.rotr)(r, 17) ^ (0, o.rotr)(r, 19) ^ (r >>> 10);
              f[t] = (i + f[t - 7] + n + f[t - 16]) | 0;
            }
            let { A: r, B: n, C: a, D: c, E: u, F: h, G: l, H: d } = this;
            for (let t = 0; t < 64; t++) {
              const e =
                  (d +
                    ((0, o.rotr)(u, 6) ^
                      (0, o.rotr)(u, 11) ^
                      (0, o.rotr)(u, 25)) +
                    (((y = u) & h) ^ (~y & l)) +
                    s[t] +
                    f[t]) |
                  0,
                p =
                  (((0, o.rotr)(r, 2) ^
                    (0, o.rotr)(r, 13) ^
                    (0, o.rotr)(r, 22)) +
                    i(r, n, a)) |
                  0;
              (d = l),
                (l = h),
                (h = u),
                (u = (c + e) | 0),
                (c = a),
                (a = n),
                (n = r),
                (r = (e + p) | 0);
            }
            let y;
            (r = (r + this.A) | 0),
              (n = (n + this.B) | 0),
              (a = (a + this.C) | 0),
              (c = (c + this.D) | 0),
              (u = (u + this.E) | 0),
              (h = (h + this.F) | 0),
              (l = (l + this.G) | 0),
              (d = (d + this.H) | 0),
              this.set(r, n, a, c, u, h, l, d);
          }
          roundClean() {
            f.fill(0);
          }
          destroy() {
            this.set(0, 0, 0, 0, 0, 0, 0, 0), this.buffer.fill(0);
          }
        }
        class u extends c {
          constructor() {
            super(),
              (this.A = -1056596264),
              (this.B = 914150663),
              (this.C = 812702999),
              (this.D = -150054599),
              (this.E = -4191439),
              (this.F = 1750603025),
              (this.G = 1694076839),
              (this.H = -1090891868),
              (this.outputLen = 28);
          }
        }
        (e.sha256 = (0, o.wrapConstructor)(() => new c())),
          (e.sha224 = (0, o.wrapConstructor)(() => new u()));
      },
      89: (t, e, r) => {
        "use strict";
        Object.defineProperty(e, "__esModule", { value: !0 }),
          (e.randomBytes =
            e.wrapXOFConstructorWithOpts =
            e.wrapConstructorWithOpts =
            e.wrapConstructor =
            e.checkOpts =
            e.Hash =
            e.concatBytes =
            e.toBytes =
            e.utf8ToBytes =
            e.asyncLoop =
            e.nextTick =
            e.hexToBytes =
            e.bytesToHex =
            e.isLE =
            e.rotr =
            e.createView =
            e.u32 =
            e.u8 =
              void 0);
        const n = r(945),
          o = (t) => t instanceof Uint8Array;
        if (
          ((e.u8 = (t) => new Uint8Array(t.buffer, t.byteOffset, t.byteLength)),
          (e.u32 = (t) =>
            new Uint32Array(
              t.buffer,
              t.byteOffset,
              Math.floor(t.byteLength / 4),
            )),
          (e.createView = (t) =>
            new DataView(t.buffer, t.byteOffset, t.byteLength)),
          (e.rotr = (t, e) => (t << (32 - e)) | (t >>> e)),
          (e.isLE =
            68 === new Uint8Array(new Uint32Array([287454020]).buffer)[0]),
          !e.isLE)
        )
          throw new Error("Non little-endian hardware is not supported");
        const i = Array.from({ length: 256 }, (t, e) =>
          e.toString(16).padStart(2, "0"),
        );
        function s(t) {
          if ("string" != typeof t)
            throw new Error("utf8ToBytes expected string, got " + typeof t);
          return new Uint8Array(new TextEncoder().encode(t));
        }
        function a(t) {
          if (("string" == typeof t && (t = s(t)), !o(t)))
            throw new Error("expected Uint8Array, got " + typeof t);
          return t;
        }
        (e.bytesToHex = function (t) {
          if (!o(t)) throw new Error("Uint8Array expected");
          let e = "";
          for (let r = 0; r < t.length; r++) e += i[t[r]];
          return e;
        }),
          (e.hexToBytes = function (t) {
            if ("string" != typeof t)
              throw new Error("hex string expected, got " + typeof t);
            const e = t.length;
            if (e % 2)
              throw new Error(
                "padded hex string expected, got unpadded hex of length " + e,
              );
            const r = new Uint8Array(e / 2);
            for (let e = 0; e < r.length; e++) {
              const n = 2 * e,
                o = t.slice(n, n + 2),
                i = Number.parseInt(o, 16);
              if (Number.isNaN(i) || i < 0)
                throw new Error("Invalid byte sequence");
              r[e] = i;
            }
            return r;
          }),
          (e.nextTick = async () => {}),
          (e.asyncLoop = async function (t, r, n) {
            let o = Date.now();
            for (let i = 0; i < t; i++) {
              n(i);
              const t = Date.now() - o;
              (t >= 0 && t < r) || (await (0, e.nextTick)(), (o += t));
            }
          }),
          (e.utf8ToBytes = s),
          (e.toBytes = a),
          (e.concatBytes = function (...t) {
            const e = new Uint8Array(t.reduce((t, e) => t + e.length, 0));
            let r = 0;
            return (
              t.forEach((t) => {
                if (!o(t)) throw new Error("Uint8Array expected");
                e.set(t, r), (r += t.length);
              }),
              e
            );
          }),
          (e.Hash = class {
            clone() {
              return this._cloneInto();
            }
          });
        const f = {}.toString;
        (e.checkOpts = function (t, e) {
          if (void 0 !== e && "[object Object]" !== f.call(e))
            throw new Error("Options should be object or undefined");
          return Object.assign(t, e);
        }),
          (e.wrapConstructor = function (t) {
            const e = (e) => t().update(a(e)).digest(),
              r = t();
            return (
              (e.outputLen = r.outputLen),
              (e.blockLen = r.blockLen),
              (e.create = () => t()),
              e
            );
          }),
          (e.wrapConstructorWithOpts = function (t) {
            const e = (e, r) => t(r).update(a(e)).digest(),
              r = t({});
            return (
              (e.outputLen = r.outputLen),
              (e.blockLen = r.blockLen),
              (e.create = (e) => t(e)),
              e
            );
          }),
          (e.wrapXOFConstructorWithOpts = function (t) {
            const e = (e, r) => t(r).update(a(e)).digest(),
              r = t({});
            return (
              (e.outputLen = r.outputLen),
              (e.blockLen = r.blockLen),
              (e.create = (e) => t(e)),
              e
            );
          }),
          (e.randomBytes = function (t = 32) {
            if (n.crypto && "function" == typeof n.crypto.getRandomValues)
              return n.crypto.getRandomValues(new Uint8Array(t));
            throw new Error("crypto.getRandomValues must be defined");
          });
      },
      885: function (t) {
        !(function (e, r) {
          "use strict";
          t.exports
            ? (t.exports = r())
            : (e.nacl || (e.nacl = {}), (e.nacl.util = r()));
        })(this, function () {
          "use strict";
          const t = {};
          function e(t) {
            if (
              !/^(?:[A-Za-z0-9+\/]{2}[A-Za-z0-9+\/]{2})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/.test(
                t,
              )
            )
              throw new TypeError("invalid encoding");
          }
          return (
            (t.decodeUTF8 = function (t) {
              if ("string" != typeof t) throw new TypeError("expected string");
              let e,
                r = unescape(encodeURIComponent(t)),
                n = new Uint8Array(r.length);
              for (e = 0; e < r.length; e++) n[e] = r.charCodeAt(e);
              return n;
            }),
            (t.encodeUTF8 = function (t) {
              let e,
                r = [];
              for (e = 0; e < t.length; e++) r.push(String.fromCharCode(t[e]));
              return decodeURIComponent(escape(r.join("")));
            }),
            "undefined" == typeof atob
              ? void 0 !== Buffer.from
                ? ((t.encodeBase64 = function (t) {
                    return Buffer.from(t).toString("base64");
                  }),
                  (t.decodeBase64 = function (t) {
                    return (
                      e(t),
                      new Uint8Array(
                        Array.prototype.slice.call(Buffer.from(t, "base64"), 0),
                      )
                    );
                  }))
                : ((t.encodeBase64 = function (t) {
                    return new Buffer(t).toString("base64");
                  }),
                  (t.decodeBase64 = function (t) {
                    return (
                      e(t),
                      new Uint8Array(
                        Array.prototype.slice.call(new Buffer(t, "base64"), 0),
                      )
                    );
                  }))
              : ((t.encodeBase64 = function (t) {
                  let e,
                    r = [],
                    n = t.length;
                  for (e = 0; e < n; e++) r.push(String.fromCharCode(t[e]));
                  return btoa(r.join(""));
                }),
                (t.decodeBase64 = function (t) {
                  e(t);
                  let r,
                    n = atob(t),
                    o = new Uint8Array(n.length);
                  for (r = 0; r < n.length; r++) o[r] = n.charCodeAt(r);
                  return o;
                })),
            t
          );
        });
      },
      780: (t, e, r) => {
        !(function (t) {
          "use strict";
          let e = function (t) {
              let e,
                r = new Float64Array(16);
              if (t) for (e = 0; e < t.length; e++) r[e] = t[e];
              return r;
            },
            n = function () {
              throw new Error("no PRNG");
            },
            o = new Uint8Array(16),
            i = new Uint8Array(32);
          i[0] = 9;
          const s = e(),
            a = e([1]),
            f = e([56129, 1]),
            c = e([
              30883, 4953, 19914, 30187, 55467, 16705, 2637, 112, 59544, 30585,
              16505, 36039, 65139, 11119, 27886, 20995,
            ]),
            u = e([
              61785, 9906, 39828, 60374, 45398, 33411, 5274, 224, 53552, 61171,
              33010, 6542, 64743, 22239, 55772, 9222,
            ]),
            h = e([
              54554, 36645, 11616, 51542, 42930, 38181, 51040, 26924, 56412,
              64982, 57905, 49316, 21502, 52590, 14035, 8553,
            ]),
            l = e([
              26200, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214,
              26214, 26214, 26214, 26214, 26214, 26214, 26214,
            ]),
            d = e([
              41136, 18958, 6951, 50414, 58488, 44335, 6150, 12099, 55207,
              15867, 153, 11085, 57099, 20417, 9344, 11139,
            ]);
          function y(t, e, r, n) {
            (t[e] = (r >> 24) & 255),
              (t[e + 1] = (r >> 16) & 255),
              (t[e + 2] = (r >> 8) & 255),
              (t[e + 3] = 255 & r),
              (t[e + 4] = (n >> 24) & 255),
              (t[e + 5] = (n >> 16) & 255),
              (t[e + 6] = (n >> 8) & 255),
              (t[e + 7] = 255 & n);
          }
          function p(t, e, r, n, o) {
            let i,
              s = 0;
            for (i = 0; i < o; i++) s |= t[e + i] ^ r[n + i];
            return (1 & ((s - 1) >>> 8)) - 1;
          }
          function g(t, e, r, n) {
            return p(t, e, r, n, 16);
          }
          function w(t, e, r, n) {
            return p(t, e, r, n, 32);
          }
          function b(t, e, r, n) {
            !(function (t, e, r, n) {
              for (
                var o,
                  i =
                    (255 & n[0]) |
                    ((255 & n[1]) << 8) |
                    ((255 & n[2]) << 16) |
                    ((255 & n[3]) << 24),
                  s =
                    (255 & r[0]) |
                    ((255 & r[1]) << 8) |
                    ((255 & r[2]) << 16) |
                    ((255 & r[3]) << 24),
                  a =
                    (255 & r[4]) |
                    ((255 & r[5]) << 8) |
                    ((255 & r[6]) << 16) |
                    ((255 & r[7]) << 24),
                  f =
                    (255 & r[8]) |
                    ((255 & r[9]) << 8) |
                    ((255 & r[10]) << 16) |
                    ((255 & r[11]) << 24),
                  c =
                    (255 & r[12]) |
                    ((255 & r[13]) << 8) |
                    ((255 & r[14]) << 16) |
                    ((255 & r[15]) << 24),
                  u =
                    (255 & n[4]) |
                    ((255 & n[5]) << 8) |
                    ((255 & n[6]) << 16) |
                    ((255 & n[7]) << 24),
                  h =
                    (255 & e[0]) |
                    ((255 & e[1]) << 8) |
                    ((255 & e[2]) << 16) |
                    ((255 & e[3]) << 24),
                  l =
                    (255 & e[4]) |
                    ((255 & e[5]) << 8) |
                    ((255 & e[6]) << 16) |
                    ((255 & e[7]) << 24),
                  d =
                    (255 & e[8]) |
                    ((255 & e[9]) << 8) |
                    ((255 & e[10]) << 16) |
                    ((255 & e[11]) << 24),
                  y =
                    (255 & e[12]) |
                    ((255 & e[13]) << 8) |
                    ((255 & e[14]) << 16) |
                    ((255 & e[15]) << 24),
                  p =
                    (255 & n[8]) |
                    ((255 & n[9]) << 8) |
                    ((255 & n[10]) << 16) |
                    ((255 & n[11]) << 24),
                  g =
                    (255 & r[16]) |
                    ((255 & r[17]) << 8) |
                    ((255 & r[18]) << 16) |
                    ((255 & r[19]) << 24),
                  w =
                    (255 & r[20]) |
                    ((255 & r[21]) << 8) |
                    ((255 & r[22]) << 16) |
                    ((255 & r[23]) << 24),
                  b =
                    (255 & r[24]) |
                    ((255 & r[25]) << 8) |
                    ((255 & r[26]) << 16) |
                    ((255 & r[27]) << 24),
                  m =
                    (255 & r[28]) |
                    ((255 & r[29]) << 8) |
                    ((255 & r[30]) << 16) |
                    ((255 & r[31]) << 24),
                  E =
                    (255 & n[12]) |
                    ((255 & n[13]) << 8) |
                    ((255 & n[14]) << 16) |
                    ((255 & n[15]) << 24),
                  v = i,
                  B = s,
                  x = a,
                  A = f,
                  S = c,
                  T = u,
                  U = h,
                  _ = l,
                  O = d,
                  I = y,
                  L = p,
                  N = g,
                  R = w,
                  k = b,
                  H = m,
                  M = E,
                  q = 0;
                q < 20;
                q += 2
              )
                (v ^=
                  ((o =
                    ((R ^=
                      ((o =
                        ((O ^=
                          ((o =
                            ((S ^= ((o = (v + R) | 0) << 7) | (o >>> 25)) + v) |
                            0) <<
                            9) |
                          (o >>> 23)) +
                          S) |
                        0) <<
                        13) |
                      (o >>> 19)) +
                      O) |
                    0) <<
                    18) |
                  (o >>> 14)),
                  (T ^=
                    ((o =
                      ((B ^=
                        ((o =
                          ((k ^=
                            ((o =
                              ((I ^= ((o = (T + B) | 0) << 7) | (o >>> 25)) +
                                T) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            I) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        k) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (L ^=
                    ((o =
                      ((U ^=
                        ((o =
                          ((x ^=
                            ((o =
                              ((H ^= ((o = (L + U) | 0) << 7) | (o >>> 25)) +
                                L) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            H) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        x) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (M ^=
                    ((o =
                      ((N ^=
                        ((o =
                          ((_ ^=
                            ((o =
                              ((A ^= ((o = (M + N) | 0) << 7) | (o >>> 25)) +
                                M) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            A) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        _) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (v ^=
                    ((o =
                      ((A ^=
                        ((o =
                          ((x ^=
                            ((o =
                              ((B ^= ((o = (v + A) | 0) << 7) | (o >>> 25)) +
                                v) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            B) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        x) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (T ^=
                    ((o =
                      ((S ^=
                        ((o =
                          ((_ ^=
                            ((o =
                              ((U ^= ((o = (T + S) | 0) << 7) | (o >>> 25)) +
                                T) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            U) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        _) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (L ^=
                    ((o =
                      ((I ^=
                        ((o =
                          ((O ^=
                            ((o =
                              ((N ^= ((o = (L + I) | 0) << 7) | (o >>> 25)) +
                                L) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            N) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        O) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (M ^=
                    ((o =
                      ((H ^=
                        ((o =
                          ((k ^=
                            ((o =
                              ((R ^= ((o = (M + H) | 0) << 7) | (o >>> 25)) +
                                M) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            R) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        k) |
                      0) <<
                      18) |
                    (o >>> 14));
              (v = (v + i) | 0),
                (B = (B + s) | 0),
                (x = (x + a) | 0),
                (A = (A + f) | 0),
                (S = (S + c) | 0),
                (T = (T + u) | 0),
                (U = (U + h) | 0),
                (_ = (_ + l) | 0),
                (O = (O + d) | 0),
                (I = (I + y) | 0),
                (L = (L + p) | 0),
                (N = (N + g) | 0),
                (R = (R + w) | 0),
                (k = (k + b) | 0),
                (H = (H + m) | 0),
                (M = (M + E) | 0),
                (t[0] = (v >>> 0) & 255),
                (t[1] = (v >>> 8) & 255),
                (t[2] = (v >>> 16) & 255),
                (t[3] = (v >>> 24) & 255),
                (t[4] = (B >>> 0) & 255),
                (t[5] = (B >>> 8) & 255),
                (t[6] = (B >>> 16) & 255),
                (t[7] = (B >>> 24) & 255),
                (t[8] = (x >>> 0) & 255),
                (t[9] = (x >>> 8) & 255),
                (t[10] = (x >>> 16) & 255),
                (t[11] = (x >>> 24) & 255),
                (t[12] = (A >>> 0) & 255),
                (t[13] = (A >>> 8) & 255),
                (t[14] = (A >>> 16) & 255),
                (t[15] = (A >>> 24) & 255),
                (t[16] = (S >>> 0) & 255),
                (t[17] = (S >>> 8) & 255),
                (t[18] = (S >>> 16) & 255),
                (t[19] = (S >>> 24) & 255),
                (t[20] = (T >>> 0) & 255),
                (t[21] = (T >>> 8) & 255),
                (t[22] = (T >>> 16) & 255),
                (t[23] = (T >>> 24) & 255),
                (t[24] = (U >>> 0) & 255),
                (t[25] = (U >>> 8) & 255),
                (t[26] = (U >>> 16) & 255),
                (t[27] = (U >>> 24) & 255),
                (t[28] = (_ >>> 0) & 255),
                (t[29] = (_ >>> 8) & 255),
                (t[30] = (_ >>> 16) & 255),
                (t[31] = (_ >>> 24) & 255),
                (t[32] = (O >>> 0) & 255),
                (t[33] = (O >>> 8) & 255),
                (t[34] = (O >>> 16) & 255),
                (t[35] = (O >>> 24) & 255),
                (t[36] = (I >>> 0) & 255),
                (t[37] = (I >>> 8) & 255),
                (t[38] = (I >>> 16) & 255),
                (t[39] = (I >>> 24) & 255),
                (t[40] = (L >>> 0) & 255),
                (t[41] = (L >>> 8) & 255),
                (t[42] = (L >>> 16) & 255),
                (t[43] = (L >>> 24) & 255),
                (t[44] = (N >>> 0) & 255),
                (t[45] = (N >>> 8) & 255),
                (t[46] = (N >>> 16) & 255),
                (t[47] = (N >>> 24) & 255),
                (t[48] = (R >>> 0) & 255),
                (t[49] = (R >>> 8) & 255),
                (t[50] = (R >>> 16) & 255),
                (t[51] = (R >>> 24) & 255),
                (t[52] = (k >>> 0) & 255),
                (t[53] = (k >>> 8) & 255),
                (t[54] = (k >>> 16) & 255),
                (t[55] = (k >>> 24) & 255),
                (t[56] = (H >>> 0) & 255),
                (t[57] = (H >>> 8) & 255),
                (t[58] = (H >>> 16) & 255),
                (t[59] = (H >>> 24) & 255),
                (t[60] = (M >>> 0) & 255),
                (t[61] = (M >>> 8) & 255),
                (t[62] = (M >>> 16) & 255),
                (t[63] = (M >>> 24) & 255);
            })(t, e, r, n);
          }
          function m(t, e, r, n) {
            !(function (t, e, r, n) {
              for (
                var o,
                  i =
                    (255 & n[0]) |
                    ((255 & n[1]) << 8) |
                    ((255 & n[2]) << 16) |
                    ((255 & n[3]) << 24),
                  s =
                    (255 & r[0]) |
                    ((255 & r[1]) << 8) |
                    ((255 & r[2]) << 16) |
                    ((255 & r[3]) << 24),
                  a =
                    (255 & r[4]) |
                    ((255 & r[5]) << 8) |
                    ((255 & r[6]) << 16) |
                    ((255 & r[7]) << 24),
                  f =
                    (255 & r[8]) |
                    ((255 & r[9]) << 8) |
                    ((255 & r[10]) << 16) |
                    ((255 & r[11]) << 24),
                  c =
                    (255 & r[12]) |
                    ((255 & r[13]) << 8) |
                    ((255 & r[14]) << 16) |
                    ((255 & r[15]) << 24),
                  u =
                    (255 & n[4]) |
                    ((255 & n[5]) << 8) |
                    ((255 & n[6]) << 16) |
                    ((255 & n[7]) << 24),
                  h =
                    (255 & e[0]) |
                    ((255 & e[1]) << 8) |
                    ((255 & e[2]) << 16) |
                    ((255 & e[3]) << 24),
                  l =
                    (255 & e[4]) |
                    ((255 & e[5]) << 8) |
                    ((255 & e[6]) << 16) |
                    ((255 & e[7]) << 24),
                  d =
                    (255 & e[8]) |
                    ((255 & e[9]) << 8) |
                    ((255 & e[10]) << 16) |
                    ((255 & e[11]) << 24),
                  y =
                    (255 & e[12]) |
                    ((255 & e[13]) << 8) |
                    ((255 & e[14]) << 16) |
                    ((255 & e[15]) << 24),
                  p =
                    (255 & n[8]) |
                    ((255 & n[9]) << 8) |
                    ((255 & n[10]) << 16) |
                    ((255 & n[11]) << 24),
                  g =
                    (255 & r[16]) |
                    ((255 & r[17]) << 8) |
                    ((255 & r[18]) << 16) |
                    ((255 & r[19]) << 24),
                  w =
                    (255 & r[20]) |
                    ((255 & r[21]) << 8) |
                    ((255 & r[22]) << 16) |
                    ((255 & r[23]) << 24),
                  b =
                    (255 & r[24]) |
                    ((255 & r[25]) << 8) |
                    ((255 & r[26]) << 16) |
                    ((255 & r[27]) << 24),
                  m =
                    (255 & r[28]) |
                    ((255 & r[29]) << 8) |
                    ((255 & r[30]) << 16) |
                    ((255 & r[31]) << 24),
                  E =
                    (255 & n[12]) |
                    ((255 & n[13]) << 8) |
                    ((255 & n[14]) << 16) |
                    ((255 & n[15]) << 24),
                  v = 0;
                v < 20;
                v += 2
              )
                (i ^=
                  ((o =
                    ((w ^=
                      ((o =
                        ((d ^=
                          ((o =
                            ((c ^= ((o = (i + w) | 0) << 7) | (o >>> 25)) + i) |
                            0) <<
                            9) |
                          (o >>> 23)) +
                          c) |
                        0) <<
                        13) |
                      (o >>> 19)) +
                      d) |
                    0) <<
                    18) |
                  (o >>> 14)),
                  (u ^=
                    ((o =
                      ((s ^=
                        ((o =
                          ((b ^=
                            ((o =
                              ((y ^= ((o = (u + s) | 0) << 7) | (o >>> 25)) +
                                u) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            y) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        b) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (p ^=
                    ((o =
                      ((h ^=
                        ((o =
                          ((a ^=
                            ((o =
                              ((m ^= ((o = (p + h) | 0) << 7) | (o >>> 25)) +
                                p) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            m) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        a) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (E ^=
                    ((o =
                      ((g ^=
                        ((o =
                          ((l ^=
                            ((o =
                              ((f ^= ((o = (E + g) | 0) << 7) | (o >>> 25)) +
                                E) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            f) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        l) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (i ^=
                    ((o =
                      ((f ^=
                        ((o =
                          ((a ^=
                            ((o =
                              ((s ^= ((o = (i + f) | 0) << 7) | (o >>> 25)) +
                                i) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            s) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        a) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (u ^=
                    ((o =
                      ((c ^=
                        ((o =
                          ((l ^=
                            ((o =
                              ((h ^= ((o = (u + c) | 0) << 7) | (o >>> 25)) +
                                u) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            h) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        l) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (p ^=
                    ((o =
                      ((y ^=
                        ((o =
                          ((d ^=
                            ((o =
                              ((g ^= ((o = (p + y) | 0) << 7) | (o >>> 25)) +
                                p) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            g) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        d) |
                      0) <<
                      18) |
                    (o >>> 14)),
                  (E ^=
                    ((o =
                      ((m ^=
                        ((o =
                          ((b ^=
                            ((o =
                              ((w ^= ((o = (E + m) | 0) << 7) | (o >>> 25)) +
                                E) |
                              0) <<
                              9) |
                            (o >>> 23)) +
                            w) |
                          0) <<
                          13) |
                        (o >>> 19)) +
                        b) |
                      0) <<
                      18) |
                    (o >>> 14));
              (t[0] = (i >>> 0) & 255),
                (t[1] = (i >>> 8) & 255),
                (t[2] = (i >>> 16) & 255),
                (t[3] = (i >>> 24) & 255),
                (t[4] = (u >>> 0) & 255),
                (t[5] = (u >>> 8) & 255),
                (t[6] = (u >>> 16) & 255),
                (t[7] = (u >>> 24) & 255),
                (t[8] = (p >>> 0) & 255),
                (t[9] = (p >>> 8) & 255),
                (t[10] = (p >>> 16) & 255),
                (t[11] = (p >>> 24) & 255),
                (t[12] = (E >>> 0) & 255),
                (t[13] = (E >>> 8) & 255),
                (t[14] = (E >>> 16) & 255),
                (t[15] = (E >>> 24) & 255),
                (t[16] = (h >>> 0) & 255),
                (t[17] = (h >>> 8) & 255),
                (t[18] = (h >>> 16) & 255),
                (t[19] = (h >>> 24) & 255),
                (t[20] = (l >>> 0) & 255),
                (t[21] = (l >>> 8) & 255),
                (t[22] = (l >>> 16) & 255),
                (t[23] = (l >>> 24) & 255),
                (t[24] = (d >>> 0) & 255),
                (t[25] = (d >>> 8) & 255),
                (t[26] = (d >>> 16) & 255),
                (t[27] = (d >>> 24) & 255),
                (t[28] = (y >>> 0) & 255),
                (t[29] = (y >>> 8) & 255),
                (t[30] = (y >>> 16) & 255),
                (t[31] = (y >>> 24) & 255);
            })(t, e, r, n);
          }
          const E = new Uint8Array([
            101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32,
            107,
          ]);
          function v(t, e, r, n, o, i, s) {
            let a,
              f,
              c = new Uint8Array(16),
              u = new Uint8Array(64);
            for (f = 0; f < 16; f++) c[f] = 0;
            for (f = 0; f < 8; f++) c[f] = i[f];
            for (; o >= 64; ) {
              for (b(u, c, s, E), f = 0; f < 64; f++)
                t[e + f] = r[n + f] ^ u[f];
              for (a = 1, f = 8; f < 16; f++)
                (a = (a + (255 & c[f])) | 0), (c[f] = 255 & a), (a >>>= 8);
              (o -= 64), (e += 64), (n += 64);
            }
            if (o > 0)
              for (b(u, c, s, E), f = 0; f < o; f++) t[e + f] = r[n + f] ^ u[f];
            return 0;
          }
          function B(t, e, r, n, o) {
            let i,
              s,
              a = new Uint8Array(16),
              f = new Uint8Array(64);
            for (s = 0; s < 16; s++) a[s] = 0;
            for (s = 0; s < 8; s++) a[s] = n[s];
            for (; r >= 64; ) {
              for (b(f, a, o, E), s = 0; s < 64; s++) t[e + s] = f[s];
              for (i = 1, s = 8; s < 16; s++)
                (i = (i + (255 & a[s])) | 0), (a[s] = 255 & i), (i >>>= 8);
              (r -= 64), (e += 64);
            }
            if (r > 0) for (b(f, a, o, E), s = 0; s < r; s++) t[e + s] = f[s];
            return 0;
          }
          function x(t, e, r, n, o) {
            const i = new Uint8Array(32);
            m(i, n, o, E);
            for (var s = new Uint8Array(8), a = 0; a < 8; a++) s[a] = n[a + 16];
            return B(t, e, r, s, i);
          }
          function A(t, e, r, n, o, i, s) {
            const a = new Uint8Array(32);
            m(a, i, s, E);
            for (var f = new Uint8Array(8), c = 0; c < 8; c++) f[c] = i[c + 16];
            return v(t, e, r, n, o, f, a);
          }
          const S = function (t) {
            let e, r, n, o, i, s, a, f;
            (this.buffer = new Uint8Array(16)),
              (this.r = new Uint16Array(10)),
              (this.h = new Uint16Array(10)),
              (this.pad = new Uint16Array(8)),
              (this.leftover = 0),
              (this.fin = 0),
              (e = (255 & t[0]) | ((255 & t[1]) << 8)),
              (this.r[0] = 8191 & e),
              (r = (255 & t[2]) | ((255 & t[3]) << 8)),
              (this.r[1] = 8191 & ((e >>> 13) | (r << 3))),
              (n = (255 & t[4]) | ((255 & t[5]) << 8)),
              (this.r[2] = 7939 & ((r >>> 10) | (n << 6))),
              (o = (255 & t[6]) | ((255 & t[7]) << 8)),
              (this.r[3] = 8191 & ((n >>> 7) | (o << 9))),
              (i = (255 & t[8]) | ((255 & t[9]) << 8)),
              (this.r[4] = 255 & ((o >>> 4) | (i << 12))),
              (this.r[5] = (i >>> 1) & 8190),
              (s = (255 & t[10]) | ((255 & t[11]) << 8)),
              (this.r[6] = 8191 & ((i >>> 14) | (s << 2))),
              (a = (255 & t[12]) | ((255 & t[13]) << 8)),
              (this.r[7] = 8065 & ((s >>> 11) | (a << 5))),
              (f = (255 & t[14]) | ((255 & t[15]) << 8)),
              (this.r[8] = 8191 & ((a >>> 8) | (f << 8))),
              (this.r[9] = (f >>> 5) & 127),
              (this.pad[0] = (255 & t[16]) | ((255 & t[17]) << 8)),
              (this.pad[1] = (255 & t[18]) | ((255 & t[19]) << 8)),
              (this.pad[2] = (255 & t[20]) | ((255 & t[21]) << 8)),
              (this.pad[3] = (255 & t[22]) | ((255 & t[23]) << 8)),
              (this.pad[4] = (255 & t[24]) | ((255 & t[25]) << 8)),
              (this.pad[5] = (255 & t[26]) | ((255 & t[27]) << 8)),
              (this.pad[6] = (255 & t[28]) | ((255 & t[29]) << 8)),
              (this.pad[7] = (255 & t[30]) | ((255 & t[31]) << 8));
          };
          function T(t, e, r, n, o, i) {
            const s = new S(i);
            return s.update(r, n, o), s.finish(t, e), 0;
          }
          function U(t, e, r, n, o, i) {
            const s = new Uint8Array(16);
            return T(s, 0, r, n, o, i), g(t, e, s, 0);
          }
          function _(t, e, r, n, o) {
            let i;
            if (r < 32) return -1;
            for (
              A(t, 0, e, 0, r, n, o), T(t, 16, t, 32, r - 32, t), i = 0;
              i < 16;
              i++
            )
              t[i] = 0;
            return 0;
          }
          function O(t, e, r, n, o) {
            let i,
              s = new Uint8Array(32);
            if (r < 32) return -1;
            if ((x(s, 0, 32, n, o), 0 !== U(e, 16, e, 32, r - 32, s)))
              return -1;
            for (A(t, 0, e, 0, r, n, o), i = 0; i < 32; i++) t[i] = 0;
            return 0;
          }
          function I(t, e) {
            let r;
            for (r = 0; r < 16; r++) t[r] = 0 | e[r];
          }
          function L(t) {
            let e,
              r,
              n = 1;
            for (e = 0; e < 16; e++)
              (r = t[e] + n + 65535),
                (n = Math.floor(r / 65536)),
                (t[e] = r - 65536 * n);
            t[0] += n - 1 + 37 * (n - 1);
          }
          function N(t, e, r) {
            for (var n, o = ~(r - 1), i = 0; i < 16; i++)
              (n = o & (t[i] ^ e[i])), (t[i] ^= n), (e[i] ^= n);
          }
          function R(t, r) {
            let n,
              o,
              i,
              s = e(),
              a = e();
            for (n = 0; n < 16; n++) a[n] = r[n];
            for (L(a), L(a), L(a), o = 0; o < 2; o++) {
              for (s[0] = a[0] - 65517, n = 1; n < 15; n++)
                (s[n] = a[n] - 65535 - ((s[n - 1] >> 16) & 1)),
                  (s[n - 1] &= 65535);
              (s[15] = a[15] - 32767 - ((s[14] >> 16) & 1)),
                (i = (s[15] >> 16) & 1),
                (s[14] &= 65535),
                N(a, s, 1 - i);
            }
            for (n = 0; n < 16; n++)
              (t[2 * n] = 255 & a[n]), (t[2 * n + 1] = a[n] >> 8);
          }
          function k(t, e) {
            const r = new Uint8Array(32),
              n = new Uint8Array(32);
            return R(r, t), R(n, e), w(r, 0, n, 0);
          }
          function H(t) {
            const e = new Uint8Array(32);
            return R(e, t), 1 & e[0];
          }
          function M(t, e) {
            let r;
            for (r = 0; r < 16; r++) t[r] = e[2 * r] + (e[2 * r + 1] << 8);
            t[15] &= 32767;
          }
          function q(t, e, r) {
            for (let n = 0; n < 16; n++) t[n] = e[n] + r[n];
          }
          function C(t, e, r) {
            for (let n = 0; n < 16; n++) t[n] = e[n] - r[n];
          }
          function F(t, e, r) {
            let n,
              o,
              i = 0,
              s = 0,
              a = 0,
              f = 0,
              c = 0,
              u = 0,
              h = 0,
              l = 0,
              d = 0,
              y = 0,
              p = 0,
              g = 0,
              w = 0,
              b = 0,
              m = 0,
              E = 0,
              v = 0,
              B = 0,
              x = 0,
              A = 0,
              S = 0,
              T = 0,
              U = 0,
              _ = 0,
              O = 0,
              I = 0,
              L = 0,
              N = 0,
              R = 0,
              k = 0,
              H = 0,
              M = r[0],
              q = r[1],
              C = r[2],
              F = r[3],
              P = r[4],
              D = r[5],
              j = r[6],
              z = r[7],
              $ = r[8],
              K = r[9],
              V = r[10],
              Z = r[11],
              Y = r[12],
              W = r[13],
              G = r[14],
              J = r[15];
            (i += (n = e[0]) * M),
              (s += n * q),
              (a += n * C),
              (f += n * F),
              (c += n * P),
              (u += n * D),
              (h += n * j),
              (l += n * z),
              (d += n * $),
              (y += n * K),
              (p += n * V),
              (g += n * Z),
              (w += n * Y),
              (b += n * W),
              (m += n * G),
              (E += n * J),
              (s += (n = e[1]) * M),
              (a += n * q),
              (f += n * C),
              (c += n * F),
              (u += n * P),
              (h += n * D),
              (l += n * j),
              (d += n * z),
              (y += n * $),
              (p += n * K),
              (g += n * V),
              (w += n * Z),
              (b += n * Y),
              (m += n * W),
              (E += n * G),
              (v += n * J),
              (a += (n = e[2]) * M),
              (f += n * q),
              (c += n * C),
              (u += n * F),
              (h += n * P),
              (l += n * D),
              (d += n * j),
              (y += n * z),
              (p += n * $),
              (g += n * K),
              (w += n * V),
              (b += n * Z),
              (m += n * Y),
              (E += n * W),
              (v += n * G),
              (B += n * J),
              (f += (n = e[3]) * M),
              (c += n * q),
              (u += n * C),
              (h += n * F),
              (l += n * P),
              (d += n * D),
              (y += n * j),
              (p += n * z),
              (g += n * $),
              (w += n * K),
              (b += n * V),
              (m += n * Z),
              (E += n * Y),
              (v += n * W),
              (B += n * G),
              (x += n * J),
              (c += (n = e[4]) * M),
              (u += n * q),
              (h += n * C),
              (l += n * F),
              (d += n * P),
              (y += n * D),
              (p += n * j),
              (g += n * z),
              (w += n * $),
              (b += n * K),
              (m += n * V),
              (E += n * Z),
              (v += n * Y),
              (B += n * W),
              (x += n * G),
              (A += n * J),
              (u += (n = e[5]) * M),
              (h += n * q),
              (l += n * C),
              (d += n * F),
              (y += n * P),
              (p += n * D),
              (g += n * j),
              (w += n * z),
              (b += n * $),
              (m += n * K),
              (E += n * V),
              (v += n * Z),
              (B += n * Y),
              (x += n * W),
              (A += n * G),
              (S += n * J),
              (h += (n = e[6]) * M),
              (l += n * q),
              (d += n * C),
              (y += n * F),
              (p += n * P),
              (g += n * D),
              (w += n * j),
              (b += n * z),
              (m += n * $),
              (E += n * K),
              (v += n * V),
              (B += n * Z),
              (x += n * Y),
              (A += n * W),
              (S += n * G),
              (T += n * J),
              (l += (n = e[7]) * M),
              (d += n * q),
              (y += n * C),
              (p += n * F),
              (g += n * P),
              (w += n * D),
              (b += n * j),
              (m += n * z),
              (E += n * $),
              (v += n * K),
              (B += n * V),
              (x += n * Z),
              (A += n * Y),
              (S += n * W),
              (T += n * G),
              (U += n * J),
              (d += (n = e[8]) * M),
              (y += n * q),
              (p += n * C),
              (g += n * F),
              (w += n * P),
              (b += n * D),
              (m += n * j),
              (E += n * z),
              (v += n * $),
              (B += n * K),
              (x += n * V),
              (A += n * Z),
              (S += n * Y),
              (T += n * W),
              (U += n * G),
              (_ += n * J),
              (y += (n = e[9]) * M),
              (p += n * q),
              (g += n * C),
              (w += n * F),
              (b += n * P),
              (m += n * D),
              (E += n * j),
              (v += n * z),
              (B += n * $),
              (x += n * K),
              (A += n * V),
              (S += n * Z),
              (T += n * Y),
              (U += n * W),
              (_ += n * G),
              (O += n * J),
              (p += (n = e[10]) * M),
              (g += n * q),
              (w += n * C),
              (b += n * F),
              (m += n * P),
              (E += n * D),
              (v += n * j),
              (B += n * z),
              (x += n * $),
              (A += n * K),
              (S += n * V),
              (T += n * Z),
              (U += n * Y),
              (_ += n * W),
              (O += n * G),
              (I += n * J),
              (g += (n = e[11]) * M),
              (w += n * q),
              (b += n * C),
              (m += n * F),
              (E += n * P),
              (v += n * D),
              (B += n * j),
              (x += n * z),
              (A += n * $),
              (S += n * K),
              (T += n * V),
              (U += n * Z),
              (_ += n * Y),
              (O += n * W),
              (I += n * G),
              (L += n * J),
              (w += (n = e[12]) * M),
              (b += n * q),
              (m += n * C),
              (E += n * F),
              (v += n * P),
              (B += n * D),
              (x += n * j),
              (A += n * z),
              (S += n * $),
              (T += n * K),
              (U += n * V),
              (_ += n * Z),
              (O += n * Y),
              (I += n * W),
              (L += n * G),
              (N += n * J),
              (b += (n = e[13]) * M),
              (m += n * q),
              (E += n * C),
              (v += n * F),
              (B += n * P),
              (x += n * D),
              (A += n * j),
              (S += n * z),
              (T += n * $),
              (U += n * K),
              (_ += n * V),
              (O += n * Z),
              (I += n * Y),
              (L += n * W),
              (N += n * G),
              (R += n * J),
              (m += (n = e[14]) * M),
              (E += n * q),
              (v += n * C),
              (B += n * F),
              (x += n * P),
              (A += n * D),
              (S += n * j),
              (T += n * z),
              (U += n * $),
              (_ += n * K),
              (O += n * V),
              (I += n * Z),
              (L += n * Y),
              (N += n * W),
              (R += n * G),
              (k += n * J),
              (E += (n = e[15]) * M),
              (s += 38 * (B += n * C)),
              (a += 38 * (x += n * F)),
              (f += 38 * (A += n * P)),
              (c += 38 * (S += n * D)),
              (u += 38 * (T += n * j)),
              (h += 38 * (U += n * z)),
              (l += 38 * (_ += n * $)),
              (d += 38 * (O += n * K)),
              (y += 38 * (I += n * V)),
              (p += 38 * (L += n * Z)),
              (g += 38 * (N += n * Y)),
              (w += 38 * (R += n * W)),
              (b += 38 * (k += n * G)),
              (m += 38 * (H += n * J)),
              (i =
                (n = (i += 38 * (v += n * q)) + (o = 1) + 65535) -
                65536 * (o = Math.floor(n / 65536))),
              (s = (n = s + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (a = (n = a + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (f = (n = f + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (c = (n = c + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (u = (n = u + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (h = (n = h + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (l = (n = l + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (d = (n = d + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (y = (n = y + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (p = (n = p + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (g = (n = g + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (w = (n = w + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (b = (n = b + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (m = (n = m + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (E = (n = E + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (i =
                (n = (i += o - 1 + 37 * (o - 1)) + (o = 1) + 65535) -
                65536 * (o = Math.floor(n / 65536))),
              (s = (n = s + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (a = (n = a + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (f = (n = f + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (c = (n = c + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (u = (n = u + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (h = (n = h + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (l = (n = l + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (d = (n = d + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (y = (n = y + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (p = (n = p + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (g = (n = g + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (w = (n = w + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (b = (n = b + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (m = (n = m + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (E = (n = E + o + 65535) - 65536 * (o = Math.floor(n / 65536))),
              (i += o - 1 + 37 * (o - 1)),
              (t[0] = i),
              (t[1] = s),
              (t[2] = a),
              (t[3] = f),
              (t[4] = c),
              (t[5] = u),
              (t[6] = h),
              (t[7] = l),
              (t[8] = d),
              (t[9] = y),
              (t[10] = p),
              (t[11] = g),
              (t[12] = w),
              (t[13] = b),
              (t[14] = m),
              (t[15] = E);
          }
          function P(t, e) {
            F(t, e, e);
          }
          function D(t, r) {
            let n,
              o = e();
            for (n = 0; n < 16; n++) o[n] = r[n];
            for (n = 253; n >= 0; n--)
              P(o, o), 2 !== n && 4 !== n && F(o, o, r);
            for (n = 0; n < 16; n++) t[n] = o[n];
          }
          function j(t, r) {
            let n,
              o = e();
            for (n = 0; n < 16; n++) o[n] = r[n];
            for (n = 250; n >= 0; n--) P(o, o), 1 !== n && F(o, o, r);
            for (n = 0; n < 16; n++) t[n] = o[n];
          }
          function z(t, r, n) {
            let o,
              i,
              s = new Uint8Array(32),
              a = new Float64Array(80),
              c = e(),
              u = e(),
              h = e(),
              l = e(),
              d = e(),
              y = e();
            for (i = 0; i < 31; i++) s[i] = r[i];
            for (
              s[31] = (127 & r[31]) | 64, s[0] &= 248, M(a, n), i = 0;
              i < 16;
              i++
            )
              (u[i] = a[i]), (l[i] = c[i] = h[i] = 0);
            for (c[0] = l[0] = 1, i = 254; i >= 0; --i)
              N(c, u, (o = (s[i >>> 3] >>> (7 & i)) & 1)),
                N(h, l, o),
                q(d, c, h),
                C(c, c, h),
                q(h, u, l),
                C(u, u, l),
                P(l, d),
                P(y, c),
                F(c, h, c),
                F(h, u, d),
                q(d, c, h),
                C(c, c, h),
                P(u, c),
                C(h, l, y),
                F(c, h, f),
                q(c, c, l),
                F(h, h, c),
                F(c, l, y),
                F(l, u, a),
                P(u, d),
                N(c, u, o),
                N(h, l, o);
            for (i = 0; i < 16; i++)
              (a[i + 16] = c[i]),
                (a[i + 32] = h[i]),
                (a[i + 48] = u[i]),
                (a[i + 64] = l[i]);
            const p = a.subarray(32),
              g = a.subarray(16);
            return D(p, p), F(g, g, p), R(t, g), 0;
          }
          function $(t, e) {
            return z(t, e, i);
          }
          function K(t, e) {
            return n(e, 32), $(t, e);
          }
          function V(t, e, r) {
            const n = new Uint8Array(32);
            return z(n, r, e), m(t, o, n, E);
          }
          (S.prototype.blocks = function (t, e, r) {
            for (
              var n,
                o,
                i,
                s,
                a,
                f,
                c,
                u,
                h,
                l,
                d,
                y,
                p,
                g,
                w,
                b,
                m,
                E,
                v,
                B = this.fin ? 0 : 2048,
                x = this.h[0],
                A = this.h[1],
                S = this.h[2],
                T = this.h[3],
                U = this.h[4],
                _ = this.h[5],
                O = this.h[6],
                I = this.h[7],
                L = this.h[8],
                N = this.h[9],
                R = this.r[0],
                k = this.r[1],
                H = this.r[2],
                M = this.r[3],
                q = this.r[4],
                C = this.r[5],
                F = this.r[6],
                P = this.r[7],
                D = this.r[8],
                j = this.r[9];
              r >= 16;

            )
              (l = h = 0),
                (l +=
                  (x +=
                    8191 & (n = (255 & t[e + 0]) | ((255 & t[e + 1]) << 8))) *
                  R),
                (l +=
                  (A +=
                    8191 &
                    ((n >>> 13) |
                      ((o = (255 & t[e + 2]) | ((255 & t[e + 3]) << 8)) <<
                        3))) *
                  (5 * j)),
                (l +=
                  (S +=
                    8191 &
                    ((o >>> 10) |
                      ((i = (255 & t[e + 4]) | ((255 & t[e + 5]) << 8)) <<
                        6))) *
                  (5 * D)),
                (l +=
                  (T +=
                    8191 &
                    ((i >>> 7) |
                      ((s = (255 & t[e + 6]) | ((255 & t[e + 7]) << 8)) <<
                        9))) *
                  (5 * P)),
                (h =
                  (l +=
                    (U +=
                      8191 &
                      ((s >>> 4) |
                        ((a = (255 & t[e + 8]) | ((255 & t[e + 9]) << 8)) <<
                          12))) *
                    (5 * F)) >>> 13),
                (l &= 8191),
                (l += (_ += (a >>> 1) & 8191) * (5 * C)),
                (l +=
                  (O +=
                    8191 &
                    ((a >>> 14) |
                      ((f = (255 & t[e + 10]) | ((255 & t[e + 11]) << 8)) <<
                        2))) *
                  (5 * q)),
                (l +=
                  (I +=
                    8191 &
                    ((f >>> 11) |
                      ((c = (255 & t[e + 12]) | ((255 & t[e + 13]) << 8)) <<
                        5))) *
                  (5 * M)),
                (l +=
                  (L +=
                    8191 &
                    ((c >>> 8) |
                      ((u = (255 & t[e + 14]) | ((255 & t[e + 15]) << 8)) <<
                        8))) *
                  (5 * H)),
                (d = h += (l += (N += (u >>> 5) | B) * (5 * k)) >>> 13),
                (d += x * k),
                (d += A * R),
                (d += S * (5 * j)),
                (d += T * (5 * D)),
                (h = (d += U * (5 * P)) >>> 13),
                (d &= 8191),
                (d += _ * (5 * F)),
                (d += O * (5 * C)),
                (d += I * (5 * q)),
                (d += L * (5 * M)),
                (h += (d += N * (5 * H)) >>> 13),
                (d &= 8191),
                (y = h),
                (y += x * H),
                (y += A * k),
                (y += S * R),
                (y += T * (5 * j)),
                (h = (y += U * (5 * D)) >>> 13),
                (y &= 8191),
                (y += _ * (5 * P)),
                (y += O * (5 * F)),
                (y += I * (5 * C)),
                (y += L * (5 * q)),
                (p = h += (y += N * (5 * M)) >>> 13),
                (p += x * M),
                (p += A * H),
                (p += S * k),
                (p += T * R),
                (h = (p += U * (5 * j)) >>> 13),
                (p &= 8191),
                (p += _ * (5 * D)),
                (p += O * (5 * P)),
                (p += I * (5 * F)),
                (p += L * (5 * C)),
                (g = h += (p += N * (5 * q)) >>> 13),
                (g += x * q),
                (g += A * M),
                (g += S * H),
                (g += T * k),
                (h = (g += U * R) >>> 13),
                (g &= 8191),
                (g += _ * (5 * j)),
                (g += O * (5 * D)),
                (g += I * (5 * P)),
                (g += L * (5 * F)),
                (w = h += (g += N * (5 * C)) >>> 13),
                (w += x * C),
                (w += A * q),
                (w += S * M),
                (w += T * H),
                (h = (w += U * k) >>> 13),
                (w &= 8191),
                (w += _ * R),
                (w += O * (5 * j)),
                (w += I * (5 * D)),
                (w += L * (5 * P)),
                (b = h += (w += N * (5 * F)) >>> 13),
                (b += x * F),
                (b += A * C),
                (b += S * q),
                (b += T * M),
                (h = (b += U * H) >>> 13),
                (b &= 8191),
                (b += _ * k),
                (b += O * R),
                (b += I * (5 * j)),
                (b += L * (5 * D)),
                (m = h += (b += N * (5 * P)) >>> 13),
                (m += x * P),
                (m += A * F),
                (m += S * C),
                (m += T * q),
                (h = (m += U * M) >>> 13),
                (m &= 8191),
                (m += _ * H),
                (m += O * k),
                (m += I * R),
                (m += L * (5 * j)),
                (E = h += (m += N * (5 * D)) >>> 13),
                (E += x * D),
                (E += A * P),
                (E += S * F),
                (E += T * C),
                (h = (E += U * q) >>> 13),
                (E &= 8191),
                (E += _ * M),
                (E += O * H),
                (E += I * k),
                (E += L * R),
                (v = h += (E += N * (5 * j)) >>> 13),
                (v += x * j),
                (v += A * D),
                (v += S * P),
                (v += T * F),
                (h = (v += U * C) >>> 13),
                (v &= 8191),
                (v += _ * q),
                (v += O * M),
                (v += I * H),
                (v += L * k),
                (x = l =
                  8191 &
                  (h =
                    ((h = (((h += (v += N * R) >>> 13) << 2) + h) | 0) +
                      (l &= 8191)) |
                    0)),
                (A = d += h >>>= 13),
                (S = y &= 8191),
                (T = p &= 8191),
                (U = g &= 8191),
                (_ = w &= 8191),
                (O = b &= 8191),
                (I = m &= 8191),
                (L = E &= 8191),
                (N = v &= 8191),
                (e += 16),
                (r -= 16);
            (this.h[0] = x),
              (this.h[1] = A),
              (this.h[2] = S),
              (this.h[3] = T),
              (this.h[4] = U),
              (this.h[5] = _),
              (this.h[6] = O),
              (this.h[7] = I),
              (this.h[8] = L),
              (this.h[9] = N);
          }),
            (S.prototype.finish = function (t, e) {
              let r,
                n,
                o,
                i,
                s = new Uint16Array(10);
              if (this.leftover) {
                for (i = this.leftover, this.buffer[i++] = 1; i < 16; i++)
                  this.buffer[i] = 0;
                (this.fin = 1), this.blocks(this.buffer, 0, 16);
              }
              for (r = this.h[1] >>> 13, this.h[1] &= 8191, i = 2; i < 10; i++)
                (this.h[i] += r), (r = this.h[i] >>> 13), (this.h[i] &= 8191);
              for (
                this.h[0] += 5 * r,
                  r = this.h[0] >>> 13,
                  this.h[0] &= 8191,
                  this.h[1] += r,
                  r = this.h[1] >>> 13,
                  this.h[1] &= 8191,
                  this.h[2] += r,
                  s[0] = this.h[0] + 5,
                  r = s[0] >>> 13,
                  s[0] &= 8191,
                  i = 1;
                i < 10;
                i++
              )
                (s[i] = this.h[i] + r), (r = s[i] >>> 13), (s[i] &= 8191);
              for (s[9] -= 8192, n = (1 ^ r) - 1, i = 0; i < 10; i++) s[i] &= n;
              for (n = ~n, i = 0; i < 10; i++)
                this.h[i] = (this.h[i] & n) | s[i];
              for (
                this.h[0] = 65535 & (this.h[0] | (this.h[1] << 13)),
                  this.h[1] = 65535 & ((this.h[1] >>> 3) | (this.h[2] << 10)),
                  this.h[2] = 65535 & ((this.h[2] >>> 6) | (this.h[3] << 7)),
                  this.h[3] = 65535 & ((this.h[3] >>> 9) | (this.h[4] << 4)),
                  this.h[4] =
                    65535 &
                    ((this.h[4] >>> 12) | (this.h[5] << 1) | (this.h[6] << 14)),
                  this.h[5] = 65535 & ((this.h[6] >>> 2) | (this.h[7] << 11)),
                  this.h[6] = 65535 & ((this.h[7] >>> 5) | (this.h[8] << 8)),
                  this.h[7] = 65535 & ((this.h[8] >>> 8) | (this.h[9] << 5)),
                  o = this.h[0] + this.pad[0],
                  this.h[0] = 65535 & o,
                  i = 1;
                i < 8;
                i++
              )
                (o = (((this.h[i] + this.pad[i]) | 0) + (o >>> 16)) | 0),
                  (this.h[i] = 65535 & o);
              (t[e + 0] = (this.h[0] >>> 0) & 255),
                (t[e + 1] = (this.h[0] >>> 8) & 255),
                (t[e + 2] = (this.h[1] >>> 0) & 255),
                (t[e + 3] = (this.h[1] >>> 8) & 255),
                (t[e + 4] = (this.h[2] >>> 0) & 255),
                (t[e + 5] = (this.h[2] >>> 8) & 255),
                (t[e + 6] = (this.h[3] >>> 0) & 255),
                (t[e + 7] = (this.h[3] >>> 8) & 255),
                (t[e + 8] = (this.h[4] >>> 0) & 255),
                (t[e + 9] = (this.h[4] >>> 8) & 255),
                (t[e + 10] = (this.h[5] >>> 0) & 255),
                (t[e + 11] = (this.h[5] >>> 8) & 255),
                (t[e + 12] = (this.h[6] >>> 0) & 255),
                (t[e + 13] = (this.h[6] >>> 8) & 255),
                (t[e + 14] = (this.h[7] >>> 0) & 255),
                (t[e + 15] = (this.h[7] >>> 8) & 255);
            }),
            (S.prototype.update = function (t, e, r) {
              let n, o;
              if (this.leftover) {
                for ((o = 16 - this.leftover) > r && (o = r), n = 0; n < o; n++)
                  this.buffer[this.leftover + n] = t[e + n];
                if (
                  ((r -= o), (e += o), (this.leftover += o), this.leftover < 16)
                )
                  return;
                this.blocks(this.buffer, 0, 16), (this.leftover = 0);
              }
              if (
                (r >= 16 &&
                  ((o = r - (r % 16)),
                  this.blocks(t, e, o),
                  (e += o),
                  (r -= o)),
                r)
              ) {
                for (n = 0; n < r; n++)
                  this.buffer[this.leftover + n] = t[e + n];
                this.leftover += r;
              }
            });
          const Z = _,
            Y = O,
            W = [
              1116352408, 3609767458, 1899447441, 602891725, 3049323471,
              3964484399, 3921009573, 2173295548, 961987163, 4081628472,
              1508970993, 3053834265, 2453635748, 2937671579, 2870763221,
              3664609560, 3624381080, 2734883394, 310598401, 1164996542,
              607225278, 1323610764, 1426881987, 3590304994, 1925078388,
              4068182383, 2162078206, 991336113, 2614888103, 633803317,
              3248222580, 3479774868, 3835390401, 2666613458, 4022224774,
              944711139, 264347078, 2341262773, 604807628, 2007800933,
              770255983, 1495990901, 1249150122, 1856431235, 1555081692,
              3175218132, 1996064986, 2198950837, 2554220882, 3999719339,
              2821834349, 766784016, 2952996808, 2566594879, 3210313671,
              3203337956, 3336571891, 1034457026, 3584528711, 2466948901,
              113926993, 3758326383, 338241895, 168717936, 666307205,
              1188179964, 773529912, 1546045734, 1294757372, 1522805485,
              1396182291, 2643833823, 1695183700, 2343527390, 1986661051,
              1014477480, 2177026350, 1206759142, 2456956037, 344077627,
              2730485921, 1290863460, 2820302411, 3158454273, 3259730800,
              3505952657, 3345764771, 106217008, 3516065817, 3606008344,
              3600352804, 1432725776, 4094571909, 1467031594, 275423344,
              851169720, 430227734, 3100823752, 506948616, 1363258195,
              659060556, 3750685593, 883997877, 3785050280, 958139571,
              3318307427, 1322822218, 3812723403, 1537002063, 2003034995,
              1747873779, 3602036899, 1955562222, 1575990012, 2024104815,
              1125592928, 2227730452, 2716904306, 2361852424, 442776044,
              2428436474, 593698344, 2756734187, 3733110249, 3204031479,
              2999351573, 3329325298, 3815920427, 3391569614, 3928383900,
              3515267271, 566280711, 3940187606, 3454069534, 4118630271,
              4000239992, 116418474, 1914138554, 174292421, 2731055270,
              289380356, 3203993006, 460393269, 320620315, 685471733, 587496836,
              852142971, 1086792851, 1017036298, 365543100, 1126000580,
              2618297676, 1288033470, 3409855158, 1501505948, 4234509866,
              1607167915, 987167468, 1816402316, 1246189591,
            ];
          function G(t, e, r, n) {
            for (
              var o,
                i,
                s,
                a,
                f,
                c,
                u,
                h,
                l,
                d,
                y,
                p,
                g,
                w,
                b,
                m,
                E,
                v,
                B,
                x,
                A,
                S,
                T,
                U,
                _,
                O,
                I = new Int32Array(16),
                L = new Int32Array(16),
                N = t[0],
                R = t[1],
                k = t[2],
                H = t[3],
                M = t[4],
                q = t[5],
                C = t[6],
                F = t[7],
                P = e[0],
                D = e[1],
                j = e[2],
                z = e[3],
                $ = e[4],
                K = e[5],
                V = e[6],
                Z = e[7],
                Y = 0;
              n >= 128;

            ) {
              for (B = 0; B < 16; B++)
                (x = 8 * B + Y),
                  (I[B] =
                    (r[x + 0] << 24) |
                    (r[x + 1] << 16) |
                    (r[x + 2] << 8) |
                    r[x + 3]),
                  (L[B] =
                    (r[x + 4] << 24) |
                    (r[x + 5] << 16) |
                    (r[x + 6] << 8) |
                    r[x + 7]);
              for (B = 0; B < 80; B++)
                if (
                  ((o = N),
                  (i = R),
                  (s = k),
                  (a = H),
                  (f = M),
                  (c = q),
                  (u = C),
                  (l = P),
                  (d = D),
                  (y = j),
                  (p = z),
                  (g = $),
                  (w = K),
                  (b = V),
                  (T = 65535 & (S = Z)),
                  (U = S >>> 16),
                  (_ = 65535 & (A = F)),
                  (O = A >>> 16),
                  (T +=
                    65535 &
                    (S =
                      (($ >>> 14) | (M << 18)) ^
                      (($ >>> 18) | (M << 14)) ^
                      ((M >>> 9) | ($ << 23)))),
                  (U += S >>> 16),
                  (_ +=
                    65535 &
                    (A =
                      ((M >>> 14) | ($ << 18)) ^
                      ((M >>> 18) | ($ << 14)) ^
                      (($ >>> 9) | (M << 23)))),
                  (O += A >>> 16),
                  (T += 65535 & (S = ($ & K) ^ (~$ & V))),
                  (U += S >>> 16),
                  (_ += 65535 & (A = (M & q) ^ (~M & C))),
                  (O += A >>> 16),
                  (A = W[2 * B]),
                  (T += 65535 & (S = W[2 * B + 1])),
                  (U += S >>> 16),
                  (_ += 65535 & A),
                  (O += A >>> 16),
                  (A = I[B % 16]),
                  (U += (S = L[B % 16]) >>> 16),
                  (_ += 65535 & A),
                  (O += A >>> 16),
                  (_ += (U += (T += 65535 & S) >>> 16) >>> 16),
                  (T = 65535 & (S = v = (65535 & T) | (U << 16))),
                  (U = S >>> 16),
                  (_ = 65535 & (A = E = (65535 & _) | ((O += _ >>> 16) << 16))),
                  (O = A >>> 16),
                  (T +=
                    65535 &
                    (S =
                      ((P >>> 28) | (N << 4)) ^
                      ((N >>> 2) | (P << 30)) ^
                      ((N >>> 7) | (P << 25)))),
                  (U += S >>> 16),
                  (_ +=
                    65535 &
                    (A =
                      ((N >>> 28) | (P << 4)) ^
                      ((P >>> 2) | (N << 30)) ^
                      ((P >>> 7) | (N << 25)))),
                  (O += A >>> 16),
                  (U += (S = (P & D) ^ (P & j) ^ (D & j)) >>> 16),
                  (_ += 65535 & (A = (N & R) ^ (N & k) ^ (R & k))),
                  (O += A >>> 16),
                  (h =
                    (65535 & (_ += (U += (T += 65535 & S) >>> 16) >>> 16)) |
                    ((O += _ >>> 16) << 16)),
                  (m = (65535 & T) | (U << 16)),
                  (T = 65535 & (S = p)),
                  (U = S >>> 16),
                  (_ = 65535 & (A = a)),
                  (O = A >>> 16),
                  (U += (S = v) >>> 16),
                  (_ += 65535 & (A = E)),
                  (O += A >>> 16),
                  (R = o),
                  (k = i),
                  (H = s),
                  (M = a =
                    (65535 & (_ += (U += (T += 65535 & S) >>> 16) >>> 16)) |
                    ((O += _ >>> 16) << 16)),
                  (q = f),
                  (C = c),
                  (F = u),
                  (N = h),
                  (D = l),
                  (j = d),
                  (z = y),
                  ($ = p = (65535 & T) | (U << 16)),
                  (K = g),
                  (V = w),
                  (Z = b),
                  (P = m),
                  B % 16 == 15)
                )
                  for (x = 0; x < 16; x++)
                    (A = I[x]),
                      (T = 65535 & (S = L[x])),
                      (U = S >>> 16),
                      (_ = 65535 & A),
                      (O = A >>> 16),
                      (A = I[(x + 9) % 16]),
                      (T += 65535 & (S = L[(x + 9) % 16])),
                      (U += S >>> 16),
                      (_ += 65535 & A),
                      (O += A >>> 16),
                      (E = I[(x + 1) % 16]),
                      (T +=
                        65535 &
                        (S =
                          (((v = L[(x + 1) % 16]) >>> 1) | (E << 31)) ^
                          ((v >>> 8) | (E << 24)) ^
                          ((v >>> 7) | (E << 25)))),
                      (U += S >>> 16),
                      (_ +=
                        65535 &
                        (A =
                          ((E >>> 1) | (v << 31)) ^
                          ((E >>> 8) | (v << 24)) ^
                          (E >>> 7))),
                      (O += A >>> 16),
                      (E = I[(x + 14) % 16]),
                      (U +=
                        (S =
                          (((v = L[(x + 14) % 16]) >>> 19) | (E << 13)) ^
                          ((E >>> 29) | (v << 3)) ^
                          ((v >>> 6) | (E << 26))) >>> 16),
                      (_ +=
                        65535 &
                        (A =
                          ((E >>> 19) | (v << 13)) ^
                          ((v >>> 29) | (E << 3)) ^
                          (E >>> 6))),
                      (O += A >>> 16),
                      (O +=
                        (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                      (I[x] = (65535 & _) | (O << 16)),
                      (L[x] = (65535 & T) | (U << 16));
              (T = 65535 & (S = P)),
                (U = S >>> 16),
                (_ = 65535 & (A = N)),
                (O = A >>> 16),
                (A = t[0]),
                (U += (S = e[0]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[0] = N = (65535 & _) | (O << 16)),
                (e[0] = P = (65535 & T) | (U << 16)),
                (T = 65535 & (S = D)),
                (U = S >>> 16),
                (_ = 65535 & (A = R)),
                (O = A >>> 16),
                (A = t[1]),
                (U += (S = e[1]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[1] = R = (65535 & _) | (O << 16)),
                (e[1] = D = (65535 & T) | (U << 16)),
                (T = 65535 & (S = j)),
                (U = S >>> 16),
                (_ = 65535 & (A = k)),
                (O = A >>> 16),
                (A = t[2]),
                (U += (S = e[2]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[2] = k = (65535 & _) | (O << 16)),
                (e[2] = j = (65535 & T) | (U << 16)),
                (T = 65535 & (S = z)),
                (U = S >>> 16),
                (_ = 65535 & (A = H)),
                (O = A >>> 16),
                (A = t[3]),
                (U += (S = e[3]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[3] = H = (65535 & _) | (O << 16)),
                (e[3] = z = (65535 & T) | (U << 16)),
                (T = 65535 & (S = $)),
                (U = S >>> 16),
                (_ = 65535 & (A = M)),
                (O = A >>> 16),
                (A = t[4]),
                (U += (S = e[4]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[4] = M = (65535 & _) | (O << 16)),
                (e[4] = $ = (65535 & T) | (U << 16)),
                (T = 65535 & (S = K)),
                (U = S >>> 16),
                (_ = 65535 & (A = q)),
                (O = A >>> 16),
                (A = t[5]),
                (U += (S = e[5]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[5] = q = (65535 & _) | (O << 16)),
                (e[5] = K = (65535 & T) | (U << 16)),
                (T = 65535 & (S = V)),
                (U = S >>> 16),
                (_ = 65535 & (A = C)),
                (O = A >>> 16),
                (A = t[6]),
                (U += (S = e[6]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[6] = C = (65535 & _) | (O << 16)),
                (e[6] = V = (65535 & T) | (U << 16)),
                (T = 65535 & (S = Z)),
                (U = S >>> 16),
                (_ = 65535 & (A = F)),
                (O = A >>> 16),
                (A = t[7]),
                (U += (S = e[7]) >>> 16),
                (_ += 65535 & A),
                (O += A >>> 16),
                (O += (_ += (U += (T += 65535 & S) >>> 16) >>> 16) >>> 16),
                (t[7] = F = (65535 & _) | (O << 16)),
                (e[7] = Z = (65535 & T) | (U << 16)),
                (Y += 128),
                (n -= 128);
            }
            return n;
          }
          function J(t, e, r) {
            let n,
              o = new Int32Array(8),
              i = new Int32Array(8),
              s = new Uint8Array(256),
              a = r;
            for (
              o[0] = 1779033703,
                o[1] = 3144134277,
                o[2] = 1013904242,
                o[3] = 2773480762,
                o[4] = 1359893119,
                o[5] = 2600822924,
                o[6] = 528734635,
                o[7] = 1541459225,
                i[0] = 4089235720,
                i[1] = 2227873595,
                i[2] = 4271175723,
                i[3] = 1595750129,
                i[4] = 2917565137,
                i[5] = 725511199,
                i[6] = 4215389547,
                i[7] = 327033209,
                G(o, i, e, r),
                r %= 128,
                n = 0;
              n < r;
              n++
            )
              s[n] = e[a - r + n];
            for (
              s[r] = 128,
                s[(r = 256 - 128 * (r < 112 ? 1 : 0)) - 9] = 0,
                y(s, r - 8, (a / 536870912) | 0, a << 3),
                G(o, i, s, r),
                n = 0;
              n < 8;
              n++
            )
              y(t, 8 * n, o[n], i[n]);
            return 0;
          }
          function X(t, r) {
            const n = e(),
              o = e(),
              i = e(),
              s = e(),
              a = e(),
              f = e(),
              c = e(),
              h = e(),
              l = e();
            C(n, t[1], t[0]),
              C(l, r[1], r[0]),
              F(n, n, l),
              q(o, t[0], t[1]),
              q(l, r[0], r[1]),
              F(o, o, l),
              F(i, t[3], r[3]),
              F(i, i, u),
              F(s, t[2], r[2]),
              q(s, s, s),
              C(a, o, n),
              C(f, s, i),
              q(c, s, i),
              q(h, o, n),
              F(t[0], a, f),
              F(t[1], h, c),
              F(t[2], c, f),
              F(t[3], a, h);
          }
          function Q(t, e, r) {
            let n;
            for (n = 0; n < 4; n++) N(t[n], e[n], r);
          }
          function tt(t, r) {
            const n = e(),
              o = e(),
              i = e();
            D(i, r[2]),
              F(n, r[0], i),
              F(o, r[1], i),
              R(t, o),
              (t[31] ^= H(n) << 7);
          }
          function et(t, e, r) {
            let n, o;
            for (
              I(t[0], s), I(t[1], a), I(t[2], a), I(t[3], s), o = 255;
              o >= 0;
              --o
            )
              Q(t, e, (n = (r[(o / 8) | 0] >> (7 & o)) & 1)),
                X(e, t),
                X(t, t),
                Q(t, e, n);
          }
          function rt(t, r) {
            const n = [e(), e(), e(), e()];
            I(n[0], h), I(n[1], l), I(n[2], a), F(n[3], h, l), et(t, n, r);
          }
          function nt(t, r, o) {
            let i,
              s = new Uint8Array(64),
              a = [e(), e(), e(), e()];
            for (
              o || n(r, 32),
                J(s, r, 32),
                s[0] &= 248,
                s[31] &= 127,
                s[31] |= 64,
                rt(a, s),
                tt(t, a),
                i = 0;
              i < 32;
              i++
            )
              r[i + 32] = t[i];
            return 0;
          }
          const ot = new Float64Array([
            237, 211, 245, 92, 26, 99, 18, 88, 214, 156, 247, 162, 222, 249,
            222, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16,
          ]);
          function it(t, e) {
            let r, n, o, i;
            for (n = 63; n >= 32; --n) {
              for (r = 0, o = n - 32, i = n - 12; o < i; ++o)
                (e[o] += r - 16 * e[n] * ot[o - (n - 32)]),
                  (r = Math.floor((e[o] + 128) / 256)),
                  (e[o] -= 256 * r);
              (e[o] += r), (e[n] = 0);
            }
            for (r = 0, o = 0; o < 32; o++)
              (e[o] += r - (e[31] >> 4) * ot[o]),
                (r = e[o] >> 8),
                (e[o] &= 255);
            for (o = 0; o < 32; o++) e[o] -= r * ot[o];
            for (n = 0; n < 32; n++)
              (e[n + 1] += e[n] >> 8), (t[n] = 255 & e[n]);
          }
          function st(t) {
            let e,
              r = new Float64Array(64);
            for (e = 0; e < 64; e++) r[e] = t[e];
            for (e = 0; e < 64; e++) t[e] = 0;
            it(t, r);
          }
          function at(t, r, n, o) {
            let i,
              s,
              a = new Uint8Array(64),
              f = new Uint8Array(64),
              c = new Uint8Array(64),
              u = new Float64Array(64),
              h = [e(), e(), e(), e()];
            J(a, o, 32), (a[0] &= 248), (a[31] &= 127), (a[31] |= 64);
            const l = n + 64;
            for (i = 0; i < n; i++) t[64 + i] = r[i];
            for (i = 0; i < 32; i++) t[32 + i] = a[32 + i];
            for (
              J(c, t.subarray(32), n + 32), st(c), rt(h, c), tt(t, h), i = 32;
              i < 64;
              i++
            )
              t[i] = o[i];
            for (J(f, t, n + 64), st(f), i = 0; i < 64; i++) u[i] = 0;
            for (i = 0; i < 32; i++) u[i] = c[i];
            for (i = 0; i < 32; i++)
              for (s = 0; s < 32; s++) u[i + s] += f[i] * a[s];
            return it(t.subarray(32), u), l;
          }
          function ft(t, r, n, o) {
            let i,
              f = new Uint8Array(32),
              u = new Uint8Array(64),
              h = [e(), e(), e(), e()],
              l = [e(), e(), e(), e()];
            if (n < 64) return -1;
            if (
              (function (t, r) {
                const n = e(),
                  o = e(),
                  i = e(),
                  f = e(),
                  u = e(),
                  h = e(),
                  l = e();
                return (
                  I(t[2], a),
                  M(t[1], r),
                  P(i, t[1]),
                  F(f, i, c),
                  C(i, i, t[2]),
                  q(f, t[2], f),
                  P(u, f),
                  P(h, u),
                  F(l, h, u),
                  F(n, l, i),
                  F(n, n, f),
                  j(n, n),
                  F(n, n, i),
                  F(n, n, f),
                  F(n, n, f),
                  F(t[0], n, f),
                  P(o, t[0]),
                  F(o, o, f),
                  k(o, i) && F(t[0], t[0], d),
                  P(o, t[0]),
                  F(o, o, f),
                  k(o, i)
                    ? -1
                    : (H(t[0]) === r[31] >> 7 && C(t[0], s, t[0]),
                      F(t[3], t[0], t[1]),
                      0)
                );
              })(l, o)
            )
              return -1;
            for (i = 0; i < n; i++) t[i] = r[i];
            for (i = 0; i < 32; i++) t[i + 32] = o[i];
            if (
              (J(u, t, n),
              st(u),
              et(h, l, u),
              rt(l, r.subarray(32)),
              X(h, l),
              tt(f, h),
              (n -= 64),
              w(r, 0, f, 0))
            ) {
              for (i = 0; i < n; i++) t[i] = 0;
              return -1;
            }
            for (i = 0; i < n; i++) t[i] = r[i + 64];
            return n;
          }
          let ct,
            ut = 64,
            ht = 32,
            lt = 64;
          function dt(t, e) {
            if (32 !== t.length) throw new Error("bad key size");
            if (24 !== e.length) throw new Error("bad nonce size");
          }
          function yt() {
            for (let t = 0; t < arguments.length; t++)
              if (!(arguments[t] instanceof Uint8Array))
                throw new TypeError("unexpected type, use Uint8Array");
          }
          function pt(t) {
            for (let e = 0; e < t.length; e++) t[e] = 0;
          }
          (t.lowlevel = {
            crypto_core_hsalsa20: m,
            crypto_stream_xor: A,
            crypto_stream: x,
            crypto_stream_salsa20_xor: v,
            crypto_stream_salsa20: B,
            crypto_onetimeauth: T,
            crypto_onetimeauth_verify: U,
            crypto_verify_16: g,
            crypto_verify_32: w,
            crypto_secretbox: _,
            crypto_secretbox_open: O,
            crypto_scalarmult: z,
            crypto_scalarmult_base: $,
            crypto_box_beforenm: V,
            crypto_box_afternm: Z,
            crypto_box: function (t, e, r, n, o, i) {
              const s = new Uint8Array(32);
              return V(s, o, i), Z(t, e, r, n, s);
            },
            crypto_box_open: function (t, e, r, n, o, i) {
              const s = new Uint8Array(32);
              return V(s, o, i), Y(t, e, r, n, s);
            },
            crypto_box_keypair: K,
            crypto_hash: J,
            crypto_sign: at,
            crypto_sign_keypair: nt,
            crypto_sign_open: ft,
            crypto_secretbox_KEYBYTES: 32,
            crypto_secretbox_NONCEBYTES: 24,
            crypto_secretbox_ZEROBYTES: 32,
            crypto_secretbox_BOXZEROBYTES: 16,
            crypto_scalarmult_BYTES: 32,
            crypto_scalarmult_SCALARBYTES: 32,
            crypto_box_PUBLICKEYBYTES: 32,
            crypto_box_SECRETKEYBYTES: 32,
            crypto_box_BEFORENMBYTES: 32,
            crypto_box_NONCEBYTES: 24,
            crypto_box_ZEROBYTES: 32,
            crypto_box_BOXZEROBYTES: 16,
            crypto_sign_BYTES: ut,
            crypto_sign_PUBLICKEYBYTES: ht,
            crypto_sign_SECRETKEYBYTES: lt,
            crypto_sign_SEEDBYTES: 32,
            crypto_hash_BYTES: 64,
            gf: e,
            D: c,
            L: ot,
            pack25519: R,
            unpack25519: M,
            M: F,
            A: q,
            S: P,
            Z: C,
            pow2523: j,
            add: X,
            set25519: I,
            modL: it,
            scalarmult: et,
            scalarbase: rt,
          }),
            (t.randomBytes = function (t) {
              const e = new Uint8Array(t);
              return n(e, t), e;
            }),
            (t.secretbox = function (t, e, r) {
              yt(t, e, r), dt(r, e);
              for (
                var n = new Uint8Array(32 + t.length),
                  o = new Uint8Array(n.length),
                  i = 0;
                i < t.length;
                i++
              )
                n[i + 32] = t[i];
              return _(o, n, n.length, e, r), o.subarray(16);
            }),
            (t.secretbox.open = function (t, e, r) {
              yt(t, e, r), dt(r, e);
              for (
                var n = new Uint8Array(16 + t.length),
                  o = new Uint8Array(n.length),
                  i = 0;
                i < t.length;
                i++
              )
                n[i + 16] = t[i];
              return n.length < 32 || 0 !== O(o, n, n.length, e, r)
                ? null
                : o.subarray(32);
            }),
            (t.secretbox.keyLength = 32),
            (t.secretbox.nonceLength = 24),
            (t.secretbox.overheadLength = 16),
            (t.scalarMult = function (t, e) {
              if ((yt(t, e), 32 !== t.length)) throw new Error("bad n size");
              if (32 !== e.length) throw new Error("bad p size");
              const r = new Uint8Array(32);
              return z(r, t, e), r;
            }),
            (t.scalarMult.base = function (t) {
              if ((yt(t), 32 !== t.length)) throw new Error("bad n size");
              const e = new Uint8Array(32);
              return $(e, t), e;
            }),
            (t.scalarMult.scalarLength = 32),
            (t.scalarMult.groupElementLength = 32),
            (t.box = function (e, r, n, o) {
              const i = t.box.before(n, o);
              return t.secretbox(e, r, i);
            }),
            (t.box.before = function (t, e) {
              yt(t, e),
                (function (t, e) {
                  if (32 !== t.length) throw new Error("bad public key size");
                  if (32 !== e.length) throw new Error("bad secret key size");
                })(t, e);
              const r = new Uint8Array(32);
              return V(r, t, e), r;
            }),
            (t.box.after = t.secretbox),
            (t.box.open = function (e, r, n, o) {
              const i = t.box.before(n, o);
              return t.secretbox.open(e, r, i);
            }),
            (t.box.open.after = t.secretbox.open),
            (t.box.keyPair = function () {
              const t = new Uint8Array(32),
                e = new Uint8Array(32);
              return K(t, e), { publicKey: t, secretKey: e };
            }),
            (t.box.keyPair.fromSecretKey = function (t) {
              if ((yt(t), 32 !== t.length))
                throw new Error("bad secret key size");
              const e = new Uint8Array(32);
              return $(e, t), { publicKey: e, secretKey: new Uint8Array(t) };
            }),
            (t.box.publicKeyLength = 32),
            (t.box.secretKeyLength = 32),
            (t.box.sharedKeyLength = 32),
            (t.box.nonceLength = 24),
            (t.box.overheadLength = t.secretbox.overheadLength),
            (t.sign = function (t, e) {
              if ((yt(t, e), e.length !== lt))
                throw new Error("bad secret key size");
              const r = new Uint8Array(ut + t.length);
              return at(r, t, t.length, e), r;
            }),
            (t.sign.open = function (t, e) {
              if ((yt(t, e), e.length !== ht))
                throw new Error("bad public key size");
              const r = new Uint8Array(t.length),
                n = ft(r, t, t.length, e);
              if (n < 0) return null;
              for (var o = new Uint8Array(n), i = 0; i < o.length; i++)
                o[i] = r[i];
              return o;
            }),
            (t.sign.detached = function (e, r) {
              for (
                var n = t.sign(e, r), o = new Uint8Array(ut), i = 0;
                i < o.length;
                i++
              )
                o[i] = n[i];
              return o;
            }),
            (t.sign.detached.verify = function (t, e, r) {
              if ((yt(t, e, r), e.length !== ut))
                throw new Error("bad signature size");
              if (r.length !== ht) throw new Error("bad public key size");
              let n,
                o = new Uint8Array(ut + t.length),
                i = new Uint8Array(ut + t.length);
              for (n = 0; n < ut; n++) o[n] = e[n];
              for (n = 0; n < t.length; n++) o[n + ut] = t[n];
              return ft(i, o, o.length, r) >= 0;
            }),
            (t.sign.keyPair = function () {
              const t = new Uint8Array(ht),
                e = new Uint8Array(lt);
              return nt(t, e), { publicKey: t, secretKey: e };
            }),
            (t.sign.keyPair.fromSecretKey = function (t) {
              if ((yt(t), t.length !== lt))
                throw new Error("bad secret key size");
              for (var e = new Uint8Array(ht), r = 0; r < e.length; r++)
                e[r] = t[32 + r];
              return { publicKey: e, secretKey: new Uint8Array(t) };
            }),
            (t.sign.keyPair.fromSeed = function (t) {
              if ((yt(t), 32 !== t.length)) throw new Error("bad seed size");
              for (
                var e = new Uint8Array(ht), r = new Uint8Array(lt), n = 0;
                n < 32;
                n++
              )
                r[n] = t[n];
              return nt(e, r, !0), { publicKey: e, secretKey: r };
            }),
            (t.sign.publicKeyLength = ht),
            (t.sign.secretKeyLength = lt),
            (t.sign.seedLength = 32),
            (t.sign.signatureLength = ut),
            (t.hash = function (t) {
              yt(t);
              const e = new Uint8Array(64);
              return J(e, t, t.length), e;
            }),
            (t.hash.hashLength = 64),
            (t.verify = function (t, e) {
              return (
                yt(t, e),
                0 !== t.length &&
                  0 !== e.length &&
                  t.length === e.length &&
                  0 === p(t, 0, e, 0, t.length)
              );
            }),
            (t.setPRNG = function (t) {
              n = t;
            }),
            (ct =
              "undefined" != typeof self
                ? self.crypto || self.msCrypto
                : null) && ct.getRandomValues
              ? t.setPRNG(function (t, e) {
                  let r,
                    n = new Uint8Array(e);
                  for (r = 0; r < e; r += 65536)
                    ct.getRandomValues(
                      n.subarray(r, r + Math.min(e - r, 65536)),
                    );
                  for (r = 0; r < e; r++) t[r] = n[r];
                  pt(n);
                })
              : (ct = r(24)) &&
                ct.randomBytes &&
                t.setPRNG(function (t, e) {
                  let r,
                    n = ct.randomBytes(e);
                  for (r = 0; r < e; r++) t[r] = n[r];
                  pt(n);
                });
        })(t.exports ? t.exports : (self.nacl = self.nacl || {}));
      },
      67: (t, e, r) => {
        const n = r(780),
          o = r(885),
          i = r(497),
          s = r(61),
          a = {
            toString: function (t, e = "utf8") {
              switch (e) {
                case "utf8":
                  return (function (t) {
                    return new TextDecoder().decode(t);
                  })(t);
                case "base16":
                  return (function (t) {
                    return Array.from(t)
                      .map((t) => t.toString(16).padStart(2, "0"))
                      .join("");
                  })(t);
                case "base64url":
                  return (function (t) {
                    return Buffer.from(t)
                      .toString("base64")
                      .replace(/\+/g, "-")
                      .replace(/\//g, "_")
                      .replace(/=+$/, "");
                  })(t);
                default:
                  throw new Error(`Unsupported encoding "${e}"`);
              }
            },
            fromString: function (t, e = "utf8") {
              if ("utf8" === e) return new TextEncoder().encode(t);
              if ("base16" === e) {
                if (t.length % 2 != 0)
                  throw new Error("Invalid hex string length.");
                const e = new Uint8Array(t.length / 2);
                for (let r = 0; r < t.length; r += 2)
                  e[r / 2] = parseInt(t.substring(r, r + 2), 16);
                return e;
              }
              if ("base64url" === e) {
                for (
                  t = t.replace(/-/g, "+").replace(/_/g, "/");
                  t.length % 4;

                )
                  t += "=";
                return new Uint8Array(Buffer.from(t, "base64"));
              }
              throw new Error(`Unsupported encoding "${e}"`);
            },
          };
        async function f(t) {
          const e = t.did,
            r = t.keys[0].privateKeyHex,
            n = await (async function (t) {
              const e = await (function (t, e = !1) {
                const r = t;
                if (32 !== r.length)
                  throw new Error(
                    `bad_key: Invalid private key format. Expecting 32 bytes, but got ${r.length}`,
                  );
                return async function (t) {
                  const n = i.secp256k1.sign(
                    (function (t) {
                      const e = "string" == typeof t ? a.fromString(t) : t;
                      return s.sha256(e);
                    })(t),
                    r,
                  );
                  return (
                    console.log(n),
                    l(
                      {
                        r: h(n.r.toString(16)),
                        s: h(n.s.toString(16)),
                        recoveryParam: n.recovery,
                      },
                      e,
                    )
                  );
                };
              })(
                (function (t, e) {
                  let r = t.startsWith("0x") ? t.substring(2) : t;
                  return (
                    r.length % 2 != 0 && (r = `0${r}`),
                    a.fromString(r.toLowerCase(), "base16")
                  );
                })(t),
                !0,
              );
              return async (t) => p(await e(t));
            })(r),
            o = Math.floor(Date.now() / 1e3),
            f = { exp: o + 60, iat: o, iss: e },
            d = await (async function (t, e, r = {}) {
              const {
                issuer: n,
                signer: o,
                alg: i,
                expiresIn: s,
                canonicalize: a,
              } = e;
              if (!o)
                throw new Error(
                  "missing_signer: No Signer functionality has been configured",
                );
              if (!n)
                throw new Error(
                  "missing_issuer: No issuing DID has been configured",
                );
              r.typ || (r.typ = "JWT"), r.alg || (r.alg = i);
              const f = { iat: Math.floor(Date.now() / 1e3), exp: void 0 };
              if (s) {
                if ("number" != typeof s)
                  throw new Error(
                    "invalid_argument: JWT expiresIn is not a number",
                  );
                f.exp = (t.nbf || f.iat) + Math.floor(s);
              }
              return (async function (t, e, r = {}, n = {}) {
                r.alg || (r.alg = c);
                const o = "string" == typeof t ? t : u(t, n.canonicalize),
                  i = [u(r, n.canonicalize), o].join("."),
                  s =
                    (!1,
                    async function (t, e) {
                      const r = await e(t);
                      return "object" == typeof (n = r) && "r" in n && "s" in n
                        ? l(r, false)
                        : r;
                      let n;
                    });
                return [i, await s(i, e)].join(".");
              })({ ...f, ...t, iss: n }, o, r, { canonicalize: a });
            })(f, { alg: void 0, issuer: e, signer: n });
          return d;
        }
        const c = "ES256K";
        function u(t, e = !1) {
          return (
            (r = e
              ? (function (t) {
                  if ("number" == typeof t && isNaN(t))
                    throw new Error("NaN is not allowed");
                  if ("number" == typeof t && !isFinite(t))
                    throw new Error("Infinity is not allowed");
                  return null === t || "object" != typeof t
                    ? JSON.stringify(t)
                    : t.toJSON instanceof Function
                    ? serialize(t.toJSON())
                    : Array.isArray(t)
                    ? `[${t.reduce(
                        (t, e, r) =>
                          `${t}${0 === r ? "" : ","}${serialize(
                            void 0 === e || "symbol" == typeof e ? null : e,
                          )}`,
                        "",
                      )}]`
                    : `{${Object.keys(t)
                        .sort()
                        .reduce(
                          (e, r) =>
                            void 0 === t[r] || "symbol" == typeof t[r]
                              ? e
                              : `${e}${0 === e.length ? "" : ","}${serialize(
                                  r,
                                )}:${serialize(t[r])}`,
                          "",
                        )}}`;
                })(t)
              : JSON.stringify(t)),
            d(a.fromString(r))
          );
          let r;
        }
        function h(t, e = 64) {
          return t.length === e ? t : "0".repeat(e - t.length) + t;
        }
        function l(t, e) {
          const { r, s: n, recoveryParam: o } = t,
            i = new Uint8Array(e ? 65 : 64);
          if (
            (i.set(a.fromString(r, "base16"), 0),
            i.set(a.fromString(n, "base16"), 32),
            e)
          ) {
            if (void 0 === o)
              throw new Error("Signer did not return a recoveryParam");
            i[64] = o;
          }
          return d(i);
        }
        function d(t) {
          return a.toString(t, "base64url");
        }
        function y(t) {
          return a.toString(t, "base16");
        }
        function p(t) {
          const e = (function (t) {
            const e = t
              .replace(/\+/g, "-")
              .replace(/\//g, "_")
              .replace(/=/g, "");
            return a.fromString(e, "base64url");
          })(t);
          if (e.length < 64 || e.length > 65)
            throw new TypeError(
              `Wrong size for signature. Expected 64 or 65 bytes, but got ${e.length}`,
            );
          return {
            r: y(e.slice(0, 32)),
            s: y(e.slice(32, 64)),
            recoveryParam: 65 === e.length ? e[64] : void 0,
          };
        }
        t.exports = {
          getNotificationCount: async function () {
            const t = localStorage.getItem("secret"),
              e = o.decodeBase64(t),
              r = (
                await (async function (t) {
                  return new Promise((t, e) => {
                    const r = indexedDB.open("TimeSafari");
                    (r.onupgradeneeded = (t) => {
                      const e = t.target.result;
                      e.objectStoreNames.contains("settings") ||
                        e.createObjectStore("settings", { keyPath: "id" });
                    }),
                      (r.onsuccess = (r) => {
                        const n = r.target.result
                          .transaction("settings", "readonly")
                          .objectStore("settings")
                          .get(1);
                        (n.onsuccess = () => t(n.result)),
                          (n.onerror = () => e(n.error));
                      }),
                      (r.onerror = () => e(r.error));
                  });
                })()
              ).activeDid,
              i = await (async function () {
                try {
                  const t = await new Promise((t, e) => {
                    const r = indexedDB.open("TimeSafariAccounts");
                    (r.onupgradeneeded = (t) => {
                      const e = t.target.result;
                      e.objectStoreNames.contains("accounts") ||
                        e.createObjectStore("accounts", { keyPath: "id" });
                    }),
                      (r.onsuccess = (r) => {
                        const n = r.target.result
                          .transaction("accounts", "readonly")
                          .objectStore("accounts")
                          .getAll();
                        (n.onsuccess = () => t(n.result)),
                          (n.onerror = () => e(n.error));
                      }),
                      (r.onerror = () => e(r.error));
                  });
                  return console.log("Accounts:", t), t;
                } catch (t) {
                  console.error("Could not get accounts:", t);
                }
              })();
            let s = null;
            for (let a = 0; a < i.length; a++) {
              const t = i[a],
                c = t.did;
              if (c == r) {
                t.publicKeyHex;
                const r = t.identity;
                const i = o.decodeBase64(r),
                  a = i.slice(0, 24),
                  u = i.slice(24, r.length),
                  h = n.secretbox.open(u, a, e),
                  l = new TextDecoder("utf-8").decode(h),
                  d = JSON.parse(JSON.parse(l)),
                  y = { "Content-Type": "application/json" };
                y.Authorization = "Bearer " + (await f(d));
                const p = await fetch(
                  "https://test-api.endorser.ch/api/v2/report/claims",
                  { method: "GET", headers: y },
                );
                (p.status_code = -200) &&
                  ((data = p.json().data), (s = { [c]: data.length }));
                break;
              }
            }
            return s;
          },
        };
      },
      24: () => {},
    },
    e = {},
    r = (function r(n) {
      const o = e[n];
      if (void 0 !== o) return o.exports;
      const i = (e[n] = { exports: {} });
      return t[n].call(i.exports, i, i.exports, r), i.exports;
    })(67);
  customModule = r;
})();