jobsys-explore 1.0.1

package/dist/index-82d74e5f.mjs

@@ -0,0 +1,2120 @@
+var Re = Object.defineProperty;
+var Ve = (t, n, e) => n in t ? Re(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var L = (t, n, e) => (Ve(t, typeof n != "symbol" ? n + "" : n, e), e);
+import { reduce as $e, find as ke, isString as me, isFunction as Ee, cloneDeep as Ze, isDate as De, isBoolean as Ke, isObject as se, isUndefined as ze, isArray as Fe } from "lodash-es";
+import ie from "axios";
+import { showToast as je, closeToast as Ye, showSuccessToast as Me, showFailToast as Ct } from "vant";
+const be = {
+  STATE_CODE_SUCCESS: "SUCCESS",
+  // 成功
+  STATE_CODE_FAIL: "FAIL",
+  // 失败
+  STATE_CODE_NOT_FOUND: "NOT_FOUND",
+  // 找不到资源
+  STATE_CODE_INFO_NOT_COMPLETE: "INCOMPLETE",
+  // 信息不完整
+  STATE_CODE_NOT_ALLOWED: "NOT_ALLOWED"
+  //没有权限
+};
+function Ge(t) {
+  return t || (t = {}), t.loading = !0, {
+    /**
+     * get请求
+     * @param url
+     * @param {Object} [config] - axios config
+     * @returns {Promise<unknown>}
+     */
+    get(n, e) {
+      return new Promise((o, r) => {
+        ie.get(n, e).then((s) => {
+          o(s);
+        }).catch((s) => {
+          r(s);
+        }).finally(() => {
+          t.loading = !1;
+        });
+      });
+    },
+    /**
+     * post请求
+     * @param {string} url
+     * @param {Object} data
+     * @param {Object} [config] - axios config
+     * @returns {Promise<unknown>}
+     */
+    post(n, e, o) {
+      return new Promise((r, s) => {
+        ie.post(n, e, o).then((c) => {
+          r(c);
+        }).catch((c) => {
+          s(c);
+        }).finally(() => {
+          t.loading = !1;
+        });
+      });
+    }
+  };
+}
+const Er = async (t, n, e) => {
+  if (t.finishedText = t.finishedText || "加载完毕", t.loading = !0, !t.uri) {
+    console.error("URI is required in pagination");
+    return;
+  }
+  let o = {};
+  try {
+    je({ type: "loading", message: "加载中...", forbidClick: !0, overlay: !0, duration: 0 }), o = await Ge().get(t.uri, {
+      params: { ...t.params || {}, page: n || !t.page ? 1 : t.page + 1 }
+    });
+  } catch {
+    t.loading = !1, t.finished = !1, t.error = !0;
+    return;
+  } finally {
+    Ye(!0);
+  }
+  if (o.status !== be.STATE_CODE_SUCCESS) {
+    t.loading = !1, t.error = !0, t.errorText = o.result;
+    return;
+  }
+  let r;
+  e ? r = e(o) : r = o.result;
+  let s = r.data;
+  !n && t.items && (s = t.items.concat(s));
+  const c = r.current_page || r.current || r.page || 1, i = r.last_page || r.lastPage || r.pages || 0, l = r.total_size || r.totalSize || r.total || 0;
+  t.loading = !1, t.error = !1, t.page = c, t.items = s, t.finished = i === 0 || i === c, t.empty = l === 0;
+};
+function br(t, n) {
+  if (!n)
+    return "";
+  const e = n.find((o) => o.value === t);
+  return e ? e.text : "";
+}
+function We(t, n, e) {
+  e = e || {
+    value: "value",
+    label: "label",
+    children: "children"
+  };
+  let o = [];
+  return $e(
+    n,
+    (r, s) => {
+      const c = ke(r, { [e.value]: s });
+      if (c)
+        return o.push(c[e.label]), c[e.children];
+    },
+    t
+  ), o;
+}
+function vr(t, n, e) {
+  return e = e || {
+    value: "value",
+    label: "text",
+    children: "children"
+  }, We(t, n, e);
+}
+const { STATE_CODE_FAIL: Qe, STATE_CODE_INFO_NOT_COMPLETE: Xe, STATE_CODE_NOT_FOUND: Je, STATE_CODE_NOT_ALLOWED: tn, STATE_CODE_SUCCESS: ce } = be;
+function xr(t) {
+  const { url: n, data: e, csrfToken: o } = t;
+  let { method: r } = t;
+  r = r || "post";
+  const s = document.createElement("form");
+  if (s.action = n, s.method = r, s.target = "_blank", s.style.display = "none", Object.keys(e).forEach((c) => {
+    const i = document.createElement("input");
+    i.type = "hidden", i.name = c, i.value = e[c], s.appendChild(i);
+  }), !o) {
+    const c = document.createElement("input");
+    c.type = "hidden", c.name = "_token", c.value = document.querySelector('meta[name="csrf-token"]').getAttribute("content"), s.appendChild(c);
+  }
+  return document.body.appendChild(s), s;
+}
+function en(t, n) {
+  const { status: e } = t, o = t.result, r = {};
+  r.default = "请求失败, 请检查数据并重试", r[Qe] = "系统错误，请稍候再试", r[Je] = "请求的内容不存在", r[Xe] = "信息不完整", r[tn] = "没有权限";
+  const s = {
+    [ce]: "success"
+  }, c = n[e] || n[s[e]] || r[e] || r.def;
+  me(c) ? e === ce ? Me(c) : Ct(o || c) : Ee(c) && c();
+}
+function Sr(t, n) {
+  en(t, { success: n });
+}
+function Br(t) {
+  t && t.errorFields ? t.errorFields.forEach((n) => {
+    Ct(n.errors.join(" "));
+  }) : t && t.response ? Ct("网络异常") : Ct("请检查填写项");
+}
+function Ar(t, n) {
+  const e = Ze(t);
+  n = n || {};
+  const o = (r) => {
+    for (let s in r) {
+      if (n.date && De(r[s])) {
+        r[s] = Math.ceil(r[s].getTime() / 1e3);
+        continue;
+      }
+      if (n.boolean && Ke(r[s])) {
+        r[s] = r[s] ? 1 : 0;
+        continue;
+      }
+      if (n.attachment) {
+        const c = n.attachment;
+        if (se(r[s]) && me(c) && !ze(r[s][c])) {
+          r[s] = r[s][c];
+          continue;
+        } else if (se(r[s]) && Ee(c)) {
+          r[s] = c(r[s]);
+          continue;
+        }
+      }
+      if (Fe(r[s]))
+        for (let c in r[s])
+          r[s][c] = o(r[s][c]);
+    }
+    return r;
+  };
+  return o(e);
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const ve = BigInt(0), Ht = BigInt(1), nn = BigInt(2), _t = (t) => t instanceof Uint8Array, rn = Array.from({ length: 256 }, (t, n) => n.toString(16).padStart(2, "0"));
+function nt(t) {
+  if (!_t(t))
+    throw new Error("Uint8Array expected");
+  let n = "";
+  for (let e = 0; e < t.length; e++)
+    n += rn[t[e]];
+  return n;
+}
+function $(t) {
+  const n = t.toString(16);
+  return n.length & 1 ? `0${n}` : n;
+}
+function _(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return BigInt(t === "" ? "0" : `0x${t}`);
+}
+function xt(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  const n = t.length;
+  if (n % 2)
+    throw new Error("padded hex string expected, got unpadded hex of length " + n);
+  const e = new Uint8Array(n / 2);
+  for (let o = 0; o < e.length; o++) {
+    const r = o * 2, s = t.slice(r, r + 2), c = Number.parseInt(s, 16);
+    if (Number.isNaN(c) || c < 0)
+      throw new Error("Invalid byte sequence");
+    e[o] = c;
+  }
+  return e;
+}
+function wt(t) {
+  return _(nt(t));
+}
+function Ft(t) {
+  if (!_t(t))
+    throw new Error("Uint8Array expected");
+  return _(nt(Uint8Array.from(t).reverse()));
+}
+function yt(t, n) {
+  return xt(t.toString(16).padStart(n * 2, "0"));
+}
+function xe(t, n) {
+  return yt(t, n).reverse();
+}
+function on(t) {
+  return xt($(t));
+}
+function M(t, n, e) {
+  let o;
+  if (typeof n == "string")
+    try {
+      o = xt(n);
+    } catch (s) {
+      throw new Error(`${t} must be valid hex string, got "${n}". Cause: ${s}`);
+    }
+  else if (_t(n))
+    o = Uint8Array.from(n);
+  else
+    throw new Error(`${t} must be hex string or Uint8Array`);
+  const r = o.length;
+  if (typeof e == "number" && r !== e)
+    throw new Error(`${t} expected ${e} bytes, got ${r}`);
+  return o;
+}
+function j(...t) {
+  const n = new Uint8Array(t.reduce((o, r) => o + r.length, 0));
+  let e = 0;
+  return t.forEach((o) => {
+    if (!_t(o))
+      throw new Error("Uint8Array expected");
+    n.set(o, e), e += o.length;
+  }), n;
+}
+function sn(t, n) {
+  if (t.length !== n.length)
+    return !1;
+  for (let e = 0; e < t.length; e++)
+    if (t[e] !== n[e])
+      return !1;
+  return !0;
+}
+function cn(t) {
+  if (typeof t != "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof t}`);
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function ln(t) {
+  let n;
+  for (n = 0; t > ve; t >>= Ht, n += 1)
+    ;
+  return n;
+}
+function fn(t, n) {
+  return t >> BigInt(n) & Ht;
+}
+const un = (t, n, e) => t | (e ? Ht : ve) << BigInt(n), jt = (t) => (nn << BigInt(t - 1)) - Ht, Vt = (t) => new Uint8Array(t), le = (t) => Uint8Array.from(t);
+function Se(t, n, e) {
+  if (typeof t != "number" || t < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof n != "number" || n < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof e != "function")
+    throw new Error("hmacFn must be a function");
+  let o = Vt(t), r = Vt(t), s = 0;
+  const c = () => {
+    o.fill(1), r.fill(0), s = 0;
+  }, i = (...u) => e(r, o, ...u), l = (u = Vt()) => {
+    r = i(le([0]), u), o = i(), u.length !== 0 && (r = i(le([1]), u), o = i());
+  }, f = () => {
+    if (s++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let u = 0;
+    const m = [];
+    for (; u < n; ) {
+      o = i();
+      const b = o.slice();
+      m.push(b), u += o.length;
+    }
+    return j(...m);
+  };
+  return (u, m) => {
+    c(), l(u);
+    let b;
+    for (; !(b = m(f())); )
+      l();
+    return c(), b;
+  };
+}
+const an = {
+  bigint: (t) => typeof t == "bigint",
+  function: (t) => typeof t == "function",
+  boolean: (t) => typeof t == "boolean",
+  string: (t) => typeof t == "string",
+  isSafeInteger: (t) => Number.isSafeInteger(t),
+  array: (t) => Array.isArray(t),
+  field: (t, n) => n.Fp.isValid(t),
+  hash: (t) => typeof t == "function" && Number.isSafeInteger(t.outputLen)
+};
+function It(t, n, e = {}) {
+  const o = (r, s, c) => {
+    const i = an[s];
+    if (typeof i != "function")
+      throw new Error(`Invalid validator "${s}", expected function`);
+    const l = t[r];
+    if (!(c && l === void 0) && !i(l, t))
+      throw new Error(`Invalid param ${String(r)}=${l} (${typeof l}), expected ${s}`);
+  };
+  for (const [r, s] of Object.entries(n))
+    o(r, s, !1);
+  for (const [r, s] of Object.entries(e))
+    o(r, s, !0);
+  return t;
+}
+const hn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  bitGet: fn,
+  bitLen: ln,
+  bitMask: jt,
+  bitSet: un,
+  bytesToHex: nt,
+  bytesToNumberBE: wt,
+  bytesToNumberLE: Ft,
+  concatBytes: j,
+  createHmacDrbg: Se,
+  ensureBytes: M,
+  equalBytes: sn,
+  hexToBytes: xt,
+  hexToNumber: _,
+  numberToBytesBE: yt,
+  numberToBytesLE: xe,
+  numberToHexUnpadded: $,
+  numberToVarBytesBE: on,
+  utf8ToBytes: cn,
+  validateObject: It
+}, Symbol.toStringTag, { value: "Module" }));
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const V = BigInt(0), H = BigInt(1), ht = BigInt(2), dn = BigInt(3), Kt = BigInt(4), fe = BigInt(5), ue = BigInt(8);
+BigInt(9);
+BigInt(16);
+function Z(t, n) {
+  const e = t % n;
+  return e >= V ? e : n + e;
+}
+function gn(t, n, e) {
+  if (e <= V || n < V)
+    throw new Error("Expected power/modulo > 0");
+  if (e === H)
+    return V;
+  let o = H;
+  for (; n > V; )
+    n & H && (o = o * t % e), t = t * t % e, n >>= H;
+  return o;
+}
+function zt(t, n) {
+  if (t === V || n <= V)
+    throw new Error(`invert: expected positive integers, got n=${t} mod=${n}`);
+  let e = Z(t, n), o = n, r = V, s = H;
+  for (; e !== V; ) {
+    const i = o / e, l = o % e, f = r - s * i;
+    o = e, e = l, r = s, s = f;
+  }
+  if (o !== H)
+    throw new Error("invert: does not exist");
+  return Z(r, n);
+}
+function wn(t) {
+  const n = (t - H) / ht;
+  let e, o, r;
+  for (e = t - H, o = 0; e % ht === V; e /= ht, o++)
+    ;
+  for (r = ht; r < t && gn(r, n, t) !== t - H; r++)
+    ;
+  if (o === 1) {
+    const c = (t + H) / Kt;
+    return function(l, f) {
+      const h = l.pow(f, c);
+      if (!l.eql(l.sqr(h), f))
+        throw new Error("Cannot find square root");
+      return h;
+    };
+  }
+  const s = (e + H) / ht;
+  return function(i, l) {
+    if (i.pow(l, n) === i.neg(i.ONE))
+      throw new Error("Cannot find square root");
+    let f = o, h = i.pow(i.mul(i.ONE, r), e), u = i.pow(l, s), m = i.pow(l, e);
+    for (; !i.eql(m, i.ONE); ) {
+      if (i.eql(m, i.ZERO))
+        return i.ZERO;
+      let b = 1;
+      for (let a = i.sqr(m); b < f && !i.eql(a, i.ONE); b++)
+        a = i.sqr(a);
+      const g = i.pow(h, H << BigInt(f - b - 1));
+      h = i.sqr(g), u = i.mul(u, g), m = i.mul(m, h), f = b;
+    }
+    return u;
+  };
+}
+function yn(t) {
+  if (t % Kt === dn) {
+    const n = (t + H) / Kt;
+    return function(o, r) {
+      const s = o.pow(r, n);
+      if (!o.eql(o.sqr(s), r))
+        throw new Error("Cannot find square root");
+      return s;
+    };
+  }
+  if (t % ue === fe) {
+    const n = (t - fe) / ue;
+    return function(o, r) {
+      const s = o.mul(r, ht), c = o.pow(s, n), i = o.mul(r, c), l = o.mul(o.mul(i, ht), c), f = o.mul(i, o.sub(l, o.ONE));
+      if (!o.eql(o.sqr(f), r))
+        throw new Error("Cannot find square root");
+      return f;
+    };
+  }
+  return wn(t);
+}
+const pn = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function mn(t) {
+  const n = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "isSafeInteger",
+    BITS: "isSafeInteger"
+  }, e = pn.reduce((o, r) => (o[r] = "function", o), n);
+  return It(t, e);
+}
+function En(t, n, e) {
+  if (e < V)
+    throw new Error("Expected power > 0");
+  if (e === V)
+    return t.ONE;
+  if (e === H)
+    return n;
+  let o = t.ONE, r = n;
+  for (; e > V; )
+    e & H && (o = t.mul(o, r)), r = t.sqr(r), e >>= H;
+  return o;
+}
+function bn(t, n) {
+  const e = new Array(n.length), o = n.reduce((s, c, i) => t.is0(c) ? s : (e[i] = s, t.mul(s, c)), t.ONE), r = t.inv(o);
+  return n.reduceRight((s, c, i) => t.is0(c) ? s : (e[i] = t.mul(s, e[i]), t.mul(s, c)), r), e;
+}
+function Yt(t, n) {
+  const e = n !== void 0 ? n : t.toString(2).length, o = Math.ceil(e / 8);
+  return { nBitLength: e, nByteLength: o };
+}
+function Be(t, n, e = !1, o = {}) {
+  if (t <= V)
+    throw new Error(`Expected Fp ORDER > 0, got ${t}`);
+  const { nBitLength: r, nByteLength: s } = Yt(t, n);
+  if (s > 2048)
+    throw new Error("Field lengths over 2048 bytes are not supported");
+  const c = yn(t), i = Object.freeze({
+    ORDER: t,
+    BITS: r,
+    BYTES: s,
+    MASK: jt(r),
+    ZERO: V,
+    ONE: H,
+    create: (l) => Z(l, t),
+    isValid: (l) => {
+      if (typeof l != "bigint")
+        throw new Error(`Invalid field element: expected bigint, got ${typeof l}`);
+      return V <= l && l < t;
+    },
+    is0: (l) => l === V,
+    isOdd: (l) => (l & H) === H,
+    neg: (l) => Z(-l, t),
+    eql: (l, f) => l === f,
+    sqr: (l) => Z(l * l, t),
+    add: (l, f) => Z(l + f, t),
+    sub: (l, f) => Z(l - f, t),
+    mul: (l, f) => Z(l * f, t),
+    pow: (l, f) => En(i, l, f),
+    div: (l, f) => Z(l * zt(f, t), t),
+    // Same as above, but doesn't normalize
+    sqrN: (l) => l * l,
+    addN: (l, f) => l + f,
+    subN: (l, f) => l - f,
+    mulN: (l, f) => l * f,
+    inv: (l) => zt(l, t),
+    sqrt: o.sqrt || ((l) => c(i, l)),
+    invertBatch: (l) => bn(i, l),
+    // TODO: do we really need constant cmov?
+    // We don't have const-time bigints anyway, so probably will be not very useful
+    cmov: (l, f, h) => h ? f : l,
+    toBytes: (l) => e ? xe(l, s) : yt(l, s),
+    fromBytes: (l) => {
+      if (l.length !== s)
+        throw new Error(`Fp.fromBytes: expected ${s}, got ${l.length}`);
+      return e ? Ft(l) : wt(l);
+    }
+  });
+  return Object.freeze(i);
+}
+function vn(t, n, e = !1) {
+  t = M("privateHash", t);
+  const o = t.length, r = Yt(n).nByteLength + 8;
+  if (r < 24 || o < r || o > 1024)
+    throw new Error(`hashToPrivateScalar: expected ${r}-1024 bytes of input, got ${o}`);
+  const s = e ? Ft(t) : wt(t);
+  return Z(s, n - H) + H;
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const xn = BigInt(0), $t = BigInt(1);
+function Sn(t, n) {
+  const e = (r, s) => {
+    const c = s.negate();
+    return r ? c : s;
+  }, o = (r) => {
+    const s = Math.ceil(n / r) + 1, c = 2 ** (r - 1);
+    return { windows: s, windowSize: c };
+  };
+  return {
+    constTimeNegate: e,
+    // non-const time multiplication ladder
+    unsafeLadder(r, s) {
+      let c = t.ZERO, i = r;
+      for (; s > xn; )
+        s & $t && (c = c.add(i)), i = i.double(), s >>= $t;
+      return c;
+    },
+    /**
+     * Creates a wNAF precomputation window. Used for caching.
+     * Default window size is set by `utils.precompute()` and is equal to 8.
+     * Number of precomputed points depends on the curve size:
+     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+     * - 𝑊 is the window size
+     * - 𝑛 is the bitlength of the curve order.
+     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+     * @returns precomputed point tables flattened to a single array
+     */
+    precomputeWindow(r, s) {
+      const { windows: c, windowSize: i } = o(s), l = [];
+      let f = r, h = f;
+      for (let u = 0; u < c; u++) {
+        h = f, l.push(h);
+        for (let m = 1; m < i; m++)
+          h = h.add(f), l.push(h);
+        f = h.double();
+      }
+      return l;
+    },
+    /**
+     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @returns real and fake (for const-time) points
+     */
+    wNAF(r, s, c) {
+      const { windows: i, windowSize: l } = o(r);
+      let f = t.ZERO, h = t.BASE;
+      const u = BigInt(2 ** r - 1), m = 2 ** r, b = BigInt(r);
+      for (let g = 0; g < i; g++) {
+        const a = g * l;
+        let w = Number(c & u);
+        c >>= b, w > l && (w -= m, c += $t);
+        const y = a, v = a + Math.abs(w) - 1, S = g % 2 !== 0, I = w < 0;
+        w === 0 ? h = h.add(e(S, s[y])) : f = f.add(e(I, s[v]));
+      }
+      return { p: f, f: h };
+    },
+    wNAFCached(r, s, c, i) {
+      const l = r._WINDOW_SIZE || 1;
+      let f = s.get(r);
+      return f || (f = this.precomputeWindow(r, l), l !== 1 && s.set(r, i(f))), this.wNAF(l, f, c);
+    }
+  };
+}
+function Ae(t) {
+  return mn(t.Fp), It(t, {
+    n: "bigint",
+    h: "bigint",
+    Gx: "field",
+    Gy: "field"
+  }, {
+    nBitLength: "isSafeInteger",
+    nByteLength: "isSafeInteger"
+  }), Object.freeze({
+    ...Yt(t.n, t.nBitLength),
+    ...t,
+    p: t.Fp.ORDER
+  });
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function Bn(t) {
+  const n = Ae(t);
+  It(n, {
+    a: "field",
+    b: "field"
+  }, {
+    allowedPrivateKeyLengths: "array",
+    wrapPrivateKey: "boolean",
+    isTorsionFree: "function",
+    clearCofactor: "function",
+    allowInfinityPoint: "boolean",
+    fromBytes: "function",
+    toBytes: "function"
+  });
+  const { endo: e, Fp: o, a: r } = n;
+  if (e) {
+    if (!o.eql(r, o.ZERO))
+      throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
+    if (typeof e != "object" || typeof e.beta != "bigint" || typeof e.splitScalar != "function")
+      throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
+  }
+  return Object.freeze({ ...n });
+}
+const { bytesToNumberBE: An, hexToBytes: Tn } = hn, dt = {
+  // asn.1 DER encoding utils
+  Err: class extends Error {
+    constructor(n = "") {
+      super(n);
+    }
+  },
+  _parseInt(t) {
+    const { Err: n } = dt;
+    if (t.length < 2 || t[0] !== 2)
+      throw new n("Invalid signature integer tag");
+    const e = t[1], o = t.subarray(2, e + 2);
+    if (!e || o.length !== e)
+      throw new n("Invalid signature integer: wrong length");
+    if (o[0] & 128)
+      throw new n("Invalid signature integer: negative");
+    if (o[0] === 0 && !(o[1] & 128))
+      throw new n("Invalid signature integer: unnecessary leading zero");
+    return { d: An(o), l: t.subarray(e + 2) };
+  },
+  toSig(t) {
+    const { Err: n } = dt, e = typeof t == "string" ? Tn(t) : t;
+    if (!(e instanceof Uint8Array))
+      throw new Error("ui8a expected");
+    let o = e.length;
+    if (o < 2 || e[0] != 48)
+      throw new n("Invalid signature tag");
+    if (e[1] !== o - 2)
+      throw new n("Invalid signature: incorrect length");
+    const { d: r, l: s } = dt._parseInt(e.subarray(2)), { d: c, l: i } = dt._parseInt(s);
+    if (i.length)
+      throw new n("Invalid signature: left bytes after parsing");
+    return { r, s: c };
+  },
+  hexFromSig(t) {
+    const n = (f) => Number.parseInt(f[0], 16) & 8 ? "00" + f : f, e = (f) => {
+      const h = f.toString(16);
+      return h.length & 1 ? `0${h}` : h;
+    }, o = n(e(t.s)), r = n(e(t.r)), s = o.length / 2, c = r.length / 2, i = e(s), l = e(c);
+    return `30${e(c + s + 4)}02${l}${r}02${i}${o}`;
+  }
+}, et = BigInt(0), G = BigInt(1);
+BigInt(2);
+const ae = BigInt(3);
+BigInt(4);
+function In(t) {
+  const n = Bn(t), { Fp: e } = n, o = n.toBytes || ((g, a, w) => {
+    const y = a.toAffine();
+    return j(Uint8Array.from([4]), e.toBytes(y.x), e.toBytes(y.y));
+  }), r = n.fromBytes || ((g) => {
+    const a = g.subarray(1), w = e.fromBytes(a.subarray(0, e.BYTES)), y = e.fromBytes(a.subarray(e.BYTES, 2 * e.BYTES));
+    return { x: w, y };
+  });
+  function s(g) {
+    const { a, b: w } = n, y = e.sqr(g), v = e.mul(y, g);
+    return e.add(e.add(v, e.mul(g, a)), w);
+  }
+  if (!e.eql(e.sqr(n.Gy), s(n.Gx)))
+    throw new Error("bad generator point: equation left != right");
+  function c(g) {
+    return typeof g == "bigint" && et < g && g < n.n;
+  }
+  function i(g) {
+    if (!c(g))
+      throw new Error("Expected valid bigint: 0 < bigint < curve.n");
+  }
+  function l(g) {
+    const { allowedPrivateKeyLengths: a, nByteLength: w, wrapPrivateKey: y, n: v } = n;
+    if (a && typeof g != "bigint") {
+      if (g instanceof Uint8Array && (g = nt(g)), typeof g != "string" || !a.includes(g.length))
+        throw new Error("Invalid key");
+      g = g.padStart(w * 2, "0");
+    }
+    let S;
+    try {
+      S = typeof g == "bigint" ? g : wt(M("private key", g, w));
+    } catch {
+      throw new Error(`private key must be ${w} bytes, hex or bigint, not ${typeof g}`);
+    }
+    return y && (S = Z(S, v)), i(S), S;
+  }
+  const f = /* @__PURE__ */ new Map();
+  function h(g) {
+    if (!(g instanceof u))
+      throw new Error("ProjectivePoint expected");
+  }
+  class u {
+    constructor(a, w, y) {
+      if (this.px = a, this.py = w, this.pz = y, a == null || !e.isValid(a))
+        throw new Error("x required");
+      if (w == null || !e.isValid(w))
+        throw new Error("y required");
+      if (y == null || !e.isValid(y))
+        throw new Error("z required");
+    }
+    // Does not validate if the point is on-curve.
+    // Use fromHex instead, or call assertValidity() later.
+    static fromAffine(a) {
+      const { x: w, y } = a || {};
+      if (!a || !e.isValid(w) || !e.isValid(y))
+        throw new Error("invalid affine point");
+      if (a instanceof u)
+        throw new Error("projective point not allowed");
+      const v = (S) => e.eql(S, e.ZERO);
+      return v(w) && v(y) ? u.ZERO : new u(w, y, e.ONE);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     * Takes a bunch of Projective Points but executes only one
+     * inversion on all of them. Inversion is very slow operation,
+     * so this improves performance massively.
+     * Optimization: converts a list of projective points to a list of identical points with Z=1.
+     */
+    static normalizeZ(a) {
+      const w = e.invertBatch(a.map((y) => y.pz));
+      return a.map((y, v) => y.toAffine(w[v])).map(u.fromAffine);
+    }
+    /**
+     * Converts hash string or Uint8Array to Point.
+     * @param hex short/long ECDSA hex
+     */
+    static fromHex(a) {
+      const w = u.fromAffine(r(M("pointHex", a)));
+      return w.assertValidity(), w;
+    }
+    // Multiplies generator point by privateKey.
+    static fromPrivateKey(a) {
+      return u.BASE.multiply(l(a));
+    }
+    // "Private method", don't use it directly
+    _setWindowSize(a) {
+      this._WINDOW_SIZE = a, f.delete(this);
+    }
+    // A point on curve is valid if it conforms to equation.
+    assertValidity() {
+      if (this.is0()) {
+        if (n.allowInfinityPoint)
+          return;
+        throw new Error("bad point: ZERO");
+      }
+      const { x: a, y: w } = this.toAffine();
+      if (!e.isValid(a) || !e.isValid(w))
+        throw new Error("bad point: x or y not FE");
+      const y = e.sqr(w), v = s(a);
+      if (!e.eql(y, v))
+        throw new Error("bad point: equation left != right");
+      if (!this.isTorsionFree())
+        throw new Error("bad point: not in prime-order subgroup");
+    }
+    hasEvenY() {
+      const { y: a } = this.toAffine();
+      if (e.isOdd)
+        return !e.isOdd(a);
+      throw new Error("Field doesn't support isOdd");
+    }
+    /**
+     * Compare one point to another.
+     */
+    equals(a) {
+      h(a);
+      const { px: w, py: y, pz: v } = this, { px: S, py: I, pz: T } = a, E = e.eql(e.mul(w, T), e.mul(S, v)), x = e.eql(e.mul(y, T), e.mul(I, v));
+      return E && x;
+    }
+    /**
+     * Flips point to one corresponding to (x, -y) in Affine coordinates.
+     */
+    negate() {
+      return new u(this.px, e.neg(this.py), this.pz);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a, b: w } = n, y = e.mul(w, ae), { px: v, py: S, pz: I } = this;
+      let T = e.ZERO, E = e.ZERO, x = e.ZERO, A = e.mul(v, v), Y = e.mul(S, S), C = e.mul(I, I), O = e.mul(v, S);
+      return O = e.add(O, O), x = e.mul(v, I), x = e.add(x, x), T = e.mul(a, x), E = e.mul(y, C), E = e.add(T, E), T = e.sub(Y, E), E = e.add(Y, E), E = e.mul(T, E), T = e.mul(O, T), x = e.mul(y, x), C = e.mul(a, C), O = e.sub(A, C), O = e.mul(a, O), O = e.add(O, x), x = e.add(A, A), A = e.add(x, A), A = e.add(A, C), A = e.mul(A, O), E = e.add(E, A), C = e.mul(S, I), C = e.add(C, C), A = e.mul(C, O), T = e.sub(T, A), x = e.mul(C, Y), x = e.add(x, x), x = e.add(x, x), new u(T, E, x);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(a) {
+      h(a);
+      const { px: w, py: y, pz: v } = this, { px: S, py: I, pz: T } = a;
+      let E = e.ZERO, x = e.ZERO, A = e.ZERO;
+      const Y = n.a, C = e.mul(n.b, ae);
+      let O = e.mul(w, S), D = e.mul(y, I), K = e.mul(v, T), rt = e.add(w, y), d = e.add(S, I);
+      rt = e.mul(rt, d), d = e.add(O, D), rt = e.sub(rt, d), d = e.add(w, v);
+      let p = e.add(S, T);
+      return d = e.mul(d, p), p = e.add(O, K), d = e.sub(d, p), p = e.add(y, v), E = e.add(I, T), p = e.mul(p, E), E = e.add(D, K), p = e.sub(p, E), A = e.mul(Y, d), E = e.mul(C, K), A = e.add(E, A), E = e.sub(D, A), A = e.add(D, A), x = e.mul(E, A), D = e.add(O, O), D = e.add(D, O), K = e.mul(Y, K), d = e.mul(C, d), D = e.add(D, K), K = e.sub(O, K), K = e.mul(Y, K), d = e.add(d, K), O = e.mul(D, d), x = e.add(x, O), O = e.mul(p, d), E = e.mul(rt, E), E = e.sub(E, O), O = e.mul(rt, D), A = e.mul(p, A), A = e.add(A, O), new u(E, x, A);
+    }
+    subtract(a) {
+      return this.add(a.negate());
+    }
+    is0() {
+      return this.equals(u.ZERO);
+    }
+    wNAF(a) {
+      return b.wNAFCached(this, f, a, (w) => {
+        const y = e.invertBatch(w.map((v) => v.pz));
+        return w.map((v, S) => v.toAffine(y[S])).map(u.fromAffine);
+      });
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed private key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(a) {
+      const w = u.ZERO;
+      if (a === et)
+        return w;
+      if (i(a), a === G)
+        return this;
+      const { endo: y } = n;
+      if (!y)
+        return b.unsafeLadder(this, a);
+      let { k1neg: v, k1: S, k2neg: I, k2: T } = y.splitScalar(a), E = w, x = w, A = this;
+      for (; S > et || T > et; )
+        S & G && (E = E.add(A)), T & G && (x = x.add(A)), A = A.double(), S >>= G, T >>= G;
+      return v && (E = E.negate()), I && (x = x.negate()), x = new u(e.mul(x.px, y.beta), x.py, x.pz), E.add(x);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(a) {
+      i(a);
+      let w = a, y, v;
+      const { endo: S } = n;
+      if (S) {
+        const { k1neg: I, k1: T, k2neg: E, k2: x } = S.splitScalar(w);
+        let { p: A, f: Y } = this.wNAF(T), { p: C, f: O } = this.wNAF(x);
+        A = b.constTimeNegate(I, A), C = b.constTimeNegate(E, C), C = new u(e.mul(C.px, S.beta), C.py, C.pz), y = A.add(C), v = Y.add(O);
+      } else {
+        const { p: I, f: T } = this.wNAF(w);
+        y = I, v = T;
+      }
+      return u.normalizeZ([y, v])[0];
+    }
+    /**
+     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
+     * Not using Strauss-Shamir trick: precomputation tables are faster.
+     * The trick could be useful if both P and Q are not G (not in our case).
+     * @returns non-zero affine point
+     */
+    multiplyAndAddUnsafe(a, w, y) {
+      const v = u.BASE, S = (T, E) => E === et || E === G || !T.equals(v) ? T.multiplyUnsafe(E) : T.multiply(E), I = S(this, w).add(S(a, y));
+      return I.is0() ? void 0 : I;
+    }
+    // Converts Projective point to affine (x, y) coordinates.
+    // Can accept precomputed Z^-1 - for example, from invertBatch.
+    // (x, y, z) ∋ (x=x/z, y=y/z)
+    toAffine(a) {
+      const { px: w, py: y, pz: v } = this, S = this.is0();
+      a == null && (a = S ? e.ONE : e.inv(v));
+      const I = e.mul(w, a), T = e.mul(y, a), E = e.mul(v, a);
+      if (S)
+        return { x: e.ZERO, y: e.ZERO };
+      if (!e.eql(E, e.ONE))
+        throw new Error("invZ was invalid");
+      return { x: I, y: T };
+    }
+    isTorsionFree() {
+      const { h: a, isTorsionFree: w } = n;
+      if (a === G)
+        return !0;
+      if (w)
+        return w(u, this);
+      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
+    }
+    clearCofactor() {
+      const { h: a, clearCofactor: w } = n;
+      return a === G ? this : w ? w(u, this) : this.multiplyUnsafe(n.h);
+    }
+    toRawBytes(a = !0) {
+      return this.assertValidity(), o(u, this, a);
+    }
+    toHex(a = !0) {
+      return nt(this.toRawBytes(a));
+    }
+  }
+  u.BASE = new u(n.Gx, n.Gy, e.ONE), u.ZERO = new u(e.ZERO, e.ONE, e.ZERO);
+  const m = n.nBitLength, b = Sn(u, n.endo ? Math.ceil(m / 2) : m);
+  return {
+    CURVE: n,
+    ProjectivePoint: u,
+    normPrivateKeyToScalar: l,
+    weierstrassEquation: s,
+    isWithinCurveOrder: c
+  };
+}
+function On(t) {
+  const n = Ae(t);
+  return It(n, {
+    hash: "hash",
+    hmac: "function",
+    randomBytes: "function"
+  }, {
+    bits2int: "function",
+    bits2int_modN: "function",
+    lowS: "boolean"
+  }), Object.freeze({ lowS: !0, ...n });
+}
+function Pn(t) {
+  const n = On(t), { Fp: e, n: o } = n, r = e.BYTES + 1, s = 2 * e.BYTES + 1;
+  function c(d) {
+    return et < d && d < e.ORDER;
+  }
+  function i(d) {
+    return Z(d, o);
+  }
+  function l(d) {
+    return zt(d, o);
+  }
+  const { ProjectivePoint: f, normPrivateKeyToScalar: h, weierstrassEquation: u, isWithinCurveOrder: m } = In({
+    ...n,
+    toBytes(d, p, B) {
+      const U = p.toAffine(), P = e.toBytes(U.x), R = j;
+      return B ? R(Uint8Array.from([p.hasEvenY() ? 2 : 3]), P) : R(Uint8Array.from([4]), P, e.toBytes(U.y));
+    },
+    fromBytes(d) {
+      const p = d.length, B = d[0], U = d.subarray(1);
+      if (p === r && (B === 2 || B === 3)) {
+        const P = wt(U);
+        if (!c(P))
+          throw new Error("Point is not on curve");
+        const R = u(P);
+        let z = e.sqrt(R);
+        const F = (z & G) === G;
+        return (B & 1) === 1 !== F && (z = e.neg(z)), { x: P, y: z };
+      } else if (p === s && B === 4) {
+        const P = e.fromBytes(U.subarray(0, e.BYTES)), R = e.fromBytes(U.subarray(e.BYTES, 2 * e.BYTES));
+        return { x: P, y: R };
+      } else
+        throw new Error(`Point of length ${p} was invalid. Expected ${r} compressed bytes or ${s} uncompressed bytes`);
+    }
+  }), b = (d) => nt(yt(d, n.nByteLength));
+  function g(d) {
+    const p = o >> G;
+    return d > p;
+  }
+  function a(d) {
+    return g(d) ? i(-d) : d;
+  }
+  const w = (d, p, B) => wt(d.slice(p, B));
+  class y {
+    constructor(p, B, U) {
+      this.r = p, this.s = B, this.recovery = U, this.assertValidity();
+    }
+    // pair (bytes of r, bytes of s)
+    static fromCompact(p) {
+      const B = n.nByteLength;
+      return p = M("compactSignature", p, B * 2), new y(w(p, 0, B), w(p, B, 2 * B));
+    }
+    // DER encoded ECDSA signature
+    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
+    static fromDER(p) {
+      const { r: B, s: U } = dt.toSig(M("DER", p));
+      return new y(B, U);
+    }
+    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(p) {
+      return new y(this.r, this.s, p);
+    }
+    recoverPublicKey(p) {
+      const { r: B, s: U, recovery: P } = this, R = x(M("msgHash", p));
+      if (P == null || ![0, 1, 2, 3].includes(P))
+        throw new Error("recovery id invalid");
+      const z = P === 2 || P === 3 ? B + n.n : B;
+      if (z >= e.ORDER)
+        throw new Error("recovery id 2 or 3 invalid");
+      const F = P & 1 ? "03" : "02", ot = f.fromHex(F + b(z)), st = l(z), pt = i(-R * st), At = i(U * st), it = f.BASE.multiplyAndAddUnsafe(ot, pt, At);
+      if (!it)
+        throw new Error("point at infinify");
+      return it.assertValidity(), it;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return g(this.s);
+    }
+    normalizeS() {
+      return this.hasHighS() ? new y(this.r, i(-this.s), this.recovery) : this;
+    }
+    // DER-encoded
+    toDERRawBytes() {
+      return xt(this.toDERHex());
+    }
+    toDERHex() {
+      return dt.hexFromSig({ r: this.r, s: this.s });
+    }
+    // padded bytes of r, then padded bytes of s
+    toCompactRawBytes() {
+      return xt(this.toCompactHex());
+    }
+    toCompactHex() {
+      return b(this.r) + b(this.s);
+    }
+  }
+  const v = {
+    isValidPrivateKey(d) {
+      try {
+        return h(d), !0;
+      } catch {
+        return !1;
+      }
+    },
+    normPrivateKeyToScalar: h,
+    /**
+     * Produces cryptographically secure private key from random of size (nBitLength+64)
+     * as per FIPS 186 B.4.1 with modulo bias being neglible.
+     */
+    randomPrivateKey: () => {
+      const d = n.randomBytes(e.BYTES + 8), p = vn(d, o);
+      return yt(p, n.nByteLength);
+    },
+    /**
+     * Creates precompute table for an arbitrary EC point. Makes point "cached".
+     * Allows to massively speed-up `point.multiply(scalar)`.
+     * @returns cached point
+     * @example
+     * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
+     * fast.multiply(privKey); // much faster ECDH now
+     */
+    precompute(d = 8, p = f.BASE) {
+      return p._setWindowSize(d), p.multiply(BigInt(3)), p;
+    }
+  };
+  function S(d, p = !0) {
+    return f.fromPrivateKey(d).toRawBytes(p);
+  }
+  function I(d) {
+    const p = d instanceof Uint8Array, B = typeof d == "string", U = (p || B) && d.length;
+    return p ? U === r || U === s : B ? U === 2 * r || U === 2 * s : d instanceof f;
+  }
+  function T(d, p, B = !0) {
+    if (I(d))
+      throw new Error("first arg must be private key");
+    if (!I(p))
+      throw new Error("second arg must be public key");
+    return f.fromHex(p).multiply(h(d)).toRawBytes(B);
+  }
+  const E = n.bits2int || function(d) {
+    const p = wt(d), B = d.length * 8 - n.nBitLength;
+    return B > 0 ? p >> BigInt(B) : p;
+  }, x = n.bits2int_modN || function(d) {
+    return i(E(d));
+  }, A = jt(n.nBitLength);
+  function Y(d) {
+    if (typeof d != "bigint")
+      throw new Error("bigint expected");
+    if (!(et <= d && d < A))
+      throw new Error(`bigint expected < 2^${n.nBitLength}`);
+    return yt(d, n.nByteLength);
+  }
+  function C(d, p, B = O) {
+    if (["recovered", "canonical"].some((ut) => ut in B))
+      throw new Error("sign() legacy options not supported");
+    const { hash: U, randomBytes: P } = n;
+    let { lowS: R, prehash: z, extraEntropy: F } = B;
+    R == null && (R = !0), d = M("msgHash", d), z && (d = M("prehashed msgHash", U(d)));
+    const ot = x(d), st = h(p), pt = [Y(st), Y(ot)];
+    if (F != null) {
+      const ut = F === !0 ? P(e.BYTES) : F;
+      pt.push(M("extraEntropy", ut, e.BYTES));
+    }
+    const At = j(...pt), it = ot;
+    function Rt(ut) {
+      const mt = E(ut);
+      if (!m(mt))
+        return;
+      const ne = l(mt), Et = f.BASE.multiply(mt).toAffine(), Q = i(Et.x);
+      if (Q === et)
+        return;
+      const bt = i(ne * i(it + Q * st));
+      if (bt === et)
+        return;
+      let re = (Et.x === Q ? 0 : 2) | Number(Et.y & G), oe = bt;
+      return R && g(bt) && (oe = a(bt), re ^= 1), new y(Q, oe, re);
+    }
+    return { seed: At, k2sig: Rt };
+  }
+  const O = { lowS: n.lowS, prehash: !1 }, D = { lowS: n.lowS, prehash: !1 };
+  function K(d, p, B = O) {
+    const { seed: U, k2sig: P } = C(d, p, B), R = n;
+    return Se(R.hash.outputLen, R.nByteLength, R.hmac)(U, P);
+  }
+  f.BASE._setWindowSize(8);
+  function rt(d, p, B, U = D) {
+    var Et;
+    const P = d;
+    if (p = M("msgHash", p), B = M("publicKey", B), "strict" in U)
+      throw new Error("options.strict was renamed to lowS");
+    const { lowS: R, prehash: z } = U;
+    let F, ot;
+    try {
+      if (typeof P == "string" || P instanceof Uint8Array)
+        try {
+          F = y.fromDER(P);
+        } catch (Q) {
+          if (!(Q instanceof dt.Err))
+            throw Q;
+          F = y.fromCompact(P);
+        }
+      else if (typeof P == "object" && typeof P.r == "bigint" && typeof P.s == "bigint") {
+        const { r: Q, s: bt } = P;
+        F = new y(Q, bt);
+      } else
+        throw new Error("PARSE");
+      ot = f.fromHex(B);
+    } catch (Q) {
+      if (Q.message === "PARSE")
+        throw new Error("signature must be Signature instance, Uint8Array or hex string");
+      return !1;
+    }
+    if (R && F.hasHighS())
+      return !1;
+    z && (p = n.hash(p));
+    const { r: st, s: pt } = F, At = x(p), it = l(pt), Rt = i(At * it), ut = i(st * it), mt = (Et = f.BASE.multiplyAndAddUnsafe(ot, Rt, ut)) == null ? void 0 : Et.toAffine();
+    return mt ? i(mt.x) === st : !1;
+  }
+  return {
+    CURVE: n,
+    getPublicKey: S,
+    getSharedSecret: T,
+    sign: K,
+    verify: rt,
+    ProjectivePoint: f,
+    Signature: y,
+    utils: v
+  };
+}
+var Un = Object.defineProperty, Te = (t, n) => {
+  for (var e in n)
+    Un(t, e, { get: n[e], enumerable: !0 });
+}, Cn = {};
+Te(Cn, {
+  EmptyArray: () => Jt,
+  arrayToHex: () => qt,
+  arrayToUtf8: () => Xt,
+  calculateSharedKey: () => rr,
+  comparePublicKeyHex: () => er,
+  compressPublicKeyHex: () => Jn,
+  doDecrypt: () => sr,
+  doEncrypt: () => or,
+  doSignature: () => ir,
+  doVerifySignature: () => cr,
+  generateKeyPairHex: () => Qt,
+  getHash: () => te,
+  getPoint: () => _e,
+  getPublicKeyFromPrivateKey: () => He,
+  getZ: () => Lt,
+  hexToArray: () => k,
+  initRNGPool: () => Mt,
+  leftPad: () => q,
+  precomputePublicKey: () => lr,
+  utf8ToHex: () => Bt,
+  verifyPublicKey: () => tr
+});
+var Nt = BigInt(0), Tt = BigInt(1), Nn = BigInt(2);
+BigInt(3);
+function Ln(t) {
+  let n = t.toString(16);
+  if (n[0] !== "-")
+    n.length % 2 === 1 ? n = "0" + n : n.match(/^[0-7]/) || (n = "00" + n);
+  else {
+    n = n.substring(1);
+    let e = n.length;
+    e % 2 === 1 ? e += 1 : n.match(/^[0-7]/) || (e += 2);
+    let o = "";
+    for (let c = 0; c < e; c++)
+      o += "f";
+    n = ((_(o) ^ t) + Tt).toString(16).replace(/^-/, "");
+  }
+  return n;
+}
+var Ie = class {
+  constructor(t = null, n = "00", e = "00", o = "") {
+    this.tlv = t, this.t = n, this.l = e, this.v = o;
+  }
+  getEncodedHex() {
+    return this.tlv || (this.v = this.getValue(), this.l = this.getLength(), this.tlv = this.t + this.l + this.v), this.tlv;
+  }
+  getLength() {
+    const t = this.v.length / 2;
+    let n = t.toString(16);
+    return n.length % 2 === 1 && (n = "0" + n), t < 128 ? n : (128 + n.length / 2).toString(16) + n;
+  }
+  getValue() {
+    return "";
+  }
+}, he = class extends Ie {
+  constructor(t) {
+    super(), this.t = "02", t && (this.v = Ln(t));
+  }
+  getValue() {
+    return this.v;
+  }
+}, Hn = class extends Ie {
+  constructor(n) {
+    super();
+    L(this, "t", "30");
+    this.asn1Array = n;
+  }
+  getValue() {
+    return this.v = this.asn1Array.map((n) => n.getEncodedHex()).join(""), this.v;
+  }
+};
+function Oe(t, n) {
+  return +t[n + 2] < 8 ? 1 : +t.substring(n + 2, n + 4) & 127 + 1;
+}
+function de(t, n) {
+  const e = Oe(t, n), o = t.substring(n + 2, n + 2 + e * 2);
+  return o ? +(+o[0] < 8 ? _(o) : _(o.substring(2))).toString() : -1;
+}
+function kt(t, n) {
+  const e = Oe(t, n);
+  return n + (e + 1) * 2;
+}
+function _n(t, n) {
+  const e = new he(t), o = new he(n);
+  return new Hn([e, o]).getEncodedHex();
+}
+function qn(t) {
+  const n = kt(t, 0), e = kt(t, n), o = de(t, n), r = t.substr(e, o * 2), s = e + r.length, c = kt(t, s), i = de(t, s), l = t.substring(c, c + i * 2), f = _(r), h = _(l);
+  return { r: f, s: h };
+}
+var Zt = 16384, gt = new Uint8Array(0), vt;
+async function Mt() {
+  if ("crypto" in globalThis) {
+    vt = globalThis.crypto;
+    return;
+  }
+  if (!(gt.length > Zt / 2))
+    if ("wx" in globalThis && "getRandomValues" in globalThis.wx)
+      gt = await new Promise((t) => {
+        wx.getRandomValues({
+          length: Zt,
+          success(n) {
+            t(new Uint8Array(n.randomValues));
+          }
+        });
+      });
+    else
+      try {
+        globalThis.crypto ? vt = globalThis.crypto : vt = (await import(
+          /* webpackIgnore: true */
+          "./__vite-browser-external-2447137e.mjs"
+        )).webcrypto;
+        const t = new Uint8Array(Zt);
+        vt.getRandomValues(t), gt = t;
+      } catch {
+        throw new Error("no available csprng, abort.");
+      }
+}
+Mt();
+function Rn(t) {
+  if (gt.length > t) {
+    const n = gt.slice(0, t);
+    return gt = gt.slice(t), Mt(), n;
+  } else
+    throw new Error("random number pool is not ready or insufficient, prevent getting too long random values or too often.");
+}
+function Vn(t = 0) {
+  const n = new Uint8Array(t);
+  return vt ? vt.getRandomValues(n) : Rn(t);
+}
+var Pe = (t) => t instanceof Uint8Array, Dt = (t) => new DataView(t.buffer, t.byteOffset, t.byteLength), $n = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+if (!$n)
+  throw new Error("Non little-endian hardware is not supported");
+var kn = Array.from({ length: 256 }, (t, n) => n.toString(16).padStart(2, "0"));
+function St(t) {
+  if (!Pe(t))
+    throw new Error("Uint8Array expected");
+  let n = "";
+  for (let e = 0; e < t.length; e++)
+    n += kn[t[e]];
+  return n;
+}
+function Zn(t) {
+  if (typeof t != "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof t}`);
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function Gt(t) {
+  if (typeof t == "string" && (t = Zn(t)), !Pe(t))
+    throw new Error(`expected Uint8Array, got ${typeof t}`);
+  return t;
+}
+var Ue = class {
+  clone() {
+    return this._cloneInto();
+  }
+};
+function Dn(t) {
+  const n = (o) => t().update(Gt(o)).digest(), e = t();
+  return n.outputLen = e.outputLen, n.blockLen = e.blockLen, n.create = () => t(), n;
+}
+var Kn = (t, n, e) => t & n | t & e | n & e, ge = (t, n, e) => t ^ n ^ e, zn = (t, n, e) => t & n | ~t & e;
+function Fn(t, n, e, o) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(n, e, o);
+  const r = BigInt(32), s = BigInt(4294967295), c = Number(e >> r & s), i = Number(e & s), l = o ? 4 : 0, f = o ? 0 : 4;
+  t.setUint32(n + l, c, o), t.setUint32(n + f, i, o);
+}
+function W(t, n) {
+  const e = n & 31;
+  return t << e | t >>> 32 - e;
+}
+function jn(t) {
+  return t ^ W(t, 9) ^ W(t, 17);
+}
+function Yn(t) {
+  return t ^ W(t, 15) ^ W(t, 23);
+}
+var Mn = class extends Ue {
+  constructor(n, e, o, r) {
+    super();
+    L(this, "buffer");
+    L(this, "view");
+    L(this, "finished", !1);
+    L(this, "length", 0);
+    L(this, "pos", 0);
+    L(this, "destroyed", !1);
+    this.blockLen = n, this.outputLen = e, this.padOffset = o, this.isLE = r, this.buffer = new Uint8Array(n), this.view = Dt(this.buffer);
+  }
+  update(n) {
+    const { view: e, buffer: o, blockLen: r } = this;
+    n = Gt(n);
+    const s = n.length;
+    for (let c = 0; c < s; ) {
+      const i = Math.min(r - this.pos, s - c);
+      if (i === r) {
+        const l = Dt(n);
+        for (; r <= s - c; c += r)
+          this.process(l, c);
+        continue;
+      }
+      o.set(n.subarray(c, c + i), this.pos), this.pos += i, c += i, this.pos === r && (this.process(e, 0), this.pos = 0);
+    }
+    return this.length += n.length, this.roundClean(), this;
+  }
+  digestInto(n) {
+    this.finished = !0;
+    const { buffer: e, view: o, blockLen: r, isLE: s } = this;
+    let { pos: c } = this;
+    e[c++] = 128, this.buffer.subarray(c).fill(0), this.padOffset > r - c && (this.process(o, 0), c = 0);
+    for (let u = c; u < r; u++)
+      e[u] = 0;
+    Fn(o, r - 8, BigInt(this.length * 8), s), this.process(o, 0);
+    const i = Dt(n), l = this.outputLen;
+    if (l % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const f = l / 4, h = this.get();
+    if (f > h.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let u = 0; u < f; u++)
+      i.setUint32(4 * u, h[u], s);
+  }
+  digest() {
+    const { buffer: n, outputLen: e } = this;
+    this.digestInto(n);
+    const o = n.slice(0, e);
+    return this.destroy(), o;
+  }
+  _cloneInto(n) {
+    n || (n = new this.constructor()), n.set(...this.get());
+    const { blockLen: e, buffer: o, length: r, finished: s, destroyed: c, pos: i } = this;
+    return n.length = r, n.pos = i, n.finished = s, n.destroyed = c, r % e && n.buffer.set(o), n;
+  }
+}, ct = new Uint32Array([1937774191, 1226093241, 388252375, 3666478592, 2842636476, 372324522, 3817729613, 2969243214]), X = new Uint32Array(68), we = new Uint32Array(64), Gn = 2043430169, Wn = 2055708042, Qn = class extends Mn {
+  constructor() {
+    super(64, 32, 8, !1);
+    L(this, "A", ct[0] | 0);
+    L(this, "B", ct[1] | 0);
+    L(this, "C", ct[2] | 0);
+    L(this, "D", ct[3] | 0);
+    L(this, "E", ct[4] | 0);
+    L(this, "F", ct[5] | 0);
+    L(this, "G", ct[6] | 0);
+    L(this, "H", ct[7] | 0);
+  }
+  get() {
+    const { A: n, B: e, C: o, D: r, E: s, F: c, G: i, H: l } = this;
+    return [n, e, o, r, s, c, i, l];
+  }
+  set(n, e, o, r, s, c, i, l) {
+    this.A = n | 0, this.B = e | 0, this.C = o | 0, this.D = r | 0, this.E = s | 0, this.F = c | 0, this.G = i | 0, this.H = l | 0;
+  }
+  process(n, e) {
+    for (let u = 0; u < 16; u++, e += 4)
+      X[u] = n.getUint32(e, !1);
+    for (let u = 16; u < 68; u++)
+      X[u] = Yn(X[u - 16] ^ X[u - 9] ^ W(X[u - 3], 15)) ^ W(X[u - 13], 7) ^ X[u - 6];
+    for (let u = 0; u < 64; u++)
+      we[u] = X[u] ^ X[u + 4];
+    let { A: o, B: r, C: s, D: c, E: i, F: l, G: f, H: h } = this;
+    for (let u = 0; u < 64; u++) {
+      let m = u >= 0 && u <= 15, b = m ? Gn : Wn, g = W(W(o, 12) + i + W(b, u), 7), a = g ^ W(o, 12), w = (m ? ge(o, r, s) : Kn(o, r, s)) + c + a + we[u] | 0, y = (m ? ge(i, l, f) : zn(i, l, f)) + h + g + X[u] | 0;
+      c = s, s = W(r, 9), r = o, o = w, h = f, f = W(l, 19), l = i, i = jn(y);
+    }
+    o = o ^ this.A | 0, r = r ^ this.B | 0, s = s ^ this.C | 0, c = c ^ this.D | 0, i = i ^ this.E | 0, l = l ^ this.F | 0, f = f ^ this.G | 0, h = h ^ this.H | 0, this.set(o, r, s, c, i, l, f, h);
+  }
+  roundClean() {
+    X.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), this.buffer.fill(0);
+  }
+}, tt = Dn(() => new Qn()), Ce = class extends Ue {
+  constructor(n, e) {
+    super();
+    L(this, "oHash");
+    L(this, "iHash");
+    L(this, "blockLen");
+    L(this, "outputLen");
+    L(this, "finished", !1);
+    L(this, "destroyed", !1);
+    const o = Gt(e);
+    if (this.iHash = n.create(), typeof this.iHash.update != "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+    const r = this.blockLen, s = new Uint8Array(r);
+    s.set(o.length > r ? n.create().update(o).digest() : o);
+    for (let c = 0; c < s.length; c++)
+      s[c] ^= 54;
+    this.iHash.update(s), this.oHash = n.create();
+    for (let c = 0; c < s.length; c++)
+      s[c] ^= 106;
+    this.oHash.update(s), s.fill(0);
+  }
+  update(n) {
+    return this.iHash.update(n), this;
+  }
+  digestInto(n) {
+    this.finished = !0, this.iHash.digestInto(n), this.oHash.update(n), this.oHash.digestInto(n), this.destroy();
+  }
+  digest() {
+    const n = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(n), n;
+  }
+  _cloneInto(n) {
+    n || (n = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: e, iHash: o, finished: r, destroyed: s, blockLen: c, outputLen: i } = this;
+    return n = n, n.finished = r, n.destroyed = s, n.blockLen = c, n.outputLen = i, n.oHash = e._cloneInto(n.oHash), n.iHash = o._cloneInto(n.iHash), n;
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}, Wt = (t, n, e) => new Ce(t, n).update(e).digest();
+Wt.create = (t, n) => new Ce(t, n);
+var Xn = Be(BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991999")), N = Pn({
+  a: BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991996"),
+  b: BigInt("18505919022281880113072981827955639221458448578012075254857346196103069175443"),
+  Fp: Xn,
+  h: Tt,
+  n: BigInt("115792089210356248756420345214020892766061623724957744567843809356293439045923"),
+  Gx: BigInt("22963146547237050559479531362550074578802567295341616970375194840604139615431"),
+  Gy: BigInt("85132369209828568825618990617112496413088388631904505083283536607588877201568"),
+  hash: tt,
+  hmac: (t, ...n) => Wt(tt, t, j(...n)),
+  randomBytes: Vn
+}), J = Be(BigInt(N.CURVE.n));
+function Qt(t) {
+  const n = t ? yt(Z(BigInt(t), Tt) + Tt, 32) : N.utils.randomPrivateKey(), e = N.getPublicKey(n, !1), o = q(nt(n), 64), r = q(nt(e), 64);
+  return { privateKey: o, publicKey: r };
+}
+function Jn(t) {
+  if (t.length !== 130)
+    throw new Error("Invalid public key to compress");
+  const n = (t.length - 2) / 2, e = t.substring(2, 2 + n), o = _(t.substring(n + 2, n + n + 2));
+  let r = "03";
+  return Z(o, Nn) === Nt && (r = "02"), r + e;
+}
+function Bt(t) {
+  t = decodeURIComponent(encodeURIComponent(t));
+  const n = t.length, e = new Uint32Array((n >>> 2) + 1);
+  for (let r = 0; r < n; r++)
+    e[r >>> 2] |= (t.charCodeAt(r) & 255) << 24 - r % 4 * 8;
+  const o = [];
+  for (let r = 0; r < n; r++) {
+    const s = e[r >>> 2] >>> 24 - r % 4 * 8 & 255;
+    o.push((s >>> 4).toString(16)), o.push((s & 15).toString(16));
+  }
+  return o.join("");
+}
+function q(t, n) {
+  return t.length >= n ? t : new Array(n - t.length + 1).join("0") + t;
+}
+function qt(t) {
+  return t.map((n) => {
+    const e = n.toString(16);
+    return e.length === 1 ? "0" + e : e;
+  }).join("");
+}
+function Xt(t) {
+  const n = [];
+  for (let e = 0, o = t.length; e < o; e++)
+    t[e] >= 240 && t[e] <= 247 ? (n.push(String.fromCodePoint(((t[e] & 7) << 18) + ((t[e + 1] & 63) << 12) + ((t[e + 2] & 63) << 6) + (t[e + 3] & 63))), e += 3) : t[e] >= 224 && t[e] <= 239 ? (n.push(String.fromCodePoint(((t[e] & 15) << 12) + ((t[e + 1] & 63) << 6) + (t[e + 2] & 63))), e += 2) : t[e] >= 192 && t[e] <= 223 ? (n.push(String.fromCodePoint(((t[e] & 31) << 6) + (t[e + 1] & 63))), e++) : n.push(String.fromCodePoint(t[e]));
+  return n.join("");
+}
+function k(t) {
+  let n = t.length;
+  n % 2 !== 0 && (t = q(t, n + 1)), n = t.length;
+  const e = n / 2, o = new Uint8Array(e);
+  for (let r = 0; r < e; r++)
+    o[r] = parseInt(t.substring(r * 2, r * 2 + 2), 16);
+  return o;
+}
+function tr(t) {
+  const n = N.ProjectivePoint.fromHex(t);
+  if (!n)
+    return !1;
+  try {
+    return n.assertValidity(), !0;
+  } catch {
+    return !1;
+  }
+}
+function er(t, n) {
+  const e = N.ProjectivePoint.fromHex(t);
+  if (!e)
+    return !1;
+  const o = N.ProjectivePoint.fromHex(n);
+  return o ? e.equals(o) : !1;
+}
+var ye = _("80000000000000000000000000000000"), pe = _("7fffffffffffffffffffffffffffffff");
+function nr(t, n) {
+  let e = new Uint8Array(n), o = 1, r = 0, s = Jt;
+  const c = new Uint8Array(4), i = () => {
+    c[0] = o >> 24 & 255, c[1] = o >> 16 & 255, c[2] = o >> 8 & 255, c[3] = o & 255, s = tt(j(t, c)), o++, r = 0;
+  };
+  i();
+  for (let l = 0, f = e.length; l < f; l++)
+    r === s.length && i(), e[l] = s[r++] & 255;
+  return e;
+}
+function rr(t, n, e, o, r, s = !1, c = "1234567812345678", i = "1234567812345678") {
+  const l = N.ProjectivePoint.fromHex(n.publicKey), f = N.ProjectivePoint.fromHex(o), h = N.ProjectivePoint.fromHex(e);
+  let u = Lt(t.publicKey, c), m = Lt(e, i);
+  s && ([u, m] = [m, u]);
+  const b = _(n.privateKey), g = _(t.privateKey), a = l.x, w = ye + (a & pe), y = J.add(g, J.mulN(w, b)), v = f.x, S = J.add(ye, v & pe), I = f.multiply(S).add(h).multiply(y), T = k(q($(I.x), 64)), E = k(q($(I.y), 64));
+  return nr(j(T, E, u, m), r);
+}
+var Ne = 0, Jt = new Uint8Array();
+function or(t, n, e = 1) {
+  const o = typeof t == "string" ? k(Bt(t)) : Uint8Array.from(t), r = typeof n == "string" ? N.ProjectivePoint.fromHex(n) : n, s = Qt(), c = _(s.privateKey);
+  let i = s.publicKey;
+  i.length > 128 && (i = i.substring(i.length - 128));
+  const l = r.multiply(c), f = k(q($(l.x), 64)), h = k(q($(l.y), 64)), u = St(tt(j(f, o, h)));
+  Le(f, h, o);
+  const m = St(o);
+  return e === Ne ? i + m + u : i + u + m;
+}
+function Le(t, n, e) {
+  let o = 1, r = 0, s = Jt;
+  const c = new Uint8Array(4), i = () => {
+    c[0] = o >> 24 & 255, c[1] = o >> 16 & 255, c[2] = o >> 8 & 255, c[3] = o & 255, s = tt(j(t, n, c)), o++, r = 0;
+  };
+  i();
+  for (let l = 0, f = e.length; l < f; l++)
+    r === s.length && i(), e[l] ^= s[r++] & 255;
+}
+function sr(t, n, e = 1, {
+  output: o = "string"
+} = {}) {
+  const r = _(n);
+  let s = t.substring(128, 128 + 64), c = t.substring(128 + 64);
+  e === Ne && (s = t.substring(t.length - 64), c = t.substring(128, t.length - 64));
+  const i = k(c), f = N.ProjectivePoint.fromHex("04" + t.substring(0, 128)).multiply(r), h = k(q($(f.x), 64)), u = k(q($(f.y), 64));
+  return Le(h, u, i), qt(Array.from(tt(j(h, i, u)))) === s.toLowerCase() ? o === "array" ? i : Xt(i) : o === "array" ? [] : "";
+}
+function ir(t, n, e = {}) {
+  let {
+    pointPool: o,
+    der: r,
+    hash: s,
+    publicKey: c,
+    userId: i
+  } = e, l = typeof t == "string" ? Bt(t) : qt(Array.from(t));
+  s && (c = c || He(n), l = te(l, c, i));
+  const f = _(n), h = _(l);
+  let u = null, m = null, b = null;
+  do {
+    do {
+      let g;
+      o && o.length ? g = o.pop() : g = _e(), u = g.k, m = J.add(h, g.x1);
+    } while (m === Nt || m + u === N.CURVE.n);
+    b = J.mul(J.inv(J.addN(f, Tt)), J.subN(u, J.mulN(m, f)));
+  } while (b === Nt);
+  return r ? _n(m, b) : q($(m), 64) + q($(b), 64);
+}
+function cr(t, n, e, o = {}) {
+  let r;
+  const {
+    hash: s,
+    der: c,
+    userId: i
+  } = o, l = typeof e == "string" ? e : e.toHex(!1);
+  s ? r = te(typeof t == "string" ? Bt(t) : t, l, i) : r = typeof t == "string" ? Bt(t) : qt(Array.from(t));
+  let f, h;
+  if (c) {
+    const w = qn(n);
+    f = w.r, h = w.s;
+  } else
+    f = _(n.substring(0, 64)), h = _(n.substring(64));
+  const u = typeof e == "string" ? N.ProjectivePoint.fromHex(e) : e, m = _(r), b = J.add(f, h);
+  if (b === Nt)
+    return !1;
+  const g = N.ProjectivePoint.BASE.multiply(h).add(u.multiply(b)), a = J.add(m, g.x);
+  return f === a;
+}
+function Lt(t, n = "1234567812345678") {
+  n = Bt(n);
+  const e = q($(N.CURVE.a), 64), o = q($(N.CURVE.b), 64), r = q($(N.ProjectivePoint.BASE.x), 64), s = q($(N.ProjectivePoint.BASE.y), 64);
+  let c, i;
+  if (t.length === 128)
+    c = t.substring(0, 64), i = t.substring(64, 128);
+  else {
+    const u = N.ProjectivePoint.fromHex(t);
+    c = q($(u.x), 64), i = q($(u.y), 64);
+  }
+  const l = k(n + e + o + r + s + c + i), f = n.length * 4;
+  return tt(j(new Uint8Array([f >> 8 & 255, f & 255]), l));
+}
+function te(t, n, e = "1234567812345678") {
+  const o = Lt(n, e);
+  return St(tt(j(o, typeof t == "string" ? k(t) : t)));
+}
+function lr(t, n) {
+  const e = N.ProjectivePoint.fromHex(t);
+  return N.utils.precompute(n, e);
+}
+function He(t) {
+  const n = N.getPublicKey(t, !1);
+  return q(nt(n), 64);
+}
+function _e() {
+  const t = Qt(), n = N.ProjectivePoint.fromHex(t.publicKey), e = _(t.privateKey);
+  return {
+    ...t,
+    k: e,
+    x1: n.x
+  };
+}
+function qe(t) {
+  const n = [];
+  for (let e = 0, o = t.length; e < o; e++) {
+    const r = t.codePointAt(e);
+    if (r <= 127)
+      n.push(r);
+    else if (r <= 2047)
+      n.push(192 | r >>> 6), n.push(128 | r & 63);
+    else if (r <= 55295 || r >= 57344 && r <= 65535)
+      n.push(224 | r >>> 12), n.push(128 | r >>> 6 & 63), n.push(128 | r & 63);
+    else if (r >= 65536 && r <= 1114111)
+      e++, n.push(240 | r >>> 18 & 28), n.push(128 | r >>> 12 & 63), n.push(128 | r >>> 6 & 63), n.push(128 | r & 63);
+    else
+      throw n.push(r), new Error("input is not supported");
+  }
+  return new Uint8Array(n);
+}
+function Ir(t, n) {
+  if (t = typeof t == "string" ? qe(t) : t, n) {
+    if ((n.mode || "hmac") !== "hmac")
+      throw new Error("invalid mode");
+    let o = n.key;
+    if (!o)
+      throw new Error("invalid key");
+    return o = typeof o == "string" ? k(o) : o, St(Wt(tt, o, t));
+  }
+  return St(tt(t));
+}
+var fr = {};
+Te(fr, {
+  decrypt: () => gr,
+  encrypt: () => dr,
+  sm4: () => ee
+});
+var lt = 0, ur = 32, at = 16, Ot = Uint8Array.from([
+  214,
+  144,
+  233,
+  254,
+  204,
+  225,
+  61,
+  183,
+  22,
+  182,
+  20,
+  194,
+  40,
+  251,
+  44,
+  5,
+  43,
+  103,
+  154,
+  118,
+  42,
+  190,
+  4,
+  195,
+  170,
+  68,
+  19,
+  38,
+  73,
+  134,
+  6,
+  153,
+  156,
+  66,
+  80,
+  244,
+  145,
+  239,
+  152,
+  122,
+  51,
+  84,
+  11,
+  67,
+  237,
+  207,
+  172,
+  98,
+  228,
+  179,
+  28,
+  169,
+  201,
+  8,
+  232,
+  149,
+  128,
+  223,
+  148,
+  250,
+  117,
+  143,
+  63,
+  166,
+  71,
+  7,
+  167,
+  252,
+  243,
+  115,
+  23,
+  186,
+  131,
+  89,
+  60,
+  25,
+  230,
+  133,
+  79,
+  168,
+  104,
+  107,
+  129,
+  178,
+  113,
+  100,
+  218,
+  139,
+  248,
+  235,
+  15,
+  75,
+  112,
+  86,
+  157,
+  53,
+  30,
+  36,
+  14,
+  94,
+  99,
+  88,
+  209,
+  162,
+  37,
+  34,
+  124,
+  59,
+  1,
+  33,
+  120,
+  135,
+  212,
+  0,
+  70,
+  87,
+  159,
+  211,
+  39,
+  82,
+  76,
+  54,
+  2,
+  231,
+  160,
+  196,
+  200,
+  158,
+  234,
+  191,
+  138,
+  210,
+  64,
+  199,
+  56,
+  181,
+  163,
+  247,
+  242,
+  206,
+  249,
+  97,
+  21,
+  161,
+  224,
+  174,
+  93,
+  164,
+  155,
+  52,
+  26,
+  85,
+  173,
+  147,
+  50,
+  48,
+  245,
+  140,
+  177,
+  227,
+  29,
+  246,
+  226,
+  46,
+  130,
+  102,
+  202,
+  96,
+  192,
+  41,
+  35,
+  171,
+  13,
+  83,
+  78,
+  111,
+  213,
+  219,
+  55,
+  69,
+  222,
+  253,
+  142,
+  47,
+  3,
+  255,
+  106,
+  114,
+  109,
+  108,
+  91,
+  81,
+  141,
+  27,
+  175,
+  146,
+  187,
+  221,
+  188,
+  127,
+  17,
+  217,
+  92,
+  65,
+  31,
+  16,
+  90,
+  216,
+  10,
+  193,
+  49,
+  136,
+  165,
+  205,
+  123,
+  189,
+  45,
+  116,
+  208,
+  18,
+  184,
+  229,
+  180,
+  176,
+  137,
+  105,
+  151,
+  74,
+  12,
+  150,
+  119,
+  126,
+  101,
+  185,
+  241,
+  9,
+  197,
+  110,
+  198,
+  132,
+  24,
+  240,
+  125,
+  236,
+  58,
+  220,
+  77,
+  32,
+  121,
+  238,
+  95,
+  62,
+  215,
+  203,
+  57,
+  72
+]), Pt = new Uint32Array([
+  462357,
+  472066609,
+  943670861,
+  1415275113,
+  1886879365,
+  2358483617,
+  2830087869,
+  3301692121,
+  3773296373,
+  4228057617,
+  404694573,
+  876298825,
+  1347903077,
+  1819507329,
+  2291111581,
+  2762715833,
+  3234320085,
+  3705924337,
+  4177462797,
+  337322537,
+  808926789,
+  1280531041,
+  1752135293,
+  2223739545,
+  2695343797,
+  3166948049,
+  3638552301,
+  4110090761,
+  269950501,
+  741554753,
+  1213159005,
+  1684763257
+]);
+function ft(t) {
+  return (Ot[t >>> 24 & 255] & 255) << 24 | (Ot[t >>> 16 & 255] & 255) << 16 | (Ot[t >>> 8 & 255] & 255) << 8 | Ot[t & 255] & 255;
+}
+function ar(t, n, e) {
+  let o = 0, r = 0, s = 0, c = 0, i = 0, l = 0, f = 0, h = 0;
+  i = t[0] & 255, l = t[1] & 255, f = t[2] & 255, h = t[3] & 255, o = i << 24 | l << 16 | f << 8 | h, i = t[4] & 255, l = t[5] & 255, f = t[6] & 255, h = t[7] & 255, r = i << 24 | l << 16 | f << 8 | h, i = t[8] & 255, l = t[9] & 255, f = t[10] & 255, h = t[11] & 255, s = i << 24 | l << 16 | f << 8 | h, i = t[12] & 255, l = t[13] & 255, f = t[14] & 255, h = t[15] & 255, c = i << 24 | l << 16 | f << 8 | h;
+  for (let u = 0; u < 32; u += 4)
+    i = r ^ s ^ c ^ e[u], i = ft(i), o ^= i ^ (i << 2 | i >>> 30) ^ (i << 10 | i >>> 22) ^ (i << 18 | i >>> 14) ^ (i << 24 | i >>> 8), l = s ^ c ^ o ^ e[u + 1], l = ft(l), r ^= l ^ (l << 2 | l >>> 30) ^ (l << 10 | l >>> 22) ^ (l << 18 | l >>> 14) ^ (l << 24 | l >>> 8), f = c ^ o ^ r ^ e[u + 2], f = ft(f), s ^= f ^ (f << 2 | f >>> 30) ^ (f << 10 | f >>> 22) ^ (f << 18 | f >>> 14) ^ (f << 24 | f >>> 8), h = o ^ r ^ s ^ e[u + 3], h = ft(h), c ^= h ^ (h << 2 | h >>> 30) ^ (h << 10 | h >>> 22) ^ (h << 18 | h >>> 14) ^ (h << 24 | h >>> 8);
+  n[0] = c >>> 24 & 255, n[1] = c >>> 16 & 255, n[2] = c >>> 8 & 255, n[3] = c & 255, n[4] = s >>> 24 & 255, n[5] = s >>> 16 & 255, n[6] = s >>> 8 & 255, n[7] = s & 255, n[8] = r >>> 24 & 255, n[9] = r >>> 16 & 255, n[10] = r >>> 8 & 255, n[11] = r & 255, n[12] = o >>> 24 & 255, n[13] = o >>> 16 & 255, n[14] = o >>> 8 & 255, n[15] = o & 255;
+}
+function hr(t, n, e) {
+  let o = 0, r = 0, s = 0, c = 0, i = 0;
+  o = (t[0] & 255) << 24 | (t[1] & 255) << 16 | (t[2] & 255) << 8 | t[3] & 255, r = (t[4] & 255) << 24 | (t[5] & 255) << 16 | (t[6] & 255) << 8 | t[7] & 255, s = (t[8] & 255) << 24 | (t[9] & 255) << 16 | (t[10] & 255) << 8 | t[11] & 255, c = (t[12] & 255) << 24 | (t[13] & 255) << 16 | (t[14] & 255) << 8 | t[15] & 255, o ^= 2746333894, r ^= 1453994832, s ^= 1736282519, c ^= 2993693404;
+  for (let l = 0; l < 32; l += 4)
+    i = r ^ s ^ c ^ Pt[l + 0], i = ft(i), o ^= i ^ (i << 13 | i >>> 19) ^ (i << 23 | i >>> 9), n[l + 0] = o, i = s ^ c ^ o ^ Pt[l + 1], i = ft(i), r ^= i ^ (i << 13 | i >>> 19) ^ (i << 23 | i >>> 9), n[l + 1] = r, i = c ^ o ^ r ^ Pt[l + 2], i = ft(i), s ^= i ^ (i << 13 | i >>> 19) ^ (i << 23 | i >>> 9), n[l + 2] = s, i = o ^ r ^ s ^ Pt[l + 3], i = ft(i), c ^= i ^ (i << 13 | i >>> 19) ^ (i << 23 | i >>> 9), n[l + 3] = c;
+  if (e === lt)
+    for (let l = 0; l < 16; l++)
+      [n[l], n[31 - l]] = [n[31 - l], n[l]];
+}
+var Ut = new Uint8Array(16);
+function ee(t, n, e, o = {}) {
+  let {
+    padding: r = "pkcs#7",
+    mode: s,
+    iv: c = new Uint8Array(16),
+    output: i
+  } = o;
+  if (s === "cbc" && (typeof c == "string" && (c = k(c)), c.length !== 128 / 8))
+    throw new Error("iv is invalid");
+  if (typeof n == "string" && (n = k(n)), n.length !== 128 / 8)
+    throw new Error("key is invalid");
+  if (typeof t == "string" ? e !== lt ? t = qe(t) : t = k(t) : t = Uint8Array.from(t), (r === "pkcs#5" || r === "pkcs#7") && e !== lt) {
+    const b = at - t.length % at, g = new Uint8Array(t.length + b);
+    g.set(t, 0);
+    for (let a = 0; a < b; a++)
+      g[t.length + a] = b;
+    t = g;
+  }
+  const l = new Uint32Array(ur);
+  hr(n, l, e);
+  let f = new Uint8Array(t.length), h = c, u = t.length, m = 0;
+  for (; u >= at; ) {
+    const b = t.subarray(m, m + 16);
+    if (s === "cbc")
+      for (let g = 0; g < at; g++)
+        e !== lt && (b[g] ^= h[g]);
+    ar(b, Ut, l);
+    for (let g = 0; g < at; g++)
+      s === "cbc" && e === lt && (Ut[g] ^= h[g]), f[m + g] = Ut[g];
+    s === "cbc" && (e !== lt ? h = Ut : h = b), u -= at, m += at;
+  }
+  if ((r === "pkcs#5" || r === "pkcs#7") && e === lt) {
+    const b = f.length, g = f[b - 1];
+    for (let a = 1; a <= g; a++)
+      if (f[b - a] !== g)
+        throw new Error("padding is invalid");
+    f = f.slice(0, b - g);
+  }
+  return i !== "array" ? e !== lt ? St(f) : Xt(f) : f;
+}
+function dr(t, n, e = {}) {
+  return ee(t, n, 1, e);
+}
+function gr(t, n, e = {}) {
+  return ee(t, n, 0, e);
+}
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+export {
+  be as S,
+  vr as a,
+  Sr as b,
+  Ar as c,
+  Br as d,
+  Er as e,
+  Ir as f,
+  fr as g,
+  br as h,
+  We as i,
+  xr as j,
+  en as k,
+  Cn as s,
+  Ge as u
+};
+//# sourceMappingURL=index-82d74e5f.mjs.map