@nsite/stealthis 0.1.0

package/dist/nsite-deploy.mjs

@@ -0,0 +1,4999 @@
+const pr = (
+  /*css*/
+  `
+  :host {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  }
+
+  .nd-trigger {
+    padding: 10px 18px;
+    background: #9b59b6;
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    font-size: 14px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: background 0.2s;
+  }
+  .nd-trigger:hover { background: #8e44ad; }
+  .nd-trigger:disabled { opacity: 0.6; cursor: default; }
+  :host(.nd-fixed) .nd-trigger {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    z-index: 99999;
+    box-shadow: 0 2px 12px rgba(0,0,0,0.3);
+  }
+
+  .nd-overlay {
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,0.6);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 100000;
+    backdrop-filter: blur(4px);
+  }
+
+  .nd-modal {
+    background: #1a1a2e;
+    border: 1px solid #0f3460;
+    border-radius: 12px;
+    padding: 24px;
+    width: 90%;
+    max-width: 420px;
+    color: #e0e0e0;
+    max-height: 90vh;
+    overflow-y: auto;
+  }
+
+  .nd-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 16px;
+  }
+  .nd-title {
+    margin: 0;
+    font-size: 18px;
+    font-weight: 700;
+  }
+  .nd-close {
+    background: none;
+    border: none;
+    color: #888;
+    font-size: 22px;
+    cursor: pointer;
+    padding: 0 0 0 8px;
+    line-height: 1;
+  }
+  .nd-close:hover { color: #e0e0e0; }
+
+  /* Auth section */
+  .nd-auth-option {
+    margin-bottom: 16px;
+  }
+  .nd-auth-option:last-child {
+    margin-bottom: 0;
+  }
+
+  .nd-divider {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    margin: 16px 0;
+    font-size: 12px;
+    color: #555;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+  .nd-divider::before, .nd-divider::after {
+    content: '';
+    flex: 1;
+    height: 1px;
+    background: #0f3460;
+  }
+
+  .nd-btn-ext {
+    width: 100%;
+    padding: 12px;
+    background: #9b59b6;
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    font-size: 14px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: background 0.2s;
+  }
+  .nd-btn-ext:hover { background: #8e44ad; }
+
+  .nd-bunker-row {
+    display: flex;
+    gap: 8px;
+  }
+  .nd-bunker-row input {
+    flex: 1;
+    padding: 8px 12px;
+    background: #16213e;
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    color: #e0e0e0;
+    font-size: 13px;
+    font-family: inherit;
+    box-sizing: border-box;
+    min-width: 0;
+  }
+  .nd-bunker-row input:focus {
+    outline: none;
+    border-color: #9b59b6;
+  }
+  .nd-bunker-row button {
+    padding: 8px 14px;
+    background: #16213e;
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    color: #e0e0e0;
+    font-size: 13px;
+    font-weight: 600;
+    cursor: pointer;
+    white-space: nowrap;
+  }
+  .nd-bunker-row button:hover { background: #0f3460; }
+
+  .nd-qr-wrap {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 10px;
+  }
+  .nd-qr-label {
+    font-size: 12px;
+    color: #888;
+  }
+  .nd-qr-code {
+    background: #fff;
+    border-radius: 8px;
+    padding: 12px;
+    display: inline-flex;
+  }
+  .nd-qr-code svg {
+    display: block;
+    width: 200px;
+    height: 200px;
+  }
+  .nd-relay-row {
+    display: flex;
+    gap: 0;
+    width: 100%;
+    max-width: 300px;
+  }
+  .nd-relay-row label {
+    padding: 6px 10px;
+    background: #0f3460;
+    border: 1px solid #0f3460;
+    border-right: none;
+    border-radius: 4px 0 0 4px;
+    color: #888;
+    font-size: 11px;
+    white-space: nowrap;
+    display: flex;
+    align-items: center;
+  }
+  .nd-relay-row input {
+    flex: 1;
+    padding: 6px 8px;
+    background: #16213e;
+    border: 1px solid #0f3460;
+    border-radius: 0 4px 4px 0;
+    color: #e0e0e0;
+    font-size: 11px;
+    font-family: monospace;
+    min-width: 0;
+    box-sizing: border-box;
+  }
+  .nd-relay-row input:focus {
+    outline: none;
+    border-color: #9b59b6;
+  }
+  .nd-qr-uri {
+    display: flex;
+    gap: 6px;
+    width: 100%;
+    max-width: 300px;
+  }
+  .nd-qr-uri input {
+    flex: 1;
+    padding: 6px 8px;
+    background: #16213e;
+    border: 1px solid #0f3460;
+    border-radius: 4px;
+    color: #888;
+    font-size: 11px;
+    font-family: monospace;
+    min-width: 0;
+    box-sizing: border-box;
+  }
+  .nd-qr-uri button {
+    padding: 6px 10px;
+    background: #16213e;
+    border: 1px solid #0f3460;
+    border-radius: 4px;
+    color: #e0e0e0;
+    font-size: 11px;
+    cursor: pointer;
+    white-space: nowrap;
+  }
+  .nd-qr-uri button:hover { background: #0f3460; }
+
+  /* Toggle */
+  .nd-toggle {
+    display: flex;
+    margin-bottom: 16px;
+    background: #16213e;
+    border-radius: 6px;
+    padding: 3px;
+  }
+  .nd-toggle-btn {
+    flex: 1;
+    padding: 8px;
+    background: transparent;
+    border: none;
+    border-radius: 4px;
+    color: #888;
+    font-size: 13px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s;
+  }
+  .nd-toggle-btn.active {
+    background: #9b59b6;
+    color: #fff;
+  }
+
+  /* Warning */
+  .nd-warn {
+    background: rgba(231, 76, 60, 0.1);
+    border: 1px solid rgba(231, 76, 60, 0.3);
+    border-radius: 6px;
+    padding: 12px;
+    font-size: 13px;
+    color: #e74c3c;
+    line-height: 1.5;
+  }
+  .nd-btn-warn {
+    background: #e74c3c;
+    color: #fff;
+  }
+  .nd-btn-warn:hover { background: #c0392b; }
+
+  .nd-root-hint {
+    font-size: 13px;
+    color: #888;
+    margin-bottom: 12px;
+    word-break: break-all;
+  }
+  .nd-root-hint strong {
+    color: #e0e0e0;
+  }
+
+  /* Form fields */
+  .nd-field {
+    margin-bottom: 12px;
+  }
+  .nd-field label {
+    display: block;
+    font-size: 11px;
+    color: #888;
+    margin-bottom: 4px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+  .nd-field input, .nd-field textarea {
+    width: 100%;
+    padding: 8px 12px;
+    background: #16213e;
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    color: #e0e0e0;
+    font-size: 14px;
+    font-family: inherit;
+    box-sizing: border-box;
+  }
+  .nd-field input:focus, .nd-field textarea:focus {
+    outline: none;
+    border-color: #9b59b6;
+  }
+  .nd-field textarea {
+    resize: vertical;
+    min-height: 60px;
+  }
+  .nd-hint {
+    font-size: 11px;
+    color: #888;
+    margin-top: 3px;
+  }
+  .nd-field-error {
+    font-size: 11px;
+    color: #e74c3c;
+    margin-top: 3px;
+  }
+
+  /* Actions */
+  .nd-actions {
+    display: flex;
+    gap: 8px;
+    margin-top: 16px;
+  }
+  .nd-btn {
+    flex: 1;
+    padding: 10px;
+    border: none;
+    border-radius: 6px;
+    font-size: 14px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: background 0.2s;
+  }
+  .nd-btn-primary {
+    background: #9b59b6;
+    color: #fff;
+  }
+  .nd-btn-primary:hover { background: #8e44ad; }
+  .nd-btn-primary:disabled { opacity: 0.5; cursor: not-allowed; }
+  .nd-btn-secondary {
+    background: #16213e;
+    color: #e0e0e0;
+    border: 1px solid #0f3460;
+  }
+  .nd-btn-secondary:hover { background: #0f3460; }
+
+  /* Status */
+  .nd-status {
+    margin-top: 12px;
+    font-size: 13px;
+    color: #888;
+  }
+  .nd-status-ok { color: #2ecc71; }
+  .nd-status-err { color: #e74c3c; }
+
+  .nd-link {
+    display: block;
+    margin-top: 12px;
+    padding: 10px;
+    background: #16213e;
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    color: #9b59b6;
+    text-decoration: none;
+    text-align: center;
+    font-size: 13px;
+    word-break: break-all;
+  }
+  .nd-link:hover { background: #0f3460; }
+
+  .nd-msg {
+    text-align: center;
+    padding: 20px 0;
+    font-size: 14px;
+    color: #888;
+  }
+
+  /* Paper trail */
+  .nd-trail {
+    margin-top: 8px;
+    text-align: center;
+  }
+  .nd-trail-toggle {
+    background: none;
+    border: none;
+    color: #888;
+    font-size: 12px;
+    cursor: pointer;
+    padding: 4px 8px;
+    transition: color 0.2s;
+  }
+  .nd-trail-toggle:hover { color: #e0e0e0; }
+  .nd-trail-list {
+    margin-top: 6px;
+    text-align: left;
+    font-size: 12px;
+    color: #888;
+    max-height: 200px;
+    overflow-y: auto;
+  }
+  .nd-trail-item {
+    padding: 3px 0;
+    font-family: monospace;
+    font-size: 11px;
+    display: flex;
+    gap: 6px;
+  }
+  .nd-trail-idx {
+    color: #555;
+    min-width: 24px;
+    text-align: right;
+  }
+  .nd-trail-pk {
+    color: #9b59b6;
+  }
+  .nd-trail-gap {
+    padding: 3px 0;
+    color: #555;
+    font-style: italic;
+  }
+
+  @keyframes nd-spin {
+    to { transform: rotate(360deg); }
+  }
+  .nd-spinner {
+    display: inline-block;
+    width: 18px;
+    height: 18px;
+    border: 2px solid #555;
+    border-top-color: #9b59b6;
+    border-radius: 50%;
+    animation: nd-spin 0.8s linear infinite;
+    vertical-align: middle;
+    margin-right: 8px;
+  }
+`
+);
+function _t(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function me(t, e = "") {
+  if (!Number.isSafeInteger(t) || t < 0) {
+    const r = e && `"${e}" `;
+    throw new Error(`${r}expected integer >= 0, got ${t}`);
+  }
+}
+function G(t, e, r = "") {
+  const n = _t(t), i = t?.length, s = e !== void 0;
+  if (!n || s && i !== e) {
+    const o = r && `"${r}" `, a = s ? ` of length ${e}` : "", u = n ? `length=${i}` : `type=${typeof t}`;
+    throw new Error(o + "expected Uint8Array" + a + ", got " + u);
+  }
+  return t;
+}
+function tt(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  me(t.outputLen), me(t.blockLen);
+}
+function ze(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 br(t, e) {
+  G(t, void 0, "digestInto() output");
+  const r = e.outputLen;
+  if (t.length < r)
+    throw new Error('"digestInto() output" expected to be of length >=' + r);
+}
+function Ne(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function at(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function de(t, e) {
+  return t << 32 - e | t >>> e;
+}
+const yn = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", yr = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function le(t) {
+  if (G(t), yn)
+    return t.toHex();
+  let e = "";
+  for (let r = 0; r < t.length; r++)
+    e += yr[t[r]];
+  return e;
+}
+const ge = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function Ft(t) {
+  if (t >= ge._0 && t <= ge._9)
+    return t - ge._0;
+  if (t >= ge.A && t <= ge.F)
+    return t - (ge.A - 10);
+  if (t >= ge.a && t <= ge.f)
+    return t - (ge.a - 10);
+}
+function ie(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (yn)
+    return Uint8Array.fromHex(t);
+  const e = t.length, r = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const n = new Uint8Array(r);
+  for (let i = 0, s = 0; i < r; i++, s += 2) {
+    const o = Ft(t.charCodeAt(s)), a = Ft(t.charCodeAt(s + 1));
+    if (o === void 0 || a === void 0) {
+      const u = t[s] + t[s + 1];
+      throw new Error('hex string expected, got non-hex character "' + u + '" at index ' + s);
+    }
+    n[i] = o * 16 + a;
+  }
+  return n;
+}
+function oe(...t) {
+  let e = 0;
+  for (let n = 0; n < t.length; n++) {
+    const i = t[n];
+    G(i), e += i.length;
+  }
+  const r = new Uint8Array(e);
+  for (let n = 0, i = 0; n < t.length; n++) {
+    const s = t[n];
+    r.set(s, i), i += s.length;
+  }
+  return r;
+}
+function wr(t, e = {}) {
+  const r = (i, s) => t(s).update(i).digest(), n = t(void 0);
+  return r.outputLen = n.outputLen, r.blockLen = n.blockLen, r.create = (i) => t(i), Object.assign(r, e), Object.freeze(r);
+}
+function $e(t = 32) {
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof e?.getRandomValues != "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return e.getRandomValues(new Uint8Array(t));
+}
+const vr = (t) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, t])
+});
+function Tt(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function mr(t) {
+  if (!Tt(t))
+    throw new Error("Uint8Array expected");
+}
+function wn(t, e) {
+  return Array.isArray(e) ? e.length === 0 ? !0 : t ? e.every((r) => typeof r == "string") : e.every((r) => Number.isSafeInteger(r)) : !1;
+}
+function xr(t) {
+  if (typeof t != "function")
+    throw new Error("function expected");
+  return !0;
+}
+function Se(t, e) {
+  if (typeof e != "string")
+    throw new Error(`${t}: string expected`);
+  return !0;
+}
+function Ct(t) {
+  if (!Number.isSafeInteger(t))
+    throw new Error(`invalid integer: ${t}`);
+}
+function vt(t) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+}
+function We(t, e) {
+  if (!wn(!0, e))
+    throw new Error(`${t}: array of strings expected`);
+}
+function vn(t, e) {
+  if (!wn(!1, e))
+    throw new Error(`${t}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function mn(...t) {
+  const e = (s) => s, r = (s, o) => (a) => s(o(a)), n = t.map((s) => s.encode).reduceRight(r, e), i = t.map((s) => s.decode).reduce(r, e);
+  return { encode: n, decode: i };
+}
+// @__NO_SIDE_EFFECTS__
+function xn(t) {
+  const e = typeof t == "string" ? t.split("") : t, r = e.length;
+  We("alphabet", e);
+  const n = new Map(e.map((i, s) => [i, s]));
+  return {
+    encode: (i) => (vt(i), i.map((s) => {
+      if (!Number.isSafeInteger(s) || s < 0 || s >= r)
+        throw new Error(`alphabet.encode: digit index outside alphabet "${s}". Allowed: ${t}`);
+      return e[s];
+    })),
+    decode: (i) => (vt(i), i.map((s) => {
+      Se("alphabet.decode", s);
+      const o = n.get(s);
+      if (o === void 0)
+        throw new Error(`Unknown letter: "${s}". Allowed: ${t}`);
+      return o;
+    }))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function En(t = "") {
+  return Se("join", t), {
+    encode: (e) => (We("join.decode", e), e.join(t)),
+    decode: (e) => (Se("join.decode", e), e.split(t))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Er(t, e = "=") {
+  return Ct(t), Se("padding", e), {
+    encode(r) {
+      for (We("padding.encode", r); r.length * t % 8; )
+        r.push(e);
+      return r;
+    },
+    decode(r) {
+      We("padding.decode", r);
+      let n = r.length;
+      if (n * t % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; n > 0 && r[n - 1] === e; n--)
+        if ((n - 1) * t % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      return r.slice(0, n);
+    }
+  };
+}
+const kn = (t, e) => e === 0 ? t : kn(e, t % e), Ye = /* @__NO_SIDE_EFFECTS__ */ (t, e) => t + (e - kn(t, e)), Ve = /* @__PURE__ */ (() => {
+  let t = [];
+  for (let e = 0; e < 40; e++)
+    t.push(2 ** e);
+  return t;
+})();
+function mt(t, e, r, n) {
+  if (vt(t), e <= 0 || e > 32)
+    throw new Error(`convertRadix2: wrong from=${e}`);
+  if (r <= 0 || r > 32)
+    throw new Error(`convertRadix2: wrong to=${r}`);
+  if (/* @__PURE__ */ Ye(e, r) > 32)
+    throw new Error(`convertRadix2: carry overflow from=${e} to=${r} carryBits=${/* @__PURE__ */ Ye(e, r)}`);
+  let i = 0, s = 0;
+  const o = Ve[e], a = Ve[r] - 1, u = [];
+  for (const w of t) {
+    if (Ct(w), w >= o)
+      throw new Error(`convertRadix2: invalid data word=${w} from=${e}`);
+    if (i = i << e | w, s + e > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${s} from=${e}`);
+    for (s += e; s >= r; s -= r)
+      u.push((i >> s - r & a) >>> 0);
+    const T = Ve[s];
+    if (T === void 0)
+      throw new Error("invalid carry");
+    i &= T - 1;
+  }
+  if (i = i << r - s & a, !n && s >= e)
+    throw new Error("Excess padding");
+  if (!n && i > 0)
+    throw new Error(`Non-zero padding: ${i}`);
+  return n && s > 0 && u.push(i >>> 0), u;
+}
+// @__NO_SIDE_EFFECTS__
+function An(t, e = !1) {
+  if (Ct(t), t <= 0 || t > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ Ye(8, t) > 32 || /* @__PURE__ */ Ye(t, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (r) => {
+      if (!Tt(r))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return mt(Array.from(r), 8, t, !e);
+    },
+    decode: (r) => (vn("radix2.decode", r), Uint8Array.from(mt(r, t, 8, e)))
+  };
+}
+function Vt(t) {
+  return xr(t), function(...e) {
+    try {
+      return t.apply(null, e);
+    } catch {
+    }
+  };
+}
+const kr = typeof Uint8Array.from([]).toBase64 == "function" && typeof Uint8Array.fromBase64 == "function", Ar = (t, e) => {
+  Se("base64", t);
+  const r = /^[A-Za-z0-9=+/]+$/, n = "base64";
+  if (t.length > 0 && !r.test(t))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(t, { alphabet: n, lastChunkHandling: "strict" });
+}, Sn = kr ? {
+  encode(t) {
+    return mr(t), t.toBase64();
+  },
+  decode(t) {
+    return Ar(t);
+  }
+} : /* @__PURE__ */ mn(/* @__PURE__ */ An(6), /* @__PURE__ */ xn("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ Er(6), /* @__PURE__ */ En("")), xt = /* @__PURE__ */ mn(/* @__PURE__ */ xn("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ En("")), Zt = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function Ce(t) {
+  const e = t >> 25;
+  let r = (t & 33554431) << 5;
+  for (let n = 0; n < Zt.length; n++)
+    (e >> n & 1) === 1 && (r ^= Zt[n]);
+  return r;
+}
+function jt(t, e, r = 1) {
+  const n = t.length;
+  let i = 1;
+  for (let s = 0; s < n; s++) {
+    const o = t.charCodeAt(s);
+    if (o < 33 || o > 126)
+      throw new Error(`Invalid prefix (${t})`);
+    i = Ce(i) ^ o >> 5;
+  }
+  i = Ce(i);
+  for (let s = 0; s < n; s++)
+    i = Ce(i) ^ t.charCodeAt(s) & 31;
+  for (let s of e)
+    i = Ce(i) ^ s;
+  for (let s = 0; s < 6; s++)
+    i = Ce(i);
+  return i ^= r, xt.encode(mt([i % Ve[30]], 30, 5, !1));
+}
+// @__NO_SIDE_EFFECTS__
+function Sr(t) {
+  const e = t === "bech32" ? 1 : 734539939, r = /* @__PURE__ */ An(5), n = r.decode, i = r.encode, s = Vt(n);
+  function o(R, _, k = 90) {
+    Se("bech32.encode prefix", R), Tt(_) && (_ = Array.from(_)), vn("bech32.encode", _);
+    const P = R.length;
+    if (P === 0)
+      throw new TypeError(`Invalid prefix length ${P}`);
+    const q = P + 7 + _.length;
+    if (k !== !1 && q > k)
+      throw new TypeError(`Length ${q} exceeds limit ${k}`);
+    const U = R.toLowerCase(), H = jt(U, _, e);
+    return `${U}1${xt.encode(_)}${H}`;
+  }
+  function a(R, _ = 90) {
+    Se("bech32.decode input", R);
+    const k = R.length;
+    if (k < 8 || _ !== !1 && k > _)
+      throw new TypeError(`invalid string length: ${k} (${R}). Expected (8..${_})`);
+    const P = R.toLowerCase();
+    if (R !== P && R !== R.toUpperCase())
+      throw new Error("String must be lowercase or uppercase");
+    const q = P.lastIndexOf("1");
+    if (q === 0 || q === -1)
+      throw new Error('Letter "1" must be present between prefix and data only');
+    const U = P.slice(0, q), H = P.slice(q + 1);
+    if (H.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const W = xt.decode(H).slice(0, -6), ne = jt(U, W, e);
+    if (!H.endsWith(ne))
+      throw new Error(`Invalid checksum in ${R}: expected "${ne}"`);
+    return { prefix: U, words: W };
+  }
+  const u = Vt(a);
+  function w(R) {
+    const { prefix: _, words: k } = a(R, !1);
+    return { prefix: _, words: k, bytes: n(k) };
+  }
+  function T(R, _) {
+    return o(R, i(_));
+  }
+  return {
+    encode: o,
+    decode: a,
+    encodeFromBytes: T,
+    decodeToBytes: w,
+    decodeUnsafe: u,
+    fromWords: n,
+    fromWordsUnsafe: s,
+    toWords: i
+  };
+}
+const zt = /* @__PURE__ */ Sr("bech32");
+new TextDecoder("utf-8");
+new TextEncoder();
+var Br = 5e3;
+function Bn(t) {
+  return _r("npub", ie(t));
+}
+function Rr(t, e) {
+  let r = zt.toWords(e);
+  return zt.encode(t, r, Br);
+}
+function _r(t, e) {
+  return Rr(t, e);
+}
+const Ie = ["wss://purplepag.es", "wss://relay.damus.io", "wss://nos.lol"], Ze = 50, Tr = /^[a-z0-9-]{1,13}$/, Cr = /^[0-9a-z]{50}[a-z0-9-]{1,13}$/;
+function Lr(t) {
+  return BigInt("0x" + t).toString(36).padStart(Ze, "0");
+}
+function Or(t) {
+  let e = 0n;
+  for (const r of t) e = e * 36n + BigInt(parseInt(r, 36));
+  return e.toString(16).padStart(64, "0");
+}
+function Ir(t) {
+  if (!t.startsWith("npub1")) return null;
+  const e = "qpzry9x8gf2tvdw0s3jn54khce6mua7l", r = [];
+  for (const a of t.slice(5)) {
+    const u = e.indexOf(a);
+    if (u === -1) return null;
+    r.push(u);
+  }
+  const n = r.slice(0, -6);
+  let i = 0, s = 0;
+  const o = [];
+  for (const a of n)
+    for (i = i << 5 | a, s += 5; s >= 8; )
+      s -= 8, o.push(i >> s & 255);
+  return o.length !== 32 ? null : o.map((a) => a.toString(16).padStart(2, "0")).join("");
+}
+function Pr() {
+  const t = window.location.hostname.split(".");
+  for (let r = 0; r < t.length; r++)
+    if (t[r].startsWith("npub1") && t[r].length >= 63) {
+      const n = Ir(t[r]);
+      if (n) return { pubkey: n, baseDomain: t.slice(r + 1).join(".") };
+    }
+  const e = t[0];
+  if (e && e.length > Ze && e.length <= 63 && Cr.test(e) && !e.endsWith("-"))
+    try {
+      return { pubkey: Or(e.slice(0, Ze)), identifier: e.slice(Ze), baseDomain: t.slice(1).join(".") };
+    } catch {
+    }
+  return null;
+}
+function Mr(t) {
+  return Tr.test(t) && !t.endsWith("-");
+}
+function Rn(t, e, r, n = 5e3) {
+  return new Promise((i) => {
+    try {
+      const s = new WebSocket(t), o = setTimeout(() => {
+        try {
+          s.close();
+        } catch {
+        }
+        i();
+      }, n), a = () => {
+        clearTimeout(o);
+        try {
+          s.close();
+        } catch {
+        }
+        i();
+      };
+      s.onopen = () => s.send(JSON.stringify(e)), s.onmessage = (u) => {
+        try {
+          r(JSON.parse(u.data)) && a();
+        } catch {
+        }
+      }, s.onerror = () => a();
+    } catch {
+      i();
+    }
+  });
+}
+async function Pe(t, e) {
+  const r = /* @__PURE__ */ new Map(), n = Math.random().toString(36).slice(2, 8);
+  return await Promise.allSettled(
+    t.map(
+      (i) => Rn(i, ["REQ", n, e], (s) => (s[0] === "EVENT" && s[1] === n && r.set(s[2].id, s[2]), s[0] === "EOSE" && s[1] === n))
+    )
+  ), [...r.values()];
+}
+async function Nr(t, e) {
+  let r = !1;
+  return await Rn(t, ["EVENT", e], (n) => n[0] === "OK" ? (r = n[2] === !0, !0) : !1), r;
+}
+async function $r(t, e) {
+  return (await Promise.allSettled(t.map((n) => Nr(n, e)))).filter((n) => n.status === "fulfilled" && n.value).length;
+}
+function _n(t) {
+  const e = /* @__PURE__ */ new Set();
+  for (const r of t)
+    for (const n of r.tags)
+      n[0] === "r" && n[1]?.startsWith("wss://") && (!n[2] || n[2] === "write") && e.add(n[1].trim());
+  return [...e];
+}
+async function Wt(t) {
+  const e = t.identifier ? { kinds: [35128], authors: [t.pubkey], "#d": [t.identifier] } : { kinds: [15128], authors: [t.pubkey], limit: 1 }, [r, n] = await Promise.all([
+    Pe(Ie, e),
+    Pe(Ie, { kinds: [10002], authors: [t.pubkey], limit: 5 })
+  ]);
+  if (r.length > 0)
+    return r.sort((o, a) => a.created_at - o.created_at)[0];
+  const i = _n(n).filter(
+    (o) => !Ie.includes(o)
+  );
+  return i.length === 0 ? null : (await Pe(i, e)).sort((o, a) => a.created_at - o.created_at)[0] ?? null;
+}
+async function Yt(t) {
+  const e = await Pe(Ie, {
+    kinds: [10002],
+    authors: [t],
+    limit: 5
+  }), r = _n(e);
+  return r.length > 0 ? r : Ie.filter((n) => n !== "wss://purplepag.es");
+}
+async function Jt(t, e, r) {
+  return (await Pe(t, r ? { kinds: [35128], authors: [e], "#d": [r], limit: 1 } : { kinds: [15128], authors: [e], limit: 1 })).length > 0;
+}
+const Gt = 9;
+function Dr(t) {
+  return t.tags.filter((e) => e[0] === "thief" && e[1] && e[2]).map((e) => ({ index: parseInt(e[1], 10), pubkey: e[2], relays: e.slice(3) })).sort((e, r) => e.index - r.index);
+}
+function qr(t, e) {
+  const r = [];
+  e.slug && r.push(["d", e.slug]);
+  for (const a of t.tags)
+    (a[0] === "path" || a[0] === "server") && r.push([...a]);
+  const n = t.tags.filter((a) => a[0] === "thief" && a[1] && a[2]).map((a) => [...a]).sort((a, u) => parseInt(a[1], 10) - parseInt(u[1], 10)), i = n.length > 0 ? Math.max(...n.map((a) => parseInt(a[1], 10))) : -1, s = ["thief", String(i + 1), e.deployerPubkey, ...e.deployerRelays], o = [...n, s];
+  if (o.length > Gt) {
+    const a = o[0], u = o.slice(o.length - (Gt - 1));
+    r.push(a, ...u);
+  } else
+    for (const a of o) r.push(a);
+  return e.title && r.push(["title", e.title]), e.description && r.push(["description", e.description]), {
+    kind: e.slug ? 35128 : 15128,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: r,
+    content: ""
+  };
+}
+function Ur(t, e, r) {
+  return r ? `https://${Lr(e)}${r}.${t}` : `https://${Bn(e)}.${t}`;
+}
+function Hr(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var ct = { exports: {} }, Xt;
+function Kr() {
+  return Xt || (Xt = 1, (function(t, e) {
+    var r = (function() {
+      var n = function(M, L) {
+        var x = 236, B = 17, g = M, E = s[L], h = null, c = 0, d = null, f = [], l = {}, v = function(y, b) {
+          c = g * 4 + 17, h = (function(p) {
+            for (var m = new Array(p), S = 0; S < p; S += 1) {
+              m[S] = new Array(p);
+              for (var N = 0; N < p; N += 1)
+                m[S][N] = null;
+            }
+            return m;
+          })(c), A(0, 0), A(c - 7, 0), A(0, c - 7), O(), I(), D(y, b), g >= 7 && $(y), d == null && (d = Z(g, E, f)), j(d, b);
+        }, A = function(y, b) {
+          for (var p = -1; p <= 7; p += 1)
+            if (!(y + p <= -1 || c <= y + p))
+              for (var m = -1; m <= 7; m += 1)
+                b + m <= -1 || c <= b + m || (0 <= p && p <= 6 && (m == 0 || m == 6) || 0 <= m && m <= 6 && (p == 0 || p == 6) || 2 <= p && p <= 4 && 2 <= m && m <= 4 ? h[y + p][b + m] = !0 : h[y + p][b + m] = !1);
+        }, C = function() {
+          for (var y = 0, b = 0, p = 0; p < 8; p += 1) {
+            v(!0, p);
+            var m = a.getLostPoint(l);
+            (p == 0 || y > m) && (y = m, b = p);
+          }
+          return b;
+        }, I = function() {
+          for (var y = 8; y < c - 8; y += 1)
+            h[y][6] == null && (h[y][6] = y % 2 == 0);
+          for (var b = 8; b < c - 8; b += 1)
+            h[6][b] == null && (h[6][b] = b % 2 == 0);
+        }, O = function() {
+          for (var y = a.getPatternPosition(g), b = 0; b < y.length; b += 1)
+            for (var p = 0; p < y.length; p += 1) {
+              var m = y[b], S = y[p];
+              if (h[m][S] == null)
+                for (var N = -2; N <= 2; N += 1)
+                  for (var F = -2; F <= 2; F += 1)
+                    N == -2 || N == 2 || F == -2 || F == 2 || N == 0 && F == 0 ? h[m + N][S + F] = !0 : h[m + N][S + F] = !1;
+            }
+        }, $ = function(y) {
+          for (var b = a.getBCHTypeNumber(g), p = 0; p < 18; p += 1) {
+            var m = !y && (b >> p & 1) == 1;
+            h[Math.floor(p / 3)][p % 3 + c - 8 - 3] = m;
+          }
+          for (var p = 0; p < 18; p += 1) {
+            var m = !y && (b >> p & 1) == 1;
+            h[p % 3 + c - 8 - 3][Math.floor(p / 3)] = m;
+          }
+        }, D = function(y, b) {
+          for (var p = E << 3 | b, m = a.getBCHTypeInfo(p), S = 0; S < 15; S += 1) {
+            var N = !y && (m >> S & 1) == 1;
+            S < 6 ? h[S][8] = N : S < 8 ? h[S + 1][8] = N : h[c - 15 + S][8] = N;
+          }
+          for (var S = 0; S < 15; S += 1) {
+            var N = !y && (m >> S & 1) == 1;
+            S < 8 ? h[8][c - S - 1] = N : S < 9 ? h[8][15 - S - 1 + 1] = N : h[8][15 - S - 1] = N;
+          }
+          h[c - 8][8] = !y;
+        }, j = function(y, b) {
+          for (var p = -1, m = c - 1, S = 7, N = 0, F = a.getMaskFunction(b), K = c - 1; K > 0; K -= 2)
+            for (K == 6 && (K -= 1); ; ) {
+              for (var X = 0; X < 2; X += 1)
+                if (h[m][K - X] == null) {
+                  var te = !1;
+                  N < y.length && (te = (y[N] >>> S & 1) == 1);
+                  var V = F(m, K - X);
+                  V && (te = !te), h[m][K - X] = te, S -= 1, S == -1 && (N += 1, S = 7);
+                }
+              if (m += p, m < 0 || c <= m) {
+                m -= p, p = -p;
+                break;
+              }
+            }
+        }, Y = function(y, b) {
+          for (var p = 0, m = 0, S = 0, N = new Array(b.length), F = new Array(b.length), K = 0; K < b.length; K += 1) {
+            var X = b[K].dataCount, te = b[K].totalCount - X;
+            m = Math.max(m, X), S = Math.max(S, te), N[K] = new Array(X);
+            for (var V = 0; V < N[K].length; V += 1)
+              N[K][V] = 255 & y.getBuffer()[V + p];
+            p += X;
+            var ae = a.getErrorCorrectPolynomial(te), ce = w(N[K], ae.getLength() - 1), Ut = ce.mod(ae);
+            F[K] = new Array(ae.getLength() - 1);
+            for (var V = 0; V < F[K].length; V += 1) {
+              var Ht = V + Ut.getLength() - F[K].length;
+              F[K][V] = Ht >= 0 ? Ut.getAt(Ht) : 0;
+            }
+          }
+          for (var Kt = 0, V = 0; V < b.length; V += 1)
+            Kt += b[V].totalCount;
+          for (var ot = new Array(Kt), Ue = 0, V = 0; V < m; V += 1)
+            for (var K = 0; K < b.length; K += 1)
+              V < N[K].length && (ot[Ue] = N[K][V], Ue += 1);
+          for (var V = 0; V < S; V += 1)
+            for (var K = 0; K < b.length; K += 1)
+              V < F[K].length && (ot[Ue] = F[K][V], Ue += 1);
+          return ot;
+        }, Z = function(y, b, p) {
+          for (var m = T.getRSBlocks(y, b), S = R(), N = 0; N < p.length; N += 1) {
+            var F = p[N];
+            S.put(F.getMode(), 4), S.put(F.getLength(), a.getLengthInBits(F.getMode(), y)), F.write(S);
+          }
+          for (var K = 0, N = 0; N < m.length; N += 1)
+            K += m[N].dataCount;
+          if (S.getLengthInBits() > K * 8)
+            throw "code length overflow. (" + S.getLengthInBits() + ">" + K * 8 + ")";
+          for (S.getLengthInBits() + 4 <= K * 8 && S.put(0, 4); S.getLengthInBits() % 8 != 0; )
+            S.putBit(!1);
+          for (; !(S.getLengthInBits() >= K * 8 || (S.put(x, 8), S.getLengthInBits() >= K * 8)); )
+            S.put(B, 8);
+          return Y(S, m);
+        };
+        l.addData = function(y, b) {
+          b = b || "Byte";
+          var p = null;
+          switch (b) {
+            case "Numeric":
+              p = _(y);
+              break;
+            case "Alphanumeric":
+              p = k(y);
+              break;
+            case "Byte":
+              p = P(y);
+              break;
+            case "Kanji":
+              p = q(y);
+              break;
+            default:
+              throw "mode:" + b;
+          }
+          f.push(p), d = null;
+        }, l.isDark = function(y, b) {
+          if (y < 0 || c <= y || b < 0 || c <= b)
+            throw y + "," + b;
+          return h[y][b];
+        }, l.getModuleCount = function() {
+          return c;
+        }, l.make = function() {
+          if (g < 1) {
+            for (var y = 1; y < 40; y++) {
+              for (var b = T.getRSBlocks(y, E), p = R(), m = 0; m < f.length; m++) {
+                var S = f[m];
+                p.put(S.getMode(), 4), p.put(S.getLength(), a.getLengthInBits(S.getMode(), y)), S.write(p);
+              }
+              for (var N = 0, m = 0; m < b.length; m++)
+                N += b[m].dataCount;
+              if (p.getLengthInBits() <= N * 8)
+                break;
+            }
+            g = y;
+          }
+          v(!1, C());
+        }, l.createTableTag = function(y, b) {
+          y = y || 2, b = typeof b > "u" ? y * 4 : b;
+          var p = "";
+          p += '<table style="', p += " border-width: 0px; border-style: none;", p += " border-collapse: collapse;", p += " padding: 0px; margin: " + b + "px;", p += '">', p += "<tbody>";
+          for (var m = 0; m < l.getModuleCount(); m += 1) {
+            p += "<tr>";
+            for (var S = 0; S < l.getModuleCount(); S += 1)
+              p += '<td style="', p += " border-width: 0px; border-style: none;", p += " border-collapse: collapse;", p += " padding: 0px; margin: 0px;", p += " width: " + y + "px;", p += " height: " + y + "px;", p += " background-color: ", p += l.isDark(m, S) ? "#000000" : "#ffffff", p += ";", p += '"/>';
+            p += "</tr>";
+          }
+          return p += "</tbody>", p += "</table>", p;
+        }, l.createSvgTag = function(y, b, p, m) {
+          var S = {};
+          typeof arguments[0] == "object" && (S = arguments[0], y = S.cellSize, b = S.margin, p = S.alt, m = S.title), y = y || 2, b = typeof b > "u" ? y * 4 : b, p = typeof p == "string" ? { text: p } : p || {}, p.text = p.text || null, p.id = p.text ? p.id || "qrcode-description" : null, m = typeof m == "string" ? { text: m } : m || {}, m.text = m.text || null, m.id = m.text ? m.id || "qrcode-title" : null;
+          var N = l.getModuleCount() * y + b * 2, F, K, X, te, V = "", ae;
+          for (ae = "l" + y + ",0 0," + y + " -" + y + ",0 0,-" + y + "z ", V += '<svg version="1.1" xmlns="http://www.w3.org/2000/svg"', V += S.scalable ? "" : ' width="' + N + 'px" height="' + N + 'px"', V += ' viewBox="0 0 ' + N + " " + N + '" ', V += ' preserveAspectRatio="xMinYMin meet"', V += m.text || p.text ? ' role="img" aria-labelledby="' + J([m.id, p.id].join(" ").trim()) + '"' : "", V += ">", V += m.text ? '<title id="' + J(m.id) + '">' + J(m.text) + "</title>" : "", V += p.text ? '<description id="' + J(p.id) + '">' + J(p.text) + "</description>" : "", V += '<rect width="100%" height="100%" fill="white" cx="0" cy="0"/>', V += '<path d="', X = 0; X < l.getModuleCount(); X += 1)
+            for (te = X * y + b, F = 0; F < l.getModuleCount(); F += 1)
+              l.isDark(X, F) && (K = F * y + b, V += "M" + K + "," + te + ae);
+          return V += '" stroke="transparent" fill="black"/>', V += "</svg>", V;
+        }, l.createDataURL = function(y, b) {
+          y = y || 2, b = typeof b > "u" ? y * 4 : b;
+          var p = l.getModuleCount() * y + b * 2, m = b, S = p - b;
+          return Q(p, p, function(N, F) {
+            if (m <= N && N < S && m <= F && F < S) {
+              var K = Math.floor((N - m) / y), X = Math.floor((F - m) / y);
+              return l.isDark(X, K) ? 0 : 1;
+            } else
+              return 1;
+          });
+        }, l.createImgTag = function(y, b, p) {
+          y = y || 2, b = typeof b > "u" ? y * 4 : b;
+          var m = l.getModuleCount() * y + b * 2, S = "";
+          return S += "<img", S += ' src="', S += l.createDataURL(y, b), S += '"', S += ' width="', S += m, S += '"', S += ' height="', S += m, S += '"', p && (S += ' alt="', S += J(p), S += '"'), S += "/>", S;
+        };
+        var J = function(y) {
+          for (var b = "", p = 0; p < y.length; p += 1) {
+            var m = y.charAt(p);
+            switch (m) {
+              case "<":
+                b += "&lt;";
+                break;
+              case ">":
+                b += "&gt;";
+                break;
+              case "&":
+                b += "&amp;";
+                break;
+              case '"':
+                b += "&quot;";
+                break;
+              default:
+                b += m;
+                break;
+            }
+          }
+          return b;
+        }, ee = function(y) {
+          var b = 1;
+          y = typeof y > "u" ? b * 2 : y;
+          var p = l.getModuleCount() * b + y * 2, m = y, S = p - y, N, F, K, X, te, V = {
+            "██": "█",
+            "█ ": "▀",
+            " █": "▄",
+            "  ": " "
+          }, ae = {
+            "██": "▀",
+            "█ ": "▀",
+            " █": " ",
+            "  ": " "
+          }, ce = "";
+          for (N = 0; N < p; N += 2) {
+            for (K = Math.floor((N - m) / b), X = Math.floor((N + 1 - m) / b), F = 0; F < p; F += 1)
+              te = "█", m <= F && F < S && m <= N && N < S && l.isDark(K, Math.floor((F - m) / b)) && (te = " "), m <= F && F < S && m <= N + 1 && N + 1 < S && l.isDark(X, Math.floor((F - m) / b)) ? te += " " : te += "█", ce += y < 1 && N + 1 >= S ? ae[te] : V[te];
+            ce += `
+`;
+          }
+          return p % 2 && y > 0 ? ce.substring(0, ce.length - p - 1) + Array(p + 1).join("▀") : ce.substring(0, ce.length - 1);
+        };
+        return l.createASCII = function(y, b) {
+          if (y = y || 1, y < 2)
+            return ee(b);
+          y -= 1, b = typeof b > "u" ? y * 2 : b;
+          var p = l.getModuleCount() * y + b * 2, m = b, S = p - b, N, F, K, X, te = Array(y + 1).join("██"), V = Array(y + 1).join("  "), ae = "", ce = "";
+          for (N = 0; N < p; N += 1) {
+            for (K = Math.floor((N - m) / y), ce = "", F = 0; F < p; F += 1)
+              X = 1, m <= F && F < S && m <= N && N < S && l.isDark(K, Math.floor((F - m) / y)) && (X = 0), ce += X ? te : V;
+            for (K = 0; K < y; K += 1)
+              ae += ce + `
+`;
+          }
+          return ae.substring(0, ae.length - 1);
+        }, l.renderTo2dContext = function(y, b) {
+          b = b || 2;
+          for (var p = l.getModuleCount(), m = 0; m < p; m++)
+            for (var S = 0; S < p; S++)
+              y.fillStyle = l.isDark(m, S) ? "black" : "white", y.fillRect(m * b, S * b, b, b);
+        }, l;
+      };
+      n.stringToBytesFuncs = {
+        default: function(M) {
+          for (var L = [], x = 0; x < M.length; x += 1) {
+            var B = M.charCodeAt(x);
+            L.push(B & 255);
+          }
+          return L;
+        }
+      }, n.stringToBytes = n.stringToBytesFuncs.default, n.createStringToBytes = function(M, L) {
+        var x = (function() {
+          for (var g = W(M), E = function() {
+            var I = g.read();
+            if (I == -1) throw "eof";
+            return I;
+          }, h = 0, c = {}; ; ) {
+            var d = g.read();
+            if (d == -1) break;
+            var f = E(), l = E(), v = E(), A = String.fromCharCode(d << 8 | f), C = l << 8 | v;
+            c[A] = C, h += 1;
+          }
+          if (h != L)
+            throw h + " != " + L;
+          return c;
+        })(), B = 63;
+        return function(g) {
+          for (var E = [], h = 0; h < g.length; h += 1) {
+            var c = g.charCodeAt(h);
+            if (c < 128)
+              E.push(c);
+            else {
+              var d = x[g.charAt(h)];
+              typeof d == "number" ? (d & 255) == d ? E.push(d) : (E.push(d >>> 8), E.push(d & 255)) : E.push(B);
+            }
+          }
+          return E;
+        };
+      };
+      var i = {
+        MODE_NUMBER: 1,
+        MODE_ALPHA_NUM: 2,
+        MODE_8BIT_BYTE: 4,
+        MODE_KANJI: 8
+      }, s = {
+        L: 1,
+        M: 0,
+        Q: 3,
+        H: 2
+      }, o = {
+        PATTERN000: 0,
+        PATTERN001: 1,
+        PATTERN010: 2,
+        PATTERN011: 3,
+        PATTERN100: 4,
+        PATTERN101: 5,
+        PATTERN110: 6,
+        PATTERN111: 7
+      }, a = (function() {
+        var M = [
+          [],
+          [6, 18],
+          [6, 22],
+          [6, 26],
+          [6, 30],
+          [6, 34],
+          [6, 22, 38],
+          [6, 24, 42],
+          [6, 26, 46],
+          [6, 28, 50],
+          [6, 30, 54],
+          [6, 32, 58],
+          [6, 34, 62],
+          [6, 26, 46, 66],
+          [6, 26, 48, 70],
+          [6, 26, 50, 74],
+          [6, 30, 54, 78],
+          [6, 30, 56, 82],
+          [6, 30, 58, 86],
+          [6, 34, 62, 90],
+          [6, 28, 50, 72, 94],
+          [6, 26, 50, 74, 98],
+          [6, 30, 54, 78, 102],
+          [6, 28, 54, 80, 106],
+          [6, 32, 58, 84, 110],
+          [6, 30, 58, 86, 114],
+          [6, 34, 62, 90, 118],
+          [6, 26, 50, 74, 98, 122],
+          [6, 30, 54, 78, 102, 126],
+          [6, 26, 52, 78, 104, 130],
+          [6, 30, 56, 82, 108, 134],
+          [6, 34, 60, 86, 112, 138],
+          [6, 30, 58, 86, 114, 142],
+          [6, 34, 62, 90, 118, 146],
+          [6, 30, 54, 78, 102, 126, 150],
+          [6, 24, 50, 76, 102, 128, 154],
+          [6, 28, 54, 80, 106, 132, 158],
+          [6, 32, 58, 84, 110, 136, 162],
+          [6, 26, 54, 82, 110, 138, 166],
+          [6, 30, 58, 86, 114, 142, 170]
+        ], L = 1335, x = 7973, B = 21522, g = {}, E = function(h) {
+          for (var c = 0; h != 0; )
+            c += 1, h >>>= 1;
+          return c;
+        };
+        return g.getBCHTypeInfo = function(h) {
+          for (var c = h << 10; E(c) - E(L) >= 0; )
+            c ^= L << E(c) - E(L);
+          return (h << 10 | c) ^ B;
+        }, g.getBCHTypeNumber = function(h) {
+          for (var c = h << 12; E(c) - E(x) >= 0; )
+            c ^= x << E(c) - E(x);
+          return h << 12 | c;
+        }, g.getPatternPosition = function(h) {
+          return M[h - 1];
+        }, g.getMaskFunction = function(h) {
+          switch (h) {
+            case o.PATTERN000:
+              return function(c, d) {
+                return (c + d) % 2 == 0;
+              };
+            case o.PATTERN001:
+              return function(c, d) {
+                return c % 2 == 0;
+              };
+            case o.PATTERN010:
+              return function(c, d) {
+                return d % 3 == 0;
+              };
+            case o.PATTERN011:
+              return function(c, d) {
+                return (c + d) % 3 == 0;
+              };
+            case o.PATTERN100:
+              return function(c, d) {
+                return (Math.floor(c / 2) + Math.floor(d / 3)) % 2 == 0;
+              };
+            case o.PATTERN101:
+              return function(c, d) {
+                return c * d % 2 + c * d % 3 == 0;
+              };
+            case o.PATTERN110:
+              return function(c, d) {
+                return (c * d % 2 + c * d % 3) % 2 == 0;
+              };
+            case o.PATTERN111:
+              return function(c, d) {
+                return (c * d % 3 + (c + d) % 2) % 2 == 0;
+              };
+            default:
+              throw "bad maskPattern:" + h;
+          }
+        }, g.getErrorCorrectPolynomial = function(h) {
+          for (var c = w([1], 0), d = 0; d < h; d += 1)
+            c = c.multiply(w([1, u.gexp(d)], 0));
+          return c;
+        }, g.getLengthInBits = function(h, c) {
+          if (1 <= c && c < 10)
+            switch (h) {
+              case i.MODE_NUMBER:
+                return 10;
+              case i.MODE_ALPHA_NUM:
+                return 9;
+              case i.MODE_8BIT_BYTE:
+                return 8;
+              case i.MODE_KANJI:
+                return 8;
+              default:
+                throw "mode:" + h;
+            }
+          else if (c < 27)
+            switch (h) {
+              case i.MODE_NUMBER:
+                return 12;
+              case i.MODE_ALPHA_NUM:
+                return 11;
+              case i.MODE_8BIT_BYTE:
+                return 16;
+              case i.MODE_KANJI:
+                return 10;
+              default:
+                throw "mode:" + h;
+            }
+          else if (c < 41)
+            switch (h) {
+              case i.MODE_NUMBER:
+                return 14;
+              case i.MODE_ALPHA_NUM:
+                return 13;
+              case i.MODE_8BIT_BYTE:
+                return 16;
+              case i.MODE_KANJI:
+                return 12;
+              default:
+                throw "mode:" + h;
+            }
+          else
+            throw "type:" + c;
+        }, g.getLostPoint = function(h) {
+          for (var c = h.getModuleCount(), d = 0, f = 0; f < c; f += 1)
+            for (var l = 0; l < c; l += 1) {
+              for (var v = 0, A = h.isDark(f, l), C = -1; C <= 1; C += 1)
+                if (!(f + C < 0 || c <= f + C))
+                  for (var I = -1; I <= 1; I += 1)
+                    l + I < 0 || c <= l + I || C == 0 && I == 0 || A == h.isDark(f + C, l + I) && (v += 1);
+              v > 5 && (d += 3 + v - 5);
+            }
+          for (var f = 0; f < c - 1; f += 1)
+            for (var l = 0; l < c - 1; l += 1) {
+              var O = 0;
+              h.isDark(f, l) && (O += 1), h.isDark(f + 1, l) && (O += 1), h.isDark(f, l + 1) && (O += 1), h.isDark(f + 1, l + 1) && (O += 1), (O == 0 || O == 4) && (d += 3);
+            }
+          for (var f = 0; f < c; f += 1)
+            for (var l = 0; l < c - 6; l += 1)
+              h.isDark(f, l) && !h.isDark(f, l + 1) && h.isDark(f, l + 2) && h.isDark(f, l + 3) && h.isDark(f, l + 4) && !h.isDark(f, l + 5) && h.isDark(f, l + 6) && (d += 40);
+          for (var l = 0; l < c; l += 1)
+            for (var f = 0; f < c - 6; f += 1)
+              h.isDark(f, l) && !h.isDark(f + 1, l) && h.isDark(f + 2, l) && h.isDark(f + 3, l) && h.isDark(f + 4, l) && !h.isDark(f + 5, l) && h.isDark(f + 6, l) && (d += 40);
+          for (var $ = 0, l = 0; l < c; l += 1)
+            for (var f = 0; f < c; f += 1)
+              h.isDark(f, l) && ($ += 1);
+          var D = Math.abs(100 * $ / c / c - 50) / 5;
+          return d += D * 10, d;
+        }, g;
+      })(), u = (function() {
+        for (var M = new Array(256), L = new Array(256), x = 0; x < 8; x += 1)
+          M[x] = 1 << x;
+        for (var x = 8; x < 256; x += 1)
+          M[x] = M[x - 4] ^ M[x - 5] ^ M[x - 6] ^ M[x - 8];
+        for (var x = 0; x < 255; x += 1)
+          L[M[x]] = x;
+        var B = {};
+        return B.glog = function(g) {
+          if (g < 1)
+            throw "glog(" + g + ")";
+          return L[g];
+        }, B.gexp = function(g) {
+          for (; g < 0; )
+            g += 255;
+          for (; g >= 256; )
+            g -= 255;
+          return M[g];
+        }, B;
+      })();
+      function w(M, L) {
+        if (typeof M.length > "u")
+          throw M.length + "/" + L;
+        var x = (function() {
+          for (var g = 0; g < M.length && M[g] == 0; )
+            g += 1;
+          for (var E = new Array(M.length - g + L), h = 0; h < M.length - g; h += 1)
+            E[h] = M[h + g];
+          return E;
+        })(), B = {};
+        return B.getAt = function(g) {
+          return x[g];
+        }, B.getLength = function() {
+          return x.length;
+        }, B.multiply = function(g) {
+          for (var E = new Array(B.getLength() + g.getLength() - 1), h = 0; h < B.getLength(); h += 1)
+            for (var c = 0; c < g.getLength(); c += 1)
+              E[h + c] ^= u.gexp(u.glog(B.getAt(h)) + u.glog(g.getAt(c)));
+          return w(E, 0);
+        }, B.mod = function(g) {
+          if (B.getLength() - g.getLength() < 0)
+            return B;
+          for (var E = u.glog(B.getAt(0)) - u.glog(g.getAt(0)), h = new Array(B.getLength()), c = 0; c < B.getLength(); c += 1)
+            h[c] = B.getAt(c);
+          for (var c = 0; c < g.getLength(); c += 1)
+            h[c] ^= u.gexp(u.glog(g.getAt(c)) + E);
+          return w(h, 0).mod(g);
+        }, B;
+      }
+      var T = (function() {
+        var M = [
+          // L
+          // M
+          // Q
+          // H
+          // 1
+          [1, 26, 19],
+          [1, 26, 16],
+          [1, 26, 13],
+          [1, 26, 9],
+          // 2
+          [1, 44, 34],
+          [1, 44, 28],
+          [1, 44, 22],
+          [1, 44, 16],
+          // 3
+          [1, 70, 55],
+          [1, 70, 44],
+          [2, 35, 17],
+          [2, 35, 13],
+          // 4
+          [1, 100, 80],
+          [2, 50, 32],
+          [2, 50, 24],
+          [4, 25, 9],
+          // 5
+          [1, 134, 108],
+          [2, 67, 43],
+          [2, 33, 15, 2, 34, 16],
+          [2, 33, 11, 2, 34, 12],
+          // 6
+          [2, 86, 68],
+          [4, 43, 27],
+          [4, 43, 19],
+          [4, 43, 15],
+          // 7
+          [2, 98, 78],
+          [4, 49, 31],
+          [2, 32, 14, 4, 33, 15],
+          [4, 39, 13, 1, 40, 14],
+          // 8
+          [2, 121, 97],
+          [2, 60, 38, 2, 61, 39],
+          [4, 40, 18, 2, 41, 19],
+          [4, 40, 14, 2, 41, 15],
+          // 9
+          [2, 146, 116],
+          [3, 58, 36, 2, 59, 37],
+          [4, 36, 16, 4, 37, 17],
+          [4, 36, 12, 4, 37, 13],
+          // 10
+          [2, 86, 68, 2, 87, 69],
+          [4, 69, 43, 1, 70, 44],
+          [6, 43, 19, 2, 44, 20],
+          [6, 43, 15, 2, 44, 16],
+          // 11
+          [4, 101, 81],
+          [1, 80, 50, 4, 81, 51],
+          [4, 50, 22, 4, 51, 23],
+          [3, 36, 12, 8, 37, 13],
+          // 12
+          [2, 116, 92, 2, 117, 93],
+          [6, 58, 36, 2, 59, 37],
+          [4, 46, 20, 6, 47, 21],
+          [7, 42, 14, 4, 43, 15],
+          // 13
+          [4, 133, 107],
+          [8, 59, 37, 1, 60, 38],
+          [8, 44, 20, 4, 45, 21],
+          [12, 33, 11, 4, 34, 12],
+          // 14
+          [3, 145, 115, 1, 146, 116],
+          [4, 64, 40, 5, 65, 41],
+          [11, 36, 16, 5, 37, 17],
+          [11, 36, 12, 5, 37, 13],
+          // 15
+          [5, 109, 87, 1, 110, 88],
+          [5, 65, 41, 5, 66, 42],
+          [5, 54, 24, 7, 55, 25],
+          [11, 36, 12, 7, 37, 13],
+          // 16
+          [5, 122, 98, 1, 123, 99],
+          [7, 73, 45, 3, 74, 46],
+          [15, 43, 19, 2, 44, 20],
+          [3, 45, 15, 13, 46, 16],
+          // 17
+          [1, 135, 107, 5, 136, 108],
+          [10, 74, 46, 1, 75, 47],
+          [1, 50, 22, 15, 51, 23],
+          [2, 42, 14, 17, 43, 15],
+          // 18
+          [5, 150, 120, 1, 151, 121],
+          [9, 69, 43, 4, 70, 44],
+          [17, 50, 22, 1, 51, 23],
+          [2, 42, 14, 19, 43, 15],
+          // 19
+          [3, 141, 113, 4, 142, 114],
+          [3, 70, 44, 11, 71, 45],
+          [17, 47, 21, 4, 48, 22],
+          [9, 39, 13, 16, 40, 14],
+          // 20
+          [3, 135, 107, 5, 136, 108],
+          [3, 67, 41, 13, 68, 42],
+          [15, 54, 24, 5, 55, 25],
+          [15, 43, 15, 10, 44, 16],
+          // 21
+          [4, 144, 116, 4, 145, 117],
+          [17, 68, 42],
+          [17, 50, 22, 6, 51, 23],
+          [19, 46, 16, 6, 47, 17],
+          // 22
+          [2, 139, 111, 7, 140, 112],
+          [17, 74, 46],
+          [7, 54, 24, 16, 55, 25],
+          [34, 37, 13],
+          // 23
+          [4, 151, 121, 5, 152, 122],
+          [4, 75, 47, 14, 76, 48],
+          [11, 54, 24, 14, 55, 25],
+          [16, 45, 15, 14, 46, 16],
+          // 24
+          [6, 147, 117, 4, 148, 118],
+          [6, 73, 45, 14, 74, 46],
+          [11, 54, 24, 16, 55, 25],
+          [30, 46, 16, 2, 47, 17],
+          // 25
+          [8, 132, 106, 4, 133, 107],
+          [8, 75, 47, 13, 76, 48],
+          [7, 54, 24, 22, 55, 25],
+          [22, 45, 15, 13, 46, 16],
+          // 26
+          [10, 142, 114, 2, 143, 115],
+          [19, 74, 46, 4, 75, 47],
+          [28, 50, 22, 6, 51, 23],
+          [33, 46, 16, 4, 47, 17],
+          // 27
+          [8, 152, 122, 4, 153, 123],
+          [22, 73, 45, 3, 74, 46],
+          [8, 53, 23, 26, 54, 24],
+          [12, 45, 15, 28, 46, 16],
+          // 28
+          [3, 147, 117, 10, 148, 118],
+          [3, 73, 45, 23, 74, 46],
+          [4, 54, 24, 31, 55, 25],
+          [11, 45, 15, 31, 46, 16],
+          // 29
+          [7, 146, 116, 7, 147, 117],
+          [21, 73, 45, 7, 74, 46],
+          [1, 53, 23, 37, 54, 24],
+          [19, 45, 15, 26, 46, 16],
+          // 30
+          [5, 145, 115, 10, 146, 116],
+          [19, 75, 47, 10, 76, 48],
+          [15, 54, 24, 25, 55, 25],
+          [23, 45, 15, 25, 46, 16],
+          // 31
+          [13, 145, 115, 3, 146, 116],
+          [2, 74, 46, 29, 75, 47],
+          [42, 54, 24, 1, 55, 25],
+          [23, 45, 15, 28, 46, 16],
+          // 32
+          [17, 145, 115],
+          [10, 74, 46, 23, 75, 47],
+          [10, 54, 24, 35, 55, 25],
+          [19, 45, 15, 35, 46, 16],
+          // 33
+          [17, 145, 115, 1, 146, 116],
+          [14, 74, 46, 21, 75, 47],
+          [29, 54, 24, 19, 55, 25],
+          [11, 45, 15, 46, 46, 16],
+          // 34
+          [13, 145, 115, 6, 146, 116],
+          [14, 74, 46, 23, 75, 47],
+          [44, 54, 24, 7, 55, 25],
+          [59, 46, 16, 1, 47, 17],
+          // 35
+          [12, 151, 121, 7, 152, 122],
+          [12, 75, 47, 26, 76, 48],
+          [39, 54, 24, 14, 55, 25],
+          [22, 45, 15, 41, 46, 16],
+          // 36
+          [6, 151, 121, 14, 152, 122],
+          [6, 75, 47, 34, 76, 48],
+          [46, 54, 24, 10, 55, 25],
+          [2, 45, 15, 64, 46, 16],
+          // 37
+          [17, 152, 122, 4, 153, 123],
+          [29, 74, 46, 14, 75, 47],
+          [49, 54, 24, 10, 55, 25],
+          [24, 45, 15, 46, 46, 16],
+          // 38
+          [4, 152, 122, 18, 153, 123],
+          [13, 74, 46, 32, 75, 47],
+          [48, 54, 24, 14, 55, 25],
+          [42, 45, 15, 32, 46, 16],
+          // 39
+          [20, 147, 117, 4, 148, 118],
+          [40, 75, 47, 7, 76, 48],
+          [43, 54, 24, 22, 55, 25],
+          [10, 45, 15, 67, 46, 16],
+          // 40
+          [19, 148, 118, 6, 149, 119],
+          [18, 75, 47, 31, 76, 48],
+          [34, 54, 24, 34, 55, 25],
+          [20, 45, 15, 61, 46, 16]
+        ], L = function(g, E) {
+          var h = {};
+          return h.totalCount = g, h.dataCount = E, h;
+        }, x = {}, B = function(g, E) {
+          switch (E) {
+            case s.L:
+              return M[(g - 1) * 4 + 0];
+            case s.M:
+              return M[(g - 1) * 4 + 1];
+            case s.Q:
+              return M[(g - 1) * 4 + 2];
+            case s.H:
+              return M[(g - 1) * 4 + 3];
+            default:
+              return;
+          }
+        };
+        return x.getRSBlocks = function(g, E) {
+          var h = B(g, E);
+          if (typeof h > "u")
+            throw "bad rs block @ typeNumber:" + g + "/errorCorrectionLevel:" + E;
+          for (var c = h.length / 3, d = [], f = 0; f < c; f += 1)
+            for (var l = h[f * 3 + 0], v = h[f * 3 + 1], A = h[f * 3 + 2], C = 0; C < l; C += 1)
+              d.push(L(v, A));
+          return d;
+        }, x;
+      })(), R = function() {
+        var M = [], L = 0, x = {};
+        return x.getBuffer = function() {
+          return M;
+        }, x.getAt = function(B) {
+          var g = Math.floor(B / 8);
+          return (M[g] >>> 7 - B % 8 & 1) == 1;
+        }, x.put = function(B, g) {
+          for (var E = 0; E < g; E += 1)
+            x.putBit((B >>> g - E - 1 & 1) == 1);
+        }, x.getLengthInBits = function() {
+          return L;
+        }, x.putBit = function(B) {
+          var g = Math.floor(L / 8);
+          M.length <= g && M.push(0), B && (M[g] |= 128 >>> L % 8), L += 1;
+        }, x;
+      }, _ = function(M) {
+        var L = i.MODE_NUMBER, x = M, B = {};
+        B.getMode = function() {
+          return L;
+        }, B.getLength = function(h) {
+          return x.length;
+        }, B.write = function(h) {
+          for (var c = x, d = 0; d + 2 < c.length; )
+            h.put(g(c.substring(d, d + 3)), 10), d += 3;
+          d < c.length && (c.length - d == 1 ? h.put(g(c.substring(d, d + 1)), 4) : c.length - d == 2 && h.put(g(c.substring(d, d + 2)), 7));
+        };
+        var g = function(h) {
+          for (var c = 0, d = 0; d < h.length; d += 1)
+            c = c * 10 + E(h.charAt(d));
+          return c;
+        }, E = function(h) {
+          if ("0" <= h && h <= "9")
+            return h.charCodeAt(0) - 48;
+          throw "illegal char :" + h;
+        };
+        return B;
+      }, k = function(M) {
+        var L = i.MODE_ALPHA_NUM, x = M, B = {};
+        B.getMode = function() {
+          return L;
+        }, B.getLength = function(E) {
+          return x.length;
+        }, B.write = function(E) {
+          for (var h = x, c = 0; c + 1 < h.length; )
+            E.put(
+              g(h.charAt(c)) * 45 + g(h.charAt(c + 1)),
+              11
+            ), c += 2;
+          c < h.length && E.put(g(h.charAt(c)), 6);
+        };
+        var g = function(E) {
+          if ("0" <= E && E <= "9")
+            return E.charCodeAt(0) - 48;
+          if ("A" <= E && E <= "Z")
+            return E.charCodeAt(0) - 65 + 10;
+          switch (E) {
+            case " ":
+              return 36;
+            case "$":
+              return 37;
+            case "%":
+              return 38;
+            case "*":
+              return 39;
+            case "+":
+              return 40;
+            case "-":
+              return 41;
+            case ".":
+              return 42;
+            case "/":
+              return 43;
+            case ":":
+              return 44;
+            default:
+              throw "illegal char :" + E;
+          }
+        };
+        return B;
+      }, P = function(M) {
+        var L = i.MODE_8BIT_BYTE, x = n.stringToBytes(M), B = {};
+        return B.getMode = function() {
+          return L;
+        }, B.getLength = function(g) {
+          return x.length;
+        }, B.write = function(g) {
+          for (var E = 0; E < x.length; E += 1)
+            g.put(x[E], 8);
+        }, B;
+      }, q = function(M) {
+        var L = i.MODE_KANJI, x = n.stringToBytesFuncs.SJIS;
+        if (!x)
+          throw "sjis not supported.";
+        (function(E, h) {
+          var c = x(E);
+          if (c.length != 2 || (c[0] << 8 | c[1]) != h)
+            throw "sjis not supported.";
+        })("友", 38726);
+        var B = x(M), g = {};
+        return g.getMode = function() {
+          return L;
+        }, g.getLength = function(E) {
+          return ~~(B.length / 2);
+        }, g.write = function(E) {
+          for (var h = B, c = 0; c + 1 < h.length; ) {
+            var d = (255 & h[c]) << 8 | 255 & h[c + 1];
+            if (33088 <= d && d <= 40956)
+              d -= 33088;
+            else if (57408 <= d && d <= 60351)
+              d -= 49472;
+            else
+              throw "illegal char at " + (c + 1) + "/" + d;
+            d = (d >>> 8 & 255) * 192 + (d & 255), E.put(d, 13), c += 2;
+          }
+          if (c < h.length)
+            throw "illegal char at " + (c + 1);
+        }, g;
+      }, U = function() {
+        var M = [], L = {};
+        return L.writeByte = function(x) {
+          M.push(x & 255);
+        }, L.writeShort = function(x) {
+          L.writeByte(x), L.writeByte(x >>> 8);
+        }, L.writeBytes = function(x, B, g) {
+          B = B || 0, g = g || x.length;
+          for (var E = 0; E < g; E += 1)
+            L.writeByte(x[E + B]);
+        }, L.writeString = function(x) {
+          for (var B = 0; B < x.length; B += 1)
+            L.writeByte(x.charCodeAt(B));
+        }, L.toByteArray = function() {
+          return M;
+        }, L.toString = function() {
+          var x = "";
+          x += "[";
+          for (var B = 0; B < M.length; B += 1)
+            B > 0 && (x += ","), x += M[B];
+          return x += "]", x;
+        }, L;
+      }, H = function() {
+        var M = 0, L = 0, x = 0, B = "", g = {}, E = function(c) {
+          B += String.fromCharCode(h(c & 63));
+        }, h = function(c) {
+          if (!(c < 0)) {
+            if (c < 26)
+              return 65 + c;
+            if (c < 52)
+              return 97 + (c - 26);
+            if (c < 62)
+              return 48 + (c - 52);
+            if (c == 62)
+              return 43;
+            if (c == 63)
+              return 47;
+          }
+          throw "n:" + c;
+        };
+        return g.writeByte = function(c) {
+          for (M = M << 8 | c & 255, L += 8, x += 1; L >= 6; )
+            E(M >>> L - 6), L -= 6;
+        }, g.flush = function() {
+          if (L > 0 && (E(M << 6 - L), M = 0, L = 0), x % 3 != 0)
+            for (var c = 3 - x % 3, d = 0; d < c; d += 1)
+              B += "=";
+        }, g.toString = function() {
+          return B;
+        }, g;
+      }, W = function(M) {
+        var L = M, x = 0, B = 0, g = 0, E = {};
+        E.read = function() {
+          for (; g < 8; ) {
+            if (x >= L.length) {
+              if (g == 0)
+                return -1;
+              throw "unexpected end of file./" + g;
+            }
+            var c = L.charAt(x);
+            if (x += 1, c == "=")
+              return g = 0, -1;
+            if (c.match(/^\s$/))
+              continue;
+            B = B << 6 | h(c.charCodeAt(0)), g += 6;
+          }
+          var d = B >>> g - 8 & 255;
+          return g -= 8, d;
+        };
+        var h = function(c) {
+          if (65 <= c && c <= 90)
+            return c - 65;
+          if (97 <= c && c <= 122)
+            return c - 97 + 26;
+          if (48 <= c && c <= 57)
+            return c - 48 + 52;
+          if (c == 43)
+            return 62;
+          if (c == 47)
+            return 63;
+          throw "c:" + c;
+        };
+        return E;
+      }, ne = function(M, L) {
+        var x = M, B = L, g = new Array(M * L), E = {};
+        E.setPixel = function(f, l, v) {
+          g[l * x + f] = v;
+        }, E.write = function(f) {
+          f.writeString("GIF87a"), f.writeShort(x), f.writeShort(B), f.writeByte(128), f.writeByte(0), f.writeByte(0), f.writeByte(0), f.writeByte(0), f.writeByte(0), f.writeByte(255), f.writeByte(255), f.writeByte(255), f.writeString(","), f.writeShort(0), f.writeShort(0), f.writeShort(x), f.writeShort(B), f.writeByte(0);
+          var l = 2, v = c(l);
+          f.writeByte(l);
+          for (var A = 0; v.length - A > 255; )
+            f.writeByte(255), f.writeBytes(v, A, 255), A += 255;
+          f.writeByte(v.length - A), f.writeBytes(v, A, v.length - A), f.writeByte(0), f.writeString(";");
+        };
+        var h = function(f) {
+          var l = f, v = 0, A = 0, C = {};
+          return C.write = function(I, O) {
+            if (I >>> O)
+              throw "length over";
+            for (; v + O >= 8; )
+              l.writeByte(255 & (I << v | A)), O -= 8 - v, I >>>= 8 - v, A = 0, v = 0;
+            A = I << v | A, v = v + O;
+          }, C.flush = function() {
+            v > 0 && l.writeByte(A);
+          }, C;
+        }, c = function(f) {
+          for (var l = 1 << f, v = (1 << f) + 1, A = f + 1, C = d(), I = 0; I < l; I += 1)
+            C.add(String.fromCharCode(I));
+          C.add(String.fromCharCode(l)), C.add(String.fromCharCode(v));
+          var O = U(), $ = h(O);
+          $.write(l, A);
+          var D = 0, j = String.fromCharCode(g[D]);
+          for (D += 1; D < g.length; ) {
+            var Y = String.fromCharCode(g[D]);
+            D += 1, C.contains(j + Y) ? j = j + Y : ($.write(C.indexOf(j), A), C.size() < 4095 && (C.size() == 1 << A && (A += 1), C.add(j + Y)), j = Y);
+          }
+          return $.write(C.indexOf(j), A), $.write(v, A), $.flush(), O.toByteArray();
+        }, d = function() {
+          var f = {}, l = 0, v = {};
+          return v.add = function(A) {
+            if (v.contains(A))
+              throw "dup key:" + A;
+            f[A] = l, l += 1;
+          }, v.size = function() {
+            return l;
+          }, v.indexOf = function(A) {
+            return f[A];
+          }, v.contains = function(A) {
+            return typeof f[A] < "u";
+          }, v;
+        };
+        return E;
+      }, Q = function(M, L, x) {
+        for (var B = ne(M, L), g = 0; g < L; g += 1)
+          for (var E = 0; E < M; E += 1)
+            B.setPixel(E, g, x(E, g));
+        var h = U();
+        B.write(h);
+        for (var c = H(), d = h.toByteArray(), f = 0; f < d.length; f += 1)
+          c.writeByte(d[f]);
+        return c.flush(), "data:image/gif;base64," + c;
+      };
+      return n;
+    })();
+    (function() {
+      r.stringToBytesFuncs["UTF-8"] = function(n) {
+        function i(s) {
+          for (var o = [], a = 0; a < s.length; a++) {
+            var u = s.charCodeAt(a);
+            u < 128 ? o.push(u) : u < 2048 ? o.push(
+              192 | u >> 6,
+              128 | u & 63
+            ) : u < 55296 || u >= 57344 ? o.push(
+              224 | u >> 12,
+              128 | u >> 6 & 63,
+              128 | u & 63
+            ) : (a++, u = 65536 + ((u & 1023) << 10 | s.charCodeAt(a) & 1023), o.push(
+              240 | u >> 18,
+              128 | u >> 12 & 63,
+              128 | u >> 6 & 63,
+              128 | u & 63
+            ));
+          }
+          return o;
+        }
+        return i(n);
+      };
+    })(), (function(n) {
+      t.exports = n();
+    })(function() {
+      return r;
+    });
+  })(ct)), ct.exports;
+}
+var Fr = Kr();
+const Vr = /* @__PURE__ */ Hr(Fr);
+function Zr(t) {
+  const e = Vr(0, "L");
+  return e.addData(t), e.make(), e.createSvgTag({ cellSize: 3, margin: 2, scalable: !0 });
+}
+function jr(t, e, r) {
+  return t & e ^ ~t & r;
+}
+function zr(t, e, r) {
+  return t & e ^ t & r ^ e & r;
+}
+class Wr {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = !1;
+  length = 0;
+  pos = 0;
+  destroyed = !1;
+  constructor(e, r, n, i) {
+    this.blockLen = e, this.outputLen = r, this.padOffset = n, this.isLE = i, this.buffer = new Uint8Array(e), this.view = at(this.buffer);
+  }
+  update(e) {
+    ze(this), G(e);
+    const { view: r, buffer: n, blockLen: i } = this, s = e.length;
+    for (let o = 0; o < s; ) {
+      const a = Math.min(i - this.pos, s - o);
+      if (a === i) {
+        const u = at(e);
+        for (; i <= s - o; o += i)
+          this.process(u, o);
+        continue;
+      }
+      n.set(e.subarray(o, o + a), this.pos), this.pos += a, o += a, this.pos === i && (this.process(r, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    ze(this), br(e, this), this.finished = !0;
+    const { buffer: r, view: n, blockLen: i, isLE: s } = this;
+    let { pos: o } = this;
+    r[o++] = 128, Ne(this.buffer.subarray(o)), this.padOffset > i - o && (this.process(n, 0), o = 0);
+    for (let R = o; R < i; R++)
+      r[R] = 0;
+    n.setBigUint64(i - 8, BigInt(this.length * 8), s), this.process(n, 0);
+    const a = at(e), u = this.outputLen;
+    if (u % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const w = u / 4, T = this.get();
+    if (w > T.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let R = 0; R < w; R++)
+      a.setUint32(4 * R, T[R], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: r } = this;
+    this.digestInto(e);
+    const n = e.slice(0, r);
+    return this.destroy(), n;
+  }
+  _cloneInto(e) {
+    e ||= new this.constructor(), e.set(...this.get());
+    const { blockLen: r, buffer: n, length: i, finished: s, destroyed: o, pos: a } = this;
+    return e.destroyed = o, e.finished = s, e.length = i, e.pos = a, i % r && e.buffer.set(n), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const be = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), Yr = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), ye = /* @__PURE__ */ new Uint32Array(64);
+class Jr extends Wr {
+  constructor(e) {
+    super(64, e, 8, !1);
+  }
+  get() {
+    const { A: e, B: r, C: n, D: i, E: s, F: o, G: a, H: u } = this;
+    return [e, r, n, i, s, o, a, u];
+  }
+  // prettier-ignore
+  set(e, r, n, i, s, o, a, u) {
+    this.A = e | 0, this.B = r | 0, this.C = n | 0, this.D = i | 0, this.E = s | 0, this.F = o | 0, this.G = a | 0, this.H = u | 0;
+  }
+  process(e, r) {
+    for (let R = 0; R < 16; R++, r += 4)
+      ye[R] = e.getUint32(r, !1);
+    for (let R = 16; R < 64; R++) {
+      const _ = ye[R - 15], k = ye[R - 2], P = de(_, 7) ^ de(_, 18) ^ _ >>> 3, q = de(k, 17) ^ de(k, 19) ^ k >>> 10;
+      ye[R] = q + ye[R - 7] + P + ye[R - 16] | 0;
+    }
+    let { A: n, B: i, C: s, D: o, E: a, F: u, G: w, H: T } = this;
+    for (let R = 0; R < 64; R++) {
+      const _ = de(a, 6) ^ de(a, 11) ^ de(a, 25), k = T + _ + jr(a, u, w) + Yr[R] + ye[R] | 0, q = (de(n, 2) ^ de(n, 13) ^ de(n, 22)) + zr(n, i, s) | 0;
+      T = w, w = u, u = a, a = o + k | 0, o = s, s = i, i = n, n = k + q | 0;
+    }
+    n = n + this.A | 0, i = i + this.B | 0, s = s + this.C | 0, o = o + this.D | 0, a = a + this.E | 0, u = u + this.F | 0, w = w + this.G | 0, T = T + this.H | 0, this.set(n, i, s, o, a, u, w, T);
+  }
+  roundClean() {
+    Ne(ye);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), Ne(this.buffer);
+  }
+}
+class Gr extends Jr {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = be[0] | 0;
+  B = be[1] | 0;
+  C = be[2] | 0;
+  D = be[3] | 0;
+  E = be[4] | 0;
+  F = be[5] | 0;
+  G = be[6] | 0;
+  H = be[7] | 0;
+  constructor() {
+    super(32);
+  }
+}
+const xe = /* @__PURE__ */ wr(
+  () => new Gr(),
+  /* @__PURE__ */ vr(1)
+);
+const Lt = /* @__PURE__ */ BigInt(0), Et = /* @__PURE__ */ BigInt(1);
+function Je(t, e = "") {
+  if (typeof t != "boolean") {
+    const r = e && `"${e}" `;
+    throw new Error(r + "expected boolean, got type=" + typeof t);
+  }
+  return t;
+}
+function Tn(t) {
+  if (typeof t == "bigint") {
+    if (!je(t))
+      throw new Error("positive bigint expected, got " + t);
+  } else
+    me(t);
+  return t;
+}
+function He(t) {
+  const e = Tn(t).toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function Cn(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? Lt : BigInt("0x" + t);
+}
+function De(t) {
+  return Cn(le(t));
+}
+function Ln(t) {
+  return Cn(le(Xr(G(t)).reverse()));
+}
+function Ot(t, e) {
+  me(e), t = Tn(t);
+  const r = ie(t.toString(16).padStart(e * 2, "0"));
+  if (r.length !== e)
+    throw new Error("number too large");
+  return r;
+}
+function On(t, e) {
+  return Ot(t, e).reverse();
+}
+function Xr(t) {
+  return Uint8Array.from(t);
+}
+function Qr(t) {
+  return Uint8Array.from(t, (e, r) => {
+    const n = e.charCodeAt(0);
+    if (e.length !== 1 || n > 127)
+      throw new Error(`string contains non-ASCII character "${t[r]}" with code ${n} at position ${r}`);
+    return n;
+  });
+}
+const je = (t) => typeof t == "bigint" && Lt <= t;
+function ei(t, e, r) {
+  return je(t) && je(e) && je(r) && e <= t && t < r;
+}
+function ti(t, e, r, n) {
+  if (!ei(e, r, n))
+    throw new Error("expected valid " + t + ": " + r + " <= n < " + n + ", got " + e);
+}
+function ni(t) {
+  let e;
+  for (e = 0; t > Lt; t >>= Et, e += 1)
+    ;
+  return e;
+}
+const It = (t) => (Et << BigInt(t)) - Et;
+function ri(t, e, r) {
+  if (me(t, "hashLen"), me(e, "qByteLen"), typeof r != "function")
+    throw new Error("hmacFn must be a function");
+  const n = (U) => new Uint8Array(U), i = Uint8Array.of(), s = Uint8Array.of(0), o = Uint8Array.of(1), a = 1e3;
+  let u = n(t), w = n(t), T = 0;
+  const R = () => {
+    u.fill(1), w.fill(0), T = 0;
+  }, _ = (...U) => r(w, oe(u, ...U)), k = (U = i) => {
+    w = _(s, U), u = _(), U.length !== 0 && (w = _(o, U), u = _());
+  }, P = () => {
+    if (T++ >= a)
+      throw new Error("drbg: tried max amount of iterations");
+    let U = 0;
+    const H = [];
+    for (; U < e; ) {
+      u = _();
+      const W = u.slice();
+      H.push(W), U += u.length;
+    }
+    return oe(...H);
+  };
+  return (U, H) => {
+    R(), k(U);
+    let W;
+    for (; !(W = H(P())); )
+      k();
+    return R(), W;
+  };
+}
+function Pt(t, e = {}, r = {}) {
+  if (!t || typeof t != "object")
+    throw new Error("expected valid options object");
+  function n(s, o, a) {
+    const u = t[s];
+    if (a && u === void 0)
+      return;
+    const w = typeof u;
+    if (w !== o || u === null)
+      throw new Error(`param "${s}" is invalid: expected ${o}, got ${w}`);
+  }
+  const i = (s, o) => Object.entries(s).forEach(([a, u]) => n(a, u, o));
+  i(e, !1), i(r, !0);
+}
+function Qt(t) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return (r, ...n) => {
+    const i = e.get(r);
+    if (i !== void 0)
+      return i;
+    const s = t(r, ...n);
+    return e.set(r, s), s;
+  };
+}
+const se = /* @__PURE__ */ BigInt(0), re = /* @__PURE__ */ BigInt(1), ke = /* @__PURE__ */ BigInt(2), In = /* @__PURE__ */ BigInt(3), Pn = /* @__PURE__ */ BigInt(4), Mn = /* @__PURE__ */ BigInt(5), ii = /* @__PURE__ */ BigInt(7), Nn = /* @__PURE__ */ BigInt(8), si = /* @__PURE__ */ BigInt(9), $n = /* @__PURE__ */ BigInt(16);
+function fe(t, e) {
+  const r = t % e;
+  return r >= se ? r : e + r;
+}
+function ue(t, e, r) {
+  let n = t;
+  for (; e-- > se; )
+    n *= n, n %= r;
+  return n;
+}
+function en(t, e) {
+  if (t === se)
+    throw new Error("invert: expected non-zero number");
+  if (e <= se)
+    throw new Error("invert: expected positive modulus, got " + e);
+  let r = fe(t, e), n = e, i = se, s = re;
+  for (; r !== se; ) {
+    const a = n / r, u = n % r, w = i - s * a;
+    n = r, r = u, i = s, s = w;
+  }
+  if (n !== re)
+    throw new Error("invert: does not exist");
+  return fe(i, e);
+}
+function Mt(t, e, r) {
+  if (!t.eql(t.sqr(e), r))
+    throw new Error("Cannot find square root");
+}
+function Dn(t, e) {
+  const r = (t.ORDER + re) / Pn, n = t.pow(e, r);
+  return Mt(t, n, e), n;
+}
+function oi(t, e) {
+  const r = (t.ORDER - Mn) / Nn, n = t.mul(e, ke), i = t.pow(n, r), s = t.mul(e, i), o = t.mul(t.mul(s, ke), i), a = t.mul(s, t.sub(o, t.ONE));
+  return Mt(t, a, e), a;
+}
+function ai(t) {
+  const e = nt(t), r = qn(t), n = r(e, e.neg(e.ONE)), i = r(e, n), s = r(e, e.neg(n)), o = (t + ii) / $n;
+  return (a, u) => {
+    let w = a.pow(u, o), T = a.mul(w, n);
+    const R = a.mul(w, i), _ = a.mul(w, s), k = a.eql(a.sqr(T), u), P = a.eql(a.sqr(R), u);
+    w = a.cmov(w, T, k), T = a.cmov(_, R, P);
+    const q = a.eql(a.sqr(T), u), U = a.cmov(w, T, q);
+    return Mt(a, U, u), U;
+  };
+}
+function qn(t) {
+  if (t < In)
+    throw new Error("sqrt is not defined for small field");
+  let e = t - re, r = 0;
+  for (; e % ke === se; )
+    e /= ke, r++;
+  let n = ke;
+  const i = nt(t);
+  for (; tn(i, n) === 1; )
+    if (n++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (r === 1)
+    return Dn;
+  let s = i.pow(n, e);
+  const o = (e + re) / ke;
+  return function(u, w) {
+    if (u.is0(w))
+      return w;
+    if (tn(u, w) !== 1)
+      throw new Error("Cannot find square root");
+    let T = r, R = u.mul(u.ONE, s), _ = u.pow(w, e), k = u.pow(w, o);
+    for (; !u.eql(_, u.ONE); ) {
+      if (u.is0(_))
+        return u.ZERO;
+      let P = 1, q = u.sqr(_);
+      for (; !u.eql(q, u.ONE); )
+        if (P++, q = u.sqr(q), P === T)
+          throw new Error("Cannot find square root");
+      const U = re << BigInt(T - P - 1), H = u.pow(R, U);
+      T = P, R = u.sqr(H), _ = u.mul(_, R), k = u.mul(k, H);
+    }
+    return k;
+  };
+}
+function ci(t) {
+  return t % Pn === In ? Dn : t % Nn === Mn ? oi : t % $n === si ? ai(t) : qn(t);
+}
+const ui = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function li(t) {
+  const e = {
+    ORDER: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  }, r = ui.reduce((n, i) => (n[i] = "function", n), e);
+  return Pt(t, r), t;
+}
+function fi(t, e, r) {
+  if (r < se)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (r === se)
+    return t.ONE;
+  if (r === re)
+    return e;
+  let n = t.ONE, i = e;
+  for (; r > se; )
+    r & re && (n = t.mul(n, i)), i = t.sqr(i), r >>= re;
+  return n;
+}
+function Un(t, e, r = !1) {
+  const n = new Array(e.length).fill(r ? t.ZERO : void 0), i = e.reduce((o, a, u) => t.is0(a) ? o : (n[u] = o, t.mul(o, a)), t.ONE), s = t.inv(i);
+  return e.reduceRight((o, a, u) => t.is0(a) ? o : (n[u] = t.mul(o, n[u]), t.mul(o, a)), s), n;
+}
+function tn(t, e) {
+  const r = (t.ORDER - re) / ke, n = t.pow(e, r), i = t.eql(n, t.ONE), s = t.eql(n, t.ZERO), o = t.eql(n, t.neg(t.ONE));
+  if (!i && !s && !o)
+    throw new Error("invalid Legendre symbol result");
+  return i ? 1 : s ? 0 : -1;
+}
+function di(t, e) {
+  e !== void 0 && me(e);
+  const r = e !== void 0 ? e : t.toString(2).length, n = Math.ceil(r / 8);
+  return { nBitLength: r, nByteLength: n };
+}
+class hi {
+  ORDER;
+  BITS;
+  BYTES;
+  isLE;
+  ZERO = se;
+  ONE = re;
+  _lengths;
+  _sqrt;
+  // cached sqrt
+  _mod;
+  constructor(e, r = {}) {
+    if (e <= se)
+      throw new Error("invalid field: expected ORDER > 0, got " + e);
+    let n;
+    this.isLE = !1, r != null && typeof r == "object" && (typeof r.BITS == "number" && (n = r.BITS), typeof r.sqrt == "function" && (this.sqrt = r.sqrt), typeof r.isLE == "boolean" && (this.isLE = r.isLE), r.allowedLengths && (this._lengths = r.allowedLengths?.slice()), typeof r.modFromBytes == "boolean" && (this._mod = r.modFromBytes));
+    const { nBitLength: i, nByteLength: s } = di(e, n);
+    if (s > 2048)
+      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+    this.ORDER = e, this.BITS = i, this.BYTES = s, this._sqrt = void 0, Object.preventExtensions(this);
+  }
+  create(e) {
+    return fe(e, this.ORDER);
+  }
+  isValid(e) {
+    if (typeof e != "bigint")
+      throw new Error("invalid field element: expected bigint, got " + typeof e);
+    return se <= e && e < this.ORDER;
+  }
+  is0(e) {
+    return e === se;
+  }
+  // is valid and invertible
+  isValidNot0(e) {
+    return !this.is0(e) && this.isValid(e);
+  }
+  isOdd(e) {
+    return (e & re) === re;
+  }
+  neg(e) {
+    return fe(-e, this.ORDER);
+  }
+  eql(e, r) {
+    return e === r;
+  }
+  sqr(e) {
+    return fe(e * e, this.ORDER);
+  }
+  add(e, r) {
+    return fe(e + r, this.ORDER);
+  }
+  sub(e, r) {
+    return fe(e - r, this.ORDER);
+  }
+  mul(e, r) {
+    return fe(e * r, this.ORDER);
+  }
+  pow(e, r) {
+    return fi(this, e, r);
+  }
+  div(e, r) {
+    return fe(e * en(r, this.ORDER), this.ORDER);
+  }
+  // Same as above, but doesn't normalize
+  sqrN(e) {
+    return e * e;
+  }
+  addN(e, r) {
+    return e + r;
+  }
+  subN(e, r) {
+    return e - r;
+  }
+  mulN(e, r) {
+    return e * r;
+  }
+  inv(e) {
+    return en(e, this.ORDER);
+  }
+  sqrt(e) {
+    return this._sqrt || (this._sqrt = ci(this.ORDER)), this._sqrt(this, e);
+  }
+  toBytes(e) {
+    return this.isLE ? On(e, this.BYTES) : Ot(e, this.BYTES);
+  }
+  fromBytes(e, r = !1) {
+    G(e);
+    const { _lengths: n, BYTES: i, isLE: s, ORDER: o, _mod: a } = this;
+    if (n) {
+      if (!n.includes(e.length) || e.length > i)
+        throw new Error("Field.fromBytes: expected " + n + " bytes, got " + e.length);
+      const w = new Uint8Array(i);
+      w.set(e, s ? 0 : w.length - e.length), e = w;
+    }
+    if (e.length !== i)
+      throw new Error("Field.fromBytes: expected " + i + " bytes, got " + e.length);
+    let u = s ? Ln(e) : De(e);
+    if (a && (u = fe(u, o)), !r && !this.isValid(u))
+      throw new Error("invalid field element: outside of range 0..ORDER");
+    return u;
+  }
+  // TODO: we don't need it here, move out to separate fn
+  invertBatch(e) {
+    return Un(this, e);
+  }
+  // We can't move this out because Fp6, Fp12 implement it
+  // and it's unclear what to return in there.
+  cmov(e, r, n) {
+    return n ? r : e;
+  }
+}
+function nt(t, e = {}) {
+  return new hi(t, e);
+}
+function Hn(t) {
+  if (typeof t != "bigint")
+    throw new Error("field order must be bigint");
+  const e = t.toString(2).length;
+  return Math.ceil(e / 8);
+}
+function Kn(t) {
+  const e = Hn(t);
+  return e + Math.ceil(e / 2);
+}
+function Fn(t, e, r = !1) {
+  G(t);
+  const n = t.length, i = Hn(e), s = Kn(e);
+  if (n < 16 || n < s || n > 1024)
+    throw new Error("expected " + s + "-1024 bytes of input, got " + n);
+  const o = r ? Ln(t) : De(t), a = fe(o, e - re) + re;
+  return r ? On(a, i) : Ot(a, i);
+}
+const Te = /* @__PURE__ */ BigInt(0), Ae = /* @__PURE__ */ BigInt(1);
+function Ge(t, e) {
+  const r = e.negate();
+  return t ? r : e;
+}
+function nn(t, e) {
+  const r = Un(t.Fp, e.map((n) => n.Z));
+  return e.map((n, i) => t.fromAffine(n.toAffine(r[i])));
+}
+function Vn(t, e) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > e)
+    throw new Error("invalid window size, expected [1.." + e + "], got W=" + t);
+}
+function ut(t, e) {
+  Vn(t, e);
+  const r = Math.ceil(e / t) + 1, n = 2 ** (t - 1), i = 2 ** t, s = It(t), o = BigInt(t);
+  return { windows: r, windowSize: n, mask: s, maxNumber: i, shiftBy: o };
+}
+function rn(t, e, r) {
+  const { windowSize: n, mask: i, maxNumber: s, shiftBy: o } = r;
+  let a = Number(t & i), u = t >> o;
+  a > n && (a -= s, u += Ae);
+  const w = e * n, T = w + Math.abs(a) - 1, R = a === 0, _ = a < 0, k = e % 2 !== 0;
+  return { nextN: u, offset: T, isZero: R, isNeg: _, isNegF: k, offsetF: w };
+}
+const lt = /* @__PURE__ */ new WeakMap(), Zn = /* @__PURE__ */ new WeakMap();
+function ft(t) {
+  return Zn.get(t) || 1;
+}
+function sn(t) {
+  if (t !== Te)
+    throw new Error("invalid wNAF");
+}
+class gi {
+  BASE;
+  ZERO;
+  Fn;
+  bits;
+  // Parametrized with a given Point class (not individual point)
+  constructor(e, r) {
+    this.BASE = e.BASE, this.ZERO = e.ZERO, this.Fn = e.Fn, this.bits = r;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(e, r, n = this.ZERO) {
+    let i = e;
+    for (; r > Te; )
+      r & Ae && (n = n.add(i)), i = i.double(), r >>= Ae;
+    return n;
+  }
+  /**
+   * Creates a wNAF precomputation window. Used for caching.
+   * Default window size is set by `utils.precompute()` and is equal to 8.
+   * Number of precomputed points depends on the curve size:
+   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+   * - 𝑊 is the window size
+   * - 𝑛 is the bitlength of the curve order.
+   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+   * @param point Point instance
+   * @param W window size
+   * @returns precomputed point tables flattened to a single array
+   */
+  precomputeWindow(e, r) {
+    const { windows: n, windowSize: i } = ut(r, this.bits), s = [];
+    let o = e, a = o;
+    for (let u = 0; u < n; u++) {
+      a = o, s.push(a);
+      for (let w = 1; w < i; w++)
+        a = a.add(o), s.push(a);
+      o = a.double();
+    }
+    return s;
+  }
+  /**
+   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+   * More compact implementation:
+   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+   * @returns real and fake (for const-time) points
+   */
+  wNAF(e, r, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let i = this.ZERO, s = this.BASE;
+    const o = ut(e, this.bits);
+    for (let a = 0; a < o.windows; a++) {
+      const { nextN: u, offset: w, isZero: T, isNeg: R, isNegF: _, offsetF: k } = rn(n, a, o);
+      n = u, T ? s = s.add(Ge(_, r[k])) : i = i.add(Ge(R, r[w]));
+    }
+    return sn(n), { p: i, f: s };
+  }
+  /**
+   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+   * @param acc accumulator point to add result of multiplication
+   * @returns point
+   */
+  wNAFUnsafe(e, r, n, i = this.ZERO) {
+    const s = ut(e, this.bits);
+    for (let o = 0; o < s.windows && n !== Te; o++) {
+      const { nextN: a, offset: u, isZero: w, isNeg: T } = rn(n, o, s);
+      if (n = a, !w) {
+        const R = r[u];
+        i = i.add(T ? R.negate() : R);
+      }
+    }
+    return sn(n), i;
+  }
+  getPrecomputes(e, r, n) {
+    let i = lt.get(r);
+    return i || (i = this.precomputeWindow(r, e), e !== 1 && (typeof n == "function" && (i = n(i)), lt.set(r, i))), i;
+  }
+  cached(e, r, n) {
+    const i = ft(e);
+    return this.wNAF(i, this.getPrecomputes(i, e, n), r);
+  }
+  unsafe(e, r, n, i) {
+    const s = ft(e);
+    return s === 1 ? this._unsafeLadder(e, r, i) : this.wNAFUnsafe(s, this.getPrecomputes(s, e, n), r, i);
+  }
+  // We calculate precomputes for elliptic curve point multiplication
+  // using windowed method. This specifies window size and
+  // stores precomputed values. Usually only base point would be precomputed.
+  createCache(e, r) {
+    Vn(r, this.bits), Zn.set(e, r), lt.delete(e);
+  }
+  hasCache(e) {
+    return ft(e) !== 1;
+  }
+}
+function pi(t, e, r, n) {
+  let i = e, s = t.ZERO, o = t.ZERO;
+  for (; r > Te || n > Te; )
+    r & Ae && (s = s.add(i)), n & Ae && (o = o.add(i)), i = i.double(), r >>= Ae, n >>= Ae;
+  return { p1: s, p2: o };
+}
+function on(t, e, r) {
+  if (e) {
+    if (e.ORDER !== t)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return li(e), e;
+  } else
+    return nt(t, { isLE: r });
+}
+function bi(t, e, r = {}, n) {
+  if (n === void 0 && (n = t === "edwards"), !e || typeof e != "object")
+    throw new Error(`expected valid ${t} CURVE object`);
+  for (const u of ["p", "n", "h"]) {
+    const w = e[u];
+    if (!(typeof w == "bigint" && w > Te))
+      throw new Error(`CURVE.${u} must be positive bigint`);
+  }
+  const i = on(e.p, r.Fp, n), s = on(e.n, r.Fn, n), a = ["Gx", "Gy", "a", "b"];
+  for (const u of a)
+    if (!i.isValid(e[u]))
+      throw new Error(`CURVE.${u} must be valid field element of CURVE.Fp`);
+  return e = Object.freeze(Object.assign({}, e)), { CURVE: e, Fp: i, Fn: s };
+}
+function jn(t, e) {
+  return function(n) {
+    const i = t(n);
+    return { secretKey: i, publicKey: e(i) };
+  };
+}
+class zn {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  finished = !1;
+  destroyed = !1;
+  constructor(e, r) {
+    if (tt(e), G(r, void 0, "key"), this.iHash = e.create(), typeof this.iHash.update != "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+    const n = this.blockLen, i = new Uint8Array(n);
+    i.set(r.length > n ? e.create().update(r).digest() : r);
+    for (let s = 0; s < i.length; s++)
+      i[s] ^= 54;
+    this.iHash.update(i), this.oHash = e.create();
+    for (let s = 0; s < i.length; s++)
+      i[s] ^= 106;
+    this.oHash.update(i), Ne(i);
+  }
+  update(e) {
+    return ze(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    ze(this), G(e, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
+  }
+  digest() {
+    const e = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(e), e;
+  }
+  _cloneInto(e) {
+    e ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash: r, iHash: n, finished: i, destroyed: s, blockLen: o, outputLen: a } = this;
+    return e = e, e.finished = i, e.destroyed = s, e.blockLen = o, e.outputLen = a, e.oHash = r._cloneInto(e.oHash), e.iHash = n._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const qe = (t, e, r) => new zn(t, e).update(r).digest();
+qe.create = (t, e) => new zn(t, e);
+const an = (t, e) => (t + (t >= 0 ? e : -e) / Wn) / e;
+function yi(t, e, r) {
+  const [[n, i], [s, o]] = e, a = an(o * t, r), u = an(-i * t, r);
+  let w = t - a * n - u * s, T = -a * i - u * o;
+  const R = w < pe, _ = T < pe;
+  R && (w = -w), _ && (T = -T);
+  const k = It(Math.ceil(ni(r) / 2)) + _e;
+  if (w < pe || w >= k || T < pe || T >= k)
+    throw new Error("splitScalar (endomorphism): failed, k=" + t);
+  return { k1neg: R, k1: w, k2neg: _, k2: T };
+}
+function kt(t) {
+  if (!["compact", "recovered", "der"].includes(t))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return t;
+}
+function dt(t, e) {
+  const r = {};
+  for (let n of Object.keys(e))
+    r[n] = t[n] === void 0 ? e[n] : t[n];
+  return Je(r.lowS, "lowS"), Je(r.prehash, "prehash"), r.format !== void 0 && kt(r.format), r;
+}
+class wi extends Error {
+  constructor(e = "") {
+    super(e);
+  }
+}
+const we = {
+  // asn.1 DER encoding utils
+  Err: wi,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (t, e) => {
+      const { Err: r } = we;
+      if (t < 0 || t > 256)
+        throw new r("tlv.encode: wrong tag");
+      if (e.length & 1)
+        throw new r("tlv.encode: unpadded data");
+      const n = e.length / 2, i = He(n);
+      if (i.length / 2 & 128)
+        throw new r("tlv.encode: long form length too big");
+      const s = n > 127 ? He(i.length / 2 | 128) : "";
+      return He(t) + s + i + e;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(t, e) {
+      const { Err: r } = we;
+      let n = 0;
+      if (t < 0 || t > 256)
+        throw new r("tlv.encode: wrong tag");
+      if (e.length < 2 || e[n++] !== t)
+        throw new r("tlv.decode: wrong tlv");
+      const i = e[n++], s = !!(i & 128);
+      let o = 0;
+      if (!s)
+        o = i;
+      else {
+        const u = i & 127;
+        if (!u)
+          throw new r("tlv.decode(long): indefinite length not supported");
+        if (u > 4)
+          throw new r("tlv.decode(long): byte length is too big");
+        const w = e.subarray(n, n + u);
+        if (w.length !== u)
+          throw new r("tlv.decode: length bytes not complete");
+        if (w[0] === 0)
+          throw new r("tlv.decode(long): zero leftmost byte");
+        for (const T of w)
+          o = o << 8 | T;
+        if (n += u, o < 128)
+          throw new r("tlv.decode(long): not minimal encoding");
+      }
+      const a = e.subarray(n, n + o);
+      if (a.length !== o)
+        throw new r("tlv.decode: wrong value length");
+      return { v: a, l: e.subarray(n + o) };
+    }
+  },
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  _int: {
+    encode(t) {
+      const { Err: e } = we;
+      if (t < pe)
+        throw new e("integer: negative integers are not allowed");
+      let r = He(t);
+      if (Number.parseInt(r[0], 16) & 8 && (r = "00" + r), r.length & 1)
+        throw new e("unexpected DER parsing assertion: unpadded hex");
+      return r;
+    },
+    decode(t) {
+      const { Err: e } = we;
+      if (t[0] & 128)
+        throw new e("invalid signature integer: negative");
+      if (t[0] === 0 && !(t[1] & 128))
+        throw new e("invalid signature integer: unnecessary leading zero");
+      return De(t);
+    }
+  },
+  toSig(t) {
+    const { Err: e, _int: r, _tlv: n } = we, i = G(t, void 0, "signature"), { v: s, l: o } = n.decode(48, i);
+    if (o.length)
+      throw new e("invalid signature: left bytes after parsing");
+    const { v: a, l: u } = n.decode(2, s), { v: w, l: T } = n.decode(2, u);
+    if (T.length)
+      throw new e("invalid signature: left bytes after parsing");
+    return { r: r.decode(a), s: r.decode(w) };
+  },
+  hexFromSig(t) {
+    const { _tlv: e, _int: r } = we, n = e.encode(2, r.encode(t.r)), i = e.encode(2, r.encode(t.s)), s = n + i;
+    return e.encode(48, s);
+  }
+}, pe = BigInt(0), _e = BigInt(1), Wn = BigInt(2), Ke = BigInt(3), vi = BigInt(4);
+function mi(t, e = {}) {
+  const r = bi("weierstrass", t, e), { Fp: n, Fn: i } = r;
+  let s = r.CURVE;
+  const { h: o, n: a } = s;
+  Pt(e, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object"
+  });
+  const { endo: u } = e;
+  if (u && (!n.is0(s.a) || typeof u.beta != "bigint" || !Array.isArray(u.basises)))
+    throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+  const w = Jn(n, i);
+  function T() {
+    if (!n.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function R(c, d, f) {
+    const { x: l, y: v } = d.toAffine(), A = n.toBytes(l);
+    if (Je(f, "isCompressed"), f) {
+      T();
+      const C = !n.isOdd(v);
+      return oe(Yn(C), A);
+    } else
+      return oe(Uint8Array.of(4), A, n.toBytes(v));
+  }
+  function _(c) {
+    G(c, void 0, "Point");
+    const { publicKey: d, publicKeyUncompressed: f } = w, l = c.length, v = c[0], A = c.subarray(1);
+    if (l === d && (v === 2 || v === 3)) {
+      const C = n.fromBytes(A);
+      if (!n.isValid(C))
+        throw new Error("bad point: is not on curve, wrong x");
+      const I = q(C);
+      let O;
+      try {
+        O = n.sqrt(I);
+      } catch (j) {
+        const Y = j instanceof Error ? ": " + j.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + Y);
+      }
+      T();
+      const $ = n.isOdd(O);
+      return (v & 1) === 1 !== $ && (O = n.neg(O)), { x: C, y: O };
+    } else if (l === f && v === 4) {
+      const C = n.BYTES, I = n.fromBytes(A.subarray(0, C)), O = n.fromBytes(A.subarray(C, C * 2));
+      if (!U(I, O))
+        throw new Error("bad point: is not on curve");
+      return { x: I, y: O };
+    } else
+      throw new Error(`bad point: got length ${l}, expected compressed=${d} or uncompressed=${f}`);
+  }
+  const k = e.toBytes || R, P = e.fromBytes || _;
+  function q(c) {
+    const d = n.sqr(c), f = n.mul(d, c);
+    return n.add(n.add(f, n.mul(c, s.a)), s.b);
+  }
+  function U(c, d) {
+    const f = n.sqr(d), l = q(c);
+    return n.eql(f, l);
+  }
+  if (!U(s.Gx, s.Gy))
+    throw new Error("bad curve params: generator point");
+  const H = n.mul(n.pow(s.a, Ke), vi), W = n.mul(n.sqr(s.b), BigInt(27));
+  if (n.is0(n.add(H, W)))
+    throw new Error("bad curve params: a or b");
+  function ne(c, d, f = !1) {
+    if (!n.isValid(d) || f && n.is0(d))
+      throw new Error(`bad point coordinate ${c}`);
+    return d;
+  }
+  function Q(c) {
+    if (!(c instanceof g))
+      throw new Error("Weierstrass Point expected");
+  }
+  function M(c) {
+    if (!u || !u.basises)
+      throw new Error("no endo");
+    return yi(c, u.basises, i.ORDER);
+  }
+  const L = Qt((c, d) => {
+    const { X: f, Y: l, Z: v } = c;
+    if (n.eql(v, n.ONE))
+      return { x: f, y: l };
+    const A = c.is0();
+    d == null && (d = A ? n.ONE : n.inv(v));
+    const C = n.mul(f, d), I = n.mul(l, d), O = n.mul(v, d);
+    if (A)
+      return { x: n.ZERO, y: n.ZERO };
+    if (!n.eql(O, n.ONE))
+      throw new Error("invZ was invalid");
+    return { x: C, y: I };
+  }), x = Qt((c) => {
+    if (c.is0()) {
+      if (e.allowInfinityPoint && !n.is0(c.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x: d, y: f } = c.toAffine();
+    if (!n.isValid(d) || !n.isValid(f))
+      throw new Error("bad point: x or y not field elements");
+    if (!U(d, f))
+      throw new Error("bad point: equation left != right");
+    if (!c.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return !0;
+  });
+  function B(c, d, f, l, v) {
+    return f = new g(n.mul(f.X, c), f.Y, f.Z), d = Ge(l, d), f = Ge(v, f), d.add(f);
+  }
+  class g {
+    // base / generator point
+    static BASE = new g(s.Gx, s.Gy, n.ONE);
+    // zero / infinity / identity point
+    static ZERO = new g(n.ZERO, n.ONE, n.ZERO);
+    // 0, 1, 0
+    // math field
+    static Fp = n;
+    // scalar field
+    static Fn = i;
+    X;
+    Y;
+    Z;
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(d, f, l) {
+      this.X = ne("x", d), this.Y = ne("y", f, !0), this.Z = ne("z", l), Object.freeze(this);
+    }
+    static CURVE() {
+      return s;
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(d) {
+      const { x: f, y: l } = d || {};
+      if (!d || !n.isValid(f) || !n.isValid(l))
+        throw new Error("invalid affine point");
+      if (d instanceof g)
+        throw new Error("projective point not allowed");
+      return n.is0(f) && n.is0(l) ? g.ZERO : new g(f, l, n.ONE);
+    }
+    static fromBytes(d) {
+      const f = g.fromAffine(P(G(d, void 0, "point")));
+      return f.assertValidity(), f;
+    }
+    static fromHex(d) {
+      return g.fromBytes(ie(d));
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     *
+     * @param windowSize
+     * @param isLazy true will defer table computation until the first multiplication
+     * @returns
+     */
+    precompute(d = 8, f = !0) {
+      return h.createCache(this, d), f || this.multiply(Ke), this;
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      x(this);
+    }
+    hasEvenY() {
+      const { y: d } = this.toAffine();
+      if (!n.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !n.isOdd(d);
+    }
+    /** Compare one point to another. */
+    equals(d) {
+      Q(d);
+      const { X: f, Y: l, Z: v } = this, { X: A, Y: C, Z: I } = d, O = n.eql(n.mul(f, I), n.mul(A, v)), $ = n.eql(n.mul(l, I), n.mul(C, v));
+      return O && $;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new g(this.X, n.neg(this.Y), this.Z);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a: d, b: f } = s, l = n.mul(f, Ke), { X: v, Y: A, Z: C } = this;
+      let I = n.ZERO, O = n.ZERO, $ = n.ZERO, D = n.mul(v, v), j = n.mul(A, A), Y = n.mul(C, C), Z = n.mul(v, A);
+      return Z = n.add(Z, Z), $ = n.mul(v, C), $ = n.add($, $), I = n.mul(d, $), O = n.mul(l, Y), O = n.add(I, O), I = n.sub(j, O), O = n.add(j, O), O = n.mul(I, O), I = n.mul(Z, I), $ = n.mul(l, $), Y = n.mul(d, Y), Z = n.sub(D, Y), Z = n.mul(d, Z), Z = n.add(Z, $), $ = n.add(D, D), D = n.add($, D), D = n.add(D, Y), D = n.mul(D, Z), O = n.add(O, D), Y = n.mul(A, C), Y = n.add(Y, Y), D = n.mul(Y, Z), I = n.sub(I, D), $ = n.mul(Y, j), $ = n.add($, $), $ = n.add($, $), new g(I, O, $);
+    }
+    // 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(d) {
+      Q(d);
+      const { X: f, Y: l, Z: v } = this, { X: A, Y: C, Z: I } = d;
+      let O = n.ZERO, $ = n.ZERO, D = n.ZERO;
+      const j = s.a, Y = n.mul(s.b, Ke);
+      let Z = n.mul(f, A), J = n.mul(l, C), ee = n.mul(v, I), y = n.add(f, l), b = n.add(A, C);
+      y = n.mul(y, b), b = n.add(Z, J), y = n.sub(y, b), b = n.add(f, v);
+      let p = n.add(A, I);
+      return b = n.mul(b, p), p = n.add(Z, ee), b = n.sub(b, p), p = n.add(l, v), O = n.add(C, I), p = n.mul(p, O), O = n.add(J, ee), p = n.sub(p, O), D = n.mul(j, b), O = n.mul(Y, ee), D = n.add(O, D), O = n.sub(J, D), D = n.add(J, D), $ = n.mul(O, D), J = n.add(Z, Z), J = n.add(J, Z), ee = n.mul(j, ee), b = n.mul(Y, b), J = n.add(J, ee), ee = n.sub(Z, ee), ee = n.mul(j, ee), b = n.add(b, ee), Z = n.mul(J, b), $ = n.add($, Z), Z = n.mul(p, b), O = n.mul(y, O), O = n.sub(O, Z), Z = n.mul(y, J), D = n.mul(p, D), D = n.add(D, Z), new g(O, $, D);
+    }
+    subtract(d) {
+      return this.add(d.negate());
+    }
+    is0() {
+      return this.equals(g.ZERO);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(d) {
+      const { endo: f } = e;
+      if (!i.isValidNot0(d))
+        throw new Error("invalid scalar: out of range");
+      let l, v;
+      const A = (C) => h.cached(this, C, (I) => nn(g, I));
+      if (f) {
+        const { k1neg: C, k1: I, k2neg: O, k2: $ } = M(d), { p: D, f: j } = A(I), { p: Y, f: Z } = A($);
+        v = j.add(Z), l = B(f.beta, D, Y, C, O);
+      } else {
+        const { p: C, f: I } = A(d);
+        l = C, v = I;
+      }
+      return nn(g, [l, v])[0];
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed secret key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(d) {
+      const { endo: f } = e, l = this;
+      if (!i.isValid(d))
+        throw new Error("invalid scalar: out of range");
+      if (d === pe || l.is0())
+        return g.ZERO;
+      if (d === _e)
+        return l;
+      if (h.hasCache(this))
+        return this.multiply(d);
+      if (f) {
+        const { k1neg: v, k1: A, k2neg: C, k2: I } = M(d), { p1: O, p2: $ } = pi(g, l, A, I);
+        return B(f.beta, O, $, v, C);
+      } else
+        return h.unsafe(l, d);
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(d) {
+      return L(this, d);
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree: d } = e;
+      return o === _e ? !0 : d ? d(g, this) : h.unsafe(this, a).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor: d } = e;
+      return o === _e ? this : d ? d(g, this) : this.multiplyUnsafe(o);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(o).is0();
+    }
+    toBytes(d = !0) {
+      return Je(d, "isCompressed"), this.assertValidity(), k(g, this, d);
+    }
+    toHex(d = !0) {
+      return le(this.toBytes(d));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  const E = i.BITS, h = new gi(g, e.endo ? Math.ceil(E / 2) : E);
+  return g.BASE.precompute(8), g;
+}
+function Yn(t) {
+  return Uint8Array.of(t ? 2 : 3);
+}
+function Jn(t, e) {
+  return {
+    secretKey: e.BYTES,
+    publicKey: 1 + t.BYTES,
+    publicKeyUncompressed: 1 + 2 * t.BYTES,
+    publicKeyHasPrefix: !0,
+    signature: 2 * e.BYTES
+  };
+}
+function xi(t, e = {}) {
+  const { Fn: r } = t, n = e.randomBytes || $e, i = Object.assign(Jn(t.Fp, r), { seed: Kn(r.ORDER) });
+  function s(k) {
+    try {
+      const P = r.fromBytes(k);
+      return r.isValidNot0(P);
+    } catch {
+      return !1;
+    }
+  }
+  function o(k, P) {
+    const { publicKey: q, publicKeyUncompressed: U } = i;
+    try {
+      const H = k.length;
+      return P === !0 && H !== q || P === !1 && H !== U ? !1 : !!t.fromBytes(k);
+    } catch {
+      return !1;
+    }
+  }
+  function a(k = n(i.seed)) {
+    return Fn(G(k, i.seed, "seed"), r.ORDER);
+  }
+  function u(k, P = !0) {
+    return t.BASE.multiply(r.fromBytes(k)).toBytes(P);
+  }
+  function w(k) {
+    const { secretKey: P, publicKey: q, publicKeyUncompressed: U } = i;
+    if (!_t(k) || "_lengths" in r && r._lengths || P === q)
+      return;
+    const H = G(k, void 0, "key").length;
+    return H === q || H === U;
+  }
+  function T(k, P, q = !0) {
+    if (w(k) === !0)
+      throw new Error("first arg must be private key");
+    if (w(P) === !1)
+      throw new Error("second arg must be public key");
+    const U = r.fromBytes(k);
+    return t.fromBytes(P).multiply(U).toBytes(q);
+  }
+  const R = {
+    isValidSecretKey: s,
+    isValidPublicKey: o,
+    randomSecretKey: a
+  }, _ = jn(a, u);
+  return Object.freeze({ getPublicKey: u, getSharedSecret: T, keygen: _, Point: t, utils: R, lengths: i });
+}
+function Ei(t, e, r = {}) {
+  tt(e), Pt(r, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  }), r = Object.assign({}, r);
+  const n = r.randomBytes || $e, i = r.hmac || ((f, l) => qe(e, f, l)), { Fp: s, Fn: o } = t, { ORDER: a, BITS: u } = o, { keygen: w, getPublicKey: T, getSharedSecret: R, utils: _, lengths: k } = xi(t, r), P = {
+    prehash: !0,
+    lowS: typeof r.lowS == "boolean" ? r.lowS : !0,
+    format: "compact",
+    extraEntropy: !1
+  }, q = a * Wn < s.ORDER;
+  function U(f) {
+    const l = a >> _e;
+    return f > l;
+  }
+  function H(f, l) {
+    if (!o.isValidNot0(l))
+      throw new Error(`invalid signature ${f}: out of range 1..Point.Fn.ORDER`);
+    return l;
+  }
+  function W() {
+    if (q)
+      throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
+  }
+  function ne(f, l) {
+    kt(l);
+    const v = k.signature, A = l === "compact" ? v : l === "recovered" ? v + 1 : void 0;
+    return G(f, A);
+  }
+  class Q {
+    r;
+    s;
+    recovery;
+    constructor(l, v, A) {
+      if (this.r = H("r", l), this.s = H("s", v), A != null) {
+        if (W(), ![0, 1, 2, 3].includes(A))
+          throw new Error("invalid recovery id");
+        this.recovery = A;
+      }
+      Object.freeze(this);
+    }
+    static fromBytes(l, v = P.format) {
+      ne(l, v);
+      let A;
+      if (v === "der") {
+        const { r: $, s: D } = we.toSig(G(l));
+        return new Q($, D);
+      }
+      v === "recovered" && (A = l[0], v = "compact", l = l.subarray(1));
+      const C = k.signature / 2, I = l.subarray(0, C), O = l.subarray(C, C * 2);
+      return new Q(o.fromBytes(I), o.fromBytes(O), A);
+    }
+    static fromHex(l, v) {
+      return this.fromBytes(ie(l), v);
+    }
+    assertRecovery() {
+      const { recovery: l } = this;
+      if (l == null)
+        throw new Error("invalid recovery id: must be present");
+      return l;
+    }
+    addRecoveryBit(l) {
+      return new Q(this.r, this.s, l);
+    }
+    recoverPublicKey(l) {
+      const { r: v, s: A } = this, C = this.assertRecovery(), I = C === 2 || C === 3 ? v + a : v;
+      if (!s.isValid(I))
+        throw new Error("invalid recovery id: sig.r+curve.n != R.x");
+      const O = s.toBytes(I), $ = t.fromBytes(oe(Yn((C & 1) === 0), O)), D = o.inv(I), j = L(G(l, void 0, "msgHash")), Y = o.create(-j * D), Z = o.create(A * D), J = t.BASE.multiplyUnsafe(Y).add($.multiplyUnsafe(Z));
+      if (J.is0())
+        throw new Error("invalid recovery: point at infinify");
+      return J.assertValidity(), J;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return U(this.s);
+    }
+    toBytes(l = P.format) {
+      if (kt(l), l === "der")
+        return ie(we.hexFromSig(this));
+      const { r: v, s: A } = this, C = o.toBytes(v), I = o.toBytes(A);
+      return l === "recovered" ? (W(), oe(Uint8Array.of(this.assertRecovery()), C, I)) : oe(C, I);
+    }
+    toHex(l) {
+      return le(this.toBytes(l));
+    }
+  }
+  const M = r.bits2int || function(l) {
+    if (l.length > 8192)
+      throw new Error("input is too large");
+    const v = De(l), A = l.length * 8 - u;
+    return A > 0 ? v >> BigInt(A) : v;
+  }, L = r.bits2int_modN || function(l) {
+    return o.create(M(l));
+  }, x = It(u);
+  function B(f) {
+    return ti("num < 2^" + u, f, pe, x), o.toBytes(f);
+  }
+  function g(f, l) {
+    return G(f, void 0, "message"), l ? G(e(f), void 0, "prehashed message") : f;
+  }
+  function E(f, l, v) {
+    const { lowS: A, prehash: C, extraEntropy: I } = dt(v, P);
+    f = g(f, C);
+    const O = L(f), $ = o.fromBytes(l);
+    if (!o.isValidNot0($))
+      throw new Error("invalid private key");
+    const D = [B($), B(O)];
+    if (I != null && I !== !1) {
+      const J = I === !0 ? n(k.secretKey) : I;
+      D.push(G(J, void 0, "extraEntropy"));
+    }
+    const j = oe(...D), Y = O;
+    function Z(J) {
+      const ee = M(J);
+      if (!o.isValidNot0(ee))
+        return;
+      const y = o.inv(ee), b = t.BASE.multiply(ee).toAffine(), p = o.create(b.x);
+      if (p === pe)
+        return;
+      const m = o.create(y * o.create(Y + p * $));
+      if (m === pe)
+        return;
+      let S = (b.x === p ? 0 : 2) | Number(b.y & _e), N = m;
+      return A && U(m) && (N = o.neg(m), S ^= 1), new Q(p, N, q ? void 0 : S);
+    }
+    return { seed: j, k2sig: Z };
+  }
+  function h(f, l, v = {}) {
+    const { seed: A, k2sig: C } = E(f, l, v);
+    return ri(e.outputLen, o.BYTES, i)(A, C).toBytes(v.format);
+  }
+  function c(f, l, v, A = {}) {
+    const { lowS: C, prehash: I, format: O } = dt(A, P);
+    if (v = G(v, void 0, "publicKey"), l = g(l, I), !_t(f)) {
+      const $ = f instanceof Q ? ", use sig.toBytes()" : "";
+      throw new Error("verify expects Uint8Array signature" + $);
+    }
+    ne(f, O);
+    try {
+      const $ = Q.fromBytes(f, O), D = t.fromBytes(v);
+      if (C && $.hasHighS())
+        return !1;
+      const { r: j, s: Y } = $, Z = L(l), J = o.inv(Y), ee = o.create(Z * J), y = o.create(j * J), b = t.BASE.multiplyUnsafe(ee).add(D.multiplyUnsafe(y));
+      return b.is0() ? !1 : o.create(b.x) === j;
+    } catch {
+      return !1;
+    }
+  }
+  function d(f, l, v = {}) {
+    const { prehash: A } = dt(v, P);
+    return l = g(l, A), Q.fromBytes(f, "recovered").recoverPublicKey(l).toBytes();
+  }
+  return Object.freeze({
+    keygen: w,
+    getPublicKey: T,
+    getSharedSecret: R,
+    utils: _,
+    lengths: k,
+    Point: t,
+    sign: h,
+    verify: c,
+    recoverPublicKey: d,
+    Signature: Q,
+    hash: e
+  });
+}
+const rt = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+}, ki = {
+  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+  basises: [
+    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+  ]
+}, Ai = /* @__PURE__ */ BigInt(0), At = /* @__PURE__ */ BigInt(2);
+function Si(t) {
+  const e = rt.p, r = BigInt(3), n = BigInt(6), i = BigInt(11), s = BigInt(22), o = BigInt(23), a = BigInt(44), u = BigInt(88), w = t * t * t % e, T = w * w * t % e, R = ue(T, r, e) * T % e, _ = ue(R, r, e) * T % e, k = ue(_, At, e) * w % e, P = ue(k, i, e) * k % e, q = ue(P, s, e) * P % e, U = ue(q, a, e) * q % e, H = ue(U, u, e) * U % e, W = ue(H, a, e) * q % e, ne = ue(W, r, e) * T % e, Q = ue(ne, o, e) * P % e, M = ue(Q, n, e) * w % e, L = ue(M, At, e);
+  if (!Xe.eql(Xe.sqr(L), t))
+    throw new Error("Cannot find square root");
+  return L;
+}
+const Xe = nt(rt.p, { sqrt: Si }), Be = /* @__PURE__ */ mi(rt, {
+  Fp: Xe,
+  endo: ki
+}), Bi = /* @__PURE__ */ Ei(Be, xe), cn = {};
+function Qe(t, ...e) {
+  let r = cn[t];
+  if (r === void 0) {
+    const n = xe(Qr(t));
+    r = oe(n, n), cn[t] = r;
+  }
+  return xe(oe(r, ...e));
+}
+const Nt = (t) => t.toBytes(!0).slice(1), $t = (t) => t % At === Ai;
+function St(t) {
+  const { Fn: e, BASE: r } = Be, n = e.fromBytes(t), i = r.multiply(n);
+  return { scalar: $t(i.y) ? n : e.neg(n), bytes: Nt(i) };
+}
+function Gn(t) {
+  const e = Xe;
+  if (!e.isValidNot0(t))
+    throw new Error("invalid x: Fail if x ≥ p");
+  const r = e.create(t * t), n = e.create(r * t + BigInt(7));
+  let i = e.sqrt(n);
+  $t(i) || (i = e.neg(i));
+  const s = Be.fromAffine({ x: t, y: i });
+  return s.assertValidity(), s;
+}
+const Me = De;
+function Xn(...t) {
+  return Be.Fn.create(Me(Qe("BIP0340/challenge", ...t)));
+}
+function un(t) {
+  return St(t).bytes;
+}
+function Ri(t, e, r = $e(32)) {
+  const { Fn: n } = Be, i = G(t, void 0, "message"), { bytes: s, scalar: o } = St(e), a = G(r, 32, "auxRand"), u = n.toBytes(o ^ Me(Qe("BIP0340/aux", a))), w = Qe("BIP0340/nonce", u, s, i), { bytes: T, scalar: R } = St(w), _ = Xn(T, s, i), k = new Uint8Array(64);
+  if (k.set(T, 0), k.set(n.toBytes(n.create(R + _ * o)), 32), !Qn(k, i, s))
+    throw new Error("sign: Invalid signature produced");
+  return k;
+}
+function Qn(t, e, r) {
+  const { Fp: n, Fn: i, BASE: s } = Be, o = G(t, 64, "signature"), a = G(e, void 0, "message"), u = G(r, 32, "publicKey");
+  try {
+    const w = Gn(Me(u)), T = Me(o.subarray(0, 32));
+    if (!n.isValidNot0(T))
+      return !1;
+    const R = Me(o.subarray(32, 64));
+    if (!i.isValidNot0(R))
+      return !1;
+    const _ = Xn(i.toBytes(T), Nt(w), a), k = s.multiplyUnsafe(R).add(w.multiplyUnsafe(i.neg(_))), { x: P, y: q } = k.toAffine();
+    return !(k.is0() || !$t(q) || P !== T);
+  } catch {
+    return !1;
+  }
+}
+const he = /* @__PURE__ */ (() => {
+  const r = (n = $e(48)) => Fn(n, rt.n);
+  return {
+    keygen: jn(r, un),
+    getPublicKey: un,
+    sign: Ri,
+    verify: Qn,
+    Point: Be,
+    utils: {
+      randomSecretKey: r,
+      taggedHash: Qe,
+      lift_x: Gn,
+      pointToBytes: Nt
+    },
+    lengths: {
+      secretKey: 32,
+      publicKey: 32,
+      publicKeyHasPrefix: !1,
+      signature: 64,
+      seed: 48
+    }
+  };
+})();
+var Re = /* @__PURE__ */ Symbol("verified"), _i = (t) => t instanceof Object;
+function Ti(t) {
+  if (!_i(t) || typeof t.kind != "number" || typeof t.content != "string" || typeof t.created_at != "number" || typeof t.pubkey != "string" || !t.pubkey.match(/^[a-f0-9]{64}$/) || !Array.isArray(t.tags))
+    return !1;
+  for (let e = 0; e < t.tags.length; e++) {
+    let r = t.tags[e];
+    if (!Array.isArray(r))
+      return !1;
+    for (let n = 0; n < r.length; n++)
+      if (typeof r[n] != "string")
+        return !1;
+  }
+  return !0;
+}
+new TextDecoder("utf-8");
+var Ci = new TextEncoder(), Li = class {
+  generateSecretKey() {
+    return he.utils.randomSecretKey();
+  }
+  getPublicKey(e) {
+    return le(he.getPublicKey(e));
+  }
+  finalizeEvent(e, r) {
+    const n = e;
+    return n.pubkey = le(he.getPublicKey(r)), n.id = ht(n), n.sig = le(he.sign(ie(ht(n)), r)), n[Re] = !0, n;
+  }
+  verifyEvent(e) {
+    if (typeof e[Re] == "boolean")
+      return e[Re];
+    try {
+      const r = ht(e);
+      if (r !== e.id)
+        return e[Re] = !1, !1;
+      const n = he.verify(ie(e.sig), ie(r), ie(e.pubkey));
+      return e[Re] = n, n;
+    } catch {
+      return e[Re] = !1, !1;
+    }
+  }
+};
+function Oi(t) {
+  if (!Ti(t))
+    throw new Error("can't serialize event with wrong or missing properties");
+  return JSON.stringify([0, t.pubkey, t.created_at, t.kind, t.tags, t.content]);
+}
+function ht(t) {
+  let e = xe(Ci.encode(Oi(t)));
+  return le(e);
+}
+var it = new Li(), er = it.generateSecretKey, Ii = it.getPublicKey;
+it.finalizeEvent;
+it.verifyEvent;
+function Pi(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function ln(t) {
+  if (typeof t != "boolean")
+    throw new Error(`boolean expected, not ${t}`);
+}
+function gt(t) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error("positive integer expected, got " + t);
+}
+function Le(t, e, r = "") {
+  const n = Pi(t), i = t?.length, s = e !== void 0;
+  if (!n || s && i !== e) {
+    const o = r && `"${r}" `, a = s ? ` of length ${e}` : "", u = n ? `length=${i}` : `type=${typeof t}`;
+    throw new Error(o + "expected Uint8Array" + a + ", got " + u);
+  }
+  return t;
+}
+function ve(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function Mi(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function Ni(t, e) {
+  if (e == null || typeof e != "object")
+    throw new Error("options must be defined");
+  return Object.assign(t, e);
+}
+function $i(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  let r = 0;
+  for (let n = 0; n < t.length; n++)
+    r |= t[n] ^ e[n];
+  return r === 0;
+}
+function fn(t) {
+  return Uint8Array.from(t);
+}
+const tr = (t) => Uint8Array.from(t.split(""), (e) => e.charCodeAt(0)), Di = tr("expand 16-byte k"), qi = tr("expand 32-byte k"), Ui = ve(Di), Hi = ve(qi);
+function z(t, e) {
+  return t << e | t >>> 32 - e;
+}
+function Bt(t) {
+  return t.byteOffset % 4 === 0;
+}
+const Fe = 64, Ki = 16, nr = 2 ** 32 - 1, dn = Uint32Array.of();
+function Fi(t, e, r, n, i, s, o, a) {
+  const u = i.length, w = new Uint8Array(Fe), T = ve(w), R = Bt(i) && Bt(s), _ = R ? ve(i) : dn, k = R ? ve(s) : dn;
+  for (let P = 0; P < u; o++) {
+    if (t(e, r, n, T, o, a), o >= nr)
+      throw new Error("arx: counter overflow");
+    const q = Math.min(Fe, u - P);
+    if (R && q === Fe) {
+      const U = P / 4;
+      if (P % 4 !== 0)
+        throw new Error("arx: invalid block position");
+      for (let H = 0, W; H < Ki; H++)
+        W = U + H, k[W] = _[W] ^ T[H];
+      P += Fe;
+      continue;
+    }
+    for (let U = 0, H; U < q; U++)
+      H = P + U, s[H] = i[H] ^ w[U];
+    P += q;
+  }
+}
+function Vi(t, e) {
+  const { allowShortKeys: r, extendNonceFn: n, counterLength: i, counterRight: s, rounds: o } = Ni({ allowShortKeys: !1, counterLength: 8, counterRight: !1, rounds: 20 }, e);
+  if (typeof t != "function")
+    throw new Error("core must be a function");
+  return gt(i), gt(o), ln(s), ln(r), (a, u, w, T, R = 0) => {
+    Le(a, void 0, "key"), Le(u, void 0, "nonce"), Le(w, void 0, "data");
+    const _ = w.length;
+    if (T === void 0 && (T = new Uint8Array(_)), Le(T, void 0, "output"), gt(R), R < 0 || R >= nr)
+      throw new Error("arx: counter overflow");
+    if (T.length < _)
+      throw new Error(`arx: output (${T.length}) is shorter than data (${_})`);
+    const k = [];
+    let P = a.length, q, U;
+    if (P === 32)
+      k.push(q = fn(a)), U = Hi;
+    else if (P === 16 && r)
+      q = new Uint8Array(32), q.set(a), q.set(a, 16), U = Ui, k.push(q);
+    else
+      throw Le(a, 32, "arx key"), new Error("invalid key size");
+    Bt(u) || k.push(u = fn(u));
+    const H = ve(q);
+    if (n) {
+      if (u.length !== 24)
+        throw new Error("arx: extended nonce must be 24 bytes");
+      n(U, H, ve(u.subarray(0, 16)), H), u = u.subarray(16);
+    }
+    const W = 16 - i;
+    if (W !== u.length)
+      throw new Error(`arx: nonce must be ${W} or 16 bytes`);
+    if (W !== 12) {
+      const Q = new Uint8Array(12);
+      Q.set(u, s ? 0 : 12 - u.length), u = Q, k.push(u);
+    }
+    const ne = ve(u);
+    return Fi(t, U, H, ne, w, T, R, o), Mi(...k), T;
+  };
+}
+function Zi(t, e, r, n, i, s = 20) {
+  let o = t[0], a = t[1], u = t[2], w = t[3], T = e[0], R = e[1], _ = e[2], k = e[3], P = e[4], q = e[5], U = e[6], H = e[7], W = i, ne = r[0], Q = r[1], M = r[2], L = o, x = a, B = u, g = w, E = T, h = R, c = _, d = k, f = P, l = q, v = U, A = H, C = W, I = ne, O = Q, $ = M;
+  for (let j = 0; j < s; j += 2)
+    L = L + E | 0, C = z(C ^ L, 16), f = f + C | 0, E = z(E ^ f, 12), L = L + E | 0, C = z(C ^ L, 8), f = f + C | 0, E = z(E ^ f, 7), x = x + h | 0, I = z(I ^ x, 16), l = l + I | 0, h = z(h ^ l, 12), x = x + h | 0, I = z(I ^ x, 8), l = l + I | 0, h = z(h ^ l, 7), B = B + c | 0, O = z(O ^ B, 16), v = v + O | 0, c = z(c ^ v, 12), B = B + c | 0, O = z(O ^ B, 8), v = v + O | 0, c = z(c ^ v, 7), g = g + d | 0, $ = z($ ^ g, 16), A = A + $ | 0, d = z(d ^ A, 12), g = g + d | 0, $ = z($ ^ g, 8), A = A + $ | 0, d = z(d ^ A, 7), L = L + h | 0, $ = z($ ^ L, 16), v = v + $ | 0, h = z(h ^ v, 12), L = L + h | 0, $ = z($ ^ L, 8), v = v + $ | 0, h = z(h ^ v, 7), x = x + c | 0, C = z(C ^ x, 16), A = A + C | 0, c = z(c ^ A, 12), x = x + c | 0, C = z(C ^ x, 8), A = A + C | 0, c = z(c ^ A, 7), B = B + d | 0, I = z(I ^ B, 16), f = f + I | 0, d = z(d ^ f, 12), B = B + d | 0, I = z(I ^ B, 8), f = f + I | 0, d = z(d ^ f, 7), g = g + E | 0, O = z(O ^ g, 16), l = l + O | 0, E = z(E ^ l, 12), g = g + E | 0, O = z(O ^ g, 8), l = l + O | 0, E = z(E ^ l, 7);
+  let D = 0;
+  n[D++] = o + L | 0, n[D++] = a + x | 0, n[D++] = u + B | 0, n[D++] = w + g | 0, n[D++] = T + E | 0, n[D++] = R + h | 0, n[D++] = _ + c | 0, n[D++] = k + d | 0, n[D++] = P + f | 0, n[D++] = q + l | 0, n[D++] = U + v | 0, n[D++] = H + A | 0, n[D++] = W + C | 0, n[D++] = ne + I | 0, n[D++] = Q + O | 0, n[D++] = M + $ | 0;
+}
+const rr = /* @__PURE__ */ Vi(Zi, {
+  counterRight: !1,
+  counterLength: 4,
+  allowShortKeys: !1
+});
+function ji(t, e, r) {
+  return tt(t), r === void 0 && (r = new Uint8Array(t.outputLen)), qe(t, r, e);
+}
+const pt = /* @__PURE__ */ Uint8Array.of(0), hn = /* @__PURE__ */ Uint8Array.of();
+function zi(t, e, r, n = 32) {
+  tt(t), me(n, "length");
+  const i = t.outputLen;
+  if (n > 255 * i)
+    throw new Error("Length must be <= 255*HashLen");
+  const s = Math.ceil(n / i);
+  r === void 0 ? r = hn : G(r, void 0, "info");
+  const o = new Uint8Array(s * i), a = qe.create(t, e), u = a._cloneInto(), w = new Uint8Array(a.outputLen);
+  for (let T = 0; T < s; T++)
+    pt[0] = T + 1, u.update(T === 0 ? hn : w).update(r).update(pt).digestInto(w), o.set(w, i * T), a._cloneInto(u);
+  return a.destroy(), u.destroy(), Ne(w, pt), o.slice(0, n);
+}
+var Ee = /* @__PURE__ */ Symbol("verified"), Wi = (t) => t instanceof Object;
+function Yi(t) {
+  if (!Wi(t) || typeof t.kind != "number" || typeof t.content != "string" || typeof t.created_at != "number" || typeof t.pubkey != "string" || !t.pubkey.match(/^[a-f0-9]{64}$/) || !Array.isArray(t.tags))
+    return !1;
+  for (let e = 0; e < t.tags.length; e++) {
+    let r = t.tags[e];
+    if (!Array.isArray(r))
+      return !1;
+    for (let n = 0; n < r.length; n++)
+      if (typeof r[n] != "string")
+        return !1;
+  }
+  return !0;
+}
+var Ji = new TextDecoder("utf-8"), Dt = new TextEncoder();
+function Oe(t) {
+  try {
+    t.indexOf("://") === -1 && (t = "wss://" + t);
+    let e = new URL(t);
+    return e.protocol === "http:" ? e.protocol = "ws:" : e.protocol === "https:" && (e.protocol = "wss:"), e.pathname = e.pathname.replace(/\/+/g, "/"), e.pathname.endsWith("/") && (e.pathname = e.pathname.slice(0, -1)), (e.port === "80" && e.protocol === "ws:" || e.port === "443" && e.protocol === "wss:") && (e.port = ""), e.searchParams.sort(), e.hash = "", e.toString();
+  } catch {
+    throw new Error(`Invalid URL: ${t}`);
+  }
+}
+var Gi = class {
+  generateSecretKey() {
+    return he.utils.randomSecretKey();
+  }
+  getPublicKey(t) {
+    return le(he.getPublicKey(t));
+  }
+  finalizeEvent(t, e) {
+    const r = t;
+    return r.pubkey = le(he.getPublicKey(e)), r.id = bt(r), r.sig = le(he.sign(ie(bt(r)), e)), r[Ee] = !0, r;
+  }
+  verifyEvent(t) {
+    if (typeof t[Ee] == "boolean")
+      return t[Ee];
+    try {
+      const e = bt(t);
+      if (e !== t.id)
+        return t[Ee] = !1, !1;
+      const r = he.verify(ie(t.sig), ie(e), ie(t.pubkey));
+      return t[Ee] = r, r;
+    } catch {
+      return t[Ee] = !1, !1;
+    }
+  }
+};
+function Xi(t) {
+  if (!Yi(t))
+    throw new Error("can't serialize event with wrong or missing properties");
+  return JSON.stringify([0, t.pubkey, t.created_at, t.kind, t.tags, t.content]);
+}
+function bt(t) {
+  let e = xe(Dt.encode(Xi(t)));
+  return le(e);
+}
+var st = new Gi();
+st.generateSecretKey;
+var gn = st.getPublicKey, Qi = st.finalizeEvent, ir = st.verifyEvent, sr = 1, or = 65535;
+function yt(t, e) {
+  const r = Bi.getSharedSecret(t, ie("02" + e)).subarray(1, 33);
+  return ji(xe, r, Dt.encode("nip44-v2"));
+}
+function ar(t, e) {
+  const r = zi(xe, t, e, 76);
+  return {
+    chacha_key: r.subarray(0, 32),
+    chacha_nonce: r.subarray(32, 44),
+    hmac_key: r.subarray(44, 76)
+  };
+}
+function cr(t) {
+  if (!Number.isSafeInteger(t) || t < 1)
+    throw new Error("expected positive integer");
+  if (t <= 32)
+    return 32;
+  const e = 1 << Math.floor(Math.log2(t - 1)) + 1, r = e <= 256 ? 32 : e / 8;
+  return r * (Math.floor((t - 1) / r) + 1);
+}
+function es(t) {
+  if (!Number.isSafeInteger(t) || t < sr || t > or)
+    throw new Error("invalid plaintext size: must be between 1 and 65535 bytes");
+  const e = new Uint8Array(2);
+  return new DataView(e.buffer).setUint16(0, t, !1), e;
+}
+function ts(t) {
+  const e = Dt.encode(t), r = e.length, n = es(r), i = new Uint8Array(cr(r) - r);
+  return oe(n, e, i);
+}
+function ns(t) {
+  const e = new DataView(t.buffer).getUint16(0), r = t.subarray(2, 2 + e);
+  if (e < sr || e > or || r.length !== e || t.length !== 2 + cr(e))
+    throw new Error("invalid padding");
+  return Ji.decode(r);
+}
+function ur(t, e, r) {
+  if (r.length !== 32)
+    throw new Error("AAD associated data must be 32 bytes");
+  const n = oe(r, e);
+  return qe(xe, t, n);
+}
+function rs(t) {
+  if (typeof t != "string")
+    throw new Error("payload must be a valid string");
+  const e = t.length;
+  if (e < 132 || e > 87472)
+    throw new Error("invalid payload length: " + e);
+  if (t[0] === "#")
+    throw new Error("unknown encryption version");
+  let r;
+  try {
+    r = Sn.decode(t);
+  } catch (s) {
+    throw new Error("invalid base64: " + s.message);
+  }
+  const n = r.length;
+  if (n < 99 || n > 65603)
+    throw new Error("invalid data length: " + n);
+  const i = r[0];
+  if (i !== 2)
+    throw new Error("unknown encryption version " + i);
+  return {
+    nonce: r.subarray(1, 33),
+    ciphertext: r.subarray(33, -32),
+    mac: r.subarray(-32)
+  };
+}
+function is(t, e, r = $e(32)) {
+  const { chacha_key: n, chacha_nonce: i, hmac_key: s } = ar(e, r), o = ts(t), a = rr(n, i, o), u = ur(s, a, r);
+  return Sn.encode(oe(new Uint8Array([2]), r, a, u));
+}
+function pn(t, e) {
+  const { nonce: r, ciphertext: n, mac: i } = rs(t), { chacha_key: s, chacha_nonce: o, hmac_key: a } = ar(e, r), u = ur(a, n, r);
+  if (!$i(u, i))
+    throw new Error("invalid MAC");
+  const w = rr(s, o, n);
+  return ns(w);
+}
+var ss = /^(?:([\w.+-]+)@)?([\w_-]+(\.[\w_-]+)+)$/, os;
+try {
+  os = fetch;
+} catch {
+}
+var as = 22242, wt = 24133;
+function cs(t, e) {
+  if (t.ids && t.ids.indexOf(e.id) === -1 || t.kinds && t.kinds.indexOf(e.kind) === -1 || t.authors && t.authors.indexOf(e.pubkey) === -1)
+    return !1;
+  for (let r in t)
+    if (r[0] === "#") {
+      let n = r.slice(1), i = t[`#${n}`];
+      if (i && !e.tags.find(([s, o]) => s === r.slice(1) && i.indexOf(o) !== -1))
+        return !1;
+    }
+  return !(t.since && e.created_at < t.since || t.until && e.created_at > t.until);
+}
+function us(t, e) {
+  for (let r = 0; r < t.length; r++)
+    if (cs(t[r], e))
+      return !0;
+  return !1;
+}
+function ls(t, e) {
+  let r = e.length + 3, n = t.indexOf(`"${e}":`) + r, i = t.slice(n).indexOf('"') + n + 1;
+  return t.slice(i, i + 64);
+}
+function fs(t) {
+  let e = t.slice(0, 22).indexOf('"EVENT"');
+  if (e === -1)
+    return null;
+  let r = t.slice(e + 7 + 1).indexOf('"');
+  if (r === -1)
+    return null;
+  let n = e + 7 + 1 + r, i = t.slice(n + 1, 80).indexOf('"');
+  if (i === -1)
+    return null;
+  let s = n + 1 + i;
+  return t.slice(n + 1, s);
+}
+function ds(t, e) {
+  return {
+    kind: as,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: [
+      ["relay", t],
+      ["challenge", e]
+    ],
+    content: ""
+  };
+}
+var lr = class extends Error {
+  constructor(t, e) {
+    super(`Tried to send message '${t} on a closed connection to ${e}.`), this.name = "SendingOnClosedConnection";
+  }
+}, fr = class {
+  url;
+  _connected = !1;
+  onclose = null;
+  onnotice = (t) => console.debug(`NOTICE from ${this.url}: ${t}`);
+  onauth;
+  baseEoseTimeout = 4400;
+  publishTimeout = 4400;
+  pingFrequency = 29e3;
+  pingTimeout = 2e4;
+  resubscribeBackoff = [1e4, 1e4, 1e4, 2e4, 2e4, 3e4, 6e4];
+  openSubs = /* @__PURE__ */ new Map();
+  enablePing;
+  enableReconnect;
+  idleSince = Date.now();
+  ongoingOperations = 0;
+  reconnectTimeoutHandle;
+  pingIntervalHandle;
+  reconnectAttempts = 0;
+  skipReconnection = !1;
+  connectionPromise;
+  openCountRequests = /* @__PURE__ */ new Map();
+  openEventPublishes = /* @__PURE__ */ new Map();
+  ws;
+  challenge;
+  authPromise;
+  serial = 0;
+  verifyEvent;
+  _WebSocket;
+  constructor(t, e) {
+    this.url = Oe(t), this.verifyEvent = e.verifyEvent, this._WebSocket = e.websocketImplementation || WebSocket, this.enablePing = e.enablePing, this.enableReconnect = e.enableReconnect || !1;
+  }
+  static async connect(t, e) {
+    const r = new fr(t, e);
+    return await r.connect(e), r;
+  }
+  closeAllSubscriptions(t) {
+    for (let [e, r] of this.openSubs)
+      r.close(t);
+    this.openSubs.clear();
+    for (let [e, r] of this.openEventPublishes)
+      r.reject(new Error(t));
+    this.openEventPublishes.clear();
+    for (let [e, r] of this.openCountRequests)
+      r.reject(new Error(t));
+    this.openCountRequests.clear();
+  }
+  get connected() {
+    return this._connected;
+  }
+  async reconnect() {
+    const t = this.resubscribeBackoff[Math.min(this.reconnectAttempts, this.resubscribeBackoff.length - 1)];
+    this.reconnectAttempts++, this.reconnectTimeoutHandle = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, t);
+  }
+  handleHardClose(t) {
+    this.pingIntervalHandle && (clearInterval(this.pingIntervalHandle), this.pingIntervalHandle = void 0), this._connected = !1, this.connectionPromise = void 0, this.idleSince = void 0, this.enableReconnect && !this.skipReconnection ? this.reconnect() : (this.onclose?.(), this.closeAllSubscriptions(t));
+  }
+  async connect(t) {
+    let e;
+    return this.connectionPromise ? this.connectionPromise : (this.challenge = void 0, this.authPromise = void 0, this.skipReconnection = !1, this.connectionPromise = new Promise((r, n) => {
+      t?.timeout && (e = setTimeout(() => {
+        n("connection timed out"), this.connectionPromise = void 0, this.skipReconnection = !0, this.onclose?.(), this.handleHardClose("relay connection timed out");
+      }, t.timeout)), t?.abort && (t.abort.onabort = n);
+      try {
+        this.ws = new this._WebSocket(this.url);
+      } catch (i) {
+        clearTimeout(e), n(i);
+        return;
+      }
+      this.ws.onopen = () => {
+        this.reconnectTimeoutHandle && (clearTimeout(this.reconnectTimeoutHandle), this.reconnectTimeoutHandle = void 0), clearTimeout(e), this._connected = !0;
+        const i = this.reconnectAttempts > 0;
+        this.reconnectAttempts = 0;
+        for (const s of this.openSubs.values()) {
+          if (s.eosed = !1, i)
+            for (let o = 0; o < s.filters.length; o++)
+              s.lastEmitted && (s.filters[o].since = s.lastEmitted + 1);
+          s.fire();
+        }
+        this.enablePing && (this.pingIntervalHandle = setInterval(() => this.pingpong(), this.pingFrequency)), r();
+      }, this.ws.onerror = () => {
+        clearTimeout(e), n("connection failed"), this.connectionPromise = void 0, this.skipReconnection = !0, this.onclose?.(), this.handleHardClose("relay connection failed");
+      }, this.ws.onclose = (i) => {
+        clearTimeout(e), n(i.message || "websocket closed"), this.handleHardClose("relay connection closed");
+      }, this.ws.onmessage = this._onmessage.bind(this);
+    }), this.connectionPromise);
+  }
+  waitForPingPong() {
+    return new Promise((t) => {
+      this.ws.once("pong", () => t(!0)), this.ws.ping();
+    });
+  }
+  waitForDummyReq() {
+    return new Promise((t, e) => {
+      if (!this.connectionPromise)
+        return e(new Error(`no connection to ${this.url}, can't ping`));
+      try {
+        const r = this.subscribe(
+          [{ ids: ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], limit: 0 }],
+          {
+            label: "<forced-ping>",
+            oneose: () => {
+              t(!0), r.close();
+            },
+            onclose() {
+              t(!0);
+            },
+            eoseTimeout: this.pingTimeout + 1e3
+          }
+        );
+      } catch (r) {
+        e(r);
+      }
+    });
+  }
+  async pingpong() {
+    this.ws?.readyState === 1 && (await Promise.any([
+      this.ws && this.ws.ping && this.ws.once ? this.waitForPingPong() : this.waitForDummyReq(),
+      new Promise((e) => setTimeout(() => e(!1), this.pingTimeout))
+    ]) || this.ws?.readyState === this._WebSocket.OPEN && this.ws?.close());
+  }
+  async send(t) {
+    if (!this.connectionPromise)
+      throw new lr(t, this.url);
+    this.connectionPromise.then(() => {
+      this.ws?.send(t);
+    });
+  }
+  async auth(t) {
+    const e = this.challenge;
+    if (!e)
+      throw new Error("can't perform auth, no challenge was received");
+    return this.authPromise ? this.authPromise : (this.authPromise = new Promise(async (r, n) => {
+      try {
+        let i = await t(ds(this.url, e)), s = setTimeout(() => {
+          let o = this.openEventPublishes.get(i.id);
+          o && (o.reject(new Error("auth timed out")), this.openEventPublishes.delete(i.id));
+        }, this.publishTimeout);
+        this.openEventPublishes.set(i.id, { resolve: r, reject: n, timeout: s }), this.send('["AUTH",' + JSON.stringify(i) + "]");
+      } catch (i) {
+        console.warn("subscribe auth function failed:", i);
+      }
+    }), this.authPromise);
+  }
+  async publish(t) {
+    this.idleSince = void 0, this.ongoingOperations++;
+    const e = new Promise((r, n) => {
+      const i = setTimeout(() => {
+        const s = this.openEventPublishes.get(t.id);
+        s && (s.reject(new Error("publish timed out")), this.openEventPublishes.delete(t.id));
+      }, this.publishTimeout);
+      this.openEventPublishes.set(t.id, { resolve: r, reject: n, timeout: i });
+    });
+    return this.send('["EVENT",' + JSON.stringify(t) + "]"), this.ongoingOperations--, this.ongoingOperations === 0 && (this.idleSince = Date.now()), e;
+  }
+  async count(t, e) {
+    this.serial++;
+    const r = e?.id || "count:" + this.serial, n = new Promise((i, s) => {
+      this.openCountRequests.set(r, { resolve: i, reject: s });
+    });
+    return this.send('["COUNT","' + r + '",' + JSON.stringify(t).substring(1)), n;
+  }
+  subscribe(t, e) {
+    e.label !== "<forced-ping>" && (this.idleSince = void 0, this.ongoingOperations++);
+    const r = this.prepareSubscription(t, e);
+    return r.fire(), e.abort && (e.abort.onabort = () => r.close(String(e.abort.reason || "<aborted>"))), r;
+  }
+  prepareSubscription(t, e) {
+    this.serial++;
+    const r = e.id || (e.label ? e.label + ":" : "sub:") + this.serial, n = new hs(this, r, t, e);
+    return this.openSubs.set(r, n), n;
+  }
+  close() {
+    this.skipReconnection = !0, this.reconnectTimeoutHandle && (clearTimeout(this.reconnectTimeoutHandle), this.reconnectTimeoutHandle = void 0), this.pingIntervalHandle && (clearInterval(this.pingIntervalHandle), this.pingIntervalHandle = void 0), this.closeAllSubscriptions("relay connection closed by us"), this._connected = !1, this.idleSince = void 0, this.onclose?.(), this.ws?.readyState === this._WebSocket.OPEN && this.ws?.close();
+  }
+  _onmessage(t) {
+    const e = t.data;
+    if (!e)
+      return;
+    const r = fs(e);
+    if (r) {
+      const n = this.openSubs.get(r);
+      if (!n)
+        return;
+      const i = ls(e, "id"), s = n.alreadyHaveEvent?.(i);
+      if (n.receivedEvent?.(this, i), s)
+        return;
+    }
+    try {
+      let n = JSON.parse(e);
+      switch (n[0]) {
+        case "EVENT": {
+          const i = this.openSubs.get(n[1]), s = n[2];
+          this.verifyEvent(s) && us(i.filters, s) ? i.onevent(s) : i.oninvalidevent?.(s), (!i.lastEmitted || i.lastEmitted < s.created_at) && (i.lastEmitted = s.created_at);
+          return;
+        }
+        case "COUNT": {
+          const i = n[1], s = n[2], o = this.openCountRequests.get(i);
+          o && (o.resolve(s.count), this.openCountRequests.delete(i));
+          return;
+        }
+        case "EOSE": {
+          const i = this.openSubs.get(n[1]);
+          if (!i)
+            return;
+          i.receivedEose();
+          return;
+        }
+        case "OK": {
+          const i = n[1], s = n[2], o = n[3], a = this.openEventPublishes.get(i);
+          a && (clearTimeout(a.timeout), s ? a.resolve(o) : a.reject(new Error(o)), this.openEventPublishes.delete(i));
+          return;
+        }
+        case "CLOSED": {
+          const i = n[1], s = this.openSubs.get(i);
+          if (!s)
+            return;
+          s.closed = !0, s.close(n[2]);
+          return;
+        }
+        case "NOTICE": {
+          this.onnotice(n[1]);
+          return;
+        }
+        case "AUTH": {
+          this.challenge = n[1], this.onauth && this.auth(this.onauth);
+          return;
+        }
+        default: {
+          this.openSubs.get(n[1])?.oncustom?.(n);
+          return;
+        }
+      }
+    } catch (n) {
+      try {
+        const [i, s, o] = JSON.parse(e);
+        console.warn(`[nostr] relay ${this.url} error processing message:`, n, o);
+      } catch {
+        console.warn(`[nostr] relay ${this.url} error processing message:`, n);
+      }
+      return;
+    }
+  }
+}, hs = class {
+  relay;
+  id;
+  lastEmitted;
+  closed = !1;
+  eosed = !1;
+  filters;
+  alreadyHaveEvent;
+  receivedEvent;
+  onevent;
+  oninvalidevent;
+  oneose;
+  onclose;
+  oncustom;
+  eoseTimeout;
+  eoseTimeoutHandle;
+  constructor(t, e, r, n) {
+    if (r.length === 0)
+      throw new Error("subscription can't be created with zero filters");
+    this.relay = t, this.filters = r, this.id = e, this.alreadyHaveEvent = n.alreadyHaveEvent, this.receivedEvent = n.receivedEvent, this.eoseTimeout = n.eoseTimeout || t.baseEoseTimeout, this.oneose = n.oneose, this.onclose = n.onclose, this.oninvalidevent = n.oninvalidevent, this.onevent = n.onevent || ((i) => {
+      console.warn(
+        `onevent() callback not defined for subscription '${this.id}' in relay ${this.relay.url}. event received:`,
+        i
+      );
+    });
+  }
+  fire() {
+    this.relay.send('["REQ","' + this.id + '",' + JSON.stringify(this.filters).substring(1)), this.eoseTimeoutHandle = setTimeout(this.receivedEose.bind(this), this.eoseTimeout);
+  }
+  receivedEose() {
+    this.eosed || (clearTimeout(this.eoseTimeoutHandle), this.eosed = !0, this.oneose?.());
+  }
+  close(t = "closed by caller") {
+    if (!this.closed && this.relay.connected) {
+      try {
+        this.relay.send('["CLOSE",' + JSON.stringify(this.id) + "]");
+      } catch (e) {
+        if (!(e instanceof lr)) throw e;
+      }
+      this.closed = !0;
+    }
+    this.relay.openSubs.delete(this.id), this.relay.ongoingOperations--, this.relay.ongoingOperations === 0 && (this.relay.idleSince = Date.now()), this.onclose?.(t);
+  }
+}, gs = (t) => (t[Ee] = !0, !0), ps = class {
+  relays = /* @__PURE__ */ new Map();
+  seenOn = /* @__PURE__ */ new Map();
+  trackRelays = !1;
+  verifyEvent;
+  enablePing;
+  enableReconnect;
+  automaticallyAuth;
+  trustedRelayURLs = /* @__PURE__ */ new Set();
+  onRelayConnectionFailure;
+  onRelayConnectionSuccess;
+  allowConnectingToRelay;
+  maxWaitForConnection;
+  _WebSocket;
+  constructor(t) {
+    this.verifyEvent = t.verifyEvent, this._WebSocket = t.websocketImplementation, this.enablePing = t.enablePing, this.enableReconnect = t.enableReconnect || !1, this.automaticallyAuth = t.automaticallyAuth, this.onRelayConnectionFailure = t.onRelayConnectionFailure, this.onRelayConnectionSuccess = t.onRelayConnectionSuccess, this.allowConnectingToRelay = t.allowConnectingToRelay, this.maxWaitForConnection = t.maxWaitForConnection || 3e3;
+  }
+  async ensureRelay(t, e) {
+    t = Oe(t);
+    let r = this.relays.get(t);
+    if (r || (r = new fr(t, {
+      verifyEvent: this.trustedRelayURLs.has(t) ? gs : this.verifyEvent,
+      websocketImplementation: this._WebSocket,
+      enablePing: this.enablePing,
+      enableReconnect: this.enableReconnect
+    }), r.onclose = () => {
+      this.relays.delete(t);
+    }, this.relays.set(t, r)), this.automaticallyAuth) {
+      const n = this.automaticallyAuth(t);
+      n && (r.onauth = n);
+    }
+    try {
+      await r.connect({
+        timeout: e?.connectionTimeout,
+        abort: e?.abort
+      });
+    } catch (n) {
+      throw this.relays.delete(t), n;
+    }
+    return r;
+  }
+  close(t) {
+    t.map(Oe).forEach((e) => {
+      this.relays.get(e)?.close(), this.relays.delete(e);
+    });
+  }
+  subscribe(t, e, r) {
+    const n = [], i = [];
+    for (let s = 0; s < t.length; s++) {
+      const o = Oe(t[s]);
+      n.find((a) => a.url === o) || i.indexOf(o) === -1 && (i.push(o), n.push({ url: o, filter: e }));
+    }
+    return this.subscribeMap(n, r);
+  }
+  subscribeMany(t, e, r) {
+    return this.subscribe(t, e, r);
+  }
+  subscribeMap(t, e) {
+    const r = /* @__PURE__ */ new Map();
+    for (const _ of t) {
+      const { url: k, filter: P } = _;
+      r.has(k) || r.set(k, []), r.get(k).push(P);
+    }
+    const n = Array.from(r.entries()).map(([_, k]) => ({ url: _, filters: k }));
+    this.trackRelays && (e.receivedEvent = (_, k) => {
+      let P = this.seenOn.get(k);
+      P || (P = /* @__PURE__ */ new Set(), this.seenOn.set(k, P)), P.add(_);
+    });
+    const i = /* @__PURE__ */ new Set(), s = [], o = [];
+    let a = (_) => {
+      o[_] || (o[_] = !0, o.filter((k) => k).length === n.length && (e.oneose?.(), a = () => {
+      }));
+    };
+    const u = [];
+    let w = (_, k) => {
+      u[_] || (a(_), u[_] = k, u.filter((P) => P).length === n.length && (e.onclose?.(u), w = () => {
+      }));
+    };
+    const T = (_) => {
+      if (e.alreadyHaveEvent?.(_))
+        return !0;
+      const k = i.has(_);
+      return i.add(_), k;
+    }, R = Promise.all(
+      n.map(async ({ url: _, filters: k }, P) => {
+        if (this.allowConnectingToRelay?.(_, ["read", k]) === !1) {
+          w(P, "connection skipped by allowConnectingToRelay");
+          return;
+        }
+        let q;
+        try {
+          q = await this.ensureRelay(_, {
+            connectionTimeout: this.maxWaitForConnection < (e.maxWait || 0) ? Math.max(e.maxWait * 0.8, e.maxWait - 1e3) : this.maxWaitForConnection,
+            abort: e.abort
+          });
+        } catch (H) {
+          this.onRelayConnectionFailure?.(_), w(P, H?.message || String(H));
+          return;
+        }
+        this.onRelayConnectionSuccess?.(_);
+        let U = q.subscribe(k, {
+          ...e,
+          oneose: () => a(P),
+          onclose: (H) => {
+            H.startsWith("auth-required: ") && e.onauth ? q.auth(e.onauth).then(() => {
+              q.subscribe(k, {
+                ...e,
+                oneose: () => a(P),
+                onclose: (W) => {
+                  w(P, W);
+                },
+                alreadyHaveEvent: T,
+                eoseTimeout: e.maxWait,
+                abort: e.abort
+              });
+            }).catch((W) => {
+              w(P, `auth was required and attempted, but failed with: ${W}`);
+            }) : w(P, H);
+          },
+          alreadyHaveEvent: T,
+          eoseTimeout: e.maxWait,
+          abort: e.abort
+        });
+        s.push(U);
+      })
+    );
+    return {
+      async close(_) {
+        await R, s.forEach((k) => {
+          k.close(_);
+        });
+      }
+    };
+  }
+  subscribeEose(t, e, r) {
+    let n;
+    return n = this.subscribe(t, e, {
+      ...r,
+      oneose() {
+        const i = "closed automatically on eose";
+        n ? n.close(i) : r.onclose?.(t.map((s) => i));
+      }
+    }), n;
+  }
+  subscribeManyEose(t, e, r) {
+    return this.subscribeEose(t, e, r);
+  }
+  async querySync(t, e, r) {
+    return new Promise(async (n) => {
+      const i = [];
+      this.subscribeEose(t, e, {
+        ...r,
+        onevent(s) {
+          i.push(s);
+        },
+        onclose(s) {
+          n(i);
+        }
+      });
+    });
+  }
+  async get(t, e, r) {
+    e.limit = 1;
+    const n = await this.querySync(t, e, r);
+    return n.sort((i, s) => s.created_at - i.created_at), n[0] || null;
+  }
+  publish(t, e, r) {
+    return t.map(Oe).map(async (n, i, s) => {
+      if (s.indexOf(n) !== i)
+        return Promise.reject("duplicate url");
+      if (this.allowConnectingToRelay?.(n, ["write", e]) === !1)
+        return Promise.reject("connection skipped by allowConnectingToRelay");
+      let o;
+      try {
+        o = await this.ensureRelay(n, {
+          connectionTimeout: this.maxWaitForConnection < (r?.maxWait || 0) ? Math.max(r.maxWait * 0.8, r.maxWait - 1e3) : this.maxWaitForConnection,
+          abort: r?.abort
+        });
+      } catch (a) {
+        return this.onRelayConnectionFailure?.(n), "connection failure: " + String(a);
+      }
+      return o.publish(e).catch(async (a) => {
+        if (a instanceof Error && a.message.startsWith("auth-required: ") && r?.onauth)
+          return await o.auth(r.onauth), o.publish(e);
+        throw a;
+      }).then((a) => {
+        if (this.trackRelays) {
+          let u = this.seenOn.get(e.id);
+          u || (u = /* @__PURE__ */ new Set(), this.seenOn.set(e.id, u)), u.add(o);
+        }
+        return a;
+      });
+    });
+  }
+  listConnectionStatus() {
+    const t = /* @__PURE__ */ new Map();
+    return this.relays.forEach((e, r) => t.set(r, e.connected)), t;
+  }
+  destroy() {
+    this.relays.forEach((t) => t.close()), this.relays = /* @__PURE__ */ new Map();
+  }
+  pruneIdleRelays(t = 1e4) {
+    const e = [];
+    for (const [r, n] of this.relays)
+      n.idleSince && Date.now() - n.idleSince >= t && (this.relays.delete(r), e.push(r), n.close());
+    return e;
+  }
+}, dr;
+try {
+  dr = WebSocket;
+} catch {
+}
+var bs = class extends ps {
+  constructor(t) {
+    super({ verifyEvent: ir, websocketImplementation: dr, maxWaitForConnection: 3e3, ...t });
+  }
+}, hr;
+try {
+  hr = fetch;
+} catch {
+}
+var ys = /^bunker:\/\/([0-9a-f]{64})\??([?\/\w:.=&%-]*)$/;
+async function ws(t) {
+  let e = t.match(ys);
+  if (e)
+    try {
+      const r = e[1], n = new URLSearchParams(e[2]);
+      return {
+        pubkey: r,
+        relays: n.getAll("relay"),
+        secret: n.get("secret")
+      };
+    } catch {
+    }
+  return vs(t);
+}
+async function vs(t) {
+  const e = t.match(ss);
+  if (!e)
+    return null;
+  const [r, n = "_", i] = e;
+  try {
+    const s = `https://${i}/.well-known/nostr.json?name=${n}`, o = await (await hr(s, { redirect: "error" })).json();
+    let a = o.names[n], u = o.nip46[a] || [];
+    return { pubkey: a, relays: u, secret: null };
+  } catch {
+    return null;
+  }
+}
+function ms(t) {
+  const e = new URLSearchParams();
+  return t.relays.forEach((r) => {
+    e.append("relay", r);
+  }), e.append("secret", t.secret), t.perms && t.perms.length > 0 && e.append("perms", t.perms.join(",")), t.name && e.append("name", t.name), t.url && e.append("url", t.url), t.image && e.append("image", t.image), `nostrconnect://${t.clientPubkey}?${e.toString()}`;
+}
+var et = class {
+  params;
+  pool;
+  subCloser;
+  isOpen;
+  serial;
+  idPrefix;
+  listeners;
+  waitingForAuth;
+  secretKey;
+  conversationKey;
+  bp;
+  cachedPubKey;
+  constructor(t, e) {
+    this.params = e, this.pool = e.pool || new bs(), this.secretKey = t, this.isOpen = !1, this.idPrefix = Math.random().toString(36).substring(7), this.serial = 0, this.listeners = {}, this.waitingForAuth = {};
+  }
+  static fromBunker(t, e, r = {}) {
+    if (e.relays.length === 0)
+      throw new Error("no relays specified for this bunker");
+    const n = new et(t, r);
+    return n.conversationKey = yt(t, e.pubkey), n.bp = e, n.setupSubscription(), n;
+  }
+  static async fromURI(t, e, r = {}, n = 3e5) {
+    const i = new et(t, r), s = new URL(e), o = gn(t);
+    return new Promise((a, u) => {
+      let w = !1;
+      const T = i.pool.subscribe(
+        s.searchParams.getAll("relay"),
+        {
+          kinds: [wt],
+          "#p": [o],
+          limit: 0
+        },
+        {
+          onevent: async (R) => {
+            try {
+              const _ = yt(t, R.pubkey), k = pn(R.content, _);
+              JSON.parse(k).result === s.searchParams.get("secret") && (T.close(), i.bp = {
+                pubkey: R.pubkey,
+                relays: s.searchParams.getAll("relay"),
+                secret: s.searchParams.get("secret")
+              }, i.conversationKey = yt(t, R.pubkey), i.setupSubscription(), w = !0, await Promise.race([new Promise((q) => setTimeout(q, 1e3)), i.switchRelays()]), a(i));
+            } catch (_) {
+              console.warn("failed to process potential connection event", _);
+            }
+          },
+          onclose: () => {
+            w || u(new Error("subscription closed before connection was established."));
+          },
+          maxWait: typeof n == "number" ? n : void 0,
+          abort: typeof n != "number" ? n : void 0
+        }
+      );
+    });
+  }
+  setupSubscription() {
+    const t = this.listeners, e = this.waitingForAuth, r = this.conversationKey;
+    this.subCloser = this.pool.subscribe(
+      this.bp.relays,
+      {
+        kinds: [wt],
+        authors: [this.bp.pubkey],
+        "#p": [gn(this.secretKey)],
+        limit: 0
+      },
+      {
+        onevent: async (n) => {
+          const i = JSON.parse(pn(n.content, r)), { id: s, result: o, error: a } = i;
+          if (o === "auth_url" && e[s]) {
+            delete e[s], this.params.onauth ? this.params.onauth(a) : console.warn(
+              `nostr-tools/nip46: remote signer ${this.bp.pubkey} tried to send an "auth_url"='${a}' but there was no onauth() callback configured.`
+            );
+            return;
+          }
+          let u = t[s];
+          u && (a ? u.reject(a) : o && u.resolve(o), delete t[s]);
+        },
+        onclose: () => {
+          this.subCloser = void 0;
+        }
+      }
+    ), this.isOpen = !0;
+  }
+  async switchRelays() {
+    try {
+      const t = await this.sendRequest("switch_relays", []);
+      let e = JSON.parse(t);
+      if (!e || JSON.stringify(e.sort()) === JSON.stringify(this.bp.relays))
+        return !1;
+      this.bp.relays = e;
+      let r = this.subCloser;
+      return setTimeout(() => {
+        r.close();
+      }, 5e3), this.subCloser = void 0, this.setupSubscription(), !0;
+    } catch {
+      return !1;
+    }
+  }
+  async close() {
+    this.isOpen = !1, this.subCloser.close();
+  }
+  async sendRequest(t, e) {
+    return new Promise(async (r, n) => {
+      try {
+        if (!this.isOpen)
+          throw new Error("this signer is not open anymore, create a new one");
+        this.subCloser || this.setupSubscription(), this.serial++;
+        const i = `${this.idPrefix}-${this.serial}`, s = is(JSON.stringify({ id: i, method: t, params: e }), this.conversationKey), o = Qi(
+          {
+            kind: wt,
+            tags: [["p", this.bp.pubkey]],
+            content: s,
+            created_at: Math.floor(Date.now() / 1e3)
+          },
+          this.secretKey
+        );
+        this.listeners[i] = { resolve: r, reject: n }, this.waitingForAuth[i] = !0, await Promise.any(this.pool.publish(this.bp.relays, o));
+      } catch (i) {
+        n(i);
+      }
+    });
+  }
+  async ping() {
+    let t = await this.sendRequest("ping", []);
+    if (t !== "pong")
+      throw new Error(`result is not pong: ${t}`);
+  }
+  async connect() {
+    await this.sendRequest("connect", [this.bp.pubkey, this.bp.secret || ""]);
+  }
+  async getPublicKey() {
+    return this.cachedPubKey || (this.cachedPubKey = await this.sendRequest("get_public_key", [])), this.cachedPubKey;
+  }
+  async signEvent(t) {
+    let e = await this.sendRequest("sign_event", [JSON.stringify(t)]), r = JSON.parse(e);
+    if (ir(r))
+      return r;
+    throw new Error(`event returned from bunker is improperly signed: ${JSON.stringify(r)}`);
+  }
+  async nip04Encrypt(t, e) {
+    return await this.sendRequest("nip04_encrypt", [t, e]);
+  }
+  async nip04Decrypt(t, e) {
+    return await this.sendRequest("nip04_decrypt", [t, e]);
+  }
+  async nip44Encrypt(t, e) {
+    return await this.sendRequest("nip44_encrypt", [t, e]);
+  }
+  async nip44Decrypt(t, e) {
+    return await this.sendRequest("nip44_decrypt", [t, e]);
+  }
+};
+const xs = "wss://bucket.coracle.social";
+function Es() {
+  return !!window.nostr;
+}
+function ks() {
+  if (!window.nostr) throw new Error("No Nostr signer extension found");
+  const t = window.nostr;
+  return {
+    getPublicKey: () => t.getPublicKey(),
+    signEvent: (e) => t.signEvent(e),
+    close() {
+    }
+  };
+}
+async function As(t) {
+  const e = er(), r = await ws(t);
+  if (!r) throw new Error("Invalid bunker URI");
+  const n = et.fromBunker(e, r);
+  return await n.connect(), gr(n);
+}
+function Ss(t) {
+  const e = er(), r = Ii(e), n = Array.from(
+    crypto.getRandomValues(new Uint8Array(16)),
+    (s) => s.toString(16).padStart(2, "0")
+  ).join(""), i = ms({
+    clientPubkey: r,
+    relays: [t],
+    secret: n,
+    name: "nsite deploy"
+  });
+  return {
+    uri: i,
+    async connect(s) {
+      const o = await et.fromURI(e, i, {}, s ?? 3e5);
+      return gr(o);
+    }
+  };
+}
+function gr(t) {
+  return {
+    getPublicKey: () => t.getPublicKey(),
+    signEvent: (e) => t.signEvent(e),
+    close: () => t.close()
+  };
+}
+const qt = class qt extends HTMLElement {
+  constructor() {
+    super(), this.state = "idle", this.ctx = null, this.manifest = null, this.signer = null, this.userPubkey = "", this.userRelays = [], this.deployedUrl = "", this.errorMsg = "", this.statusMsg = "", this.slug = "", this.siteTitle = "", this.siteDescription = "", this.deployAsRoot = !0, this.hasRootSite = null, this.nostrConnectUri = "", this.nip46Relay = xs, this.qrAbort = null, this.ncConnect = null, this.manifestPromise = null, this.relaysPromise = null, this.thieves = [], this.thievesExpanded = !1, this.shadow = this.attachShadow({ mode: "open" }), this.ctx = Pr(), this.ctx && (this.manifestPromise = Wt(this.ctx), this.manifestPromise.then((e) => {
+      e && (this.thieves = Dr(e), this.thieves.length > 0 && this.state === "idle" && this.render());
+    }), this.render());
+  }
+  attributeChangedCallback() {
+    this.state === "idle" && this.render();
+  }
+  get buttonLabel() {
+    return this.getAttribute("label") || "Borrow this";
+  }
+  esc(e) {
+    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  modal(e) {
+    return `<div class="nd-overlay"><div class="nd-modal">${e}</div></div>`;
+  }
+  render() {
+    this.preserveFormValues();
+    let e = `<style>${pr}</style>`;
+    switch (this.state) {
+      case "idle":
+        e += `<button class="nd-trigger" part="trigger">${this.esc(this.buttonLabel)}</button>`, e += this.paperTrailContent();
+        break;
+      case "auth":
+        e += `<button class="nd-trigger" disabled>${this.esc(this.buttonLabel)}</button>`, e += this.modal(this.authContent());
+        break;
+      case "connecting":
+        e += '<button class="nd-trigger" disabled>Connecting...</button>', e += this.modal(`
+          <div class="nd-header">
+            <h2 class="nd-title">Connecting</h2>
+            <button class="nd-close" data-action="close">&times;</button>
+          </div>
+          <div class="nd-msg"><span class="nd-spinner"></span>${this.esc(this.statusMsg)}</div>
+        `);
+        break;
+      case "loading":
+        e += '<button class="nd-trigger" disabled>Loading...</button>', e += this.modal(`
+          <div class="nd-msg"><span class="nd-spinner"></span>Fetching site manifest...</div>
+        `);
+        break;
+      case "form":
+        e += `<button class="nd-trigger" disabled>${this.esc(this.buttonLabel)}</button>`, e += this.modal(this.formContent());
+        break;
+      case "confirm":
+        e += `<button class="nd-trigger" disabled>${this.esc(this.buttonLabel)}</button>`, e += this.modal(this.confirmContent());
+        break;
+      case "deploying":
+        e += '<button class="nd-trigger" disabled>Deploying...</button>', e += this.modal(`
+          <h2 class="nd-title">Deploying</h2>
+          <div class="nd-msg"><span class="nd-spinner"></span>${this.esc(this.statusMsg)}</div>
+        `);
+        break;
+      case "success":
+        e += '<button class="nd-trigger" disabled>Deployed!</button>', e += this.modal(`
+          <div class="nd-header">
+            <h2 class="nd-title">Deployed!</h2>
+            <button class="nd-close" data-action="close">&times;</button>
+          </div>
+          <div class="nd-status nd-status-ok">Your site is live</div>
+          <a class="nd-link" href="${this.esc(this.deployedUrl)}" target="_blank" rel="noopener">${this.esc(this.deployedUrl)}</a>
+          <div class="nd-actions">
+            <button class="nd-btn nd-btn-secondary" data-action="close">Close</button>
+          </div>
+        `);
+        break;
+      case "error":
+        e += `<button class="nd-trigger" part="trigger">${this.esc(this.buttonLabel)}</button>`, e += this.modal(`
+          <div class="nd-header">
+            <h2 class="nd-title">Error</h2>
+            <button class="nd-close" data-action="close">&times;</button>
+          </div>
+          <div class="nd-status nd-status-err">${this.esc(this.errorMsg)}</div>
+          <div class="nd-actions">
+            <button class="nd-btn nd-btn-secondary" data-action="close">Close</button>
+          </div>
+        `);
+        break;
+    }
+    this.shadow.innerHTML = e, this.bind();
+  }
+  // --- Content builders ---
+  paperTrailContent() {
+    if (this.thieves.length === 0) return "";
+    let e = `<div class="nd-trail">
+      <button class="nd-trail-toggle" data-action="toggle-trail">Stolen by ${this.thieves.length} npub${this.thieves.length === 1 ? "" : "s"}</button>`;
+    if (this.thievesExpanded) {
+      e += '<div class="nd-trail-list">';
+      const r = this.thieves[0], n = this.thieves.length > 1 ? this.thieves[1] : null;
+      if (e += this.thiefItem(r), n && n.index > r.index + 1) {
+        const i = n.index - r.index - 1;
+        e += `<div class="nd-trail-gap">... ${i} more</div>`;
+      }
+      for (let i = 1; i < this.thieves.length; i++)
+        e += this.thiefItem(this.thieves[i]);
+      e += "</div>";
+    }
+    return e += "</div>", e;
+  }
+  thiefItem(e) {
+    const r = Bn(e.pubkey), n = r.slice(0, 12) + "..." + r.slice(-4);
+    return `<div class="nd-trail-item">
+      <span class="nd-trail-idx">#${e.index}</span>
+      <span class="nd-trail-pk">${n}</span>
+    </div>`;
+  }
+  authContent() {
+    const e = Es(), r = this.nostrConnectUri ? Zr(this.nostrConnectUri) : "";
+    let n = `
+      <div class="nd-header">
+        <h2 class="nd-title">Sign In</h2>
+        <button class="nd-close" data-action="close">&times;</button>
+      </div>`;
+    return e && (n += `
+        <div class="nd-auth-option">
+          <button class="nd-btn-ext" data-action="ext">Sign in with Extension</button>
+        </div>
+        <div class="nd-divider">or</div>`), n += `
+      <div class="nd-auth-option">
+        <div class="nd-qr-label" style="margin-bottom:6px">Paste a bunker URI</div>
+        <div class="nd-bunker-row">
+          <input type="text" placeholder="bunker://..." id="nd-bunker" />
+          <button data-action="bunker">Connect</button>
+        </div>
+      </div>
+      <div class="nd-divider">or scan</div>
+      <div class="nd-auth-option">
+        <div class="nd-qr-wrap">
+          <div class="nd-qr-label">Scan with your signer app</div>
+          <div class="nd-qr-code">${r}</div>
+          <div class="nd-relay-row">
+            <label>relay</label>
+            <input type="text" id="nd-nip46-relay" value="${this.esc(this.nip46Relay)}" />
+          </div>
+          <div class="nd-qr-uri">
+            <input readonly value="${this.esc(this.nostrConnectUri)}" id="nd-nc-uri" />
+            <button data-action="copy-uri">Copy</button>
+          </div>
+        </div>
+      </div>`, n;
+  }
+  formContent() {
+    let e = `
+      <div class="nd-header">
+        <h2 class="nd-title">Deploy this Page</h2>
+        <button class="nd-close" data-action="close">&times;</button>
+      </div>
+      ${this.hasRootSite ? `<div class="nd-toggle">
+        <button class="nd-toggle-btn ${this.deployAsRoot ? "active" : ""}" data-action="type-root">Root Site</button>
+        <button class="nd-toggle-btn ${this.deployAsRoot ? "" : "active"}" data-action="type-named">Named Site</button>
+      </div>` : ""}`;
+    return this.deployAsRoot ? e += '<div class="nd-root-hint">Your primary site, served at your npub subdomain.</div>' : e += `
+        <div class="nd-root-hint">A sub-site with its own name, served alongside your root site.</div>
+        <div class="nd-field">
+          <label for="nd-slug">Site name</label>
+          <input id="nd-slug" type="text" placeholder="my-site" value="${this.esc(this.slug)}" maxlength="13" autocomplete="off" />
+          <div class="nd-hint">Lowercase a-z, 0-9, hyphens. 1-13 chars.</div>
+          <div class="nd-field-error" id="nd-slug-err"></div>
+        </div>`, e += `
+      <div class="nd-field">
+        <label for="nd-title">Title</label>
+        <input id="nd-title" type="text" placeholder="Optional" value="${this.esc(this.siteTitle)}" />
+      </div>
+      <div class="nd-field">
+        <label for="nd-desc">Description</label>
+        <textarea id="nd-desc" placeholder="Optional">${this.esc(this.siteDescription)}</textarea>
+      </div>
+      <div class="nd-actions">
+        <button class="nd-btn nd-btn-secondary" data-action="close">Cancel</button>
+        <button class="nd-btn nd-btn-primary" data-action="deploy" ${this.hasRootSite === null ? "disabled" : ""}>
+          ${this.hasRootSite === null ? '<span class="nd-spinner"></span>Checking...' : "Deploy"}
+        </button>
+      </div>`, e;
+  }
+  confirmContent() {
+    return `
+      <div class="nd-header">
+        <h2 class="nd-title">Site Already Exists</h2>
+        <button class="nd-close" data-action="close">&times;</button>
+      </div>
+      <div class="nd-warn">
+        You already have ${this.deployAsRoot ? "a root site" : `a site named "${this.esc(this.slug)}"`}. Deploying will replace it with this page's content.
+      </div>
+      <div class="nd-actions">
+        <button class="nd-btn nd-btn-secondary" data-action="back">Back</button>
+        <button class="nd-btn nd-btn-warn" data-action="confirm-deploy">Overwrite</button>
+      </div>`;
+  }
+  // --- Bindings ---
+  bind() {
+    this.shadow.querySelector(".nd-trigger:not([disabled])")?.addEventListener("click", () => this.open()), this.shadow.querySelectorAll('[data-action="close"]').forEach((r) => r.addEventListener("click", () => this.close())), this.shadow.querySelector('[data-action="deploy"]')?.addEventListener("click", () => this.onDeploy()), this.shadow.querySelector('[data-action="confirm-deploy"]')?.addEventListener("click", () => this.executeDeploy()), this.shadow.querySelector('[data-action="back"]')?.addEventListener("click", () => this.setState("form")), this.shadow.querySelector('[data-action="ext"]')?.addEventListener("click", () => this.authExtension()), this.shadow.querySelector('[data-action="bunker"]')?.addEventListener("click", () => this.authBunker()), this.shadow.querySelector('[data-action="copy-uri"]')?.addEventListener("click", () => this.copyUri()), this.shadow.querySelector('[data-action="toggle-trail"]')?.addEventListener("click", () => {
+      this.thievesExpanded = !this.thievesExpanded, this.render();
+    }), this.shadow.querySelector('[data-action="type-named"]')?.addEventListener("click", () => {
+      this.deployAsRoot = !1, this.setState("form");
+    }), this.shadow.querySelector('[data-action="type-root"]')?.addEventListener("click", () => {
+      this.deployAsRoot = !0, this.setState("form");
+    }), this.shadow.querySelector(".nd-overlay")?.addEventListener("click", (r) => {
+      r.target.classList.contains("nd-overlay") && this.close();
+    });
+    const e = this.shadow.querySelector("#nd-nip46-relay");
+    if (e) {
+      const r = () => {
+        const n = e.value.trim();
+        n && n !== this.nip46Relay && (this.nip46Relay = n, this.startNostrConnect());
+      };
+      e.addEventListener("blur", r), e.addEventListener("keydown", (n) => {
+        n.key === "Enter" && (n.preventDefault(), r());
+      });
+    }
+  }
+  preserveFormValues() {
+    if (this.state !== "form") return;
+    const e = this.shadow.querySelector("#nd-slug"), r = this.shadow.querySelector("#nd-title"), n = this.shadow.querySelector("#nd-desc");
+    e && (this.slug = e.value), r && (this.siteTitle = r.value), n && (this.siteDescription = n.value);
+  }
+  setState(e) {
+    this.state = e, this.render();
+  }
+  close() {
+    this.cancelQr(), this.signer?.close(), this.signer = null, this.setState("idle");
+  }
+  cancelQr() {
+    this.qrAbort?.abort(), this.qrAbort = null, this.ncConnect = null;
+  }
+  showError(e) {
+    this.errorMsg = e, this.setState("error");
+  }
+  // --- Nostrconnect lifecycle ---
+  startNostrConnect() {
+    this.cancelQr(), this.ncConnect = Ss(this.nip46Relay), this.nostrConnectUri = this.ncConnect.uri, this.state === "auth" && this.render(), this.qrAbort = new AbortController(), this.ncConnect.connect(this.qrAbort.signal).then((e) => {
+      this.state === "auth" || this.state === "connecting" ? (this.signer = e, this.onAuthenticated()) : e.close();
+    }).catch(() => {
+    });
+  }
+  // --- Auth ---
+  async open() {
+    !this.manifestPromise && this.ctx && (this.manifestPromise = Wt(this.ctx)), this.state = "auth", this.startNostrConnect();
+  }
+  async authExtension() {
+    this.cancelQr();
+    try {
+      this.signer = ks(), this.onAuthenticated();
+    } catch (e) {
+      this.showError(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async authBunker() {
+    const e = this.shadow.querySelector("#nd-bunker")?.value.trim();
+    if (e) {
+      this.cancelQr(), this.statusMsg = "Connecting to bunker...", this.setState("connecting");
+      try {
+        this.signer = await As(e), this.onAuthenticated();
+      } catch (r) {
+        this.showError(r instanceof Error ? r.message : String(r));
+      }
+    }
+  }
+  async copyUri() {
+    try {
+      await navigator.clipboard.writeText(this.nostrConnectUri);
+      const e = this.shadow.querySelector('[data-action="copy-uri"]');
+      e && (e.textContent = "Copied!", setTimeout(() => {
+        e.isConnected && (e.textContent = "Copy");
+      }, 2e3));
+    } catch {
+    }
+  }
+  // --- Post-auth ---
+  async onAuthenticated() {
+    this.setState("loading");
+    try {
+      if (this.userPubkey = await this.signer.getPublicKey(), this.manifest = await this.manifestPromise, !this.manifest) {
+        this.showError("Could not find the site manifest on any relay.");
+        return;
+      }
+      this.siteTitle = "", this.siteDescription = "", this.slug = this.ctx.identifier ?? "", this.deployAsRoot = !0, this.hasRootSite = null, this.setState("form"), this.relaysPromise = Yt(this.userPubkey), this.relaysPromise.then(async (e) => {
+        this.userRelays = e;
+        const r = await Jt(e, this.userPubkey);
+        this.hasRootSite = r, r && this.state === "form" && this.deployAsRoot && (this.deployAsRoot = !1), this.state === "form" && this.render();
+      });
+    } catch (e) {
+      this.showError(e instanceof Error ? e.message : String(e));
+    }
+  }
+  // --- Deploy ---
+  readFormValues() {
+    if (!this.deployAsRoot) {
+      const n = this.shadow.querySelector("#nd-slug");
+      n && (this.slug = n.value.trim());
+    }
+    const e = this.shadow.querySelector("#nd-title"), r = this.shadow.querySelector("#nd-desc");
+    e && (this.siteTitle = e.value.trim()), r && (this.siteDescription = r.value.trim());
+  }
+  async onDeploy() {
+    if (this.readFormValues(), !this.deployAsRoot) {
+      const e = this.shadow.querySelector("#nd-slug-err");
+      if (!this.slug) {
+        e.textContent = "Site name is required";
+        return;
+      }
+      if (!Mr(this.slug)) {
+        e.textContent = "Lowercase a-z, 0-9, hyphens only. Cannot end with hyphen.";
+        return;
+      }
+    }
+    this.statusMsg = "Checking for existing site...", this.setState("deploying");
+    try {
+      this.relaysPromise && (this.userRelays = await this.relaysPromise), this.userRelays.length === 0 && (this.userRelays = await Yt(this.userPubkey));
+      const e = this.deployAsRoot ? void 0 : this.slug;
+      if (await Jt(this.userRelays, this.userPubkey, e)) {
+        this.setState("confirm");
+        return;
+      }
+      await this.executeDeploy();
+    } catch (e) {
+      this.showError(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async executeDeploy() {
+    this.statusMsg = "Creating event...", this.setState("deploying");
+    try {
+      const e = this.deployAsRoot ? void 0 : this.slug, r = qr(this.manifest, {
+        slug: e,
+        title: this.siteTitle || void 0,
+        description: this.siteDescription || void 0,
+        deployerPubkey: this.userPubkey,
+        deployerRelays: this.userRelays
+      });
+      this.statusMsg = "Waiting for signature...", this.render();
+      const n = await this.signer.signEvent(r);
+      if (this.statusMsg = `Publishing to ${this.userRelays.length} relay${this.userRelays.length === 1 ? "" : "s"}...`, this.render(), await $r(this.userRelays, n) === 0) {
+        this.showError("Failed to publish to any relay. Please try again.");
+        return;
+      }
+      this.deployedUrl = Ur(this.ctx.baseDomain, this.userPubkey, e), this.setState("success");
+    } catch (e) {
+      this.showError(e instanceof Error ? e.message : String(e));
+    }
+  }
+};
+qt.observedAttributes = ["label"];
+let Rt = qt;
+customElements.define("nsite-deploy", Rt);
+function bn() {
+  if (!document.querySelector("nsite-deploy")) {
+    const t = document.createElement("nsite-deploy");
+    t.classList.add("nd-fixed"), document.body.appendChild(t);
+  }
+}
+document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", bn) : bn();